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