# Module `Stdlib.Float`

## Floating-point arithmetic

OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-point operations never raise an exception on overflow, underflow, division by zero, etc. Instead, special IEEE numbers are returned as appropriate, such as `infinity`

for `1.0 /. 0.0`

, `neg_infinity`

for `-1.0 /. 0.0`

, and `nan`

('not a number') for `0.0 /. 0.0`

. These special numbers then propagate through floating-point computations as expected: for instance, `1.0 /. infinity`

is `0.0`

, and any arithmetic operation with `nan`

as argument returns `nan`

as result.

- since
- 4.07.0

`val rem : float -> float -> float`

`rem a b`

returns the remainder of`a`

with respect to`b`

. The returned value is`a -. n *. b`

, where`n`

is the quotient`a /. b`

rounded towards zero to an integer.

`val nan : float`

A special floating-point value denoting the result of an undefined operation such as

`0.0 /. 0.0`

. Stands for 'not a number'. Any floating-point operation with`nan`

as argument returns`nan`

as result. As for floating-point comparisons,`=`

,`<`

,`<=`

,`>`

and`>=`

return`false`

and`<>`

returns`true`

if one or both of their arguments is`nan`

.

`val epsilon : float`

The difference between

`1.0`

and the smallest exactly representable floating-point number greater than`1.0`

.

`val to_int : float -> int`

Truncate the given floating-point number to an integer. The result is unspecified if the argument is

`nan`

or falls outside the range of representable integers.

`val of_string : string -> float`

Convert the given string to a float. The string is read in decimal (by default) or in hexadecimal (marked by

`0x`

or`0X`

). The format of decimal floating-point numbers is`[-] dd.ddd (e|E) [+|-] dd`

, where`d`

stands for a decimal digit. The format of hexadecimal floating-point numbers is`[-] 0(x|X) hh.hhh (p|P) [+|-] dd`

, where`h`

stands for an hexadecimal digit and`d`

for a decimal digit. In both cases, at least one of the integer and fractional parts must be given; the exponent part is optional. The`_`

(underscore) character can appear anywhere in the string and is ignored. Depending on the execution platforms, other representations of floating-point numbers can be accepted, but should not be relied upon. Raise`Failure "float_of_string"`

if the given string is not a valid representation of a float.

`type fpclass`

`= Stdlib.Pervasives.fpclass`

`=`

The five classes of floating-point numbers, as determined by the

`classify_float`

function.

`val classify_float : float -> fpclass`

Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.

`val expm1 : float -> float`

`expm1 x`

computes`exp x -. 1.0`

, giving numerically-accurate results even if`x`

is close to`0.0`

.

`val log1p : float -> float`

`log1p x`

computes`log(1.0 +. x)`

(natural logarithm), giving numerically-accurate results even if`x`

is close to`0.0`

.

`val acos : float -> float`

Arc cosine. The argument must fall within the range

`[-1.0, 1.0]`

. Result is in radians and is between`0.0`

and`pi`

.

`val asin : float -> float`

Arc sine. The argument must fall within the range

`[-1.0, 1.0]`

. Result is in radians and is between`-pi/2`

and`pi/2`

.

`val atan2 : float -> float -> float`

`atan2 y x`

returns the arc tangent of`y /. x`

. The signs of`x`

and`y`

are used to determine the quadrant of the result. Result is in radians and is between`-pi`

and`pi`

.

`val hypot : float -> float -> float`

`hypot x y`

returns`sqrt(x *. x + y *. y)`

, that is, the length of the hypotenuse of a right-angled triangle with sides of length`x`

and`y`

, or, equivalently, the distance of the point`(x,y)`

to origin. If one of`x`

or`y`

is infinite, returns`infinity`

even if the other is`nan`

.

`val ceil : float -> float`

Round above to an integer value.

`ceil f`

returns the least integer value greater than or equal to`f`

. The result is returned as a float.

`val floor : float -> float`

Round below to an integer value.

`floor f`

returns the greatest integer value less than or equal to`f`

. The result is returned as a float.

`val copysign : float -> float -> float`

`copysign x y`

returns a float whose absolute value is that of`x`

and whose sign is that of`y`

. If`x`

is`nan`

, returns`nan`

. If`y`

is`nan`

, returns either`x`

or`-. x`

, but it is not specified which.

`val frexp : float -> float * int`

`frexp f`

returns the pair of the significant and the exponent of`f`

. When`f`

is zero, the significant`x`

and the exponent`n`

of`f`

are equal to zero. When`f`

is non-zero, they are defined by`f = x *. 2 ** n`

and`0.5 <= x < 1.0`

.

`val compare : t -> t -> int`

`compare x y`

returns`0`

if`x`

is equal to`y`

, a negative integer if`x`

is less than`y`

, and a positive integer if`x`

is greater than`y`

.`compare`

treats`nan`

as equal to itself and less than any other float value. This treatment of`nan`

ensures that`compare`

defines a total ordering relation.

`val hash : t -> int`

The hash function for floating-point numbers.

`module Array : sig ... end`