Stdlib.Float(3)

🌸 NAME 🌸

okay so bestie, this is Stdlib.Float(3) — an OCaml library page — and the NAME is Stdlib.Float, which is literally just no description. iconic of it to serve absolute mystery. 💅

🎀 Module 🎀

the module vibe is exactly this:

Module Float : (module Stdlib__Float)

✨ Documentation ✨

• 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 — the five classes of floating-point numbers, as determined by the Float.classify_float function. the type itself is literally:

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

• 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 — frexp f hands you back the pair of the significant and the exponent of f. 💅 When f is zero, the significant x and the exponent n of f are both equal to zero. When f is non-zero, they're defined by f = x *. 2 ** n and 0.5 <= abs x < 1.0. iconic math, no notes ✨
• val ldexp : float -> int -> float — ldexp x n gives you x *. 2 ** n. that's it, that's the whole vibe 🦋
• val modf : float -> float * float — modf f returns the pair of the fractional and integral part of f. split it like a friendship bracelet 🎀
• type t = float — literally just an alias for the type of floating-point numbers. doing the same job under a cuter name, iykyk 💖
• 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. ok now the important part 👀 compare treats nan as equal to itself and less than any other float value. that treatment of nan is what makes compare define a total ordering relation — the whole thing stays consistent, periodt 👑
• val equal : t -> t -> bool — the equal function for floating-point numbers, compared using Float.compare. that's the method it's committed to 🫶
• val min : t -> t -> t — min x y returns the minimum of x and y. it returns nan when x or y is nan. and as a bonus: 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. and 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. two birds, one call, ate 💅

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. and note these little gems 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. the whole point is that it lets this module be passed as an argument to the functor Hashtbl.MakeSeeded. passing modules around like notes in class fr fr 💌

Since 5.1

• val hash : t -> int — an unseeded hash function for floats, with the same output value as Hashtbl.hash. this one lets this module be passed as an argument to the functor Hashtbl.Make. same energy, no seed 🌈
• module Array : sig end — Float arrays with packed representation. fancy storage, minimal drama 🧚
• module ArrayLabels : sig end — Float arrays with packed representation (labeled functions). same slay, but with labels 🎀

---

that's the whole page bestie, we made it to the end 🫶 this little masterpiece was served up by OCamldoc, dated 2026-06-22, and it lives at Stdlib.Float(3) in the section-3 lineup — go forth and float responsibly 💜✨