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 : float
0.
val one : float
1.
val neg : float -> float
val succ : float -> float
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.val pred : float -> float
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 abs : float -> float
val 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.numeric
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
val cos : float -> float
BatFloat.atan2
.val sin : float -> float
BatFloat.atan2
.val tan : float -> float
BatFloat.atan2
.val acos : float -> float
BatFloat.atan2
.val asin : float -> float
BatFloat.atan2
.val atan : float -> float
BatFloat.atan2
.val atan2 : float -> float -> float
val cosh : float -> float
BatFloat.tanh
.val sinh : float -> float
BatFloat.tanh
.val tanh : float -> float
val ceil : float -> float
BatFloat.floor
.val floor : float -> float
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
.val round : float -> float
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.
.val round_to_int : float -> int
round_to_int x
is int_of_float (round x)
.val round_to_string : ?digits:int -> float -> string
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.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_int
round_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 -> float
root x n
calculates the nth root of x.Invalid_argument
if n is negative or if the result would
be imaginaryval signbit : float -> bool
x
is set. This usually indicates thet x
is negative.val copysign : float -> float -> float
copysign x y
returns a copy of x
with the same sign as y
.val is_nan : float -> bool
is_nan f
returns true
if f
is nan
, false
otherwise.val is_special : float -> bool
is_special f
returns true
if f
is nan
or +/- infinity
,
false
otherwise.val is_finite : float -> bool
is_finite f
returns true
if f
is not nan
or +/- infinity
,
false
otherwise.is_special
, is_nan
,
etc. testsval infinity : float
val neg_infinity : float
val nan : float
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
.val epsilon : float
x
such that 1.0 +. x <> 1.0
.val e : float
val log2e : float
Math.log2 e
val log10e : float
log10 e
val ln2 : float
log 2
val ln10 : float
log 10
val pi : float
val pi2 : float
pi /. 2.
val pi4 : float
pi /. 4.
val invpi : float
1. /. pi
val invpi2 : float
2. /. pi
val sqrtpi2 : float
2. *. sqrt pi
val sqrt2 : float
sqrt 2.
val invsqrt2 : float
1. /. sqrt 2.
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
.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 -> fpkind
val approx_equal : ?epsilon:float -> float -> float -> bool
epsilon
defaults to 1e-5.module Infix:sig
..end
module Compare:BatNumber.Compare
with type bat__compare_t = t
include BatNumber.RefOps
val print : (t, 'a) BatIO.printer
module Safe_float:sig
..end