# std/fenv

Theme:

- Manual
- Standard library
- Index
- Compiler docs
- Fusion docs
- devel, stable

Search:
Source Edit

Floating-point environment. Handling of floating-point rounding and exceptions (overflow, division by zero, etc.). The types, vars and procs are bindings for the C standard library <fenv.h> header.

# Types

    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. Source Edit

    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. Source Edit

# Vars

    FE_ALL_EXCEPT {.importc, header: "<fenv.h>".}: cint

  bitwise OR of all supported exceptions Source Edit

    FE_DFL_ENV {.importc, header: "<fenv.h>".}: 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 Source Edit

    FE_DIVBYZERO {.importc, header: "<fenv.h>".}: cint

  division by zero Source Edit

    FE_DOWNWARD {.importc, header: "<fenv.h>".}: cint

  round toward -Inf Source Edit

    FE_INEXACT {.importc, header: "<fenv.h>".}: cint

  inexact result Source Edit

    FE_INVALID {.importc, header: "<fenv.h>".}: cint

  invalid operation Source Edit

    FE_OVERFLOW {.importc, header: "<fenv.h>".}: cint

  result not representable due to overflow Source Edit

    FE_TONEAREST {.importc, header: "<fenv.h>".}: cint

  round to nearest Source Edit

    FE_TOWARDZERO {.importc, header: "<fenv.h>".}: cint

  round toward 0 Source Edit

    FE_UNDERFLOW {.importc, header: "<fenv.h>".}: cint

  result not representable due to underflow Source Edit

    FE_UPWARD {.importc, header: "<fenv.h>".}: cint

  round toward +Inf Source Edit

# Procs

    proc feclearexcept(excepts: cint): cint {.importc, header: "<fenv.h>",
        ...raises: [], tags: [], forbids: [].}

  Clear the supported exceptions represented by `excepts`. Source Edit

    proc fegetenv(envp: ptr Tfenv): cint {.importc, header: "<fenv.h>", ...raises: [],
                                           tags: [], forbids: [].}

  Store the current floating-point environment in the object pointed to by `envp`. Source Edit

    proc fegetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint {.importc,
        header: "<fenv.h>", ...raises: [], tags: [], forbids: [].}

  Store implementation-defined representation of the exception flags indicated by `excepts` in the object pointed to by `flagp`. Source Edit

    proc fegetround(): cint {.importc, header: "<fenv.h>", ...raises: [], tags: [],
                              forbids: [].}

  Get current rounding direction. Source Edit

    proc feholdexcept(envp: ptr Tfenv): cint {.importc, header: "<fenv.h>",
        ...raises: [], tags: [], forbids: [].}

  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. Source Edit

    proc feraiseexcept(excepts: cint): cint {.importc, header: "<fenv.h>",
        ...raises: [], tags: [], forbids: [].}

  Raise the supported exceptions represented by `excepts`. Source Edit

    proc fesetenv(a1: ptr Tfenv): cint {.importc, header: "<fenv.h>", ...raises: [],
                                         tags: [], forbids: [].}

  Establish the floating-point environment represented by the object pointed to by `envp`. Source Edit

    proc fesetexceptflag(flagp: ptr Tfexcept; excepts: cint): cint {.importc,
        header: "<fenv.h>", ...raises: [], tags: [], forbids: [].}

  Set complete status for exceptions indicated by `excepts` according to the representation in the object pointed to by `flagp`. Source Edit

    proc fesetround(roundingDirection: cint): cint {.importc, header: "<fenv.h>",
        ...raises: [], tags: [], forbids: [].}

  Establish the rounding direction represented by `roundingDirection`. Source Edit

    proc fetestexcept(excepts: cint): cint {.importc, header: "<fenv.h>",
        ...raises: [], tags: [], forbids: [].}

  Determine which of subset of the exceptions specified by `excepts` are currently set. Source Edit

    proc feupdateenv(envp: ptr Tfenv): cint {.importc, header: "<fenv.h>",
        ...raises: [], tags: [], forbids: [].}

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

# Templates

    template digits(T: typedesc[float32]): int

  Number of decimal digits that can be represented in a 32-bit floating-point type without losing precision. Source Edit

    template digits(T: typedesc[float64]): int

  Number of decimal digits that can be represented in a 64-bit floating-point type without losing precision. Source Edit

    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. Source Edit

    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. Source Edit

    template fpRadix(): int

  The (integer) value of the radix used to represent any floating point type on the architecture used to build the program. Source Edit

    template mantissaDigits(T: typedesc[float32]): int

  Number of digits (in base `floatingPointRadix`) in the mantissa of 32-bit floating-point numbers. Source Edit

    template mantissaDigits(T: typedesc[float64]): int

  Number of digits (in base `floatingPointRadix`) in the mantissa of 64-bit floating-point numbers. Source Edit

    template max10Exponent(T: typedesc[float32]): int

  Maximum (positive) exponent in base 10 for 32-bit floating-point numbers. Source Edit

    template max10Exponent(T: typedesc[float64]): int

  Maximum (positive) exponent in base 10 for 64-bit floating-point numbers. Source Edit

    template maxExponent(T: typedesc[float32]): int

  Maximum (positive) exponent for 32-bit floating-point numbers. Source Edit

    template maxExponent(T: typedesc[float64]): int

  Maximum (positive) exponent for 64-bit floating-point numbers. Source Edit

    template maximumPositiveValue(T: typedesc[float32]): float32

  The largest positive number that can be represented in a 32-bit floating-point type. Source Edit

    template maximumPositiveValue(T: typedesc[float64]): float64

  The largest positive number that can be represented in a 64-bit floating-point type. Source Edit

    template min10Exponent(T: typedesc[float32]): int

  Minimum (negative) exponent in base 10 for 32-bit floating-point numbers. Source Edit

    template min10Exponent(T: typedesc[float64]): int

  Minimum (negative) exponent in base 10 for 64-bit floating-point numbers. Source Edit

    template minExponent(T: typedesc[float32]): int

  Minimum (negative) exponent for 32-bit floating-point numbers. Source Edit

    template minExponent(T: typedesc[float64]): int

  Minimum (negative) exponent for 64-bit floating-point numbers. Source Edit

    template minimumPositiveValue(T: typedesc[float32]): float32

  The smallest positive (nonzero) number that can be represented in a 32-bit floating-point type. Source Edit

    template minimumPositiveValue(T: typedesc[float64]): float64

  The smallest positive (nonzero) number that can be represented in a 64-bit floating-point type. Source Edit