Module Core.FloatSource

Floating-point numbers.

Sourceval globalize : float -> float
Sourceval t_sexp_grammar : float Sexplib0.Sexp_grammar.t
include Base.Floatable.S with type t := float
Sourceval of_float : float -> float
Sourceval to_float : float -> float

max and min will return nan if either argument is nan.

The validate_* functions always fail if class is Nan or Infinite.

include Base.Identifiable.S with type t := float
include Sexplib0.Sexpable.S with type t := float
include Base.Stringable.S with type t := float
include Base.Comparable.S with type t := float
include Base.Comparisons.S with type t := float
include Base.Comparisons.Infix with type t := float
include Base.Comparator.S with type t := float
Sourcetype comparator_witness = Base.Float.comparator_witness
include Base.Pretty_printer.S with type t := float
Sourceval of_string_opt : string -> float option
include Base.Comparable.With_zero with type t := float
Sourceval is_positive : float -> bool
Sourceval is_non_negative : float -> bool
Sourceval is_negative : float -> bool
Sourceval is_non_positive : float -> bool
Sourceval equal__local : float -> float -> bool
Sourceval compare__local : float -> float -> int
include Base.Invariant.S with type t := float
Sourceval invariant : float -> unit
include Base.Comparisons.S_with_local_opt with type t := float
Sourceval nan : float
Sourceval infinity : float
Sourceval neg_infinity : float
Sourceval max_value : float

Equal to infinity.

Sourceval min_value : float

Equal to neg_infinity.

Sourceval zero : float
Sourceval one : float
Sourceval minus_one : float
Sourceval pi : float

The constant pi.

Sourceval sqrt_pi : float

The constant sqrt(pi).

Sourceval sqrt_2pi : float

The constant sqrt(2 * pi).

Sourceval euler : float

Euler-Mascheroni constant (γ).

Sourceval epsilon_float : float

The difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0. That is:

epsilon_float = (one_ulp `Up 1.0) -. 1.0

This gives the relative accuracy of type t, in the sense that for numbers on the order of x, the roundoff error is on the order of x *. float_epsilon.

See also: Machine epsilon.

Sourceval max_finite_value : float
Sourceval min_positive_subnormal_value : float
Sourceval min_positive_normal_value : float
Sourceval to_int64_preserve_order : float -> int64 option

An order-preserving bijection between all floats except for nans, and all int64s with absolute value smaller than or equal to 2**63 - 2**52. Note both 0. and -0. map to 0L.

Sourceval to_int64_preserve_order_exn : float -> int64
Sourceval of_int64_preserve_order : int64 -> float

Returns nan if the absolute value of the argument is too large.

Sourceval one_ulp : [ `Up | `Down ] -> float -> float

The next or previous representable float. ULP stands for "unit of least precision", and is the spacing between floating point numbers. Both one_ulp `Up infinity and one_ulp `Down neg_infinity return a nan.

Sourceval of_int : int -> float

Note that this doesn't round trip in either direction. For example, Float.to_int (Float.of_int max_int) <> max_int.

Sourceval to_int : float -> int
Sourceval of_int63 : Base.Int63.t -> float
Sourceval of_int64 : int64 -> float
Sourceval to_int64 : float -> int64
Sourceval round : ?dir:[ `Zero | `Nearest | `Up | `Down ] -> float -> float

round rounds a float to an integer float. iround{,_exn} rounds a float to an int. Both round according to a direction dir, with default dir being `Nearest.

  | `Down    | rounds toward Float.neg_infinity                             |
  | `Up      | rounds toward Float.infinity                                 |
  | `Nearest | rounds to the nearest int ("round half-integers up")         |
  | `Zero    | rounds toward zero                                           |

iround_exn raises when trying to handle nan or trying to handle a float outside the range [float min_int, float max_int).

Here are some examples for round for each direction:

  | `Down    | [-2.,-1.)   to -2. | [-1.,0.)   to -1. | [0.,1.) to 0., [1.,2.) to 1. |
  | `Up      | (-2.,-1.]   to -1. | (-1.,0.]   to -0. | (0.,1.] to 1., (1.,2.] to 2. |
  | `Zero    | (-2.,-1.]   to -1. | (-1.,1.)   to 0.  | [1.,2.) to 1.                |
  | `Nearest | [-1.5,-0.5) to -1. | [-0.5,0.5) to 0.  | [0.5,1.5) to 1.              |

For convenience, versions of these functions with the dir argument hard-coded are provided. If you are writing performance-critical code you should use the versions with the hard-coded arguments (e.g. iround_down_exn). The _exn ones are the fastest.

The following properties hold:

  • of_int (iround_*_exn i) = i for any float i that is an integer with min_int <= i <= max_int.
  • round_* i = i for any float i that is an integer.
  • iround_*_exn (of_int i) = i for any int i with -2**52 <= i <= 2**52.
Sourceval iround : ?dir:[ `Zero | `Nearest | `Up | `Down ] -> float -> int option
Sourceval iround_exn : ?dir:[ `Zero | `Nearest | `Up | `Down ] -> float -> int
Sourceval round_towards_zero : float -> float
Sourceval round_down : float -> float
Sourceval round_up : float -> float
Sourceval round_nearest : float -> float

Rounds half integers up.

Sourceval round_nearest_half_to_even : float -> float

Rounds half integers to the even integer.

Sourceval iround_towards_zero : float -> int option
Sourceval iround_down : float -> int option
Sourceval iround_up : float -> int option
Sourceval iround_nearest : float -> int option
Sourceval iround_towards_zero_exn : float -> int
Sourceval iround_down_exn : float -> int
Sourceval iround_up_exn : float -> int
Sourceval iround_nearest_exn : float -> int
Sourceval int63_round_down_exn : float -> Base.Int63.t
Sourceval int63_round_up_exn : float -> Base.Int63.t
Sourceval int63_round_nearest_exn : float -> Base.Int63.t
Sourceval iround_lbound : float

If f < iround_lbound || f > iround_ubound, then iround* functions will refuse to round f, returning None or raising as appropriate.

Sourceval iround_ubound : float
Sourceval int63_round_lbound : float
Sourceval int63_round_ubound : float
Sourceval round_significant : float -> significant_digits:int -> float

round_significant x ~significant_digits:n rounds to the nearest number with n significant digits. More precisely: it returns the representable float closest to x rounded to n significant digits. It is meant to be equivalent to sprintf "%.*g" n x |> Float.of_string but faster (10x-15x). Exact ties are resolved as round-to-even.

However, it might in rare cases break the contract above.

It might in some cases appear as if it violates the round-to-even rule:

  let x = 4.36083208835;;
  let z = 4.3608320883;;
  assert (z = fast_approx_round_significant x ~sf:11)

But in this case so does sprintf, since x as a float is slightly under-represented:

  sprintf "%.11g" x = "4.3608320883";;
  sprintf "%.30g" x = "4.36083208834999958014577714493"

More importantly, round_significant might sometimes give a different result than sprintf ... |> Float.of_string because it round-trips through an integer. For example, the decimal fraction 0.009375 is slightly under-represented as a float:

 sprintf "%.17g" 0.009375 = "0.0093749999999999997" 

But:

 0.009375 *. 1e5 = 937.5 

Therefore:

 round_significant 0.009375 ~significant_digits:3 = 0.00938 

whereas:

 sprintf "%.3g" 0.009375 = "0.00937" 

In general we believe (and have tested on numerous examples) that the following holds for all x:

  let s = sprintf "%.*g" significant_digits x |> Float.of_string in
  s = round_significant ~significant_digits x
  || s = round_significant ~significant_digits (one_ulp `Up x)
  || s = round_significant ~significant_digits (one_ulp `Down x)

Also, for float representations of decimal fractions (like 0.009375), round_significant is more likely to give the "desired" result than sprintf ... |> of_string (that is, the result of rounding the decimal fraction, rather than its float representation). But it's not guaranteed either--see the 4.36083208835 example above.

Sourceval round_decimal : float -> decimal_digits:int -> float

round_decimal x ~decimal_digits:n rounds x to the nearest 10**(-n). For positive n it is meant to be equivalent to sprintf "%.*f" n x |> Float.of_string, but faster.

All the considerations mentioned in round_significant apply (both functions use the same code path).

Sourceval is_nan : float -> bool
Sourceval is_inf : float -> bool

A float is infinite when it is either infinity or neg_infinity.

Sourceval is_finite : float -> bool

A float is finite when neither is_nan nor is_inf is true.

Sourceval is_integer : float -> bool

is_integer x is true if and only if x is an integer.

min_inan and max_inan return, respectively, the min and max of the two given values, except when one of the values is a nan, in which case the other is returned. (Returns nan if both arguments are nan.)

Sourceval min_inan : float -> float -> float
Sourceval max_inan : float -> float -> float
Sourceval (+) : float -> float -> float
Sourceval (-) : float -> float -> float
Sourceval (/) : float -> float -> float
Sourceval (%) : float -> float -> float

In analogy to Int.( % ), ( % ):

  • always produces non-negative (or NaN) result
  • raises when given a negative modulus.

Like the other infix operators, NaNs in mean NaNs out.

Other cases: (a % Infinity) = a when 0 <= a < Infinity, (a % Infinity) = Infinity when -Infinity < a < 0, (+/- Infinity % a) = NaN, (a % 0) = NaN.

Sourceval (*) : float -> float -> float
Sourceval (**) : float -> float -> float
Sourceval (~-) : float -> float
Sourcemodule Parts = Base.Float.Parts

Returns the fractional part and the whole (i.e., integer) part. For example, modf (-3.14) returns { fractional = -0.14; integral = -3.; }!

Sourceval modf : float -> Parts.t
Sourceval mod_float : float -> float -> float

mod_float x y returns a result with the same sign as x. It returns nan if y is 0. It is basically

 let mod_float x y = x -. float(truncate(x/.y)) *. y

not

 let mod_float x y = x -. floor(x/.y) *. y 

and therefore resembles mod on integers more than %.

Sourceval add : float -> float -> float

Ordinary functions for arithmetic operations

These are for modules that inherit from t, since the infix operators are more convenient.

Sourceval sub : float -> float -> float
Sourceval neg : float -> float
Sourceval scale : float -> float -> float
Sourceval abs : float -> float
Sourcemodule O_dot = Base.Float.O_dot

Similar to O, except that operators are suffixed with a dot, allowing one to have both int and float operators in scope simultaneously.

Sourceval to_string_hum : ?delimiter:char -> ?decimals:int -> ?strip_zero:bool -> ?explicit_plus:bool -> float -> string

Pretty print float, for example to_string_hum ~decimals:3 1234.1999 = "1_234.200" to_string_hum ~decimals:3 ~strip_zero:true 1234.1999 = "1_234.2" . No delimiters are inserted to the right of the decimal.

Sourceval to_padded_compact_string : float -> string

Produce a lossy compact string representation of the float. The float is scaled by an appropriate power of 1000 and rendered with one digit after the decimal point, except that the decimal point is written as '.', 'k', 'm', 'g', 't', or 'p' to indicate the scale factor. (However, if the digit after the "decimal" point is 0, it is suppressed.)

The smallest scale factor that allows the number to be rendered with at most 3 digits to the left of the decimal is used. If the number is too large for this format (i.e., the absolute value is at least 999.95e15), scientific notation is used instead. E.g.:

  • to_padded_compact_string (-0.01) = "-0 "
  • to_padded_compact_string 1.89 = "1.9"
  • to_padded_compact_string 999_949.99 = "999k9"
  • to_padded_compact_string 999_950. = "1m "

In the case where the digit after the "decimal", or the "decimal" itself is omitted, the numbers are padded on the right with spaces to ensure the last two columns of the string always correspond to the decimal and the digit afterward (except in the case of scientific notation, where the exponent is the right-most element in the string and could take up to four characters).

  • to_padded_compact_string 1. = "1 "
  • to_padded_compact_string 1.e6 = "1m "
  • to_padded_compact_string 1.e16 = "1.e+16"
  • to_padded_compact_string max_finite_value = "1.8e+308"

Numbers in the range -.05 < x < .05 are rendered as "0 " or "-0 ".

Other cases:

  • to_padded_compact_string nan = "nan "
  • to_padded_compact_string infinity = "inf "
  • to_padded_compact_string neg_infinity = "-inf "

Exact ties are resolved to even in the decimal:

  • to_padded_compact_string 3.25 = "3.2"
  • to_padded_compact_string 3.75 = "3.8"
  • to_padded_compact_string 33_250. = "33k2"
  • to_padded_compact_string 33_350. = "33k4"

to_padded_compact_string is defined in terms of to_padded_compact_string_custom below as

  let to_padded_compact_string t =
    to_padded_compact_string_custom t ?prefix:None
      ~kilo:"k" ~mega:"m" ~giga:"g" ~tera:"t" ~peta:"p"
      ()
Sourceval to_padded_compact_string_custom : float -> ?prefix:string -> kilo:string -> mega:string -> giga:string -> tera:string -> ?peta:string -> unit -> string

Similar to to_padded_compact_string but allows the user to provide different abbreviations. This can be useful to display currency values, e.g. $1mm3, where prefix="$", mega="mm".

Sourceval int_pow : float -> int -> float

int_pow x n computes x ** float n via repeated squaring. It is generally much faster than **.

Note that int_pow x 0 always returns 1., even if x = nan. This coincides with x ** 0. and is intentional.

For n >= 0 the result is identical to an n-fold product of x with itself under *., with a certain placement of parentheses. For n < 0 the result is identical to int_pow (1. /. x) (-n).

The error will be on the order of |n| ulps, essentially the same as if you perturbed x by up to a ulp and then exponentiated exactly.

Benchmarks show a factor of 5-10 speedup (relative to **) for exponents up to about 1000 (approximately 10ns vs. 70ns). For larger exponents the advantage is smaller but persists into the trillions. For a recent or more detailed comparison, run the benchmarks.

Depending on context, calling this function might or might not allocate 2 minor words. Even if called in a way that causes allocation, it still appears to be faster than **.

Sourceval square : float -> float

square x returns x *. x.

Sourceval ldexp : float -> int -> float

ldexp x n returns x *. 2 ** n

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 log10 : float -> float

Base 10 logarithm.

Sourceval log2 : float -> float

Base 2 logarithm.

Sourceval expm1 : float -> float

expm1 x computes exp x -. 1.0, giving numerically-accurate results even if x is close to 0.0.

Sourceval log1p : float -> float

log1p x computes log(1.0 +. x) (natural logarithm), giving numerically-accurate results even if x is close to 0.0.

Sourceval copysign : float -> float -> float

copysign 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.

Sourceval cos : float -> float

Cosine. Argument is in radians.

Sourceval sin : float -> float

Sine. Argument is in radians.

Sourceval tan : float -> float

Tangent. Argument is in radians.

Sourceval acos : float -> float

Arc cosine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between 0.0 and pi.

Sourceval asin : float -> float

Arc sine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between -pi/2 and pi/2.

Sourceval atan : float -> float

Arc tangent. Result is in radians and is between -pi/2 and pi/2.

Sourceval atan2 : float -> float -> float

atan2 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.

Sourceval hypot : float -> float -> float

hypot 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.

Sourceval cosh : float -> float

Hyperbolic cosine. Argument is in radians.

Sourceval sinh : float -> float

Hyperbolic sine. Argument is in radians.

Sourceval tanh : float -> float

Hyperbolic tangent. Argument is in radians.

Sourceval acosh : float -> float

Hyperbolic arc cosine. The argument must fall within the range [1.0, inf]. Result is in radians and is between 0.0 and inf.

Sourceval asinh : float -> float

Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.

Sourceval atanh : float -> float

Hyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]. Result is in radians and ranges over the entire real line.

Sourceval sqrt : float -> float

Square root.

Sourceval exp : float -> float

Exponential.

Sourceval log : float -> float

Natural logarithm.

Sourcemodule Class = Base.Float.Class

Excluding nan the floating-point "number line" looks like:

Sourceval classify : float -> Class.t
Sourceval sign_exn : float -> Base.Sign.t

The sign of a float. Both -0. and 0. map to Zero. Raises on nan. All other values map to Neg or Pos.

Sourceval sign_or_nan : float -> Base.Sign_or_nan.t

The sign of a float, with support for NaN. Both -0. and 0. map to Zero. All NaN values map to Nan. All other values map to Neg or Pos.

Sourceval create_ieee : negative:bool -> exponent:int -> mantissa:Base.Int63.t -> float Base.Or_error.t

These functions construct and destruct 64-bit floating point numbers based on their IEEE representation with a sign bit, an 11-bit non-negative (biased) exponent, and a 52-bit non-negative mantissa (or significand). See Wikipedia for details of the encoding.

In particular, if 1 <= exponent <= 2046, then:

  create_ieee_exn ~negative:false ~exponent ~mantissa
  = 2 ** (exponent - 1023) * (1 + (2 ** -52) * mantissa)
Sourceval create_ieee_exn : negative:bool -> exponent:int -> mantissa:Base.Int63.t -> float
Sourceval ieee_negative : float -> bool
Sourceval ieee_exponent : float -> int
Sourceval ieee_mantissa : float -> Base.Int63.t
include Typerep_lib.Typerepable.S with type t := t
Sourceval typename_of_t : t Typerep_lib.Typename.t
include Bin_prot.Binable.S_local with type t := t
include Bin_prot.Binable.S_local_only_functions with type t := t
Sourceval bin_size_t__local : t Bin_prot.Size.sizer_local
Sourceval bin_write_t__local : t Bin_prot.Write.writer_local
Sourcemodule Robust_compare : sig ... end

So-called "robust" comparisons, which include a small tolerance, so that float that differ by a small amount are considered equal.

Note that the results of robust comparisons on nan should be considered undefined.

include Robust_compare.S
Sourceval robust_comparison_tolerance : Base.Float.t

intended to be a tolerance on human-entered floats

include Robustly_comparable.S with type t := Base.Float.t
Sourceval (>=.) : Base.Float.t -> Base.Float.t -> bool
Sourceval (<=.) : Base.Float.t -> Base.Float.t -> bool
Sourceval (=.) : Base.Float.t -> Base.Float.t -> bool
Sourceval (>.) : Base.Float.t -> Base.Float.t -> bool
Sourceval (<.) : Base.Float.t -> Base.Float.t -> bool
Sourceval (<>.) : Base.Float.t -> Base.Float.t -> bool
Sourceval robustly_compare : Base.Float.t -> Base.Float.t -> int
Sourcemodule O : sig ... end
Sourcemodule Terse : sig ... end
include Identifiable.S with type t := t and type comparator_witness := Base.Float.comparator_witness
include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
Sourceval bin_size_t : t Bin_prot.Size.sizer
Sourceval bin_write_t : t Bin_prot.Write.writer
Sourceval bin_read_t : t Bin_prot.Read.reader
Sourceval __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

Sourceval bin_shape_t : Bin_prot.Shape.t
include Ppx_hash_lib.Hashable.S with type t := t
include Sexplib0.Sexpable.S with type t := t
Sourceval t_of_sexp : Sexplib0.Sexp.t -> t
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
Sourceval sexp_of_t : t -> Sexplib0.Sexp.t
include Base.Stringable.S with type t := t
Sourceval of_string : string -> t
include Base.Pretty_printer.S with type t := t
Sourceval pp : Base.Formatter.t -> t -> unit
include Comparable.S_binable with type t := t with type comparator_witness := Base.Float.comparator_witness
include Base.Comparable.S with type t := t with type comparator_witness := Base.Float.comparator_witness
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix with type t := t
Sourceval (>=) : t -> t -> bool
Sourceval (<=) : t -> t -> bool
Sourceval (=) : t -> t -> bool
Sourceval (>) : t -> t -> bool
Sourceval (<) : t -> t -> bool
Sourceval (<>) : t -> t -> bool
Sourceval equal : t -> t -> bool
Sourceval compare : t -> t -> int

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

Sourceval min : t -> t -> t
Sourceval max : t -> t -> t
Sourceval ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

Sourceval descending : t -> t -> int
Sourceval between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

Sourceval clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

Sourceval clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Hashable.S_binable with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
Sourceval hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
Sourceval hashable : t Base.Hashable.t
Sourcemodule Table : Hashtbl.S_binable with type key = t
Sourcemodule Hash_set : Hash_set.S_binable with type elt = t
Sourcemodule Hash_queue : Hash_queue.S with type key = t
include Comparable.Validate_with_zero with type t := t
Sourceval validate_lbound : min:t Maybe_bound.t -> t Validate.check
Sourceval validate_ubound : max:t Maybe_bound.t -> t Validate.check
Sourceval validate_bound : min:t Maybe_bound.t -> max:t Maybe_bound.t -> t Validate.check
Sourceval validate_positive : t Validate.check
Sourceval validate_non_negative : t Validate.check
Sourceval validate_negative : t Validate.check
Sourceval validate_non_positive : t Validate.check
Sourceval validate_ordinary : t Validate.check

validate_ordinary fails if class is Nan or Infinite.

Sourceval to_string_12 : t -> Base.String.t

to_string_12 x builds a string representing x using up to 12 significant digits. It loses precision. You can use "%{Float#12}" in formats, but consider "%.12g", "%{Float#hum}", or "%{Float}" as alternatives.

Sourceval to_string : t -> Base.String.t

to_string x builds a string s representing the float x that guarantees the round trip, i.e., Float.equal x (Float.of_string s).

It usually yields as few significant digits as possible. That is, it won't print 3.14 as 3.1400000000000001243. The only exception is that occasionally it will output 17 significant digits when the number can be represented with just 16 (but not 15 or fewer) of them.

include Quickcheckable.S with type t := t
Sourceval quickcheck_generator : t Base_quickcheck.Generator.t
Sourceval quickcheck_observer : t Base_quickcheck.Observer.t
Sourceval quickcheck_shrinker : t Base_quickcheck.Shrinker.t
Sourceval sign : t -> Sign.t
  • deprecated [since 2016-01] Replace [sign] with [robust_sign] or [sign_exn]
Sourceval robust_sign : t -> Sign.t

(Formerly sign) Uses robust comparison (so sufficiently small numbers are mapped to Zero). Also maps NaN to Zero. Using this function is weakly discouraged.

Sourceval gen_uniform_excl : t -> t -> t Quickcheck.Generator.t

gen_uniform_excl lo hi creates a Quickcheck generator producing finite t values between lo and hi, exclusive. The generator approximates a uniform distribution over the interval (lo, hi). Raises an exception if lo is not finite, hi is not finite, or the requested range is empty.

The implementation chooses values uniformly distributed between 0 (inclusive) and 1 (exclusive) up to 52 bits of precision, then scales that interval to the requested range. Due to rounding errors and non-uniform floating point precision, the resulting distribution may not be precisely uniform and may not include all values between lo and hi.

Sourceval gen_incl : t -> t -> t Quickcheck.Generator.t

gen_incl lo hi creates a Quickcheck generator that produces values between lo and hi, inclusive, approximately uniformly distributed, with extra weight given to generating the endpoints lo and hi. Raises an exception if lo is not finite, hi is not finite, or the requested range is empty.

gen_finite produces all finite t values, excluding infinities and all NaN values.

Sourceval gen_positive : t Quickcheck.Generator.t

gen_positive produces all (strictly) positive finite t values.

Sourceval gen_negative : t Quickcheck.Generator.t

gen_negative produces all (strictly) negative finite t values.

Sourceval gen_without_nan : t Quickcheck.Generator.t

gen_without_nan produces all finite and infinite t values, excluding all NaN values.

Sourceval gen_infinite : t Quickcheck.Generator.t

gen_infinite produces both infinite values

gen_nan produces all NaN values.

gen_normal produces all normal values

Sourceval gen_subnormal : t Quickcheck.Generator.t

gen_subnormal produces all subnormal values

gen_zero produces both zero values

Sourcemodule Stable : sig ... end

Note that float is already stable by itself, since as a primitive type it is an integral part of the sexp / bin_io protocol. Float.Stable exists only to introduce Float.Stable.Set and Float.Stable.Map, and provide interface uniformity with other stable types.