1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/ossrv_pub/math_operations_api/inc/stdapis/math.h Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,571 @@
1.4 +/*
1.5 +* Portions Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
1.6 + * ====================================================
1.7 + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
1.8 + *
1.9 + * Developed at SunPro, a Sun Microsystems, Inc. business.
1.10 + * Permission to use, copy, modify, and distribute this
1.11 + * software is freely granted, provided that this notice
1.12 + * is preserved.
1.13 + * ====================================================
1.14 + */
1.15 +
1.16 +/*
1.17 + * from: @(#)fdlibm.h 5.1 93/09/24
1.18 + * $FreeBSD: src/lib/msun/src/math.h,v 1.61 2005/04/16 21:12:47 das Exp $
1.19 + */
1.20 +
1.21 +#ifndef _MATH_H_
1.22 +#define _MATH_H_
1.23 +
1.24 +#if (defined(__SYMBIAN32__) && !defined(SYMBIAN))
1.25 +#define SYMBIAN
1.26 +#endif
1.27 +
1.28 +#ifdef __SYMBIAN32__
1.29 +#ifdef __VC32__
1.30 +/* warning C4056: overflow in floating-point constant arithmetic
1.31 + * Caused by negative floating point constants, it seems!
1.32 + * For example, static double foo = -1.0;
1.33 + */
1.34 +#pragma warning( disable: 4056 )
1.35 +#endif
1.36 +#ifdef __ARMCC__
1.37 +/* Warning: #222-D: floating-point operation result is out of range
1.38 + * The compiler detects constant math that overflows, we want overflow though!
1.39 + * Warning: #39-D: division by zero
1.40 +*/
1.41 +#pragma diag_suppress 222
1.42 +#pragma diag_suppress 39
1.43 +#pragma diag_suppress 2874
1.44 +#endif
1.45 +#endif //__SYMBIAN32__
1.46 +
1.47 +#ifdef __SYMBIAN32__
1.48 +#include <_ansi.h>
1.49 +#endif //__SYMBIAN32__
1.50 +
1.51 +#include <sys/cdefs.h>
1.52 +#include <sys/_types.h>
1.53 +#include <machine/_limits.h>
1.54 +
1.55 +#ifdef __SYMBIAN32__
1.56 +#include <libm_aliases.h>
1.57 +#endif //__SYMBIAN32__
1.58 +#ifdef __SYMBIAN32__
1.59 +#include <signgam.h>
1.60 +
1.61 +// IEC 559 math functionality
1.62 +#define __STDC_IEC_559__ 1
1.63 +#endif //__SYMBIAN32__
1.64 +
1.65 +/*
1.66 + * ANSI/POSIX
1.67 + */
1.68 +#ifndef __SYMBIAN32__
1.69 +extern const union __infinity_un {
1.70 + unsigned char __uc[8];
1.71 + double __ud;
1.72 +} __infinity;
1.73 +
1.74 +extern const union __nan_un {
1.75 + unsigned char __uc[sizeof(float)];
1.76 + float __uf;
1.77 +} __nan;
1.78 +#endif //__SYMBIAN32__
1.79 +
1.80 +#if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
1.81 +#define __MATH_BUILTIN_CONSTANTS
1.82 +#endif
1.83 +
1.84 +#if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
1.85 +#define __MATH_BUILTIN_RELOPS
1.86 +#endif
1.87 +
1.88 +#ifdef __SYMBIAN32__
1.89 +#define HUGE_VAL __infinite(1.0)
1.90 +#else
1.91 +#ifdef __MATH_BUILTIN_CONSTANTS
1.92 +#define HUGE_VAL __builtin_huge_val()
1.93 +#else
1.94 +#define HUGE_VAL (__infinity.__ud)
1.95 +#endif
1.96 +#endif //__SYMBIAN32__
1.97 +
1.98 +#if __ISO_C_VISIBLE >= 1999
1.99 +#define FP_ILOGB0 (-__INT_MAX)
1.100 +#define FP_ILOGBNAN __INT_MAX
1.101 +
1.102 +#ifdef __MATH_BUILTIN_CONSTANTS
1.103 +#define HUGE_VALF __builtin_huge_valf()
1.104 +#define HUGE_VALL __builtin_huge_vall()
1.105 +#define INFINITY __builtin_inf()
1.106 +#define NAN __builtin_nan("")
1.107 +#else
1.108 +#define HUGE_VALF (float)HUGE_VAL
1.109 +#define HUGE_VALL (long double)HUGE_VAL
1.110 +#define INFINITY HUGE_VALF
1.111 +#ifdef __SYMBIAN32__
1.112 +#define NAN nanvalf()
1.113 +#else
1.114 +#define NAN (__nan.__uf)
1.115 +#endif //__SYMBIAN32__
1.116 +#endif /* __MATH_BUILTIN_CONSTANTS */
1.117 +
1.118 +#define MATH_ERRNO 1
1.119 +#define MATH_ERREXCEPT 2
1.120 +#define math_errhandling MATH_ERREXCEPT
1.121 +
1.122 +/* XXX We need a <machine/math.h>. */
1.123 +#if defined(__ia64__) || defined(__sparc64__)
1.124 +#define FP_FAST_FMA
1.125 +#endif
1.126 +#ifdef __ia64__
1.127 +#define FP_FAST_FMAL
1.128 +#endif
1.129 +#define FP_FAST_FMAF
1.130 +
1.131 +/* Symbolic constants to classify floating point numbers. */
1.132 +#define FP_INFINITE 0x01
1.133 +#define FP_NAN 0x02
1.134 +#define FP_NORMAL 0x04
1.135 +#define FP_SUBNORMAL 0x08
1.136 +#define FP_ZERO 0x10
1.137 +
1.138 +#define fpclassify(x) \
1.139 + ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) \
1.140 + : (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) \
1.141 + : __fpclassifyl(x))
1.142 +
1.143 +#define isfinite(x) \
1.144 + ((sizeof (x) == sizeof (float)) ? __isfinitef(x) \
1.145 + : (sizeof (x) == sizeof (double)) ? __isfinite(x) \
1.146 + : __isfinitel(x))
1.147 +#define isinf(x) \
1.148 + ((sizeof (x) == sizeof (float)) ? __isinff(x) \
1.149 + : (sizeof (x) == sizeof (double)) ? __isinf(x) \
1.150 + : __isinfl(x))
1.151 +#define isnan(x) \
1.152 + ((sizeof (x) == sizeof (float)) ? __isnanf(x) \
1.153 + : (sizeof (x) == sizeof (double)) ? __isnan(x) \
1.154 + : __isnanl(x))
1.155 +#define isnormal(x) \
1.156 + ((sizeof (x) == sizeof (float)) ? __isnormalf(x) \
1.157 + : (sizeof (x) == sizeof (double)) ? __isnormal(x) \
1.158 + : __isnormall(x))
1.159 +
1.160 +
1.161 +#ifdef __MATH_BUILTIN_RELOPS
1.162 +#define isgreater(x, y) __builtin_isgreater((x), (y))
1.163 +#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y))
1.164 +#define isless(x, y) __builtin_isless((x), (y))
1.165 +#define islessequal(x, y) __builtin_islessequal((x), (y))
1.166 +#define islessgreater(x, y) __builtin_islessgreater((x), (y))
1.167 +#define isunordered(x, y) __builtin_isunordered((x), (y))
1.168 +#else
1.169 +#define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
1.170 +#define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
1.171 +#define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
1.172 +#define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
1.173 +#define islessgreater(x, y) (!isunordered((x), (y)) && \
1.174 + ((x) > (y) || (y) > (x)))
1.175 +#define isunordered(x, y) (isnan(x) || isnan(y))
1.176 +#endif /* __MATH_BUILTIN_RELOPS */
1.177 +
1.178 +#define signbit(x) \
1.179 + ((sizeof (x) == sizeof (float)) ? __signbitf(x) \
1.180 + : (sizeof (x) == sizeof (double)) ? __signbit(x) \
1.181 + : __signbitl(x))
1.182 +
1.183 +typedef __double_t double_t;
1.184 +typedef __float_t float_t;
1.185 +#endif /* __ISO_C_VISIBLE >= 1999 */
1.186 +
1.187 +/*
1.188 + * XOPEN/SVID
1.189 + */
1.190 +#if __BSD_VISIBLE || __XSI_VISIBLE
1.191 +#define M_E 2.7182818284590452354 /* e */
1.192 +#define M_LOG2E 1.4426950408889634074 /* log 2e */
1.193 +#define M_LOG10E 0.43429448190325182765 /* log 10e */
1.194 +#define M_LN2 0.69314718055994530942 /* log e2 */
1.195 +#define M_LN10 2.30258509299404568402 /* log e10 */
1.196 +#define M_PI 3.14159265358979323846 /* pi */
1.197 +#define M_PI_2 1.57079632679489661923 /* pi/2 */
1.198 +#define M_PI_4 0.78539816339744830962 /* pi/4 */
1.199 +#define M_1_PI 0.31830988618379067154 /* 1/pi */
1.200 +#define M_2_PI 0.63661977236758134308 /* 2/pi */
1.201 +#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
1.202 +#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
1.203 +#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
1.204 +
1.205 +#define MAXFLOAT ((float)3.40282346638528860e+38)
1.206 +#ifdef __SYMBIAN32__
1.207 +#ifndef __WINSCW__
1.208 +extern int _signgam;
1.209 +#endif //__WINSCW__
1.210 +#else
1.211 +extern int signgam;
1.212 +#endif //__SYMBIAN32__
1.213 +#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
1.214 +
1.215 +#if __BSD_VISIBLE
1.216 +#if 0
1.217 +/* Old value from 4.4BSD-Lite math.h; this is probably better. */
1.218 +#define HUGE HUGE_VAL
1.219 +#else
1.220 +#define HUGE MAXFLOAT
1.221 +#endif
1.222 +#endif /* __BSD_VISIBLE */
1.223 +
1.224 +/*
1.225 + * Most of these functions depend on the rounding mode and have the side
1.226 + * effect of raising floating-point exceptions, so they are not declared
1.227 + * as __pure2. In C99, FENV_ACCESS affects the purity of these functions.
1.228 + */
1.229 +__BEGIN_DECLS
1.230 +/*
1.231 + * ANSI/POSIX
1.232 + */
1.233 +#ifdef __SYMBIAN32__
1.234 +IMPORT_C double __infinite(double x);
1.235 +IMPORT_C float __infinitef(float x);
1.236 +
1.237 +IMPORT_C double nanval(void );
1.238 +IMPORT_C float nanvalf(void );
1.239 +#endif //__SYMBIAN32__
1.240 +
1.241 +
1.242 +IMPORT_C int __fpclassifyd(double) __pure2;
1.243 +IMPORT_C int __fpclassifyf(float) __pure2;
1.244 +IMPORT_C int __fpclassifyl(long double) __pure2;
1.245 +IMPORT_C int __isfinitef(float) __pure2;
1.246 +IMPORT_C int __isfinite(double) __pure2;
1.247 +IMPORT_C int __isfinitel(long double) __pure2;
1.248 +IMPORT_C int __isinf(double) __pure2;
1.249 +IMPORT_C int __isinff(float) __pure2;
1.250 +IMPORT_C int __isinfl(long double) __pure2;
1.251 +#ifdef __SYMBIAN32__
1.252 +IMPORT_C int __isnan(double) __pure2;
1.253 +IMPORT_C int __isnanf(float) __pure2;
1.254 +#endif //__SYMBIAN32__
1.255 +IMPORT_C int __isnanl(long double) __pure2;
1.256 +IMPORT_C int __isnormalf(float) __pure2;
1.257 +IMPORT_C int __isnormal(double) __pure2;
1.258 +IMPORT_C int __isnormall(long double) __pure2;
1.259 +IMPORT_C int __signbit(double) __pure2;
1.260 +IMPORT_C int __signbitf(float) __pure2;
1.261 +IMPORT_C int __signbitl(long double) __pure2;
1.262 +
1.263 +IMPORT_C double acos(double);
1.264 +IMPORT_C double asin(double);
1.265 +IMPORT_C double atan(double);
1.266 +IMPORT_C double atan2(double, double);
1.267 +IMPORT_C double cos(double);
1.268 +IMPORT_C double sin(double);
1.269 +IMPORT_C double tan(double);
1.270 +
1.271 +IMPORT_C double cosh(double);
1.272 +IMPORT_C double sinh(double);
1.273 +IMPORT_C double tanh(double);
1.274 +
1.275 +IMPORT_C double exp(double);
1.276 +IMPORT_C double frexp(double, int *); /* fundamentally !__pure2 */
1.277 +IMPORT_C double ldexp(double, int);
1.278 +IMPORT_C double log(double);
1.279 +IMPORT_C double log10(double);
1.280 +IMPORT_C double modf(double, double *); /* fundamentally !__pure2 */
1.281 +
1.282 +IMPORT_C double pow(double, double);
1.283 +IMPORT_C double sqrt(double);
1.284 +
1.285 +IMPORT_C double ceil(double);
1.286 +IMPORT_C double fabs(double) __pure2;
1.287 +IMPORT_C double floor(double);
1.288 +IMPORT_C double fmod(double, double);
1.289 +
1.290 +/*
1.291 + * These functions are not in C90.
1.292 + */
1.293 +#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE
1.294 +IMPORT_C double acosh(double);
1.295 +IMPORT_C double asinh(double);
1.296 +IMPORT_C double atanh(double);
1.297 +IMPORT_C double cbrt(double);
1.298 +IMPORT_C double erf(double);
1.299 +IMPORT_C double erfc(double);
1.300 +IMPORT_C double exp2(double);
1.301 +IMPORT_C double expm1(double);
1.302 +IMPORT_C double fma(double, double, double);
1.303 +IMPORT_C double hypot(double, double);
1.304 +
1.305 +
1.306 +IMPORT_C int ilogb(double) __pure2;
1.307 +/*
1.308 +int (isinf)(double) __pure2;
1.309 +int (isnan)(double) __pure2;
1.310 +*/
1.311 +IMPORT_C double lgamma(double);
1.312 +IMPORT_C long long llrint(double);
1.313 +IMPORT_C long long llround(double);
1.314 +IMPORT_C double log1p(double);
1.315 +IMPORT_C double logb(double);
1.316 +IMPORT_C long lrint(double);
1.317 +IMPORT_C long lround(double);
1.318 +IMPORT_C double nextafter(double, double);
1.319 +IMPORT_C double remainder(double, double);
1.320 +IMPORT_C double remquo(double, double, int *);
1.321 +IMPORT_C double rint(double);
1.322 +#endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */
1.323 +
1.324 +#if __BSD_VISIBLE || __XSI_VISIBLE
1.325 +IMPORT_C double j0(double);
1.326 +IMPORT_C double j1(double);
1.327 +IMPORT_C double jn(int, double);
1.328 +IMPORT_C double scalb(double, double);
1.329 +IMPORT_C double y0(double);
1.330 +IMPORT_C double y1(double);
1.331 +IMPORT_C double yn(int, double);
1.332 +
1.333 +#if __XSI_VISIBLE <= 500 || __BSD_VISIBLE
1.334 +IMPORT_C double gamma(double);
1.335 +#endif
1.336 +#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
1.337 +
1.338 +#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999
1.339 +IMPORT_C double copysign(double, double) __pure2;
1.340 +IMPORT_C double fdim(double, double);
1.341 +IMPORT_C double fmax(double, double) __pure2;
1.342 +IMPORT_C double fmin(double, double) __pure2;
1.343 +IMPORT_C double nearbyint(double);
1.344 +IMPORT_C double round(double);
1.345 +IMPORT_C double scalbln(double, long);
1.346 +IMPORT_C double scalbn(double, int);
1.347 +IMPORT_C double trunc(double);
1.348 +#endif
1.349 +
1.350 +/*
1.351 + * BSD math library entry points
1.352 + */
1.353 +#if __BSD_VISIBLE
1.354 +IMPORT_C double drem(double, double);
1.355 +IMPORT_C int finite(double) __pure2;
1.356 +
1.357 +/*
1.358 + * Reentrant version of gamma & lgamma; passes signgam back by reference
1.359 + * as the second argument; user must allocate space for signgam.
1.360 + */
1.361 +IMPORT_C double lgamma_r(double, int *);
1.362 +
1.363 +/*
1.364 + * IEEE Test Vector
1.365 + */
1.366 +IMPORT_C double significand(double);
1.367 +#endif /* __BSD_VISIBLE */
1.368 +
1.369 +/* float versions of ANSI/POSIX functions */
1.370 +#if __ISO_C_VISIBLE >= 1999
1.371 +IMPORT_C float acosf(float);
1.372 +
1.373 +IMPORT_C float acosf(float);
1.374 +IMPORT_C float asinf(float);
1.375 +IMPORT_C float atanf(float);
1.376 +IMPORT_C float atan2f(float, float);
1.377 +IMPORT_C float cosf(float);
1.378 +IMPORT_C float sinf(float);
1.379 +IMPORT_C float tanf(float);
1.380 +
1.381 +IMPORT_C float coshf(float);
1.382 +IMPORT_C float sinhf(float);
1.383 +IMPORT_C float tanhf(float);
1.384 +IMPORT_C float exp2f(float);
1.385 +IMPORT_C float expf(float);
1.386 +IMPORT_C float expm1f(float);
1.387 +IMPORT_C float frexpf(float, int *); /* fundamentally !__pure2 */
1.388 +IMPORT_C int ilogbf(float) __pure2;
1.389 +#ifndef __SYMBIAN32__
1.390 +float ldexpf(float, int);
1.391 +#endif //__SYMBIAN32__
1.392 +IMPORT_C float log10f(float);
1.393 +IMPORT_C float log1pf(float);
1.394 +IMPORT_C float logf(float);
1.395 +IMPORT_C float modff(float, float *); /* fundamentally !__pure2 */
1.396 +
1.397 +IMPORT_C float powf(float, float);
1.398 +IMPORT_C float sqrtf(float);
1.399 +
1.400 +IMPORT_C float ceilf(float);
1.401 +IMPORT_C float fabsf(float) __pure2;
1.402 +IMPORT_C float floorf(float);
1.403 +IMPORT_C float fmodf(float, float);
1.404 +IMPORT_C float roundf(float);
1.405 +
1.406 +IMPORT_C float erff(float);
1.407 +IMPORT_C float erfcf(float);
1.408 +IMPORT_C float hypotf(float, float);
1.409 +IMPORT_C float lgammaf(float);
1.410 +
1.411 +IMPORT_C float acoshf(float);
1.412 +IMPORT_C float asinhf(float);
1.413 +IMPORT_C float atanhf(float);
1.414 +IMPORT_C float cbrtf(float);
1.415 +IMPORT_C float logbf(float);
1.416 +IMPORT_C float copysignf(float, float) __pure2;
1.417 +IMPORT_C long long llrintf(float);
1.418 +IMPORT_C long long llroundf(float);
1.419 +IMPORT_C long lrintf(float);
1.420 +IMPORT_C long lroundf(float);
1.421 +IMPORT_C float nearbyintf(float);
1.422 +IMPORT_C float nextafterf(float, float);
1.423 +IMPORT_C float remainderf(float, float);
1.424 +IMPORT_C float remquof(float, float, int *);
1.425 +IMPORT_C float rintf(float);
1.426 +IMPORT_C float scalblnf(float, long);
1.427 +IMPORT_C float scalbnf(float, int);
1.428 +IMPORT_C float truncf(float);
1.429 +
1.430 +IMPORT_C float fdimf(float, float);
1.431 +IMPORT_C float fmaf(float, float, float);
1.432 +IMPORT_C float fmaxf(float, float) __pure2;
1.433 +IMPORT_C float fminf(float, float) __pure2;
1.434 +#endif
1.435 +
1.436 +/*
1.437 + * float versions of BSD math library entry points
1.438 + */
1.439 +#if __BSD_VISIBLE
1.440 +
1.441 +#ifdef __SYMBIAN_COMPILE_UNUSED__
1.442 +float dremf(float, float);
1.443 +#endif
1.444 +
1.445 +IMPORT_C int finitef(float) __pure2;
1.446 +IMPORT_C float gammaf(float);
1.447 +IMPORT_C float j0f(float);
1.448 +IMPORT_C float j1f(float);
1.449 +IMPORT_C float jnf(int, float);
1.450 +IMPORT_C float scalbf(float, float);
1.451 +IMPORT_C float y0f(float);
1.452 +IMPORT_C float y1f(float);
1.453 +IMPORT_C float ynf(int, float);
1.454 +
1.455 +/*
1.456 + * Float versions of reentrant version of gamma & lgamma; passes
1.457 + * signgam back by reference as the second argument; user must
1.458 + * allocate space for signgam.
1.459 + */
1.460 +IMPORT_C float lgammaf_r(float, int *);
1.461 +
1.462 +/*
1.463 + * float version of IEEE Test Vector
1.464 + */
1.465 +IMPORT_C float significandf(float);
1.466 +#endif /* __BSD_VISIBLE */
1.467 +
1.468 +/*
1.469 + * long double versions of ISO/POSIX math functions
1.470 + */
1.471 +#if __ISO_C_VISIBLE >= 1999
1.472 +#if 0
1.473 +long double acoshl(long double);
1.474 +long double acosl(long double);
1.475 +long double asinhl(long double);
1.476 +long double asinl(long double);
1.477 +long double atan2l(long double, long double);
1.478 +long double atanhl(long double);
1.479 +long double atanl(long double);
1.480 +long double cbrtl(long double);
1.481 +#endif
1.482 +#ifndef __SYMBIAN32__
1.483 +long double ceill(long double);
1.484 +#endif //__SYMBIAN32__
1.485 +IMPORT_C long double copysignl(long double, long double) __pure2;
1.486 +#if 0
1.487 +long double coshl(long double);
1.488 +long double cosl(long double);
1.489 +long double erfcl(long double);
1.490 +long double erfl(long double);
1.491 +long double exp2l(long double);
1.492 +long double expl(long double);
1.493 +long double expm1l(long double);
1.494 +#endif
1.495 +IMPORT_C long double fabsl(long double) __pure2;
1.496 +IMPORT_C long double fdiml(long double, long double);
1.497 +#ifndef __SYMBIAN32__
1.498 +long double floorl(long double);
1.499 +long double fmal(long double, long double, long double);
1.500 +#endif //__SYMBIAN32__
1.501 +IMPORT_C long double fmaxl(long double, long double) __pure2;
1.502 +#ifndef __SYMBIAN32__
1.503 +long double fminl(long double, long double) __pure2;
1.504 +#endif //__SYMBIAN32__
1.505 +#if 0
1.506 +long double fmodl(long double, long double);
1.507 +#endif
1.508 +#ifndef __SYMBIAN32__
1.509 +long double frexpl(long double value, int *); /* fundamentally !__pure2 */
1.510 +#endif //__SYMBIAN32__
1.511 +#if 0
1.512 +long double hypotl(long double, long double);
1.513 +#endif
1.514 +IMPORT_C int ilogbl(long double) __pure2;
1.515 +#ifndef __SYMBIAN32__
1.516 +long double ldexpl(long double, int);
1.517 +#endif //__SYMBIAN32__
1.518 +#if 0
1.519 +long double lgammal(long double);
1.520 +long long llrintl(long double);
1.521 +#endif
1.522 +#ifndef __SYMBIAN32__
1.523 +long long llroundl(long double);
1.524 +#endif //__SYMBIAN32__
1.525 +#if 0
1.526 +long double log10l(long double);
1.527 +long double log1pl(long double);
1.528 +long double log2l(long double);
1.529 +long double logbl(long double);
1.530 +long double logl(long double);
1.531 +long lrintl(long double);
1.532 +#endif
1.533 +#ifndef __SYMBIAN32__
1.534 +long lroundl(long double);
1.535 +#endif //__SYMBIAN32__
1.536 +#if 0
1.537 +long double modfl(long double, long double *); /* fundamentally !__pure2 */
1.538 +long double nanl(const char *) __pure2;
1.539 +long double nearbyintl(long double);
1.540 +#endif
1.541 +#ifndef __SYMBIAN32__
1.542 +long double nextafterl(long double, long double);
1.543 +double nexttoward(double, long double);
1.544 +#endif //__SYMBIAN32__
1.545 +IMPORT_C float nexttowardf(float, long double);
1.546 +#ifndef __SYMBIAN32__
1.547 +long double nexttowardl(long double, long double);
1.548 +#endif //__SYMBIAN32__
1.549 +#if 0
1.550 +long double powl(long double, long double);
1.551 +long double remainderl(long double, long double);
1.552 +long double remquol(long double, long double, int *);
1.553 +long double rintl(long double);
1.554 +#endif
1.555 +#ifndef __SYMBIAN32__
1.556 +long double roundl(long double);
1.557 +#endif //__SYMBIAN32__
1.558 +IMPORT_C long double scalblnl(long double, long);
1.559 +#ifndef __SYMBIAN32__
1.560 +long double scalbnl(long double, int);
1.561 +#endif //__SYMBIAN32__
1.562 +#if 0
1.563 +long double sinhl(long double);
1.564 +long double sinl(long double);
1.565 +long double sqrtl(long double);
1.566 +long double tanhl(long double);
1.567 +long double tanl(long double);
1.568 +#endif
1.569 +IMPORT_C long double truncl(long double);
1.570 +
1.571 +#endif /* __ISO_C_VISIBLE >= 1999 */
1.572 +__END_DECLS
1.573 +
1.574 +#endif /* !_MATH_H_ */