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.
Authors:
Ilya Yaroshenko
fmamath
Functions attribute, an alias for AliasSeq!(llvmFastMathFlag("contract"));.
  • 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.

optmath
Functions attribute, an alias for AliasSeq!(llvmAttr("unsafe-fp-math", "false"), 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.

fastmath
Functions attribute, an alias for ldc.attributes.fastmath = AliasSeq!(llvmAttr("unsafe-fp-math", "true"), llvmFastMathFlag("fast")) .
  • 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).
  • 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.
  • 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.
  • Allow optimizations to treat the sign of a zero argument or result as insignificant.
  • Allow optimizations to use the reciprocal of an argument rather than perform division.
  • Allow floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).
  • 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 x)
if (isFloatingPoint!T);
T sin(T)(in T x)
if (isFloatingPoint!T);
T cos(T)(in T x)
if (isFloatingPoint!T);
T pow(T)(in T x, in T power)
if (isFloatingPoint!T);
T powi(T)(in T x, int power)
if (isFloatingPoint!T);
T exp(T)(in T x)
if (isFloatingPoint!T);
T log(T)(in T x)
if (isFloatingPoint!T);
T fabs(T)(in T x)
if (isFloatingPoint!T);
T floor(T)(in T x)
if (isFloatingPoint!T);
T exp2(T)(in T x)
if (isFloatingPoint!T);
T log10(T)(in T x)
if (isFloatingPoint!T);
T log2(T)(in T x)
if (isFloatingPoint!T);
T ceil(T)(in T x)
if (isFloatingPoint!T);
T trunc(T)(in T x)
if (isFloatingPoint!T);
T rint(T)(in T x)
if (isFloatingPoint!T);
T nearbyint(T)(in T x)
if (isFloatingPoint!T);
T copysign(T)(in T mag, in T sgn)
if (isFloatingPoint!T);
T round(T)(in T x)
if (isFloatingPoint!T);
T fmuladd(T)(in T a, in T b, in T c)
if (isFloatingPoint!T);
T fmin(T)(in T x, in T y)
if (isFloatingPoint!T);
T fmax(T)(in T x, in T y)
if (isFloatingPoint!T);