std
std.array
std.atomic
std.bitarray
std.exception
std.intrinsic
std.memory
std.regexp
std.thread
std.traits
std.unicode
std.vararg
std.math.core
std.math.ieee
std.math.special
|
|
std.math.ieee
- real rndtonl(real x);
- Returns x rounded to a long value using the FE_TONEAREST rounding mode.
If the integer value of x is
greater than long.max, the result is
indeterminate.
- real frexp(real value, out int exp);
- Separate floating point value into significand and exponent.
Returns:
Calculate and return x and exp such that
value =x*2 and
.5 <= |x| < 1.0
x has same sign as value.
- real ldexp(real n, int exp);
- Compute n * 2
References:
frexp
- int ilogb(real x);
- Extracts the exponent of x as a signed integral value.
If x is not a special value, the result is the same as
cast(int)logb(x).
- real logb(real x);
- Extracts the exponent of x as a signed integral value.
If x is subnormal, it is treated as if it were normalized.
For a positive, finite x:
1 <= x * FLT_RADIX < FLT_RADIX
- real scalbn(real x, int n);
- Efficiently calculates x * 2.
scalbn handles underflow and overflow in
the same fashion as the basic arithmetic operators.
- real nextafter(real x, real y);
- Calculates the next representable value after x in the direction of y.
If y > x, the result will be the next largest floating-point value;
if y < x, the result will be the next smallest value.
If x == y, the result is y.
The FE_INEXACT and FE_OVERFLOW exceptions will be raised if x is finite and
the function result is infinite. The FE_INEXACT and FE_UNDERFLOW
exceptions will be raised if the function value is subnormal, and x is
not equal to y.
- real nan(char[] tagp);
- Creates a quiet NAN with the information from tagp[] embedded in it.
- real fdim(real x, real y);
- Returns the positive difference between x and y.
Returns:
x, y | fdim(x, y)
| x > y | x - y
| x <= y | +0.0
|
- real fabs(real x);
- Returns |x|
- real fma(real x, real y, real z);
- Returns (x * y) + z, rounding only once according to the
current rounding mode.
- creal fcis(ireal y);
- Calculate cos(y) + i sin(y).
On x86 CPUs, this is a very efficient operation;
almost twice as fast as calculating sin(y) and cos(y)
seperately, and is the preferred method when both are required.
- int isnormal(float x);
int isnormal(double d);
int isnormal(real e);
- Returns !=0 if x is normalized.
(Need one for each format because subnormal
floats might be converted to normal reals)
|