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, ...
val zero : floatThe floating point 0.
val one : floatThe floating-point 1.
val minus_one : floatThe floating-point -1.
val neg : float -> floatUnary negation.
val add : float -> float -> floatFloating-point addition.
val sub : float -> float -> floatFloating-point subtraction.
val mul : float -> float -> floatFloating-point multiplication.
val div : float -> float -> floatFloating-point division.
val fma : float -> float -> float -> floatfma 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.
val rem : float -> float -> floatrem 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 -> floatsucc x returns the floating point number right after x i.e.,
   the smallest floating-point number greater than x.  See also
   Float.next_after.
val pred : float -> floatpred x returns the floating-point number right before x i.e.,
   the greatest floating-point number smaller than x.  See also
   Float.next_after.
val abs : float -> floatabs f returns the absolute value of f.
val infinity : floatPositive infinity.
val neg_infinity : floatNegative infinity.
val nan : floatA 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.
val pi : floatThe constant pi.
val max_float : floatThe largest positive finite value of type float.
val min_float : floatThe smallest positive, non-zero, non-denormalized value of type float.
val epsilon : floatThe difference between 1.0 and the smallest exactly representable
    floating-point number greater than 1.0.
val is_finite : float -> boolis_finite x is true if and only if x is finite i.e., not infinite and
   not Float.nan.
val is_infinite : float -> boolis_infinite x is true if and only if x is Float.infinity or
    Float.neg_infinity.
val is_nan : float -> boolis_nan x is true if and only if x is not a number (see Float.nan).
val is_integer : float -> boolis_integer x is true if and only if x is an integer.
val of_int : int -> floatConvert an integer to floating-point.
val to_int : float -> intTruncate 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 -> floatConvert 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.
Failure if the given string is not a valid
    representation of a float.val of_string_opt : string -> float optionSame as of_string, but returns None instead of raising.
val to_string : float -> stringReturn the string representation of a floating-point number.
typefpclass =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 -> fpclassReturn the class of the given floating-point number: normal, subnormal, zero, infinite, or not a number.
val pow : float -> float -> floatExponentiation.
val sqrt : float -> floatSquare root.
val cbrt : float -> floatCube root.
val exp : float -> floatExponential.
val exp2 : float -> floatBase 2 exponential function.
val log : float -> floatNatural logarithm.
val log10 : float -> floatBase 10 logarithm.
val log2 : float -> floatBase 2 logarithm.
val expm1 : float -> floatexpm1 x computes exp x -. 1.0, giving numerically-accurate results
    even if x is close to 0.0.
val log1p : float -> floatlog1p x computes log(1.0 +. x) (natural logarithm),
    giving numerically-accurate results even if x is close to 0.0.
val cos : float -> floatCosine. Argument is in radians.
val sin : float -> floatSine. Argument is in radians.
val tan : float -> floatTangent. Argument is in radians.
val acos : float -> floatArc 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 -> floatArc 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 -> floatArc tangent.
    Result is in radians and is between -pi/2 and pi/2.
val atan2 : float -> float -> floatatan2 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 -> floathypot 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 -> floatHyperbolic cosine. Argument is in radians.
val sinh : float -> floatHyperbolic sine. Argument is in radians.
val tanh : float -> floatHyperbolic tangent. Argument is in radians.
val acosh : float -> floatHyperbolic arc cosine.  The argument must fall within the range
    [1.0, inf].
    Result is in radians and is between 0.0 and inf.
val asinh : float -> floatHyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
val atanh : float -> floatHyperbolic arc tangent.  The argument must fall within the range
    [-1.0, 1.0].
    Result is in radians and ranges over the entire real line.
val erf : float -> floatError function.  The argument ranges over the entire real line.
    The result is always within [-1.0, 1.0].
val erfc : float -> floatComplementary error function (erfc x = 1 - erf x).
    The argument ranges over the entire real line.
    The result is always within [-1.0, 1.0].
val trunc : float -> floattrunc x rounds x to the nearest integer whose absolute value is
   less than or equal to x.
val round : float -> floatround 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.
val ceil : float -> floatRound 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 -> floatRound 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 -> floatnext_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.
val copy_sign : float -> float -> floatcopy_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 -> boolsign_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.
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.
typet =float
An alias for the type of floating-point numbers.
val compare : t -> t -> intcompare 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 -> boolThe equal function for floating-point numbers, compared using Float.compare.
val min : t -> t -> tmin x y returns the minimum of x and y.  It returns nan
   when x or y is nan.  Moreover min (-0.) (+0.) = -0.
val max : float -> float -> floatmax x y returns the maximum of x and y.  It returns nan
   when x or y is nan.  Moreover max (-0.) (+0.) = +0.
val min_max : float -> float -> float * floatmin_max x y is (min x y, max x y), just more efficient.
val min_num : t -> t -> tmin_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.
val max_num : t -> t -> tmax_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.
val min_max_num : float -> float -> float * floatmin_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).
val hash : t -> intThe hash function for floating-point numbers.
module Array:sig..end
Float arrays with packed representation.
module ArrayLabels:sig..end
Float arrays with packed representation (labeled functions).