Report a bug
If you spot a problem with this page, click here to create a GitHub issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

mir.math.common

Common floating point math functions.
This module has generic LLVM-oriented API compatible with all D compilers.
License:
Authors:
Ilya Yaroshenko, Phobos Team
alias fmamath = T;
Functions attribute, an alias for AliasSeq!(llvmFastMathFlag("contract"));.
  • 1. Allow floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).

Note Can be used with all compilers.

alias optmath = T;
Functions attribute, an alias for AliasSeq!(llvmFastMathFlag("fast")).
It is similar to fastmath, but does not allow unsafe-fp-math. This flag does NOT force LDC to use the reciprocal of an argument rather than perform division.
This flag is default for string lambdas.

Note Can be used with all compilers.

alias fastmath = TList;
Functions attribute, an alias for ldc.attributes.fastmath .
  • 1. Enable optimizations that make unsafe assumptions about IEEE math (e.g. that addition is associative) or may not work for all input ranges. These optimizations allow the code generator to make use of some instructions which would otherwise not be usable (such as fsin on X86).
  • 2. Allow optimizations to assume the arguments and result are not NaN. Such optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.
  • 3. Allow optimizations to assume the arguments and result are not +`-inf. Such optimizations are required to retain defined behavior over +`-Inf, but the value of the result is undefined.
  • 4. Allow optimizations to treat the sign of a zero argument or result as insignificant.
  • 5. Allow optimizations to use the reciprocal of an argument rather than perform division.
  • 6. Allow floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).
  • 7. Allow algebraically equivalent transformations that may dramatically change results in floating point (e.g. reassociate).

Note Can be used with all compilers.

T sqrt(T)(in T val)
if (isFloatingPoint!T);
T sin(T)(in T val)
if (isFloatingPoint!T);
T cos(T)(in T val)
if (isFloatingPoint!T);
T powi(T)(in T val, int power)
if (isFloatingPoint!T);
T pow(T)(in T val, in T power)
if (isFloatingPoint!T);
T exp(T)(in T val)
if (isFloatingPoint!T);
T log(T)(in T val)
if (isFloatingPoint!T);
T fma(T)(T vala, T valb, T valc)
if (isFloatingPoint!T);
T fabs(T)(in T val)
if (isFloatingPoint!T);
T floor(T)(in T val)
if (isFloatingPoint!T);
T exp2(T)(in T val)
if (isFloatingPoint!T);
T log10(T)(in T val)
if (isFloatingPoint!T);
T log2(T)(in T val)
if (isFloatingPoint!T);
T ceil(T)(in T val)
if (isFloatingPoint!T);
T trunc(T)(in T val)
if (isFloatingPoint!T);
T rint(T)(in T val)
if (isFloatingPoint!T);
T nearbyint(T)(in T val)
if (isFloatingPoint!T);
T copysign(T)(in T mag, in T sgn)
if (isFloatingPoint!T);
T round(T)(in T val)
if (isFloatingPoint!T);
T fmuladd(T)(in T vala, in T valb, in T valc)
if (isFloatingPoint!T);
T fmin(T)(in T vala, in T valb)
if (isFloatingPoint!T);
T fmax(T)(in T vala, in T valb)
if (isFloatingPoint!T);
auto fabs(T)(in T x)
if (isComplex!T);
Overload for cdouble, cfloat and creal
Examples:
assert(fabs(3 + 4i) == 25);
bool approxEqual(T)(const T lhs, const T rhs, const T maxRelDiff = T(9.53674e-07F), const T maxAbsDiff = T(9.53674e-07F));

bool approxEqual(T : cfloat)(const T lhs, const T rhs, float maxRelDiff = 9.53674e-07F, float maxAbsDiff = 9.53674e-07F);

bool approxEqual(T : cdouble)(const T lhs, const T rhs, double maxRelDiff = 9.53674e-07F, double maxAbsDiff = 9.53674e-07F);

bool approxEqual(T : creal)(const T lhs, const T rhs, real maxRelDiff = 9.53674e-07F, real maxAbsDiff = 9.53674e-07F);
Computes whether two values are approximately equal, admitting a maximum relative difference, and a maximum absolute difference.
Parameters:
T lhs First item to compare.
T rhs Second item to compare.
T maxRelDiff Maximum allowable difference relative to rhs. Defaults to 0.5 ^^ 20.
T maxAbsDiff Maximum absolute difference. Defaults to 0.5 ^^ 20.
Returns:
true if the two items are equal or approximately equal under either criterium.
Examples:
assert(approxEqual(1.0, 1.0000001));
assert(approxEqual(1.0f, 1.0000001f));
assert(approxEqual(1.0L, 1.0000001L));

assert(approxEqual(10000000.0, 10000001));
assert(approxEqual(10000000f, 10000001f));
assert(!approxEqual(100000.0L, 100001L));
Examples:
Complex types works as approxEqual(l.re, r.re) && approxEqual(l.im, r.im)
assert(approxEqual(1.0 + 1i, 1.0000001 + 1.0000001i));
assert(!approxEqual(100000.0L + 0i, 100001L + 0i));