Float(3)

📦
version 5.5.0 · 19 versions
, in arch rolling

💖 Float(3) — OCaml library 💖

🌸 NAME 🌸

Float — floating-point arithmetic, bestie. That’s the whole assignment. 💅

🧚 Module 🧚

Module Float

 : sig end

✨ Documentation ✨

Floating-point arithmetic, and ngl this module is lowkey iconic. 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, basic arithmetic operations (+., -., *., /.) with nan as an argument return nan, … 🫶

Since 4.07 ⭐

  • 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. Flip the vibe, flip the sign. 💅
  • val add : float -> float -> float — floating-point addition. Math but make it sparkle. ✨
  • val sub : float -> float -> float — floating-point subtraction. Bye-bye, amount. 🦋
  • val mul : float -> float -> float — floating-point multiplication. Double it and give it to the next one. 💖
  • val div : float -> float -> float — floating-point division. Sharing is caring, allegedly. 🌈
  • 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. Remainder, but make it precise. 🧚
  • 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. Next up, bestie. ⏭️ 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. Back it up, back it up. ⏮️ Since 4.08
  • val abs : float -> float — abs f returns the absolute value of f. No negatives in this house. 🚫
  • val infinity : float — positive infinity. Going up forever, fr fr. ♾️
  • val neg_infinity : float — negative infinity. Going down forever, no cap. 🕳️
  • 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. Shhh, it’s giving calm but still not a number. 🤫 Since 5.1
  • val pi : float — the constant pi. Circumference queen. 🥧
  • val max_float : float — the largest positive finite value of type float. Big energy, but finite. 👑
  • val min_float : float — the smallest positive, non-zero, non-denormalized value of type float. Tiny but mighty. 🐜
  • val epsilon : float — the difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0. The tiny gap between besties. 💞
  • 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. Whole number behavior. 🔢 Since 4.08
  • val of_int : int -> float — convert an integer to floating-point. Glow-up from int to float. ✨
  • 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. 🚨
⚠️ That “unspecified” is not a vibe check, bestie — don’t rely on it. 💀
  • 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. Gentle parenting the parser. 🫶
  • 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. 💅

  • fpclass type — the five classes of floating-point numbers, as determined by the Float.classify_float function. 🧚
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. Sorting hat, but for floats. 🎩
  • val pow : float -> float -> float — exponentiation. Raise it up. 🔥
  • val sqrt : float -> float — square root. Rooting for you, bestie. 🌱
  • val cbrt : float -> float — cube root. Three-dimensional root energy. 🧊 Since 4.13
  • val exp : float -> float — exponential. Eeeeee. 📈
  • val exp2 : float -> float — base 2 exponential function. Binary glow-up. 🌈 Since 4.13
  • val log : float -> float — natural logarithm. Logging it for the group chat. 📝
  • val log10 : float -> float — base 10 logarithm. Ten out of ten. 🔟
  • val log2 : float -> float — base 2 logarithm. Two cool. 🎀 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. Tiny-number protection, slay. ✨
  • 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. Same tiny-number care, different function. 🫶
  • 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. Quadrant-aware, main character energy. 👑
  • 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. Triangle math, but make it fashion. 📐💅
  • val cosh : float -> float — hyperbolic cosine. Hyperbolic, not dramatic. 🎭
  • 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. Chopping off the fractional bit, respectfully. ✂️ 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. Up, up, up. ⬆️
  • 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. Down, down, down. ⬇️
  • 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 — signature only in this part, bestie. 🫶
  • 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 — the chaos is the point, iykyk 🙈
  • 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. math but make it cute 🧚
  • val ldexp : float -> int -> float — ldexp x n returns x *. 2 ** n. simple, iconic, no notes 💅
  • 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. same float energy, different name tag 🎀
  • 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. nan said “I contain multitudes but I’m still orderable” 👑
  • 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. two-for-one behavior, we love efficiency 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. hash girl summer 🌈
  • module Array : sig end — Float arrays with packed representation. 🎀
  • module ArrayLabels : sig end — Float arrays with packed representation (labeled functions). 🦋

Shoutout to OCamldoc — that’s the source/version tag on this page — dated 2026-06-22, and we are officially wrapping Float(3). Bye bestie, go treat your floats right! 💖✨

📦 where this page comes from