Mercurial > projects > ldc
diff tango/tango/stdc/math.d @ 132:1700239cab2e trunk
[svn r136] MAJOR UNSTABLE UPDATE!!!
Initial commit after moving to Tango instead of Phobos.
Lots of bugfixes...
This build is not suitable for most things.
author | lindquist |
---|---|
date | Fri, 11 Jan 2008 17:57:40 +0100 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tango/tango/stdc/math.d Fri Jan 11 17:57:40 2008 +0100 @@ -0,0 +1,624 @@ +/** + * D header file for C99. + * + * Copyright: Public Domain + * License: Public Domain + * Authors: Sean Kelly, Walter Bright + * Standards: ISO/IEC 9899:1999 (E) + */ +module tango.stdc.math; + +private import tango.stdc.config; + +extern (C): + +alias float float_t; +alias double double_t; + +const double HUGE_VAL = double.infinity; +const double HUGE_VALF = float.infinity; +const double HUGE_VALL = real.infinity; + +const float INFINITY = float.infinity; +const float NAN = float.nan; + +const int FP_ILOGB0 = int.min; +const int FP_ILOGBNAN = int.min; + +const int MATH_ERRNO = 1; +const int MATH_ERREXCEPT = 2; +const int math_errhandling = MATH_ERRNO | MATH_ERREXCEPT; + +version( none ) +{ + // + // these functions are all macros in C + // + + //int fpclassify(real-floating x); + int fpclassify(float x); + int fpclassify(double x); + int fpclassify(real x); + + //int isfinite(real-floating x); + int isfinite(float x); + int isfinite(double x); + int isfinite(real x); + + //int isinf(real-floating x); + int isinf(float x); + int isinf(double x); + int isinf(real x); + + //int isnan(real-floating x); + int isnan(float x); + int isnan(double x); + int isnan(real x); + + //int isnormal(real-floating x); + int isnormal(float x); + int isnormal(double x); + int isnormal(real x); + + //int signbit(real-floating x); + int signbit(float x); + int signbit(double x); + int signbit(real x); + + //int isgreater(real-floating x, real-floating y); + int isgreater(float x, float y); + int isgreater(double x, double y); + int isgreater(real x, real y); + + //int isgreaterequal(real-floating x, real-floating y); + int isgreaterequal(float x, float y); + int isgreaterequal(double x, double y); + int isgreaterequal(real x, real y); + + //int isless(real-floating x, real-floating y); + int isless(float x, float y); + int isless(double x, double y); + int isless(real x, real y); + + //int islessequal(real-floating x, real-floating y); + int islessequal(float x, float y); + int islessequal(double x, double y); + int islessequal(real x, real y); + + //int islessgreater(real-floating x, real-floating y); + int islessgreater(float x, float y); + int islessgreater(double x, double y); + int islessgreater(real x, real y); + + //int isunordered(real-floating x, real-floating y); + int isunordered(float x, float y); + int isunordered(double x, double y); + int isunordered(real x, real y); +} + +version( DigitalMars ) version( Win32 ) + version = DigitalMarsWin32; + +version( DigitalMarsWin32 ) +{ + enum + { + FP_NANS = 0, + FP_NANQ = 1, + FP_INFINITE = 2, + FP_NORMAL = 3, + FP_SUBNORMAL = 4, + FP_ZERO = 5, + FP_NAN = FP_NANQ, + FP_EMPTY = 6, + FP_UNSUPPORTED = 7, + } + + enum + { + FP_FAST_FMA = 0, + FP_FAST_FMAF = 0, + FP_FAST_FMAL = 0, + } + + uint __fpclassify_f(float x); + uint __fpclassify_d(double x); + uint __fpclassify_ld(real x); + + extern (D) + { + //int fpclassify(real-floating x); + int fpclassify(float x) { return __fpclassify_f(x); } + int fpclassify(double x) { return __fpclassify_d(x); } + int fpclassify(real x) + { + return (real.sizeof == double.sizeof) + ? __fpclassify_d(x) + : __fpclassify_ld(x); + } + + //int isfinite(real-floating x); + int isfinite(float x) { return fpclassify(x) >= FP_NORMAL; } + int isfinite(double x) { return fpclassify(x) >= FP_NORMAL; } + int isfinite(real x) { return fpclassify(x) >= FP_NORMAL; } + + //int isinf(real-floating x); + int isinf(float x) { return fpclassify(x) == FP_INFINITE; } + int isinf(double x) { return fpclassify(x) == FP_INFINITE; } + int isinf(real x) { return fpclassify(x) == FP_INFINITE; } + + //int isnan(real-floating x); + int isnan(float x) { return fpclassify(x) <= FP_NANQ; } + int isnan(double x) { return fpclassify(x) <= FP_NANQ; } + int isnan(real x) { return fpclassify(x) <= FP_NANQ; } + + //int isnormal(real-floating x); + int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } + int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } + int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } + + //int signbit(real-floating x); + int signbit(float x) { return (cast(short*)&(x))[1] & 0x8000; } + int signbit(double x) { return (cast(short*)&(x))[3] & 0x8000; } + int signbit(real x) + { + return (real.sizeof == double.sizeof) + ? (cast(short*)&(x))[3] & 0x8000 + : (cast(short*)&(x))[4] & 0x8000; + } + } +} +else version( linux ) +{ + enum + { + FP_NAN, + FP_INFINITE, + FP_ZERO, + FP_SUBNORMAL, + FP_NORMAL, + } + + enum + { + FP_FAST_FMA = 0, + FP_FAST_FMAF = 0, + FP_FAST_FMAL = 0, + } + + int __fpclassifyf(float x); + int __fpclassify(double x); + int __fpclassifyl(real x); + + int __finitef(float x); + int __finite(double x); + int __finitel(real x); + + int __isinff(float x); + int __isinf(double x); + int __isinfl(real x); + + int __isnanf(float x); + int __isnan(double x); + int __isnanl(real x); + + int __signbitf(float x); + int __signbit(double x); + int __signbitl(real x); + + extern (D) + { + //int fpclassify(real-floating x); + int fpclassify(float x) { return __fpclassifyf(x); } + int fpclassify(double x) { return __fpclassify(x); } + int fpclassify(real x) + { + return (real.sizeof == double.sizeof) + ? __fpclassify(x) + : __fpclassifyl(x); + } + + //int isfinite(real-floating x); + int isfinite(float x) { return __finitef(x); } + int isfinite(double x) { return __finite(x); } + int isfinite(real x) + { + return (real.sizeof == double.sizeof) + ? __finite(x) + : __finitel(x); + } + + //int isinf(real-floating x); + int isinf(float x) { return __isinff(x); } + int isinf(double x) { return __isinf(x); } + int isinf(real x) + { + return (real.sizeof == double.sizeof) + ? __isinf(x) + : __isinfl(x); + } + + //int isnan(real-floating x); + int isnan(float x) { return __isnanf(x); } + int isnan(double x) { return __isnan(x); } + int isnan(real x) + { + return (real.sizeof == double.sizeof) + ? __isnan(x) + : __isnanl(x); + } + + //int isnormal(real-floating x); + int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } + int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } + int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } + + //int signbit(real-floating x); + int signbit(float x) { return __signbitf(x); } + int signbit(double x) { return __signbit(x); } + int signbit(real x) + { + return (real.sizeof == double.sizeof) + ? __signbit(x) + : __signbitl(x); + } + } +} +else version( darwin ) +{ + enum + { + FP_NAN = 1, + FP_INFINITE = 2, + FP_ZERO = 3, + FP_NORMAL = 4, + FP_SUBNORMAL = 5, + FP_SUPERNORMAL = 6 + } + + enum + { + FP_FAST_FMA = 0, + FP_FAST_FMAF = 0, + FP_FAST_FMAL = 0, + } + + int __fpclassifyf(float x); + int __fpclassifyd(double x); + int __fpclassify(real x); + + int __isfinitef(float x); + int __isfinited(double x); + int __isfinite(real x); + + int __isinff(float x); + int __isinfd(double x); + int __isinf(real x); + + int __isnanf(float x); + int __isnand(double x); + int __isnan(real x); + + int __signbitf(float x); + int __signbitd(double x); + int __signbitl(real x); + + extern (D) + { + //int fpclassify(real-floating x); + int fpclassify(float x) { return __fpclassifyf(x); } + int fpclassify(double x) { return __fpclassifyd(x); } + int fpclassify(real x) + { + return (real.sizeof == double.sizeof) + ? __fpclassifyd(x) + : __fpclassify(x); + } + + //int isfinite(real-floating x); + int isfinite(float x) { return __isfinitef(x); } + int isfinite(double x) { return __isfinited(x); } + int isfinite(real x) + { + return (real.sizeof == double.sizeof) + ? __isfinited(x) + : __isfinite(x); + } + + //int isinf(real-floating x); + int isinf(float x) { return __isinff(x); } + int isinf(double x) { return __isinfd(x); } + int isinf(real x) + { + return (real.sizeof == double.sizeof) + ? __isinfd(x) + : __isinf(x); + } + + //int isnan(real-floating x); + int isnan(float x) { return __isnanf(x); } + int isnan(double x) { return __isnand(x); } + int isnan(real x) + { + return (real.sizeof == double.sizeof) + ? __isnand(x) + : __isnan(x); + } + + //int isnormal(real-floating x); + int isnormal(float x) { return fpclassify(x) == FP_NORMAL; } + int isnormal(double x) { return fpclassify(x) == FP_NORMAL; } + int isnormal(real x) { return fpclassify(x) == FP_NORMAL; } + + //int signbit(real-floating x); + int signbit(float x) { return __signbitf(x); } + int signbit(double x) { return __signbitd(x); } + int signbit(real x) + { + return (real.sizeof == double.sizeof) + ? __signbitd(x) + : __signbitl(x); + } + } +} + +extern (D) +{ + //int isgreater(real-floating x, real-floating y); + int isgreater(float x, float y) { return !(x !> y); } + int isgreater(double x, double y) { return !(x !> y); } + int isgreater(real x, real y) { return !(x !> y); } + + //int isgreaterequal(real-floating x, real-floating y); + int isgreaterequal(float x, float y) { return !(x !>= y); } + int isgreaterequal(double x, double y) { return !(x !>= y); } + int isgreaterequal(real x, real y) { return !(x !>= y); } + + //int isless(real-floating x, real-floating y); + int isless(float x, float y) { return !(x !< y); } + int isless(double x, double y) { return !(x !< y); } + int isless(real x, real y) { return !(x !< y); } + + //int islessequal(real-floating x, real-floating y); + int islessequal(float x, float y) { return !(x !<= y); } + int islessequal(double x, double y) { return !(x !<= y); } + int islessequal(real x, real y) { return !(x !<= y); } + + //int islessgreater(real-floating x, real-floating y); + int islessgreater(float x, float y) { return !(x !<> y); } + int islessgreater(double x, double y) { return !(x !<> y); } + int islessgreater(real x, real y) { return !(x !<> y); } + + //int isunordered(real-floating x, real-floating y); + int isunordered(float x, float y) { return (x !<>= y); } + int isunordered(double x, double y) { return (x !<>= y); } + int isunordered(real x, real y) { return (x !<>= y); } +} + +double acos(double x); +float acosf(float x); +real acosl(real x); + +double asin(double x); +float asinf(float x); +real asinl(real x); + +double atan(double x); +float atanf(float x); +real atanl(real x); + +double atan2(double y, double x); +float atan2f(float y, float x); +real atan2l(real y, real x); + +double cos(double x); +float cosf(float x); +real cosl(real x); + +double sin(double x); +float sinf(float x); +real sinl(real x); + +double tan(double x); +float tanf(float x); +real tanl(real x); + +double acosh(double x); +float acoshf(float x); +real acoshl(real x); + +double asinh(double x); +float asinhf(float x); +real asinhl(real x); + +double atanh(double x); +float atanhf(float x); +real atanhl(real x); + +double cosh(double x); +float coshf(float x); +real coshl(real x); + +double sinh(double x); +float sinhf(float x); +real sinhl(real x); + +double tanh(double x); +float tanhf(float x); +real tanhl(real x); + +double exp(double x); +float expf(float x); +real expl(real x); + +double exp2(double x); +float exp2f(float x); +real exp2l(real x); + +double expm1(double x); +float expm1f(float x); +real expm1l(real x); + +double frexp(double value, int* exp); +float frexpf(float value, int* exp); +real frexpl(real value, int* exp); + +int ilogb(double x); +int ilogbf(float x); +int ilogbl(real x); + +double ldexp(double x, int exp); +float ldexpf(float x, int exp); +real ldexpl(real x, int exp); + +double log(double x); +float logf(float x); +real logl(real x); + +double log10(double x); +float log10f(float x); +real log10l(real x); + +double log1p(double x); +float log1pf(float x); +real log1pl(real x); + +double log2(double x); +float log2f(float x); +real log2l(real x); + +double logb(double x); +float logbf(float x); +real logbl(real x); + +double modf(double value, double* iptr); +float modff(float value, float* iptr); +real modfl(real value, real *iptr); + +double scalbn(double x, int n); +float scalbnf(float x, int n); +real scalbnl(real x, int n); + +double scalbln(double x, c_long n); +float scalblnf(float x, c_long n); +real scalblnl(real x, c_long n); + +double cbrt(double x); +float cbrtf(float x); +real cbrtl(real x); + +double fabs(double x); +float fabsf(float x); +real fabsl(real x); + +double hypot(double x, double y); +float hypotf(float x, float y); +real hypotl(real x, real y); + +double pow(double x, double y); +float powf(float x, float y); +real powl(real x, real y); + +double sqrt(double x); +float sqrtf(float x); +real sqrtl(real x); + +double erf(double x); +float erff(float x); +real erfl(real x); + +double erfc(double x); +float erfcf(float x); +real erfcl(real x); + +double lgamma(double x); +float lgammaf(float x); +real lgammal(real x); + +double tgamma(double x); +float tgammaf(float x); +real tgammal(real x); + +double ceil(double x); +float ceilf(float x); +real ceill(real x); + +double floor(double x); +float floorf(float x); +real floorl(real x); + +double nearbyint(double x); +float nearbyintf(float x); +real nearbyintl(real x); + +double rint(double x); +float rintf(float x); +real rintl(real x); + +c_long lrint(double x); +c_long lrintf(float x); +c_long lrintl(real x); + +long llrint(double x); +long llrintf(float x); +long llrintl(real x); + +double round(double x); +float roundf(float x); +real roundl(real x); + +c_long lround(double x); +c_long lroundf(float x); +c_long lroundl(real x); + +long llround(double x); +long llroundf(float x); +long llroundl(real x); + +double trunc(double x); +float truncf(float x); +real truncl(real x); + +double fmod(double x, double y); +float fmodf(float x, float y); +real fmodl(real x, real y); + +double remainder(double x, double y); +float remainderf(float x, float y); +real remainderl(real x, real y); + +double remquo(double x, double y, int* quo); +float remquof(float x, float y, int* quo); +real remquol(real x, real y, int* quo); + +double copysign(double x, double y); +float copysignf(float x, float y); +real copysignl(real x, real y); + +double nan(char* tagp); +float nanf(char* tagp); +real nanl(char* tagp); + +double nextafter(double x, double y); +float nextafterf(float x, float y); +real nextafterl(real x, real y); + +double nexttoward(double x, real y); +float nexttowardf(float x, real y); +real nexttowardl(real x, real y); + +double fdim(double x, double y); +float fdimf(float x, float y); +real fdiml(real x, real y); + +double fmax(double x, double y); +float fmaxf(float x, float y); +real fmaxl(real x, real y); + +double fmin(double x, double y); +float fminf(float x, float y); +real fminl(real x, real y); + +double fma(double x, double y, double z); +float fmaf(float x, float y, float z); +real fmal(real x, real y, real z);