Float(3) OCaml library Float(3)
NAME
Float - Floating-point arithmetic.
Module
Module Float
Documentation
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 , basic arithmetic operations ( +. , -. , *. , /. )
with nan as an argument return nan , ...
Since 4.07
val zero : float
The floating point 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 on 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. 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 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 [-1.0,
1.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 signbit 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
<= 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).
OCamldoc 2024-05-31 Float(3)