module Float:`sig`

..`end`

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`

Floating-point addition.

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

Cosine. Argument is in radians.

`val sin : ``float -> float`

Sine. Argument is in radians.

`val tan : ``float -> float`

Tangent. Argument is in radians.

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