package batteries

  1. Overview
  2. Docs
package batteries
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module BatFloat.Safe_floatSource

Operations on floating-point numbers, with exceptions raised in case of error.

The operations implemented in this module are the same as the operations implemented in module Float, with the exception that no operation returns nan, infinity or neg_infinity. In case of overflow, instead of returning infinity or neg_infinity, operations raise exception Number.Overflow. In case of nan, operations raise exception Number.NaN.

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 David Teller

@documents Safe_float

Sourcetype t = float

The type of floating-point numbers.

Floating-point numbers are the default representation of real numbers by OCaml.

Usual operations
Sourceval zero : float

Floating number zero. This is the same thing as 0.

Sourceval one : float

Floating number one. This is the same thing as 1.

Sourceval neg : float -> float
Sourceval succ : float -> float

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.

Sourceval pred : float -> float

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.

Sourceval abs : float -> float

The absolute value of a floating point number.

Sourceval add : float -> float -> float
Sourceval sub : float -> float -> float
Sourceval mul : float -> float -> float
Sourceval div : float -> float -> float
Sourceval modulo : float -> float -> float
Sourceval pow : float -> float -> float
Sourceval compare : float -> float -> int
Sourceval of_int : int -> float
Sourceval to_int : float -> int
Sourceval of_float : float -> float
Sourceval to_float : float -> float
Sourceval of_string : string -> float
Sourceval to_string : float -> string
Sourceval (+) : t -> t -> t
Sourceval (-) : t -> t -> t
Sourceval (*) : t -> t -> t
Sourceval (/) : t -> t -> t
Sourceval (**) : t -> t -> t
Sourceval operations : t BatNumber.numeric
include BatNumber.Bounded with type bounded = t
Sourcetype bounded = t
Sourceval min_num : bounded
Sourceval max_num : bounded
Operations specific to floating-point numbers
Sourceval exp : float -> float

Exponential.

Sourceval log : float -> float

Natural logarithm.

Sourceval log10 : float -> float

Base 10 logarithm.

Sourceval cos : float -> float

See atan2.

Sourceval sin : float -> float

See atan2.

Sourceval tan : float -> float

See atan2.

Sourceval acos : float -> float

See atan2.

Sourceval asin : float -> float

See atan2.

Sourceval atan : float -> float

See atan2.

Sourceval atan2 : float -> float -> float

The usual trigonometric functions.

Sourceval cosh : float -> float

See tanh.

Sourceval sinh : float -> float

See tanh.

Sourceval tanh : float -> float

The usual hyperbolic trigonometric functions.

Sourceval ceil : float -> float

See floor.

Sourceval floor : float -> float

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.

Sourceval infinity : float

Positive infinity.

Sourceval neg_infinity : float

Negative infinity.

Sourceval 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. As for floating-point comparisons, =, <, <=, > and >= return false and <> returns true if one or both of their arguments is nan.

Sourceval is_nan : float -> bool

is_nan f returns true if f is nan, false otherwise.

Sourceval epsilon : float

The smallest positive float x such that 1.0 +. x <> 1.0.

Sourceval pi : float

The constant pi (3.14159...)

Operations on the internal representation of floating-point numbers
Sourceval 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.

Sourceval ldexp : float -> int -> float

ldexp x n returns x *. 2 ** n.

Sourceval modf : float -> float * float

modf f returns the pair of the fractional and integral part of f.

Sourcetype fpkind = Pervasives.fpclass =
  1. | FP_normal
    (*

    Normal number, none of the below

    *)
  2. | FP_subnormal
    (*

    Number very close to 0.0, has reduced precision

    *)
  3. | FP_zero
    (*

    Number is 0.0 or -0.0

    *)
  4. | FP_infinite
    (*

    Number is positive or negative infinity

    *)
  5. | FP_nan
    (*

    Not a number: result of an undefined operation

    *)

Classes of floating point numbers

The five classes of floating-point numbers, as determined by the classify function.

Sourceval classify : float -> fpkind

Return the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.

Boilerplate code
Sourceval print : 'a BatInnerIO.output -> t -> unit

Printing