www.digitalmars.com Home | Search | D | Comments
Last update Sat Mar 18 23:51:29 2006
D
Language
Phobos
Comparisons


object

std
 std.base64
 std.boxer
 std.compiler
 std.conv
 std.cover
 std.ctype
 std.date
 std.demangle
 std.file
 std.format
 std.gc
 std.intrinsic
 std.math
 std.md5
 std.mmfile
 std.openrj
 std.outbuffer
 std.path
 std.process
 std.random
 std.recls
 std.regexp
 std.socket
 std.socketstream
 std.stdint
 std.stdio
 std.cstream
 std.stream
 std.string
 std.system
 std.thread
 std.uri
 std.utf
 std.zip
 std.zlib
 std.c.fenv
 std.c.math
 std.c.process
 std.c.stdarg
 std.c.stddef
 std.c.stdio
 std.c.stdlib
 std.c.string
 std.c.time
 std.c.wcharh
 std.windows.charset

std.windows

std.linux

std.c.windows

std.c.linux

std.c.math

C's <math.h>

Authors:
Walter Bright, Digital Mars, www.digitalmars.com

License:
Public Domain

alias float_t;


alias double_t;


const double HUGE_VAL;
const float HUGE_VALF;
const real HUGE_VALL;


const float INFINITY;


const float NAN;


FP_INFINITE


FP_NAN


FP_NORMAL


FP_SUBNORMAL


FP_ZERO


FP_FAST_FMA


FP_FAST_FMAF


FP_FAST_FMAL


const int FP_ILOGB0;


const int FP_ILOGBNAN;


const int MATH_ERRNO;


const int MATH_ERREXCEPT;


const int math_errhandling;


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, int n);
float scalblnf(float x, int n);
real scalblnl(real x, int 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);


int lrint(double x);
int lrintf(float x);
int 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);


int lround(double x);
int lroundf(float x);
int 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);


int isgreater(real x, real y);


int isgreaterequal(real x, real y);


int isless(real x, real y);


int islessequal(real x, real y);


int islessgreater(real x, real y);


int isunordered(real x, real y);