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