X-Git-Url: https://git.llucax.com/software/druntime.git/blobdiff_plain/5a07183e26b7ca151959629420a83f59af5339f3..1fc925b692ce11612c9c0d24d42e349b2229906a:/import/stdc/math.d?ds=inline

diff --git a/import/stdc/math.d b/import/stdc/math.d
index 3baa33a..3c1881a 100644
--- a/import/stdc/math.d
+++ b/import/stdc/math.d
@@ -365,11 +365,11 @@ else version( freebsd )
 {
     enum
     {
-                FP_INFINITE = 0x01,
-                FP_NAN = 0x02,
-                FP_NORMAL = 0x04,
-                FP_SUBNORMAL = 0x08,
-                FP_ZERO = 0x10
+        FP_INFINITE = 0x01,
+        FP_NAN = 0x02,
+        FP_NORMAL = 0x04,
+        FP_SUBNORMAL = 0x08,
+        FP_ZERO = 0x10
     }
 
     enum
@@ -379,43 +379,43 @@ else version( freebsd )
         FP_FAST_FMAL = 0,
     }
 
-        int     __fpclassifyd(double);
-        int     __fpclassifyf(float);
-        int     __fpclassifyl(real);
-        int     __isfinitef(float);
-        int     __isfinite(double);
-        int     __isfinitel(real);
-        int     __isinff(float);
-        int     __isinfl(real);
-        int     __isnanl(real);
-        int     __isnormalf(float);
-        int     __isnormal(double);
-        int     __isnormall(real);
-        int     __signbit(double);
-        int     __signbitf(float);
-        int     __signbitl(real);
+    int __fpclassifyd(double);
+    int __fpclassifyf(float);
+    int __fpclassifyl(real);
+    int __isfinitef(float);
+    int __isfinite(double);
+    int __isfinitel(real);
+    int __isinff(float);
+    int __isinfl(real);
+    int __isnanl(real);
+    int __isnormalf(float);
+    int __isnormal(double);
+    int __isnormall(real);
+    int __signbit(double);
+    int __signbitf(float);
+    int __signbitl(real);
 
   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 __fpclassifyl(x); }
+    int fpclassify(real x)    { return __fpclassifyl(x); }
 
     //int isfinite(real-floating x);
     int isfinite(float x)       { return __isfinitef(x); }
     int isfinite(double x)      { return __isfinite(x); }
-        int isfinite(double x)      { return __isfinitel(x); }
+    int isfinite(real x)      { return __isfinitel(x); }
 
     //int isinf(real-floating x);
     int isinf(float x)          { return __isinff(x); }
     int isinf(double x)         { return __isinfl(x); }
-        int isinf(real x)         { return __isinfl(x); }
+    int isinf(real x)         { return __isinfl(x); }
 
     //int isnan(real-floating x);
     int isnan(float x)          { return __isnanl(x); }
     int isnan(double x)         { return __isnanl(x); }
-        int isnan(real x)         { return __isnanl(x); }
+    int isnan(real x)         { return __isnanl(x); }
 
     //int isnormal(real-floating x);
     int isnormal(float x)       { return __isnormalf(x); }
@@ -425,7 +425,7 @@ else version( freebsd )
     //int signbit(real-floating x);
     int signbit(float x)     { return __signbitf(x); }
     int signbit(double x)    { return __signbit(x); }
-        int signbit(double x)    { return __signbit(x); }
+    int signbit(real x)    { return __signbit(x); }
     }
 }
 
@@ -462,230 +462,467 @@ extern (D)
     int isunordered(real x, real y)        { return (x !<>= y); }
 }
 
-double  acos(double x);
-float   acosf(float x);
-real    acosl(real x);
+// NOTE: freebsd < 8-CURRENT doesn't appear to support *l, but we can
+//       approximate.
+version( freebsd )
+{
+    double  acos(double x);
+    float   acosf(float x);
+    real    acosl(real x) { return acos(x); }
+
+    double  asin(double x);
+    float   asinf(float x);
+    real    asinl(real x) { return asin(x); }
+
+    double  atan(double x);
+    float   atanf(float x);
+    real    atanl(real x) { return atan(x); }
+
+    double  atan2(double y, double x);
+    float   atan2f(float y, float x);
+    real    atan2l(real y, real x) { return atan2(y, x); }
+
+    double  cos(double x);
+    float   cosf(float x);
+    real    cosl(real x) { return cos(x); }
+
+    double  sin(double x);
+    float   sinf(float x);
+    real    sinl(real x) { return sin(x); }
+
+    double  tan(double x);
+    float   tanf(float x);
+    real    tanl(real x) { return tan(x); }
+
+    double  acosh(double x);
+    float   acoshf(float x);
+    real    acoshl(real x) { return acosh(x); }
+
+    double  asinh(double x);
+    float   asinhf(float x);
+    real    asinhl(real x) { return asinh(x); }
+
+    double  atanh(double x);
+    float   atanhf(float x);
+    real    atanhl(real x) { return atanh(x); }
+
+    double  cosh(double x);
+    float   coshf(float x);
+    real    coshl(real x) { return cosh(x); }
+
+    double  sinh(double x);
+    float   sinhf(float x);
+    real    sinhl(real x) { return sinh(x); }
+
+    double  tanh(double x);
+    float   tanhf(float x);
+    real    tanhl(real x) { return tanh(x); }
+
+    double  exp(double x);
+    float   expf(float x);
+    real    expl(real x) { return exp(x); }
+
+    double  exp2(double x);
+    float   exp2f(float x);
+    real    exp2l(real x) { return exp2(x); }
+
+    double  expm1(double x);
+    float   expm1f(float x);
+    real    expm1l(real x) { return expm1(x); }
+
+    double  frexp(double value, int* exp);
+    float   frexpf(float value, int* exp);
+    real    frexpl(real value, int* exp) { return frexp(value, exp); }
+
+    int     ilogb(double x);
+    int     ilogbf(float x);
+    int     ilogbl(real x) { return ilogb(x); }
+
+    double  ldexp(double x, int exp);
+    float   ldexpf(float x, int exp);
+    real    ldexpl(real x, int exp) { return ldexp(x, exp); }
+
+    double  log(double x);
+    float   logf(float x);
+    real    logl(real x) { return log(x); }
+
+    double  log10(double x);
+    float   log10f(float x);
+    real    log10l(real x) { return log10(x); }
+
+    double  log1p(double x);
+    float   log1pf(float x);
+    real    log1pl(real x) { return log1p(x); }
+
+    private const real ONE_LN2 = 1 / 0x1.62e42fefa39ef358p-1L;
+    double  log2(double x) { return log(x) * ONE_LN2; }
+    float   log2f(float x) { return logf(x) * ONE_LN2; }
+    real    log2l(real x) { return logl(x) * ONE_LN2; }
+
+    double  logb(double x);
+    float   logbf(float x);
+    real    logbl(real x) { return logb(x); }
+
+    double  modf(double value, double* iptr);
+    float   modff(float value, float* iptr);
+    //real    modfl(real value, real *iptr); // nontrivial conversion
+
+    double  scalbn(double x, int n);
+    float   scalbnf(float x, int n);
+    real    scalbnl(real x, int n) { return scalbn(x, n); }
+
+    double  scalbln(double x, c_long n);
+    float   scalblnf(float x, c_long n);
+    real    scalblnl(real x, c_long n) { return scalbln(x, n); }
+
+
+    double  cbrt(double x);
+    float   cbrtf(float x);
+    real    cbrtl(real x) { return cbrt(x); }
+
+    double  fabs(double x);
+    float   fabsf(float x);
+    real    fabsl(real x) { return fabs(x); }
+
+    double  hypot(double x, double y);
+    float   hypotf(float x, float y);
+    real    hypotl(real x, real y) { return hypot(x, y); }
+
+    double  pow(double x, double y);
+    float   powf(float x, float y);
+    real    powl(real x, real y) { return pow(x, y); }
+
+    double  sqrt(double x);
+    float   sqrtf(float x);
+    real    sqrtl(real x) { return sqrt(x); }
+
+    double  erf(double x);
+    float   erff(float x);
+    real    erfl(real x) { return erf(x); }
+
+    double  erfc(double x);
+    float   erfcf(float x);
+    real    erfcl(real x) { return erfc(x); }
+
+    double  lgamma(double x);
+    float   lgammaf(float x);
+    real    lgammal(real x) { return lgamma(x); }
+
+    double  tgamma(double x);
+    float   tgammaf(float x);
+    real    tgammal(real x) { return tgamma(x); }
+
+    double  ceil(double x);
+    float   ceilf(float x);
+    real    ceill(real x) { return ceil(x); }
+
+    double  floor(double x);
+    float   floorf(float x);
+    real    floorl(real x) { return floor(x); }
+
+    double  nearbyint(double x);
+    float   nearbyintf(float x);
+    real    nearbyintl(real x) { return nearbyint(x); }
+
+    double  rint(double x);
+    float   rintf(float x);
+    real    rintl(real x) { return rint(x); }
+
+    c_long  lrint(double x);
+    c_long  lrintf(float x);
+    c_long  lrintl(real x) { return lrint(x); }
+
+    long    llrint(double x);
+    long    llrintf(float x);
+    long    llrintl(real x) { return llrint(x); }
+
+    double  round(double x);
+    float   roundf(float x);
+    real    roundl(real x) { return round(x); }
+
+    c_long  lround(double x);
+    c_long  lroundf(float x);
+    c_long  lroundl(real x) { return lround(x); }
+
+    long    llround(double x);
+    long    llroundf(float x);
+    long    llroundl(real x) { return llround(x); }
+
+    double  trunc(double x);
+    float   truncf(float x);
+    real    truncl(real x) { return trunc(x); }
+
+    double  fmod(double x, double y);
+    float   fmodf(float x, float y);
+    real    fmodl(real x, real y) { return fmod(x, y); }
+
+    double  remainder(double x, double y);
+    float   remainderf(float x, float y);
+    real    remainderl(real x, real y) { return remainder(x, 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) { return remquo(x, y, quo); }
+
+    double  copysign(double x, double y);
+    float   copysignf(float x, float y);
+    real    copysignl(real x, real y) { return copysign(x, 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) { return nextafter(x, y); }
+
+    double  nexttoward(double x, real y);
+    float   nexttowardf(float x, real y);
+    real    nexttowardl(real x, real y) { return nexttoward(x, y); }
+
+    double  fdim(double x, double y);
+    float   fdimf(float x, float y);
+    real    fdiml(real x, real y) { return fdim(x, y); }
+
+    double  fmax(double x, double y);
+    float   fmaxf(float x, float y);
+    real    fmaxl(real x, real y) { return fmax(x, y); }
+
+    double  fmin(double x, double y);
+    float   fminf(float x, float y);
+    real    fminl(real x, real y) { return fmin(x, 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) { return fma(x, y, z); }
+}
+else
+{
+    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  asin(double x);
+    float   asinf(float x);
+    real    asinl(real x);
 
-double  atan(double x);
-float   atanf(float x);
-real    atanl(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  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  cos(double x);
+    float   cosf(float x);
+    real    cosl(real x);
 
-double  sin(double x);
-float   sinf(float x);
-real    sinl(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  tan(double x);
+    float   tanf(float x);
+    real    tanl(real x);
 
-double  acosh(double x);
-float   acoshf(float x);
-real    acoshl(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  asinh(double x);
+    float   asinhf(float x);
+    real    asinhl(real x);
 
-double  atanh(double x);
-float   atanhf(float x);
-real    atanhl(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  cosh(double x);
+    float   coshf(float x);
+    real    coshl(real x);
 
-double  sinh(double x);
-float   sinhf(float x);
-real    sinhl(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  tanh(double x);
+    float   tanhf(float x);
+    real    tanhl(real x);
 
-double  exp(double x);
-float   expf(float x);
-real    expl(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  exp2(double x);
+    float   exp2f(float x);
+    real    exp2l(real x);
 
-double  expm1(double x);
-float   expm1f(float x);
-real    expm1l(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);
+    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);
+    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  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  log(double x);
+    float   logf(float x);
+    real    logl(real x);
 
-double  log10(double x);
-float   log10f(float x);
-real    log10l(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  log1p(double x);
+    float   log1pf(float x);
+    real    log1pl(real x);
 
-double  log2(double x);
-float   log2f(float x);
-real    log2l(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  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  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  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  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  cbrt(double x);
+    float   cbrtf(float x);
+    real    cbrtl(real x);
 
-double  fabs(double x);
-float   fabsf(float x);
-real    fabsl(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  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  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  sqrt(double x);
+    float   sqrtf(float x);
+    real    sqrtl(real x);
 
-double  erf(double x);
-float   erff(float x);
-real    erfl(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  erfc(double x);
+    float   erfcf(float x);
+    real    erfcl(real x);
 
-double  lgamma(double x);
-float   lgammaf(float x);
-real    lgammal(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  tgamma(double x);
+    float   tgammaf(float x);
+    real    tgammal(real x);
 
-double  ceil(double x);
-float   ceilf(float x);
-real    ceill(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  floor(double x);
+    float   floorf(float x);
+    real    floorl(real x);
 
-double  nearbyint(double x);
-float   nearbyintf(float x);
-real    nearbyintl(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);
+    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);
+    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);
+    long    llrint(double x);
+    long    llrintf(float x);
+    long    llrintl(real x);
 
-double  round(double x);
-float   roundf(float x);
-real    roundl(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);
+    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);
+    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  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  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  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  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  copysign(double x, double y);
+    float   copysignf(float x, float y);
+    real    copysignl(real x, real y);
 
-double  nan(in char* tagp);
-float   nanf(in char* tagp);
-real    nanl(in char* tagp);
+    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  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  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  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  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  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);
+    double  fma(double x, double y, double z);
+    float   fmaf(float x, float y, float z);
+    real    fmal(real x, real y, real z);
+}
\ No newline at end of file