# General-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 formatOf general-computational operations:

## add

Description: The function computes the addition of two floating-point numbers; the result is then converted to the destination format.

Calling interface:
`float __binary32_add_binary32_binary32(float x, float y);`
`float __binary32_add_binary32_binary64(float x, double y);`
`float __binary32_add_binary64_binary32(double x, float y);`
`float __binary32_add_binary64_binary64(double x, double y);`
`double __binary64_add_binary32_binary32(float x, float y);`
`double __binary64_add_binary32_binary64(float x, double y);`
`double __binary64_add_binary64_binary32(double x, float y);`
`double __binary64_add_binary64_binary64(double x, double y);`

## sub

Description: The function computes the subtraction of two floating-point numbers; the result is then converted to the destination format.

Calling interface:
`float __binary32_sub_binary32_binary32(float x, float y);`
`float __binary32_sub_binary32_binary64(float x, double y);`
`float __binary32_sub_binary64_binary32(double x, float y);`
`float __binary32_sub_binary64_binary64(double x, double y);`
`double __binary64_sub_binary32_binary32(float x, float y);`
`double __binary64_sub_binary32_binary64(float x, double y);`
`double __binary64_sub_binary64_binary32(double x, float y);`
`double __binary64_sub_binary64_binary64(double x, double y);`

## mul

Description: The function computes the multiplication of two floating-point numbers; the result is then converted to the destination format.

Calling interface:
`float __binary32_mul_binary32_binary32(float x, float y);`
`float __binary32_mul_binary32_binary64(float x, double y);`
`float __binary32_mul_binary64_binary32(double x, float y);`
`float __binary32_mul_binary64_binary64(double x, double y);`
`double __binary64_mul_binary32_binary32(float x, float y);`
`double __binary64_mul_binary32_binary64(float x, double y);`
`double __binary64_mul_binary64_binary32(double x, float y);`
`double __binary64_mul_binary64_binary64(double x, double y);`

## div

Description: The function computes the division of two floating-point numbers; the result is then converted to the destination format.

Calling interface:
`float __binary32_div_binary32_binary32(float x, float y);`
`float __binary32_div_binary32_binary64(float x, double y);`
`float __binary32_div_binary64_binary32(double x, float y);`
`float __binary32_div_binary64_binary64(double x, double y);`
`double __binary64_div_binary32_binary32(float x, float y);`
`double __binary64_div_binary32_binary64(float x, double y);`
`double __binary64_div_binary64_binary32(double x, float y);`
`double __binary64_div_binary64_binary64(double x, double y);`

## sqrt

Description: The function computes the square root of floating-point number; the result is then converted to the destination format.

Calling interface:
`float __binary32_sqrt_binary32(float x);`
`float __binary32_sqrt_binary64(double x);`
`double __binary32_sqrt_binary32(float x);`
`double __binary32_sqrt_binary64(double x);`

## fma

Description: The function computes the fused multiply and add of three floating-point numbers x, y, and z as (x×y) +z; the result is then converted to the destination format.

Calling interface:
`float __binary32_fma_binary32_binary32_binary32(float x, float y, float z);`
`float __binary32_fma_binary32_binary32_binary64(float x, float y, double z);`
`float __binary32_fma_binary32_binary64_binary32(float x, double y, float z);`
`float __binary32_fma_binary32_binary64_binary64(float x, double y, double z);`
`float __binary32_fma_binary64_binary32_binary32(double x, float y, float z);`
`float __binary32_fma_binary64_binary32_binary64(double x, float y, double z);`
`float __binary32_fma_binary64_binary64_binary32(double x, double y, float z);`
`float __binary32_fma_binary64_binary64_binary64(double x, double y, double z);`
`double __binary64_fma_binary32_binary32_binary32(float x, float y, float z);`
`double __binary64_fma_binary32_binary32_binary64(float x, float y, double z);`
`double __binary64_fma_binary32_binary64_binary32(float x, double y, float z);`
`double __binary64_fma_binary32_binary64_binary64(float x, double y, double z);`
`double __binary64_fma_binary64_binary32_binary32(double x, float y, float z);`
`double __binary64_fma_binary64_binary32_binary64(double x, float y, double z);`
`double __binary64_fma_binary64_binary64_binary32(double x, double y, float z);`
`double __binary64_fma_binary64_binary64_binary64(double x, double y, double z);`

## from_int32 / from_uint32 / from_int64 / from_uint64

Description: This function converts integral values in the specified integer format to floating-point number.

Calling interface:
`float __binary32_from_int32(int n);`
`double __binary64_from_int32(int n);`
`float __binary32_from_uint32(unsigned int n);`
`double __binary64_from_uint32(unsigned int n);`
`float __binary32_from_int64(long long int n);`
`double __binary64_from_int64(long long int n);`
`float __binary32_from_uint64(unsigned long long int n);`
`double __binary64_from_uint64(unsigned long long int n);`

## to_int32_rnint / to_uint32_rnint / to_int64_rnint / to_uint64_rnint

Description: This function rounds floating-point number to the nearest integral value in the specified integer format, with halfway cases rounded to even, without signaling the inexact exception.

Calling interface:
`int __binary32_to_int32_rnint(float x);`
`int __binary64_to_int32_rnint(double x);`
`unsigned int __binary32_to_uint32_rnint(float x);`
`unsigned int __binary64_to_uint32_rnint(double x);`
`long long int __binary32_to_int64_rnint(float x);`
`long long int __binary64_to_int64_rnint(double x);`
`unsigned long long int __binary32_to_uint64_rnint(float x);`
`unsigned long long int __binary64_to_uint64_rnint(double x);`

## to_int32_int / to_uint32_int / to_int64_int / to_uint64_int

Description: This function rounds floating-point number to the nearest integral value in the specified integer format toward zero, without signaling the inexact exception.

Calling interface:
`int __binary32_to_int32_int(float x);`
`int __binary64_to_int32_int(double x);`
`unsigned int __binary32_to_uint32_int(float x);`
`unsigned int __binary64_to_uint32_int(double x);`
`long long int __binary32_to_int64_int(float x);`
`long long int __binary64_to_int64_int(double x);`
`unsigned long long int __binary32_to_uint64_int(float x);`
`unsigned long long int __binary64_to_uint64_int(double x);`

## to_int32_ceil/ to_uint32_ceil / to_int64_ceil / to_uint64_ceil

Description: This function rounds floating-point number to the nearest integral value in the specified integer format toward positive infinity, without signaling the inexact exception.

Calling interface:
`int __binary32_to_int32_ceil(float x);`
`int __binary64_to_int32_ceil(double x);`
`unsigned int __binary32_to_uint32_ceil(float x);`
`unsigned int __binary64_to_uint32_ceil(double x);`
`long long int __binary32_to_int64_ceil(float x);`
`long long int __binary64_to_int64_ceil(double x);`
`unsigned long long int __binary32_to_uint64_ceil(float x);`
`unsigned long long int __binary64_to_uint64_ceil(double x);`

## to_int32_floor/ to_uint32_floor / to_int64_floor / to_uint64_floor

Description: This function rounds floating-point number to the nearest integral value in the specified integer format toward negative infinity, without signaling the inexact exception.

Calling interface:
`int __binary32_to_int32_floor(float x);`
`int __binary64_to_int32_floor(double x);`
`unsigned int __binary32_to_uint32_floor(float x);`
`unsigned int __binary64_to_uint32_floor(double x);`
`long long int __binary32_to_int64_floor(float x);`
`long long int __binary64_to_int64_floor(double x);`
`unsigned long long int __binary32_to_uint64_floor(float x);`
`unsigned long long int __binary64_to_uint64_floor(double x);`

## to_int32_rninta / to_uint32_rninta / to_int64_rninta / to_uint64_rninta

Description: This function rounds floating-point number to the nearest integral value in the specified integer format, with halfway cases rounded away from zero, without signaling the inexact exception.

Calling interface:
`int __binary32_to_int32_rninta(float x);`
`int __binary64_to_int32_rninta(double x);`
`unsigned int __binary32_to_uint32_rninta(float x);`
`unsigned int __binary64_to_uint32_rninta(double x);`
`long long int __binary32_to_int64_rninta(float x);`
`long long int __binary64_to_int64_rninta(double x);`
`unsigned long long int __binary32_to_uint64_rninta(float x);`
`unsigned long long int __binary64_to_uint64_rninta(double x);`

## to_int32_xrnint / to_uint32_xrnint / to_int64_xrnint / to_uint64_xrnint

Description: This function rounds floating-point number to the nearest integral value in the specified integer format, with halfway cases rounded to even, signaling if inexact.

Calling interface:
`int __binary32_to_int32_xrnint(float x);`
`int __binary64_to_int32_xrnint(double x);`
`unsigned int __binary32_to_uint32_xrnint(float x);`
`unsigned int __binary64_to_uint32_xrnint(double x);`
`long long int __binary32_to_int64_xrnint(float x);`
`long long int __binary64_to_int64_xrnint(double x);`
`unsigned long long int __binary32_to_uint64_xrnint(float x);`
`unsigned long long int __binary64_to_uint64_xrnint(double x);`

## to_int32_xint / to_uint32_xint / to_int64_xint / to_uint64_xint

Description: This function rounds floating-point number to the nearest integral value in the specified integer format toward zero, signaling if inexact.

Calling interface:
`int __binary32_to_int32_xint(float x);`
`int __binary64_to_int32_xint(double x);`
`unsigned int __binary32_to_uint32_xint(float x);`
`unsigned int __binary64_to_uint32_xint(double x);`
`long long int __binary32_to_int64_xint(float x);`
`long long int __binary64_to_int64_xint(double x);`
`unsigned long long int __binary32_to_uint64_xint(float x);`
`unsigned long long int __binary64_to_uint64_xint(double x);`

## to_int32_xceil / to_uint32_xceil / to_int64_xceil / to_uint64_xceil

Description: This function rounds floating-point number to the nearest integral value in the specified integer format toward positive infinity, signaling if inexact.

Calling interface:
`int __binary32_to_int32_xceil(float x);`
`int __binary64_to_int32_xceil(double x);`
`unsigned int __binary32_to_uint32_xceil(float x);`
`unsigned int __binary64_to_uint32_xceil(double x);`
`long long int __binary32_to_int64_xceil(float x);`
`long long int __binary64_to_int64_xceil(double x);`
`unsigned long long int __binary32_to_uint64_xceil(float x);`
`unsigned long long int __binary64_to_uint64_xceil(double x);`

## to_int32_xfloor / to_uint32_xfloor / to_int64_xfloor / to_uint64_xfloor

Description: This function rounds floating-point number to the nearest integral value in the specified integer format toward negative infinity, signaling if inexact.

Calling interface:
`int __binary32_to_int32_xfloor(float x);`
`int __binary64_to_int32_xfloor(double x);`
`unsigned int __binary32_to_uint32_xfloor(float x);`
`unsigned int __binary64_to_uint32_xfloor(double x);`
`long long int __binary32_to_int64_xfloor(float x);`
`long long int __binary64_to_int64_xfloor(double x);`
`unsigned long long int __binary32_to_uint64_xfloor(float x);`
`unsigned long long int __binary64_to_uint64_xfloor(double x);`

## to_int32_xrninta / to_uint32_xrninta / to_int64_xrninta / to_uint64_xrninta

Description: This function rounds floating-point number to the nearest integral value in the specified integer format, with halfway cases rounded away from zero, signaling if inexact.

Calling interface:
`int __binary32_to_int32_xrninta(float x);`
`int __binary64_to_int32_xrninta(double x);`
`unsigned int __binary32_to_uint32_xrninta(float x);`
`unsigned int __binary64_to_uint32_xrninta(double x);`
`long long int __binary32_to_int64_xrninta(float x);`
`long long int __binary64_to_int64_xrninta(double x);`
`unsigned long long int __binary32_to_uint64_xrninta(float x);`
`unsigned long long int __binary64_to_uint64_xrninta(double x);`

## binary32_to_binary64

Description: This function converts floating-point number in binary32 format to binary64 format.

Calling interface:
`double __binary32_to_binary64(float x);`

## binary64_to_binary32

Description: This function rounds floating-point number in binary64 format to binary32 format.

Calling interface:
`float __binary64_to_binary32(double x);`

## from_string

Description: This function converts decimal character sequence to floating-point number.

Calling interface:
`float __binary32_from_string(char * s);`
`double __binary64_from_string(char * s);`

## to_string

Description: This function converts floating-point number to decimal character sequence.

Calling interface:
`void__binary32_to_string(char * s, float x);`
`void__binary64_to_string(char * s, double x);`

## from_hexstring

Description: This function converts hexadecimal character sequence to floating-point number.

Calling interface:
`float __binary32_from_hexstring(char * s);`
`double __binary64_from_hexstring(char * s);`

## to_hexstring

Description: This function converts floating-point number to hexadecimal character sequence.

Calling interface:
`void__binary32_to_hexstring(cgar * s, float x);`
`void__binary64_to_hexstring(char * s, double x);`

Parent topic: Function List