module BatFloat:sig..end
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.
Author(s): Gabriel Scherer, David Teller, Edgar Friendly
typet =float
Floating-point numbers are the default representation of
real numbers by OCaml.
val zero : float0.val one : float1.val neg : float -> floatval succ : float -> float1. 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.val pred : float -> float1. 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 abs : float -> floatval add : float -> float -> float
val sub : float -> float -> float
val mul : float -> float -> float
val div : float -> float -> float
val modulo : float -> float -> float
val pow : float -> float -> float
val min_num : float
val max_num : float
val compare : float -> float -> int
val equal : float -> float -> bool
val ord : float -> float -> BatOrd.order
val of_int : int -> float
val to_int : float -> int
val of_float : float -> float
val to_float : float -> float
val of_string : string -> float
val to_string : float -> string
val (+) : t -> t -> t
val (-) : t -> t -> t
val ( * ) : t -> t -> t
val (/) : t -> t -> t
val ( ** ) : t -> t -> t
val min : float -> float -> float
val max : float -> float -> float
val (--) : t -> t -> t BatEnum.t
val (---) : t -> t -> t BatEnum.t
val operations : t BatNumber.numericval sqrt : float -> floatval exp : float -> floatval log : float -> floatval log10 : float -> floatval cos : float -> floatBatFloat.atan2.val sin : float -> floatBatFloat.atan2.val tan : float -> floatBatFloat.atan2.val acos : float -> floatBatFloat.atan2.val asin : float -> floatBatFloat.atan2.val atan : float -> floatBatFloat.atan2.val atan2 : float -> float -> floatval cosh : float -> floatBatFloat.tanh.val sinh : float -> floatBatFloat.tanh.val tanh : float -> floatval ceil : float -> floatBatFloat.floor.val floor : float -> floatfloor 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.val round : float -> floatround 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..val round_to_int : float -> intround_to_int x is int_of_float (round x).val round_to_string : ?digits:int -> float -> stringround_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.Invalid_argument if the ~digits argument is negative.
This is strictly a convenience function for simple end-user printing and you should not rely on its behavior. One possible implementation is to rely on C `sprintf` internally, which means:
round or round_to_intround_to_string ~digits:0 3. may return "3" instead of
"3." as string_of_float wouldround_to_string
~digits:max_int x may return the empty string.val root : float -> int -> floatroot x n calculates the nth root of x.Invalid_argument if n is negative or if the result would
be imaginaryval signbit : float -> boolx is set. This usually indicates thet x is negative.val copysign : float -> float -> floatcopysign x y returns a copy of x with the same sign as y.val is_nan : float -> boolis_nan f returns true if f is nan, false otherwise.val is_special : float -> boolis_special f returns true if f is nan or +/- infinity,
false otherwise.val is_finite : float -> boolis_finite f returns true if f is not nan or +/- infinity,
false otherwise.is_special, is_nan,
etc. testsval infinity : floatval neg_infinity : floatval nan : float0.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.val epsilon : floatx such that 1.0 +. x <> 1.0.val e : floatval log2e : floatMath.log2 eval log10e : floatlog10 eval ln2 : floatlog 2val ln10 : floatlog 10val pi : floatval pi2 : floatpi /. 2.val pi4 : floatpi /. 4.val invpi : float1. /. pival invpi2 : float2. /. pival sqrtpi2 : float2. *. sqrt pival sqrt2 : floatsqrt 2.val invsqrt2 : float1. /. sqrt 2.val frexp : float -> float * intfrexp 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 -> floatldexp x n returns x *. 2 ** n.val modf : float -> float * floatmodf f returns the pair of the fractional and integral
part of f.typefpkind =Pervasives.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 BatFloat.classify function.
val classify : float -> fpkindval approx_equal : ?epsilon:float -> float -> float -> boolepsilon defaults to 1e-5.module Infix:sig..end
module Compare:BatNumber.Comparewith type bat__compare_t = t
include BatNumber.RefOps
val print : (t, 'a) BatIO.printermodule Safe_float:sig..end