Stdlib.Float(3) OCaml library Stdlib.Float(3)

# [NAME](#NAME)

Stdlib.Float - no description

# [Module](#Module)

Module Stdlib.Float

# [Documentation](#Documentation)

Module **Float**  
: **(module Stdlib\_\_Float)**

*val zero* : **float**

The floating-point number 0.

**Since** 4.08

*val one* : **float**

The floating-point 1.

**Since** 4.08

*val minus\_one* : **float**

The floating-point -1.

**Since** 4.08

*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 fma* : **float -> float -> float -> float**

**fma x y z** returns **x * y + z** , with a best effort for computing this expression with a single rounding, using either hardware instructions (providing full IEEE compliance) or a software emulation.

On 64-bit Cygwin, 64-bit mingw-w64 and MSVC 2017 and earlier, this function may be emulated owing to known bugs or limitations on these platforms. Note: since software emulation of the fma is costly, make sure that you are using hardware fma support if performance matters.

**Since** 4.08

*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 succ* : **float -> float**

**succ x** returns the floating point number right after **x** i.e., the smallest floating-point number greater than **x** . See also **Float.next\_after** .

**Since** 4.08

*val pred* : **float -> float**

**pred x** returns the floating-point number right before **x** i.e., the greatest floating-point number smaller than **x** . See also **Float.next\_after** .

**Since** 4.08

*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, unless otherwise specified in IEEE 754 standard. As for floating-point comparisons, **=** , **<** , **<=** , **>** and **>=** return **false** and **<>** returns **true** if one or both of their arguments is **nan** .

**nan** is **quiet\_nan** since 5.1; it was a signaling NaN before.

*val signaling\_nan* : **float**

Signaling NaN. The corresponding signals do not raise OCaml exception, but the value can be useful for interoperability with C libraries.

**Since** 5.1

*val quiet\_nan* : **float**

Quiet NaN.

**Since** 5.1

*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 is\_finite* : **float -> bool**

**is\_finite x** is **true** if and only if **x** is finite i.e., not infinite and not **Float.nan** .

**Since** 4.08

*val is\_infinite* : **float -> bool**

**is\_infinite x** is **true** if and only if **x** is **Float.infinity** or **Float.neg\_infinity** .

**Since** 4.08

*val is\_nan* : **float -> bool**

**is\_nan x** is **true** if and only if **x** is not a number (see **Float.nan** ).

**Since** 4.08

*val is\_integer* : **float -> bool**

**is\_integer x** is **true** if and only if **x** is an integer.

**Since** 4.08

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

**Raises Failure** 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 a string representation of a floating-point number.

This conversion can involve a loss of precision. For greater control over the manner in which the number is printed, see **Printf** .

This function is an alias for **string\_of\_float** .

*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 cbrt* : **float -> float**

Cube root.

**Since** 4.13

*val exp* : **float -> float**

Exponential.

*val exp2* : **float -> float**

Base 2 exponential function.

**Since** 4.13

*val log* : **float -> float**

Natural logarithm.

*val log10* : **float -> float**

Base 10 logarithm.

*val log2* : **float -> float**

Base 2 logarithm.

**Since** 4.13

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

*val sinh* : **float -> float**

Hyperbolic sine.

*val tanh* : **float -> float**

Hyperbolic tangent.

*val acosh* : **float -> float**

Hyperbolic arc cosine. The argument must fall within the range **\[1.0, inf]** . Result is in radians and is between **0.0** and **inf** .

**Since** 4.13

*val asinh* : **float -> float**

Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.

**Since** 4.13

*val atanh* : **float -> float**

Hyperbolic arc tangent. The argument must fall within the range **\[-1.0, 1.0]** . Result is in radians and ranges over the entire real line.

**Since** 4.13

*val erf* : **float -> float**

Error function. The argument ranges over the entire real line. The result is always within **\[-1.0, 1.0]** .

**Since** 4.13

*val erfc* : **float -> float**

Complementary error function ( **erfc x = 1 - erf x** ). The argument ranges over the entire real line. The result is always within **\[0.0, 2.0]** .

**Since** 4.13

*val trunc* : **float -> float**

**trunc x** rounds **x** to the nearest integer whose absolute value is less than or equal to **x** .

**Since** 4.08

*val round* : **float -> float**

**round x** rounds **x** to the nearest integer with ties (fractional values of 0.5) rounded away from zero, regardless of the current rounding direction. If **x** is an integer, **+0.** , **-0.** , **nan** , or infinite, **x** itself is returned.

On 64-bit mingw-w64, this function may be emulated owing to a bug in the C runtime library (CRT) on this platform.

**Since** 4.08

*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 next\_after* : **float -> float -> float**

**next\_after x y** returns the next representable floating-point value following **x** in the direction of **y** . More precisely, if **y** is greater (resp. less) than **x** , it returns the smallest (resp. largest) representable number greater (resp. less) than **x** . If **x** equals **y** , the function returns **y** . If **x** or **y** is **nan** , a **nan** is returned. Note that **next\_after max\_float infinity = infinity** and that **next\_after 0. infinity** is the smallest denormalized positive number. If **x** is the smallest denormalized positive number, **next\_after x 0. = 0.**

**Since** 4.08

*val copy\_sign* : **float -> float -> float**

**copy\_sign 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 sign\_bit* : **float -> bool**

**sign\_bit x** is **true** if and only if the sign bit of **x** is set. For example **sign\_bit 1.** and **sign\_bit 0.** are **false** while **sign\_bit (-1.)** and **sign\_bit (-0.)** are **true** .

**Since** 4.08

*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 <= abs 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 min* : **t -> t -> t**

**min x y** returns the minimum of **x** and **y** . It returns **nan** when **x** or **y** is **nan** . Moreover **min (-0.) (+0.) = -0.**

**Since** 4.08

*val max* : **float -> float -> float**

**max x y** returns the maximum of **x** and **y** . It returns **nan** when **x** or **y** is **nan** . Moreover **max (-0.) (+0.) = +0.**

**Since** 4.08

*val min\_max* : **float -> float -> float * float**

**min\_max x y** is **(min x y, max x y)** , just more efficient.

**Since** 4.08

*val min\_num* : **t -> t -> t**

**min\_num x y** returns the minimum of **x** and **y** treating **nan** as missing values. If both **x** and **y** are **nan** , **nan** is returned. Moreover **min\_num (-0.) (+0.) = -0.**

**Since** 4.08

*val max\_num* : **t -> t -> t**

**max\_num x y** returns the maximum of **x** and **y** treating **nan** as missing values. If both **x** and **y** are **nan** **nan** is returned. Moreover **max\_num (-0.) (+0.) = +0.**

**Since** 4.08

*val min\_max\_num* : **float -> float -> float * float**

**min\_max\_num x y** is **(min\_num x y, max\_num x y)** , just more efficient. Note that in particular **min\_max\_num x nan = (x, x)** and **min\_max\_num nan y = (y, y)** .

**Since** 4.08

*val seeded\_hash* : **int -> t -> int**

A seeded hash function for floats, with the same output value as **Hashtbl.seeded\_hash** . This function allows this module to be passed as argument to the functor **Hashtbl.MakeSeeded** .

**Since** 5.1

*val hash* : **t -> int**

An unseeded hash function for floats, with the same output value as **Hashtbl.hash** . This function allows this module to be passed as argument to the functor **Hashtbl.Make** .

*module Array :* **sig end**

Float arrays with packed representation.

*module ArrayLabels :* **sig end**

Float arrays with packed representation (labeled functions).

2026-10-01 OCamldoc

---

Document: Stdlib.Float(3o) from ocaml 5.5.1-r1 (Chainguard OS)
Source: https://github.com/ocaml/ocaml