# ieee_arithmetic: IEEE Arithmetic Facilities Module

## Table of Contents

- 1 Name
- 2 Usage
- 3 Synopsis
- 4 Derived-Type Description
- 5 Parameter Description
- 6 Operator Description
- 7 Procedure Description
- 8 See Also
- 9 Bugs

## 1 Name

`ieee_arithmetic` — Intrinsic module providing IEEE arithmetic facilities

## 2 Usage

USE,INTRINSIC :: IEEE_ARITHMETIC

This module provides various facilities related to IEEE arithmetic.

The contents of this module conform to technical report ISO/IEC TR 15580:1998(E). Additional features from the Fortran 2018 standard (ISO/IEC 1539-1:2018) are included.

## 3 Synopsis

Derived Types

  IEEE_CLASS_TYPE, IEEE_FLAG_TYPE (from IEEE_EXCEPTIONS), IEEE_ROUND_TYPE, IEEE_STATUS_TYPE (from IEEE_EXCEPTIONS).

Parameters

  IEEE_ALL (from IEEE_EXCEPTIONS), IEEE_DIVIDE_BY_ZERO (from IEEE_EXCEPTIONS), IEEE_AWAY*, IEEE_DOWN, IEEE_INEXACT (from IEEE_EXCEPTIONS), IEEE_INVALID (from IEEE_EXCEPTIONS), IEEE_NEAREST, IEEE_NEGATIVE_DENORMAL, IEEE_NEGATIVE_SUBNORMAL*, IEEE_NEGATIVE_INF, IEEE_NEGATIVE_NORMAL, IEEE_NEGATIVE_ZERO, IEEE_OTHER, IEEE_OVERFLOW (from IEEE_EXCEPTIONS), IEEE_POSITIVE_DENORMAL, IEEE_POSITIVE_SUBNORMAL*, IEEE_POSITIVE_INF, IEEE_POSITIVE_NORMAL, IEEE_POSITIVE_ZERO, IEEE_QUIET_NAN, IEEE_SIGNALING_NAN, IEEE_TO_ZERO, IEEE_UNDERFLOW (from IEEE_EXCEPTIONS), IEEE_UP, IEEE_USUAL (from IEEE_EXCEPTIONS).

  * These are from the Fortran 2018 standard.

Operators
  ==, /=.
Procedures

  IEEE_CLASS, IEEE_COPY_SIGN, IEEE_FMA*, IEEE_GET_FLAG (from IEEE_EXCEPTIONS), IEEE_GET_HALTING_MODE (from IEEE_EXCEPTIONS), IEEE_GET_ROUNDING_MODE, IEEE_GET_STATUS (from IEEE_EXCEPTIONS), IEEE_INT*, IEEE_IS_FINITE, IEEE_IS_NAN, IEEE_IS_NEGATIVE, IEEE_IS_NORMAL, IEEE_LOGB, IEEE_MAX_NUM*, IEEE_MAX_NUM_MAG*, IEEE_MIN_NUM*, IEEE_MIN_NUM_MAG* IEEE_NEXT_AFTER, IEEE_NEXT_DOWN*, IEEE_NEXT_UP*, IEEE_REAL*, IEEE_REM, IEEE_RINT, IEEE_SCALB, IEEE_SELECTED_REAL_KIND, IEEE_SET_FLAG (from IEEE_EXCEPTIONS), IEEE_SET_HALTING_MODE (from IEEE_EXCEPTIONS), IEEE_SET_ROUNDING_MODE, IEEE_SET_STATUS (from IEEE_EXCEPTIONS), IEEE_SUPPORT_DATATYPE, IEEE_SUPPORT_DENORMAL, IEEE_SUPPORT_DIVIDE, IEEE_SUPPORT_FLAG (from IEEE_EXCEPTIONS), IEEE_SUPPORT_HALTING (from IEEE_EXCEPTIONS), IEEE_SUPPORT_INF, IEEE_SUPPORT_NAN, IEEE_SUPPORT_ROUNDING, IEEE_SUPPORT_SQRT, IEEE_SUPPORT_SUBNORMAL* IEEE_SUPPORT_STANDARD, IEEE_UNORDERED, IEEE_VALUE.

  * These are from the Fortran 2018 standard.

## 4 Derived-Type Description

      TYPE IEEE_CLASS_TYPE
        PRIVATE
        ...
      END TYPE

Type for specifying the class of a number. Its only possible values are those of the named constants exported by this module.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_FLAG_TYPE

See IEEE_EXCEPTIONS for a description of this type.

      TYPE IEEE_ROUND_TYPE
        PRIVATE
        ...
      END TYPE

Type for specifying the rounding mode. Its only possible values are those of the named constants exported by this module.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_STATUS_TYPE

See IEEE_EXCEPTIONS for a description of this type.

## 5 Parameter Description

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_ALL

See IEEE_EXCEPTIONS for a description of this parameter.

      TYPE(IEEE_ROUND_TYPE),PARAMETER :: IEEE_AWAY

The rounding mode in which the results of a calculation are rounded to the nearest machine-representable number; ties are rounded away from zero. The IEEE standard only requires this rounding mode for decimal, and binary hardware does not support this, so it cannot be used.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_DIVIDE_BY_ZERO

See IEEE_EXCEPTIONS for a description of this parameter.

      TYPE(IEEE_ROUND_TYPE),PARAMETER :: IEEE_DOWN

The rounding mode in which the results of a calculation are rounded to the nearest machine-representable number that is less than the true result.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_INEXACT

See IEEE_EXCEPTIONS for a description of this parameter.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_INVALID

See IEEE_EXCEPTIONS for a description of this parameter.

      TYPE(IEEE_ROUND_TYPE),PARAMETER :: IEEE_NEAREST

The rounding mode in which the results of a calculation are rounded to the nearest machine-representable number. Ties are rounded to an even number.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_NEGATIVE_DENORMAL

A negative number whose precision is less than that of the normal numbers; the result of an IEEE gradual underflow.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_NEGATIVE_INF

Negative infinity.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_NEGATIVE_NORMAL

A normal negative number.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_NEGATIVE_SUBNORMAL

A negative number whose precision is less than that of the normal numbers; this constant is from Fortran 2018, and has the same value as `IEEE_NEGATIVE_DENORMAL`.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_NEGATIVE_ZERO

Negative zero.

      TYPE(IEEE_ROUND_TYPE),PARAMETER :: IEEE_OTHER

Any processor-dependent rounding mode other than IEEE_DOWN, IEEE_NEAREST, IEEE_TO_ZERO and IEEE_UP.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_OVERFLOW

See IEEE_EXCEPTIONS for a description of this parameter.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_POSITIVE_DENORMAL

A positive number whose precision is less than that of the normal numbers; the result of an IEEE gradual underflow.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_POSITIVE_INF

Positive infinity.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_POSITIVE_NORMAL

A normal positive number.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_POSITIVE_SUBNORMAL

A positive number whose precision is less than that of the normal numbers; this constant is from Fortran 2018, and has the same value as `IEEE_NEGATIVE_DENORMAL`.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_POSITIVE_ZERO

Positive zero.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_QUIET_NAN

A “Not-a-Number” value that propagates through arithmetic operations but which does not necessarily raise the IEEE_INVALID exception on use.

      TYPE(IEEE_CLASS_TYPE),PARAMETER :: IEEE_SIGNALING_NAN

A “Not-a-Number” that raises the IEEE_INVALID exception on use.

      TYPE(IEEE_ROUND_TYPE),PARAMETER :: IEEE_TO_ZERO

The rounding mode in which the results of a calculation are rounded to the nearest machine-representable number that lies between zero and the true result.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_UNDERFLOW

See IEEE_EXCEPTIONS for a description of this parameter.

      TYPE(IEEE_ROUND_TYPE),PARAMETER :: IEEE_UP

The rounding mode in which the results of a calculation are rounded to the nearest machine-representable number that is greater than the true result.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_USUAL

See IEEE_EXCEPTIONS for a description of this parameter.

## 6 Operator Description

In addition to ISO/IEC TR 15580:1998(E), the module IEEE_ARITHMETIC defines the ‘`==`’ and ‘`/=`’ operators for the IEEE_CLASS_TYPE. These may be used to test the return value of the IEEE_CLASS function. For example,

      USE,INTRINSIC :: IEEE_ARITHMETIC, ONLY: IEEE_CLASS, &
        IEEE_QUIET_NAN, OPERATOR(==)
        ...
        IF (IEEE_CLASS(X)==IEEE_QUIET_NAN) THEN
        ...

## 7 Procedure Description

      ELEMENTAL TYPE(IEEE_CLASS_TYPE) FUNCTION IEEE_CLASS(X)
      REAL(any kind),INTENT(IN) :: X

Returns the IEEE class that the value of X falls into.

      ELEMENTAL REAL(KIND(X)) FUNCTION IEEE_COPY_SIGN(X,Y)
      REAL(*),INTENT(IN) :: X
      REAL(*),INTENT(IN) :: Y

Returns the value of X with the sign of Y. The result has the same kind as X.

Restriction: this function must not be invoked when the kind of `X` or `Y` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (X)` or `IEEE_SUPPORT_DATATYPE (Y)` returns false.

      ELEMENTAL REAL(KIND(A)) IEEE_FMA (A, B, C)
      REAL(*),INTENT(IN) :: A
      REAL(KIND(A)) :: B, C

The result is a fused multiply-add operation; its value is (`A`×`B`)+`C` with only one rounding. That is, the whole operation is computed mathematically and only rounded to the format of `A` at the end. For example, `IEEE_OVERFLOW` is not signalled if `A`×`B` overflows, but only if the final result is out of range.

Restriction: this function must not be invoked when the kind of `A` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (A)` returns false.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_GET_FLAG

See IEEE_EXCEPTIONS for a description of this procedure.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_GET_HALTING_MODE

See IEEE_EXCEPTIONS for a description of this procedure.

      SUBROUTINE IEEE_GET_ROUNDING_MODE(ROUND_VALUE,RADIX)
      TYPE(IEEE_ROUND_TYPE),INTENT(OUT) :: ROUND_VALUE
      INTEGER(*),INTENT(IN),OPTIONAL :: RADIX

Sets ROUND_VALUE to the current rounding mode for the specified radix, which must be equal to two or ten, or to the binary rounding mode if `RADIX` is absent. The rounding mode will be one of IEEE_AWAY, IEEE_DOWN, IEEE_NEAREST, IEEE_OTHER, IEEE_TO_ZERO or IEEE_UP.

Note: The `RADIX` argument is a Fortran 2018 addition.

      SUBROUTINE IEEE_GET_UNDERFLOW_MODE(GRADUAL)
      LOGICAL,INTENT(OUT) :: GRADUAL

This procedure was added in Fortran 2003. It sets `GRADUAL` to whether the current underflow mode permits gradual underflow (subnormal results), rather than abrupt underflow (subnormal results flushed to zero). It may only be invoked if `IEEE_SUPPORT_UNDERFLOW_CONTROL(X)` is `.TRUE.` for some kind of `X`. From Fortran 2018, `GRADUAL` may be any kind of `LOGICAL`.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_GET_STATUS

See IEEE_EXCEPTIONS for a description of this procedure.

      ELEMENTAL FUNCTION IEEE_INT(A, ROUND, KIND)
      REAL(*),INTENT(IN) :: A
      TYPE(IEEE_ROUND_TYPE),INTENT(IN) :: ROUND
      INTEGER(*),OPTIONAL,INTENT(IN) :: KIND
      INTEGER(KIND) IEEE_INT

This procedure was added in Fortran 2018. It converts an IEEE Real value to Integer with a specific rounding mode. Note that the `KIND` argument must be a scalar constant expression; if it does not appear, the result has default kind.

The value of `A` is rounded to an integer using the rounding mode specified by `ROUND`. If that value is representable in the result kind, the result has that value; otherwise, the result is processor-dependent and `IEEE_INVALID` is signalled.

This operation is either the `convertToInteger{round}` or the `convertToIntegerExact{round}` operation specified by the IEEE standard. If it is the latter, and `IEEE_INVALID` was not signalled, but `A` was not already an integer, `IEEE_INEXACT` is signalled.

Restriction: this function must not be invoked when the kind of `A` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (A)` returns false.

      ELEMENTAL LOGICAL FUNCTION IEEE_IS_FINITE(X)
      REAL(any kind),INTENT(IN) :: X

Returns true if X is a finite number, i.e. neither an infinity nor a NaN.

Restriction: this function must not be invoked when the kind of `X` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (X)` returns false.

      ELEMENTAL LOGICAL FUNCTION IEEE_IS_NAN(X)
      REAL(any kind),INTENT(IN) :: X

Returns true if X is a NaN (either quiet or signalling).

Restriction: this function must not be invoked if `IEEE_SUPPORT_NAN (X)` returns false.

      ELEMENTAL LOGICAL FUNCTION IEEE_IS_NEGATIVE(X)
      REAL(any kind),INTENT(IN) :: X

Returns true if X is negative, even for negative zero.

Restriction: this function must not be invoked when the kind of `X` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (X)` returns false.

      ELEMENTAL LOGICAL FUNCTION IEEE_IS_NORMAL(X)
      REAL(any kind),INTENT(IN) :: X

Returns if X is normal, i.e. not an infinity, a NaN, or denormal.

Restriction: this function must not be invoked when the kind of `X` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (X)` returns false.

      ELEMENTAL REAL(kind) FUNCTION IEEE_LOGB(X)
      REAL(kind),INTENT(IN) :: X

Returns the unbiased exponent of X. For normal, non-zero numbers this is the same as the EXPONENT(X)-1; for zero, IEEE_DIVIDE_BY_ZERO is signalled and the result is negative infinity (or -HUGE(X) if negative infinity is not available); for an infinity the result is positive infinity; for a NaN the result is a quiet NaN.

Restriction: this function must not be invoked when the kind of `X` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (X)` returns false.

      ELEMENTAL FUNCTION IEEE_MAX_NUM(X, Y) RESULT(RESULT)
      ELEMENTAL FUNCTION IEEE_MAX_NUM_MAG(X, Y) RESULT(RESULT)
      ELEMENTAL FUNCTION IEEE_MIN_NUM(X, Y) RESULT(RESULT)
      ELEMENTAL FUNCTION IEEE_MIN_NUM_MAG(X, Y) RESULT(RESULT)
      ...
      REAL(*),INTENT(IN) :: X
      REAL(KIND(X)),INTENT(IN) :: Y
      REAL(KIND(X)) :: RESULT

These functions perform maximum/minimum operations ignoring NaN values. If an argument is a signalling NaN, `IEEE_INVALID` is raised, if only one argument is a NaN, the result is the other argument; only if both arguments are NaNs is the result a NaN.

The value of `IEEE_MAX_NUM` is the maximum value of `X` and `Y`, ignoring NaN. The value of `IEEE_MAX_NUM_MAG` is whichever of `X` and `Y` has the greater magnitude. The value of `IEEE_MIN_NUM` is the minimum value of `X` and `Y`, ignoring NaN. The value of `IEEE_MIN_NUM_MAG` is whichever of `X` and `Y` has the smaller magnitude.

Restriction: these functions must not be invoked when the kind of `X` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (X)` returns false.

      ELEMENTAL REAL(kind) FUNCTION IEEE_NEXT_AFTER(X,Y)
      REAL(kind),INTENT(IN) :: X
      REAL(kind),INTENT(IN) :: Y

Returns the closest machine-representable number to X (of the same kind as X) that is either greater than X (if X<Y) or less than X (if X>Y). If X and Y are equal, X is returned. If the result is subnormal, `IEEE_UNDERFLOW` is signalled. If the result is infinite but `X` is finite, `IEEE_OVERFLOW` is signalled.

Restriction: this function must not be invoked when the kind of `X` or `Y` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (X)` or `IEEE_SUPPORT_DATATYPE (Y)` returns false.

      ELEMENTAL REAL(kind) FUNCTION IEEE_NEXT_DOWN(X)
      REAL(kind),INTENT(IN) :: X

Returns the closest machine-representable number to X (of the same kind as X) that is less than X (unless X is −∞ or a NaN; if X is a signalling NaN the result is a quiet NaN, otherwise X is returned). No exception is signalled unless X is a signalling NaN. This function is from Fortran 2018.

      ELEMENTAL REAL(kind) FUNCTION IEEE_NEXT_UP(X)
      REAL(kind),INTENT(IN) :: X

Returns the closest machine-representable number to X (of the same kind as X) that is greater than X (unless X is +∞ or a NaN; if X is a signalling NaN the result is a quiet NaN, otherwise X is returned). No exception is signalled unless X is a signalling NaN. This function is from Fortran 2018.

      ELEMENTAL FUNCTION IEEE_REAL(A, KIND)
      REAL(*),INTENT(IN) :: A
      INTEGER(*),OPTIONAL,INTENT(IN) :: KIND
      REAL(KIND) IEEE_REAL

This procedure was added in Fortran 2018. It converts an Integer or IEEE format Real value to the specified IEEE format Real value. Note that the `KIND` argument must be a scalar constant expression; if it does not appear, the result has default kind.

If the value of `A` is representable in the kind of the result, that value is the result. Otherwise, the value of `A` is rounded to the kind of the result using the current rounding mode.

Restriction: this function must not be invoked when the kind of `A` or the result is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (A)` or if `IEEE_SUPPORT_DATATYPE(REAL(0,KIND))` returns false.

      ELEMENTAL REAL(kind) FUNCTION IEEE_REM(X,Y)
      REAL(kind),INTENT(IN) :: X
      REAL(kind),INTENT(IN) :: Y

The result value is the exact remainder from the division X/Y, viz X-Y*N where N is the nearest integer to the true result of X/Y.

      ELEMENTAL REAL(kind) FUNCTION IEEE_RINT(X, [ ROUND ])
      REAL(kind),INTENT(IN) :: X
      TYPE(IEEE_ROUND_TYPE),OPTIONAL,INTENT(IN) :: ROUND

When `ROUND` is present, the result is the value of `X` rounded to an integer according to the mode specified by `ROUND`; this is the operation the IEEE standard calls `roundToIntegral{rounding}`. When `ROUND` is absent, the result is the value of `X` rounded to an integer according to the current rounding mode; this is the operation the IEEE standard calls `roundToIntegralExact`.

Note: The `ROUND` argument is a Fortran 2018 addition.

Restriction: this function must not be invoked when the kind of `X` is not an IEEE format, i.e. if `IEEE_SUPPORT_DATATYPE (X)` returns false.

      ELEMENTAL REAL(kind) FUNCTION IEEE_SCALB(X,I)
      REAL(kind),INTENT(IN) :: X
      INTEGER(any kind),INTENT(IN) :: I

The result is X*2**I without computing 2**I, with overflow or underflow exceptions signalled only if the end result overflows or underflows.

      INTEGER FUNCTION IEEE_SELECTED_REAL_KIND(P,R,RADIX)
      INTEGER(any kind),INTENT(IN),OPTIONAL :: P
      INTEGER(any kind),INTENT(IN),OPTIONAL :: R
      INTEGER(any kind),INTENT(IN),OPTIONAL :: RADIX

The same as the intrinsic function SELECTED_REAL_KIND(P,R,RADIX), but only returns numbers of kinds for which IEEE_SUPPORT_DATATYPE returns true.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_SET_FLAG

See IEEE_EXCEPTIONS for a description of this procedure.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_SET_HALTING_MODE

See IEEE_EXCEPTIONS for a description of this procedure.

      SUBROUTINE IEEE_SET_ROUNDING_MODE(ROUND_VALUE,RADIX)
      TYPE(IEEE_ROUND_TYPE),INTENT(IN) :: ROUND_VALUE
      INTEGER(*),INTENT(IN),OPTIONAL :: RADIX

Sets the current rounding mode for the specified radix to ROUND_VALUE; if `RADIX` is absent, the binary rounding mode is set. The value of `RADIX` must be equal to two or ten.

Note: The `RADIX` argument is a Fortran 2018 addition.

Restriction: This subroutine must not be invoked unless there is some `X` (with radix `RADIX` if it is present) for which both `IEEE_SUPPORT_DATATYPE(X)` and `IEEE_SUPPORT_ROUNDING(ROUND_VALUE,X)` are true.

      SUBROUTINE IEEE_SET_UNDERFLOW_MODE(GRADUAL)
      LOGICAL,INTENT(IN) :: GRADUAL

This procedure was added in Fortran 2003. It sets the current underflow mode to “gradual underflow” (subnormal values may be produced) if `GRADUAL` is `.TRUE.`, and to “abrupt underflow” (subnormal results are flushed to zero) otherwise. It may only be invoked if `IEEE_SUPPORT_UNDERFLOW_CONTROL(X)` is `.TRUE.` for some kind of `X`. From Fortran 2018, `GRADUAL` may be any kind of `LOGICAL`.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_SET_STATUS

See IEEE_EXCEPTIONS for a description of this procedure.

      LOGICAL FUNCTION IEEE_SUPPORT_DATATYPE(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

Returns true if and only if all reals (if X is absent), or reals of the same kind as X conform to the IEEE standard for representation, addition, subtraction and multiplication when the operands and results have normal values.

      LOGICAL FUNCTION IEEE_SUPPORT_DENORMAL(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

Returns true if and only if IEEE denormalised values are supported for all real kinds (if X is absent) or for reals of the same kind as X.

      LOGICAL FUNCTION IEEE_SUPPORT_DIVIDE(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

Returns true if and only if division on all reals (if X is absent) or on reals of the same kind as X is performed to the accuracy required by the IEEE standard.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_SUPPORT_FLAG

See IEEE_EXCEPTIONS for a description of this procedure.

      USE,INTRINSIC :: IEEE_EXCEPTIONS,ONLY:IEEE_SUPPORT_HALTING

See IEEE_EXCEPTIONS for a description of this procedure.

      LOGICAL FUNCTION IEEE_SUPPORT_INF(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

Returns true if and only if IEEE infinities are supported for all reals (if X is absent) or for reals of the same kind as X.

      LOGICAL FUNCTION IEEE_SUPPORT_NAN(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

Returns true if and only if IEEE NaNs are supported for all reals (if X is absent) or for reals of the same kind as X.

      LOGICAL FUNCTION IEEE_SUPPORT_ROUNDING(ROUND_VALUE,X)
      TYPE(IEEE_ROUND_TYPE) :: ROUND_VALUE
      REAL(any kind),OPTIONAL :: X

Returns true if and only if the rounding mode for all reals (if X is absent) or reals of the same kind as X, can be changed to the specified rounding mode by the IEEE_SET_ROUNDING procedure.

      LOGICAL FUNCTION IEEE_SUPPORT_SQRT(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

Returns true if and only if the SQRT intrinsic conforms to the IEEE standard for all reals (if X is absent) or for reals of the same kind as X.

      LOGICAL FUNCTION IEEE_SUPPORT_SUBNORMAL(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

Returns true if and only if IEEE subnormal values are supported for all real kinds (if X is absent) or for reals of the same kind as X. This function is from Fortran 2018.

      LOGICAL FUNCTION IEEE_SUPPORT_STANDARD(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

Returns true if and only if all the other IEEE_SUPPORT inquiry functions return the value true for all reals (if X is absent) or for reals of the same kind as X.

      LOGICAL FUNCTION IEEE_SUPPORT_UNDERFLOW_CONTROL(X)
      REAL(any kind),INTENT(IN),OPTIONAL :: X

This enquiry function was added in Fortran 2003. It returns true if and only if control of the underflow mode (gradual or abrupt) is available for all reals (if `X` is absent) or for reals of the same kind as `X`.

      ELEMENTAL LOGICAL FUNCTION IEEE_UNORDERED(X,Y)
      REAL(any kind),INTENT(IN) :: X
      REAL(any kind),INTENT(IN) :: Y

Returns IEEE_IS_NAN(X).OR.IEEE_IS_NAN(Y).

      ELEMENTAL REAL(kind) FUNCTION IEEE_VALUE(X,CLASS)
      REAL(kind),INTENT(IN) :: X
      TYPE(IEEE_CLASS_TYPE),INTENT(IN) :: CLASS

Returns a sample value of the same kind as X that falls into the specified IEEE number class. For a given kind of X and class, the same value is always returned.

## 8 See Also

nagfor(1), ieee_exceptions(3), ieee_features(3), intro(3), nag_modules(3).

## 9 Bugs

Please report any bugs found to ‘support@nag.co.uk’ or ‘support@nag.com’, along with any suggestions for improvements.