Commits

Anonymous committed 0b61c85 Merge

Added @safe pure nothrow again

Comments (0)

Files changed (1)

d/druntime/core/stdc/math.d

-/**
- * D header file for C99.
- *
- * Copyright: Copyright Sean Kelly 2005 - 2009.
- * License:   <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
- * Authors:   Sean Kelly
- * Standards: ISO/IEC 9899:1999 (E)
- */
-
-/*          Copyright Sean Kelly 2005 - 2009.
- * Distributed under the Boost Software License, Version 1.0.
- *    (See accompanying file LICENSE_1_0.txt or copy at
- *          http://www.boost.org/LICENSE_1_0.txt)
- */
-
-/* NOTE: This file has been patched from the original DMD distribution to
-   work with the GDC compiler.
-*/
-module core.stdc.math;
-
-version(GNU) import gcc.builtins;
-
-private import core.stdc.config;
-
-extern (C):
-nothrow:
-
-alias float  float_t;
-alias double double_t;
-
-enum double HUGE_VAL      = double.infinity;
-enum double HUGE_VALF     = float.infinity;
-enum double HUGE_VALL     = real.infinity;
-
-enum float INFINITY       = float.infinity;
-enum float NAN            = float.nan;
-
-enum int FP_ILOGB0        = int.min;
-enum int FP_ILOGBNAN      = int.min;
-
-enum int MATH_ERRNO       = 1;
-enum int MATH_ERREXCEPT   = 2;
-enum 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( Windows )
-    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( OSX )
-{
-    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);
-    }
-  }
-}
-else version( FreeBSD )
-{
-    enum
-    {
-        FP_INFINITE  = 0x01,
-        FP_NAN       = 0x02,
-        FP_NORMAL    = 0x04,
-        FP_SUBNORMAL = 0x08,
-        FP_ZERO      = 0x10,
-    }
-
-    enum
-    {
-        FP_FAST_FMA  = 0,
-        FP_FAST_FMAF = 0,
-        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);
-
-  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 isfinite(real-floating x);
-    int isfinite(float x)       { return __isfinitef(x); }
-    int isfinite(double x)      { return __isfinite(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 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 isnormal(real-floating x);
-    int isnormal(float x)       { return __isnormalf(x); }
-    int isnormal(double x)      { return __isnormal(x); }
-    int isnormal(real x)        { return __isnormall(x); }
-
-    //int signbit(real-floating x);
-    int signbit(float x)        { return __signbitf(x); }
-    int signbit(double x)       { return __signbit(x); }
-    int signbit(real x)         { return __signbit(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); }
-}
-
-/**
- * FreeBSD is missing a few symbols in -lm, so for the symbols that are missing,
- * we use the lower resolution double versions for the long double functions.
- *
- * For everything else we use the GCC builtins.
- **/
-version( GNU )
-{
-    alias __builtin_acos  acos;
-    alias __builtin_acosf acosf;
-    alias __builtin_acosl acosl;
-
-    alias __builtin_asin  asin;
-    alias __builtin_asinf asinf;
-    alias __builtin_asinl asinl;
-
-    alias __builtin_atan  atan;
-    alias __builtin_atanf atanf;
-    alias __builtin_atanl atanl;
-
-    alias __builtin_atan2  atan2;
-    alias __builtin_atan2f atan2f;
-    alias __builtin_atan2l atan2l;
-
-    alias __builtin_cos  cos;
-    alias __builtin_cosf cosf;
-    alias __builtin_cosl cosl;
-
-    alias __builtin_sin  sin;
-    alias __builtin_sinf sinf;
-    alias __builtin_sinl sinl;
-
-    alias __builtin_tan  tan;
-    alias __builtin_tanf tanf;
-    alias __builtin_tanl tanl;
-
-    alias __builtin_acosh  acosh;
-    alias __builtin_acoshf acoshf;
-    alias __builtin_acoshl acoshl;
-
-    alias __builtin_asinh  asinh;
-    alias __builtin_asinhf asinhf;
-    alias __builtin_asinhl asinhl;
-
-    alias __builtin_atanh  atanh;
-    alias __builtin_atanhf atanhf;
-    alias __builtin_atanhl atanhl;
-
-    alias __builtin_cosh  cosh;
-    alias __builtin_coshf coshf;
-    alias __builtin_coshl coshl;
-
-    alias __builtin_sinh  sinh;
-    alias __builtin_sinhf sinhf;
-    alias __builtin_sinhl sinhl;
-
-    alias __builtin_tanh  tanh;
-    alias __builtin_tanhf tanhf;
-    alias __builtin_tanhl tanhl;
-
-    alias __builtin_exp  exp;
-    alias __builtin_expf expf;
-    alias __builtin_expl expl;
-
-    alias __builtin_exp2  exp2;
-    alias __builtin_exp2f exp2f;
-    alias __builtin_exp2l exp2l;
-
-    alias __builtin_expm1  expm1;
-    alias __builtin_expm1f expm1f;
-    alias __builtin_expm1l expm1l;
-
-    alias __builtin_frexp  frexp;
-    alias __builtin_frexpf frexpf;
-    alias __builtin_frexpl frexpl;
-
-    alias __builtin_ilogb  ilogb;
-    alias __builtin_ilogbf ilogbf;
-    alias __builtin_ilogbl ilogbl;
-
-    alias __builtin_ldexp  ldexp;
-    alias __builtin_ldexpf ldexpf;
-    alias __builtin_ldexpl ldexpl;
-
-    alias __builtin_log  log;
-    alias __builtin_logf logf;
-
-    version(FreeBSD) real logl(real x) { return log(x); }
-    else alias __builtin_logl logl;
-
-    alias __builtin_log10  log10;
-    alias __builtin_log10f log10f;
-
-    version(FreeBSD) real log10l(real x) { return log10(x); }
-    else alias __builtin_log10l log10l;
-
-    alias __builtin_log1p  log1p;
-    alias __builtin_log1pf log1pf;
-
-    version(FreeBSD) real log1pl(real x) { return log1pl(x); }
-    else alias __builtin_log1pl log1pl;
-
-    alias __builtin_log2  log2;
-    alias __builtin_log2f log2f;
-    alias __builtin_log2l log2l;
-
-    alias __builtin_logb  logb;
-    alias __builtin_logbf logbf;
-    alias __builtin_logbl logbl;
-
-    alias __builtin_modf  modf;
-    alias __builtin_modff modff;
-    alias __builtin_modfl modfl;
-
-    alias __builtin_scalbn  scalbn;
-    alias __builtin_scalbnf scalbnf;
-    alias __builtin_scalbnl scalbnl;
-
-    alias __builtin_scalbln  scalbln;
-    alias __builtin_scalblnf scalblnf;
-    alias __builtin_scalblnl scalblnl;
-
-    alias __builtin_cbrt  cbrt;
-    alias __builtin_cbrtf cbrtf;
-
-    version(FreeBSD) real cbrtl(real x) { return cbrt(x); }
-    else alias __builtin_cbrtl cbrtl;
-
-    alias __builtin_fabs  fabs;
-    alias __builtin_fabsf fabsf;
-    alias __builtin_fabsl fabsl;
-
-    alias __builtin_hypot  hypot;
-    alias __builtin_hypotf hypotf;
-    alias __builtin_hypotl hypotl;
-
-    alias __builtin_pow  pow;
-    alias __builtin_powf powf;
-    alias __builtin_powl powl;
-
-    alias __builtin_sqrt  sqrt;
-    alias __builtin_sqrtf sqrtf;
-    alias __builtin_sqrtl sqrtl;
-
-    alias __builtin_erf  erf;
-    alias __builtin_erff erff;
-
-    version(FreeBSD) real erfl(real x) { return erfl(x); }
-    else alias __builtin_erfl erfl;
-
-    alias __builtin_erfc  erfc;
-    alias __builtin_erfcf erfcf;
-
-    version(FreeBSD) real erfcl(real x) { return erfc(x); }
-    else alias __builtin_erfcl erfcl;
-
-    alias __builtin_lgamma  lgamma;
-    alias __builtin_lgammaf lgammaf;
-
-    version(FreeBSD) real lgammal(real x) { return lgammal(x); }
-    else alias __builtin_lgammal lgammal;
-
-    alias __builtin_tgamma  tgamma;
-    alias __builtin_tgammaf tgammaf;
-
-    version(FreeBSD) real tgammal(real x) { return tgamma(x); }
-    else alias __builtin_tgammal tgammal;
-
-    alias __builtin_ceil  ceil;
-    alias __builtin_ceilf ceilf;
-    alias __builtin_ceill ceill;
-
-    alias __builtin_floor  floor;
-    alias __builtin_floorf floorf;
-    alias __builtin_floorl floorl;
-
-    alias __builtin_nearbyint  nearbyint;
-    alias __builtin_nearbyintf nearbyintf;
-    alias __builtin_nearbyintl nearbyintl;
-
-    alias __builtin_rint  rint;
-    alias __builtin_rintf rintf;
-    alias __builtin_rintl rintl;
-
-    alias __builtin_lrint  lrint;
-    alias __builtin_lrintf lrintf;
-    alias __builtin_lrintl lrintl;
-
-    alias __builtin_llrint  llrint;
-    alias __builtin_llrintf llrintf;
-    alias __builtin_llrintl llrintl;
-
-    alias __builtin_round  round;
-    alias __builtin_roundf roundf;
-    alias __builtin_roundl roundl;
-
-    alias __builtin_lround  lround;
-    alias __builtin_lroundf lroundf;
-    alias __builtin_lroundl lroundl;
-
-    alias __builtin_llround  llround;
-    alias __builtin_llroundf llroundf;
-    alias __builtin_llroundl llroundl;
-
-    alias __builtin_trunc  trunc;
-    alias __builtin_truncf truncf;
-    alias __builtin_truncl truncl;
-
-    alias __builtin_fmod  fmod;
-    alias __builtin_fmodf fmodf;
-    alias __builtin_fmodl fmodl;
-
-    alias __builtin_remainder  remainder;
-    alias __builtin_remainderf remainderf;
-    alias __builtin_remainderl remainderl;
-
-    alias __builtin_remquo  remquo;
-    alias __builtin_remquof remquof;
-    alias __builtin_remquol remquol;
-
-    alias __builtin_copysign  copysign;
-    alias __builtin_copysignf copysignf;
-    alias __builtin_copysignl copysignl;
-
-    alias __builtin_nan  nan;
-    alias __builtin_nanf nanf;
-    alias __builtin_nanl nanl;
-
-    alias __builtin_nextafter  nextafter;
-    alias __builtin_nextafterf nextafterf;
-    alias __builtin_nextafterl nextafterl;
-
-    alias __builtin_nexttoward  nexttoward;
-    alias __builtin_nexttowardf nexttowardf;
-    alias __builtin_nexttowardl nexttowardl;
-
-    alias __builtin_fdim  fdim;
-    alias __builtin_fdimf fdimf;
-    alias __builtin_fdiml fdiml;
-
-    alias __builtin_fmax  fmax;
-    alias __builtin_fmaxf fmaxf;
-    alias __builtin_fmaxl fmaxl;
-
-    alias __builtin_fmin  fmin;
-    alias __builtin_fminf fminf;
-    alias __builtin_fminl fminl;
-
-    alias __builtin_fma  fma;
-    alias __builtin_fmaf fmaf;
-    alias __builtin_fmal fmal;
-}
-/* NOTE: freebsd < 8-CURRENT doesn't appear to support *l, but we can
- *       approximate.
- * A lot of them were added in 8.0-RELEASE, and so a lot of these workarounds
- * should then be removed.
- */
-// NOTE: FreeBSD 8.0-RELEASE doesn't support log2* nor these *l functions:
-//         acoshl, asinhl, atanhl, coshl, sinhl, tanhl, cbrtl, powl, expl,
-//         expm1l, logl, log1pl, log10l, erfcl, erfl, lgammal, tgammal;
-//       but we can approximate.
-else version( FreeBSD )
-{
-  version (all) // < 8-CURRENT
-  {
-    real    acosl(real x) { return acos(x); }
-    real    asinl(real x) { return asin(x); }
-    real    atanl(real x) { return atan(x); }
-    real    atan2l(real y, real x) { return atan2(y, x); }
-    real    cosl(real x) { return cos(x); }
-    real    sinl(real x) { return sin(x); }
-    real    tanl(real x) { return tan(x); }
-    real    exp2l(real x) { return exp2(x); }
-    real    frexpl(real value, int* exp) { return frexp(value, exp); }
-    int     ilogbl(real x) { return ilogb(x); }
-    real    ldexpl(real x, int exp) { return ldexp(x, exp); }
-    real    logbl(real x) { return logb(x); }
-    //real    modfl(real value, real *iptr); // nontrivial conversion
-    real    scalbnl(real x, int n) { return scalbn(x, n); }
-    real    scalblnl(real x, c_long n) { return scalbln(x, n); }
-    real    fabsl(real x) { return fabs(x); }
-    real    hypotl(real x, real y) { return hypot(x, y); }
-    real    sqrtl(real x) { return sqrt(x); }
-    real    ceill(real x) { return ceil(x); }
-    real    floorl(real x) { return floor(x); }
-    real    nearbyintl(real x) { return nearbyint(x); }
-    real    rintl(real x) { return rint(x); }
-    c_long  lrintl(real x) { return lrint(x); }
-    real    roundl(real x) { return round(x); }
-    c_long  lroundl(real x) { return lround(x); }
-    long    llroundl(real x) { return llround(x); }
-    real    truncl(real x) { return trunc(x); }
-    real    fmodl(real x, real y) { return fmod(x, y); }
-    real    remainderl(real x, real y) { return remainder(x, y); }
-    real    remquol(real x, real y, int* quo) { return remquo(x, y, quo); }
-    real    copysignl(real x, real y) { return copysign(x, y); }
-//  double  nan(char* tagp);
-//  float   nanf(char* tagp);
-//  real    nanl(char* tagp);
-    real    nextafterl(real x, real y) { return nextafter(x, y); }
-    real    nexttowardl(real x, real y) { return nexttoward(x, y); }
-    real    fdiml(real x, real y) { return fdim(x, y); }
-    real    fmaxl(real x, real y) { return fmax(x, y); }
-    real    fminl(real x, real y) { return fmin(x, y); }
-    real    fmal(real x, real y, real z) { return fma(x, y, z); }
-  }
-  else
-  {
-    real    acosl(real x);
-    real    asinl(real x);
-    real    atanl(real x);
-    real    atan2l(real y, real x);
-    real    cosl(real x);
-    real    sinl(real x);
-    real    tanl(real x);
-    real    exp2l(real x);
-    real    frexpl(real value, int* exp);
-    int     ilogbl(real x);
-    real    ldexpl(real x, int exp);
-    real    logbl(real x);
-    real    modfl(real value, real *iptr);
-    real    scalbnl(real x, int n);
-    real    scalblnl(real x, c_long n);
-    real    fabsl(real x);
-    real    hypotl(real x, real y);
-    real    sqrtl(real x);
-    real    ceill(real x);
-    real    floorl(real x);
-    real    nearbyintl(real x);
-    real    rintl(real x);
-    c_long  lrintl(real x);
-    real    roundl(real x);
-    c_long  lroundl(real x);
-    long    llroundl(real x);
-    real    truncl(real x);
-    real    fmodl(real x, real y);
-    real    remainderl(real x, real y);
-    real    remquol(real x, real y, int* quo);
-    real    copysignl(real x, real y);
-    double  nan(char* tagp);
-    float   nanf(char* tagp);
-    real    nanl(char* tagp);
-    real    nextafterl(real x, real y);
-    real    nexttowardl(real x, real y);
-    real    fdiml(real x, real y);
-    real    fmaxl(real x, real y);
-    real    fminl(real x, real y);
-    real    fmal(real x, real y, real z);
-  }
-    double  acos(double x);
-    float   acosf(float x);
-
-    double  asin(double x);
-    float   asinf(float x);
-
-    double  atan(double x);
-    float   atanf(float x);
-
-    double  atan2(double y, double x);
-    float   atan2f(float y, float x);
-
-    double  cos(double x);
-    float   cosf(float x);
-
-    double  sin(double x);
-    float   sinf(float x);
-
-    double  tan(double x);
-    float   tanf(float 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);
-
-    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);
-
-    int     ilogb(double x);
-    int     ilogbf(float x);
-
-    double  ldexp(double x, int exp);
-    float   ldexpf(float x, int 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 enum 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);
-
-    double  modf(double value, double* iptr);
-    float   modff(float value, float* iptr);
-
-    double  scalbn(double x, int n);
-    float   scalbnf(float x, int n);
-
-    double  scalbln(double x, c_long n);
-    float   scalblnf(float x, c_long n);
-
-    double  cbrt(double x);
-    float   cbrtf(float x);
-    real    cbrtl(real x) { return cbrt(x); }
-
-    double  fabs(double x);
-    float   fabsf(float x);
-
-    double  hypot(double x, double y);
-    float   hypotf(float x, float 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);
-
-    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);
-
-    double  floor(double x);
-    float   floorf(float x);
-
-    double  nearbyint(double x);
-    float   nearbyintf(float x);
-
-    double  rint(double x);
-    float   rintf(float x);
-
-    c_long  lrint(double x);
-    c_long  lrintf(float x);
-
-    long    llrint(double x);
-    long    llrintf(float x);
-    long    llrintl(real x) { return llrint(x); }
-
-    double  round(double x);
-    float   roundf(float x);
-
-    c_long  lround(double x);
-    c_long  lroundf(float x);
-
-    long    llround(double x);
-    long    llroundf(float x);
-
-    double  trunc(double x);
-    float   truncf(float x);
-
-    double  fmod(double x, double y);
-    float   fmodf(float x, float y);
-
-    double  remainder(double x, double y);
-    float   remainderf(float x, float y);
-
-    double  remquo(double x, double y, int* quo);
-    float   remquof(float x, float y, int* quo);
-
-    double  copysign(double x, double y);
-    float   copysignf(float x, float y);
-
-    double  nextafter(double x, double y);
-    float   nextafterf(float x, float y);
-
-    double  nexttoward(double x, real y);
-    float   nexttowardf(float x, real y);
-
-    double  fdim(double x, double y);
-    float   fdimf(float x, float y);
-
-    double  fmax(double x, double y);
-    float   fmaxf(float x, float y);
-
-    double  fmin(double x, double y);
-    float   fminf(float x, float y);
-
-    double  fma(double x, double y, double z);
-    float   fmaf(float x, float y, float 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  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);
-}