Floating-point environment. Handling of floating-point rounding and exceptions (overflow, division by zero, etc.).

Tfenv {...}{.importc: "fenv_t", header: "<fenv.h>", final, pure.} = object

- Represents the entire floating-point environment. The floating-point environment refers collectively to any floating-point status flags and control modes supported by the implementation.
Tfexcept {...}{.importc: "fexcept_t", header: "<fenv.h>", final, pure.} = object

- Represents the floating-point status flags collectively, including any status the implementation associates with the flags. A floating-point status flag is a system variable whose value is set (but never cleared) when a floating-point exception is raised, which occurs as a side effect of exceptional floating-point arithmetic to provide auxiliary information. A floating-point control mode is a system variable whose value may be set by the user to affect the subsequent behavior of floating-point arithmetic.

FE_DIVBYZERO: cint

- division by zero
FE_INEXACT: cint

- inexact result
FE_INVALID: cint

- invalid operation
FE_OVERFLOW: cint

- result not representable due to overflow
FE_UNDERFLOW: cint

- result not representable due to underflow
FE_ALL_EXCEPT: cint

- bitwise OR of all supported exceptions
FE_DOWNWARD: cint

- round toward -Inf
FE_TONEAREST: cint

- round to nearest
FE_TOWARDZERO: cint

- round toward 0
FE_UPWARD: cint

- round toward +Inf
FE_DFL_ENV: cint

- macro of type pointer to fenv_t to be used as the argument to functions taking an argument of type fenv_t; in this case the default environment will be used

proc feclearexcept(excepts: cint): cint {...}{.importc, header: "<fenv.h>".}

- Clear the supported exceptions represented by
*excepts*. proc fegetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint {...}{.importc, header: "<fenv.h>".}

- Store implementation-defined representation of the exception flags indicated by
*excepts*in the object pointed to by*flagp*. proc feraiseexcept(excepts: cint): cint {...}{.importc, header: "<fenv.h>".}

- Raise the supported exceptions represented by
*excepts*. proc fesetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint {...}{.importc, header: "<fenv.h>".}

- Set complete status for exceptions indicated by
*excepts*according to the representation in the object pointed to by*flagp*. proc fetestexcept(excepts: cint): cint {...}{.importc, header: "<fenv.h>".}

- Determine which of subset of the exceptions specified by
*excepts*are currently set. proc fegetround(): cint {...}{.importc, header: "<fenv.h>".}

- Get current rounding direction.
proc fesetround(roundingDirection: cint): cint {...}{.importc, header: "<fenv.h>".}

- Establish the rounding direction represented by
*roundingDirection*. proc fegetenv(envp: ptr Tfenv): cint {...}{.importc, header: "<fenv.h>".}

- Store the current floating-point environment in the object pointed to by
*envp*. proc feholdexcept(envp: ptr Tfenv): cint {...}{.importc, header: "<fenv.h>".}

- Save the current environment in the object pointed to by
*envp*, clear exception flags and install a non-stop mode (if available) for all exceptions. proc fesetenv(a1: ptr Tfenv): cint {...}{.importc, header: "<fenv.h>".}

- Establish the floating-point environment represented by the object pointed to by
*envp*. proc feupdateenv(envp: ptr Tfenv): cint {...}{.importc, header: "<fenv.h>".}

- Save current exceptions in temporary storage, install environment represented by object pointed to by
*envp*and raise exceptions according to saved exceptions.

template fpRadix(): int

- The (integer) value of the radix used to represent any floating point type on the architecture used to build the program.
template mantissaDigits(T: typedesc[float32]): int

- Number of digits (in base
`floatingPointRadix`

) in the mantissa of 32-bit floating-point numbers. template digits(T: typedesc[float32]): int

- Number of decimal digits that can be represented in a 32-bit floating-point type without losing precision.
template minExponent(T: typedesc[float32]): int

- Minimum (negative) exponent for 32-bit floating-point numbers.
template maxExponent(T: typedesc[float32]): int

- Maximum (positive) exponent for 32-bit floating-point numbers.
template min10Exponent(T: typedesc[float32]): int

- Minimum (negative) exponent in base 10 for 32-bit floating-point numbers.
template max10Exponent(T: typedesc[float32]): int

- Maximum (positive) exponent in base 10 for 32-bit floating-point numbers.
template minimumPositiveValue(T: typedesc[float32]): float32

- The smallest positive (nonzero) number that can be represented in a 32-bit floating-point type.
template maximumPositiveValue(T: typedesc[float32]): float32

- The largest positive number that can be represented in a 32-bit floating-point type.
template epsilon(T: typedesc[float32]): float32

- The difference between 1.0 and the smallest number greater than 1.0 that can be represented in a 32-bit floating-point type.
template mantissaDigits(T: typedesc[float64]): int

- Number of digits (in base
`floatingPointRadix`

) in the mantissa of 64-bit floating-point numbers. template digits(T: typedesc[float64]): int

- Number of decimal digits that can be represented in a 64-bit floating-point type without losing precision.
template minExponent(T: typedesc[float64]): int

- Minimum (negative) exponent for 64-bit floating-point numbers.
template maxExponent(T: typedesc[float64]): int

- Maximum (positive) exponent for 64-bit floating-point numbers.
template min10Exponent(T: typedesc[float64]): int

- Minimum (negative) exponent in base 10 for 64-bit floating-point numbers.
template max10Exponent(T: typedesc[float64]): int

- Maximum (positive) exponent in base 10 for 64-bit floating-point numbers.
template minimumPositiveValue(T: typedesc[float64]): float64

- The smallest positive (nonzero) number that can be represented in a 64-bit floating-point type.
template maximumPositiveValue(T: typedesc[float64]): float64

- The largest positive number that can be represented in a 64-bit floating-point type.
template epsilon(T: typedesc[float64]): float64

- The difference between 1.0 and the smallest number greater than 1.0 that can be represented in a 64-bit floating-point type.

© 2006–2018 Andreas Rumpf

Licensed under the MIT License.

https://nim-lang.org/docs/fenv.html