BatFloat
Operations on floating-point numbers.
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 operation with nan
as argument returns nan
as result.
For more precision, see The Wikipedia entry on standard IEEE 754.
@documents Float
The type of floating-point numbers.
Floating-point numbers are the default representation of real numbers by OCaml.
Add 1.
to a floating number. Note that, as per IEEE 754, if x
is a large enough float number, succ x
might be equal to x
, due to rounding.
Subtract 1.
from a floating number. Note that, as per IEEE 754, if x
is a large enough float number, pred x
might be equal to x
, due to rounding.
val ord : float -> float -> BatOrd.order
val operations : t BatNumber.numeric
See atan2
.
See atan2
.
See atan2
.
See atan2
.
See atan2
.
See atan2
.
See tanh
.
See tanh
.
See floor
.
Round the given float to an integer value. floor f
returns the greatest integer value less than or equal to f
. ceil f
returns the least integer value greater than or equal to f
.
round x
rounds x
to the nearest integral floating-point (the nearest of floor x
and ceil x
). In case the fraction of x is exactly 0.5, we round away from 0. : round 1.5
is 2.
but round (-3.5)
is -4.
.
round_to_string ~digits:d x
will return a string representation of x
-- in base 10 -- rounded to d
digits after the decimal point. By default, digits
is 0
, we round to the nearest integer.
is_special f
returns true
if f
is nan
or +/- infinity
, false
otherwise.
is_finite f
returns true
if f
is not nan
or +/- infinity
, false
otherwise.
Special float constants. It may not be safe to compare directly with these, as they have multiple internal representations. Instead use the is_special
, is_nan
, etc. tests
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
.
Numeric constants
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
.
type fpkind = Pervasives.fpclass =
Classes of floating point numbers
The five classes of floating-point numbers, as determined by the classify
function.
val classify : float -> fpkind
Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
Test whether two floats are approximately equal (i.e. within epsilon of each other). epsilon
defaults to 1e-5.
module Infix : sig ... end
module Compare : BatNumber.Compare with type bat__compare_t = t
include BatNumber.RefOps with type bat__refops_t = t
type bat__refops_t = t
val (+=) : bat__refops_t ref -> bat__refops_t -> unit
val (-=) : bat__refops_t ref -> bat__refops_t -> unit
val (*=) : bat__refops_t ref -> bat__refops_t -> unit
val (/=) : bat__refops_t ref -> bat__refops_t -> unit
val print : (t, _) BatIO.printer
Printing
module Safe_float : sig ... end
Operations on floating-point numbers, with exceptions raised in case of error.