# Module Float

`module Float: `sig` .. `end``

## 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 neg : `float -> float``

Unary negation.

`val add : `float -> float -> float``

`val sub : `float -> float -> float``

Floating-point subtraction.

`val mul : `float -> float -> float``

Floating-point multiplication.

`val div : `float -> float -> float``

Floating-point division.

`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 abs : `float -> float``

`abs f` returns the absolute value of `f`.

`val infinity : `float``

Positive infinity.

`val neg_infinity : `float``

Negative infinity.

`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 pi : `float``

The constant pi.

`val max_float : `float``

The largest positive finite value of type `float`.

`val min_float : `float``

The smallest positive, non-zero, non-denormalized value of type `float`.

`val epsilon : `float``

The difference between `1.0` and the smallest exactly representable floating-point number greater than `1.0`.

`val of_int : `int -> float``

Convert an integer to floating-point.

`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.

`val of_string_opt : `string -> float option``

Same as `of_string`, but returns `None` instead of raising.

`val to_string : `float -> string``

Return the string representation of a floating-point number.

`type fpclass = `fpclass` = `
 `|` `FP_normal` `(*` Normal number, none of the below `*)` `|` `FP_subnormal` `(*` Number very close to 0.0, has reduced precision `*)` `|` `FP_zero` `(*` Number is 0.0 or -0.0 `*)` `|` `FP_infinite` `(*` Number is positive or negative infinity `*)` `|` `FP_nan` `(*` Not a number: result of an undefined operation `*)`

The five classes of floating-point numbers, as determined by the `Float.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 pow : `float -> float -> float``

Exponentiation.

`val sqrt : `float -> float``

Square root.

`val exp : `float -> float``

Exponential.

`val log : `float -> float``

Natural logarithm.

`val log10 : `float -> float``

Base 10 logarithm.

`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 cos : `float -> float``

`val sin : `float -> float``

`val tan : `float -> float``

`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 atan : `float -> float``

Arc tangent. 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 cosh : `float -> float``

Hyperbolic cosine. Argument is in radians.

`val sinh : `float -> float``

Hyperbolic sine. Argument is in radians.

`val tanh : `float -> float``

Hyperbolic tangent. Argument is in radians.

`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 ldexp : `float -> int -> float``

`ldexp x n` returns `x *. 2 ** n`.

`val modf : `float -> float * float``

`modf f` returns the pair of the fractional and integral part of `f`.

`type t = `float` `

An alias for the type of floating-point numbers.

`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 equal : `t -> t -> bool``

The equal function for floating-point numbers, compared using `Float.compare`.

`val hash : `t -> int``

The hash function for floating-point numbers.

`module Array: `sig` .. `end``