# Signaling-Computational Operations Functions

Many routines in the libbfp754 Library are more optimized for Intel® microprocessors than for non-Intel microprocessors.

The Intel® IEEE 754-2008 Binary Conformance Library supports the following functions for signaling-computational operations:

## quiet_equal

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is equal, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is in the inputs.

Calling interface:
`int __binary32_quiet_equal_binary32 (float x, float y);`
`int __binary32_quiet_equal_binary64(float x, double y);`
`int __binary64_quiet_equal_binary32(double x, float y);`
`int __binary64_quiet_equal_ binary64(double x, double y);`

## quiet_not_equal

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is not equal, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_not_equal_binary32(float x, float y);`
`int __binary32_quiet_not_equal_binary64(float x, double y);`
`int __binary64_quiet_not_equal_binary32(double x, float y);`
`int __binary64_quiet_not_equal_binary64(double x, double y);`

## signaling_equal

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is equal, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_equal_binary32(float x, float y);`
`int __binary32_signaling_equal_binary64(float x, double y);`
`int __binary64_signaling_equal_binary32(double x, float y);`
`int __binary64_signaling_equal_binary64(double x, double y);`

## signaling_greater

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is greater, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_greater_binary32(float x, float y);`
`int __binary32_signaling_greater_binary64(float x, double y);`
`int __binary64_signaling_greater_binary32(double x, float y);`
`int __binary64_signaling_greater_binary64(double x, double y);`

## signaling_greater_equal

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is greater or equal, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_greater_equal_binary32(float x, float y);`
`int __binary32_signaling_greater_equal_binary64(float x, double y);`
`int __binary64_signaling_greater_equal_binary32(double x, float y);`
`int __binary64_signaling_greater_equal_binary64(double x, double y);`

## signaling_less

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is less, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_less_binary32(float x, float y);`
`int __binary32_signaling_less_binary64(float x, double y);`
`int __binary64_signaling_less_binary32(double x, float y);`
`int __binary64_signaling_less_binary64(double x, double y);`

## signaling_less_equal

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is less or equal, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_less_equal_binary32(float x, float y);`
`int __binary32_signaling_less_equal_binary64(float x, double y);`
`int __binary64_signaling_less_equal_binary32(double x, float y);`
`int __binary64_signaling_less_equal_binary64(double x, double y);`

## signaling_not_equal

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is not equal, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_not_equal_binary32(float x, float y);`
`int __binary32_signaling_not_equal_binary64(float x, double y);`
`int __binary64_signaling_not_equal_binary32(double x, float y);`
`int __binary64_signaling_not_equal_binary64(double x, double y);`

## signaling_not_greater

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is not greater, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_not_greater_binary32(float x, float y);`
`int __binary32_signaling_not_greater_binary64(float x, double y);`
`int __binary64_signaling_not_greater_binary32(double x, float y);`
`int __binary64_signaling_not_greater_binary64(double x, double y);`

## signaling_less_unordered

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is less or unordered, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_less_unordered_binary32(float x, float y);`
`int __binary32_signaling_less_unordered_binary64(float x, double y);`
`int __binary64_signaling_less_unordered_binary32(double x, float y);`
`int __binary64_signaling_less_unordered_binary64(double x, double y);`

## signaling_not_less

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is not less, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_not_less_ binary32(float x, float y);`
`int __binary32_signaling_not_less_binary64(float x, double y);`
`int __binary64_signaling_not_less_binary32(double x, float y);`
`int __binary64_signaling_not_less_binary64 (double x, double y);`

## signaling_greater_unordered

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is greater or unordered, returns 0 (false) otherwise. The function signals invalid operation exception when `NaN` is in the inputs.

Calling interface:
`int __binary32_signaling_greater_unordered_binary32(float x, float y);`
`int __binary32_signaling_greater_unordered_binary64(float x, double y);`
`int __binary64_ signaling_greater_unordered_binary32(double x, float y);`
`int __binary64_signaling_greater_unordered_binary64(double x, double y);`

## quiet_greater

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is greater, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_greater_binary32(float x, float y);`
`int __binary32_quiet_greater_binary64(float x, double y);`
`int __binary64_quiet_greater_binary32(double x, float y);`
`int __binary64_quiet_greater_binary64(double x, double y);`

## quiet_greater_equal

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is greater or equal, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_greater_equal_binary32(float x, float y);`
`int __binary32_quiet_greater_equal_binary64(float x, double y);`
`int __binary64_quiet_greater_equal_binary32(double x, float y);`
`int __binary64_quiet_greater_equal_binary64(double x, double y);`

## quiet_less

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is less, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_less_binary32(float x, float y);`
`int __binary32_quiet_less_binary64(float x, double y);`
`int __binary64_quiet_less_binary32(double x, float y);`
`int __binary64_quiet_less_binary64(double x, double y);`

## quiet_less_equal

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is less or equal, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_less_equal_binary32(float x, float y);`
`int __binary32_quiet_less_equal_binary64(float x, double y)`
`int __binary64_quiet_less_equal_binary32(double x, float y);`
`int __binary64_quiet_less_equal_binary64(double x, double y);`

## quiet_unordered

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is unordered, returns zero (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs

Calling interface:
`int __binary32_quiet_unordered_binary32(float x, float y);`
`int __binary32_quiet_unordered_binary64(float x, double y);`
`int __binary64_quiet_unordered_binary32(double x, float y);`
`int __binary64_quiet_unordered_binary64(double x, double y);`

## quiet_not_greater

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is not greater, returns zero (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_not_greater_binary32(float x, float y);`
`int __binary32_quiet_not_greater_binary64(float x, double y);`
`int __binary64_quiet_not_greater_binary32(double x, float y);`
`int __binary64_quiet_not_greater_binary64(double x, double y);`

## quiet_less_unordered

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is less or unordered, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_less_unordered_binary32(float x, float y);`
`int __binary32_quiet_less_unordered_binary64(float x, double y);`
`int __binary64_quiet_less_unordered_binary32(double x, float y);`
`int __binary64_quiet_less_unordered_binary64(double x, double y);`

## quiet_not_less

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is not less, returns zero (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_not_less_binary32(float x, float y);`
`int __binary32_quiet_not_less_binary64(float x, double y);`
`int __binary64_quiet_not_less_binary32(double x, float y);`
`int __binary64_quiet_not_less_binary64(double x, double y);`

## quiet_greater_unordered

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is greater or unordered, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_greater_unordered_binary32(float x, float y);`
`int __binary32_quiet_greater_unordered_binary64(float x, double y);`
`int __binary64_quiet_greater_unordered_binary32(double x, float y);`
`int __binary64_quiet_greater_unordered_binary64(double x, double y);`

## quiet_ordered

Description: The function returns 1 (true) if the relation between the two inputs `x` and `y` is ordered, returns 0 (false) otherwise. The function signals invalid operation exception when signaling `NaN` is one of the inputs.

Calling interface:
`int __binary32_quiet_ordered_binary32(float x, float y);`
`int __binary32_quiet_ordered_binary64(float x, double y);`
`int __binary64_quiet_ordered_binary32(double x, float y);`
`int __binary64_quiet_ordered_binary64(double x, double y);`

Parent topic: IEEE 754-2008 Binary Floating-Point Conformance Library