Module Core_extended.Std.Float

include Core.Float

Floating-point numbers.

include sig ... end
val typerep_of_t : t Typerep_lib.Std.Typerep.t
val typename_of_t : t Typerep_lib.Std.Typename.t
module Robust_compare = Core_kernel.Float.Robust_compare

The results of robust comparisons on nan should be considered undefined.

include Robust_compare.S
val robust_comparison_tolerance : Core_kernel__.Import.float

intended to be a tolerance on human-entered floats

include Core_kernel.Robustly_comparable.S with type t := Core_kernel__.Import.float
type t
val (>=.) : t ‑> t ‑> bool
val (<=.) : t ‑> t ‑> bool
val (=.) : t ‑> t ‑> bool
val (>.) : t ‑> t ‑> bool
val (<.) : t ‑> t ‑> bool
val (<>.) : t ‑> t ‑> bool
val robustly_compare : t ‑> t ‑> int
include Core_kernel.Identifiable.S with type t := t and type comparator_witness := Base.Float.comparator_witness
type t
include sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Core_kernel__.Import.int ‑> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
include Core_kernel.Identifiable.S_common with type t := t
type t
include sig ... end
val compare : t ‑> t ‑> Core_kernel__.Import.int
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val sexp_of_t : t ‑> Base.Sexp.t
include Core_kernel__.Import.Stringable.S with type t := t
type t
val of_string : string ‑> t
val to_string : t ‑> string
include Core_kernel__.Import.Pretty_printer.S with type t := t
type t
val pp : Base.Formatter.t ‑> t ‑> unit
include Core_kernel.Comparable.S_binable with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable.S
include Base__.Comparable_intf.Polymorphic_compare
include Base.Comparisons.Infix
type t
val (>=) : t ‑> t ‑> bool
val (<=) : t ‑> t ‑> bool
val (=) : t ‑> t ‑> bool
val (>) : t ‑> t ‑> bool
val (<) : t ‑> t ‑> bool
val (<>) : t ‑> t ‑> bool
val equal : t ‑> t ‑> bool
val 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.

val min : t ‑> t ‑> t
val max : t ‑> t ‑> t
val 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.

val descending : t ‑> t ‑> int
val between : t ‑> low:t ‑> high:t ‑> bool

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

val 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).

val clamp : t ‑> min:t ‑> max:t ‑> t Base.Or_error.t
include Base.Comparator.S with type t := t
type t
type comparator_witness
include Base__.Comparable_intf.Validate with type t := t
type t
val validate_lbound : min:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_ubound : max:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_bound : min:t Base.Maybe_bound.t ‑> max:t Base.Maybe_bound.t ‑> t Base.Validate.check
include Core_kernel__.Comparable_intf.Map_and_set_binable with type t := t with type comparator_witness := comparator_witness
type t
include Core_kernel.Comparator.S with type t := t
type t
type comparator_witness
include Core_kernel.Hashable.S_binable with type t := t
type t
include sig ... end
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
include module type of sig ... end with type t := t with module O := Base.Float.O with module Terse := Base.Float.Terse
type t = float
val of_float : float ‑> t
val to_float : t ‑> float
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
val of_string : string ‑> t
val (>=) : t ‑> t ‑> bool
val (<=) : t ‑> t ‑> bool
val (=) : t ‑> t ‑> bool
val (>) : t ‑> t ‑> bool
val (<) : t ‑> t ‑> bool
val (<>) : t ‑> t ‑> bool
val equal : t ‑> t ‑> bool
val compare : t ‑> t ‑> int
val min : t ‑> t ‑> t
val max : t ‑> t ‑> t
val ascending : t ‑> t ‑> int
val descending : t ‑> t ‑> int
val between : t ‑> low:t ‑> high:t ‑> bool
val clamp_exn : t ‑> min:t ‑> max:t ‑> t
val clamp : t ‑> min:t ‑> max:t ‑> t Base.Or_error.t
type comparator_witness = Base__Float.comparator_witness
val validate_lbound : min:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_ubound : max:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_bound : min:t Base.Maybe_bound.t ‑> max:t Base.Maybe_bound.t ‑> t Base.Validate.check
val pp : Base.Formatter.t ‑> t ‑> unit
val validate_positive : t Base.Validate.check
val validate_non_negative : t Base.Validate.check
val validate_negative : t Base.Validate.check
val validate_non_positive : t Base.Validate.check
val is_positive : t ‑> bool
val is_non_negative : t ‑> bool
val is_negative : t ‑> bool
val is_non_positive : t ‑> bool
val validate_ordinary : t Base.Validate.check
val nan : t
val infinity : t
val neg_infinity : t
val max_value : t
val min_value : t
val zero : t
val one : t
val minus_one : t
val pi : t
val sqrt_pi : t
val sqrt_2pi : t
val euler : t
val epsilon_float : t
val max_finite_value : t
val min_positive_subnormal_value : t
val min_positive_normal_value : t
val to_int64_preserve_order : t ‑> int64 option
val to_int64_preserve_order_exn : t ‑> int64
val of_int64_preserve_order : int64 ‑> t
val one_ulp : [ `Down | `Up ] ‑> t ‑> t
val of_int : int ‑> t
val to_int : t ‑> int
val of_int63 : Base.Int63.t ‑> t
val of_int64 : int64 ‑> t
val to_int64 : t ‑> int64
val round : ?⁠dir:[ `Down | `Nearest | `Up | `Zero ] ‑> t ‑> t
val iround : ?⁠dir:[ `Down | `Nearest | `Up | `Zero ] ‑> t ‑> int option
val iround_exn : ?⁠dir:[ `Down | `Nearest | `Up | `Zero ] ‑> t ‑> int
val round_towards_zero : t ‑> t
val round_down : t ‑> t
val round_up : t ‑> t
val round_nearest : t ‑> t
val round_nearest_half_to_even : t ‑> t
val iround_towards_zero : t ‑> int option
val iround_down : t ‑> int option
val iround_up : t ‑> int option
val iround_nearest : t ‑> int option
val iround_towards_zero_exn : t ‑> int
val iround_down_exn : t ‑> int
val iround_up_exn : t ‑> int
val iround_nearest_exn : t ‑> int
val int63_round_down_exn : t ‑> Base.Int63.t
val int63_round_up_exn : t ‑> Base.Int63.t
val int63_round_nearest_exn : t ‑> Base.Int63.t
val iround_lbound : t
val iround_ubound : t
val round_significant : float ‑> significant_digits:int ‑> float
val round_decimal : float ‑> decimal_digits:int ‑> float
val is_nan : t ‑> bool
val is_inf : t ‑> bool
val min_inan : t ‑> t ‑> t
val max_inan : t ‑> t ‑> t
val (+) : t ‑> t ‑> t
val (-) : t ‑> t ‑> t
val (/) : t ‑> t ‑> t
val (*) : t ‑> t ‑> t
val (**) : t ‑> t ‑> t
val (~-) : t ‑> t
val modf : t ‑> Parts.t
val mod_float : t ‑> t ‑> t
val add : t ‑> t ‑> t
val sub : t ‑> t ‑> t
val neg : t ‑> t
val scale : t ‑> t ‑> t
val abs : t ‑> t
module O = Base__Float.O
val to_string : t ‑> string
val to_string_hum : ?⁠delimiter:char ‑> ?⁠decimals:int ‑> ?⁠strip_zero:bool ‑> t ‑> string
val to_padded_compact_string : t ‑> string
val int_pow : t ‑> int ‑> t
val ldexp : t ‑> int ‑> t
val frexp : t ‑> t * int
external log10 : t ‑> t = "caml_log10_float" "log10"
external expm1 : t ‑> t = "caml_expm1_float" "caml_expm1"
external log1p : t ‑> t = "caml_log1p_float" "caml_log1p"
external copysign : t ‑> t ‑> t = "caml_copysign_float" "caml_copysign"
external cos : t ‑> t = "caml_cos_float" "cos"
external sin : t ‑> t = "caml_sin_float" "sin"
external tan : t ‑> t = "caml_tan_float" "tan"
external acos : t ‑> t = "caml_acos_float" "acos"
external asin : t ‑> t = "caml_asin_float" "asin"
external atan : t ‑> t = "caml_atan_float" "atan"
external atan2 : t ‑> t ‑> t = "caml_atan2_float" "atan2"
external hypot : t ‑> t ‑> t = "caml_hypot_float" "caml_hypot"
external cosh : t ‑> t = "caml_cosh_float" "cosh"
external sinh : t ‑> t = "caml_sinh_float" "sinh"
external tanh : t ‑> t = "caml_tanh_float" "tanh"
external sqrt : t ‑> t = "caml_sqrt_float" "sqrt"
external exp : t ‑> t = "caml_exp_float" "exp"
external log : t ‑> t = "caml_log_float" "log"
val classify : t ‑> Class.t
val is_finite : t ‑> bool
val sign : t ‑> Base.Sign.t
  • Deprecated [since 2016-01] Replace [sign] with [robust_sign] or [sign_exn]
val sign_exn : t ‑> Base.Sign.t
val sign_or_nan : t ‑> Sign_or_nan.t
val create_ieee : negative:bool ‑> exponent:int ‑> mantissa:Base.Int63.t ‑> t Base.Or_error.t
val create_ieee_exn : negative:bool ‑> exponent:int ‑> mantissa:Base.Int63.t ‑> t
val ieee_negative : t ‑> bool
val ieee_exponent : t ‑> int
val ieee_mantissa : t ‑> Base.Int63.t
val to_string_12 : t ‑> Core_kernel__.Import.string

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.

val to_string : t ‑> Core_kernel__.Import.string

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.

val to_string_round_trippable : t ‑> Core_kernel__.Import.string
  • Deprecated [since 2017-04] Use [Float.to_string]
include Core_kernel.Quickcheckable.S with type t := t
type 'a gen
type 'a obs
type 'a shr
type t
val gen : t gen
val obs : t obs
val shrinker : t shr
val sign : t ‑> Core_kernel.Sign.t
  • Deprecated [since 2016-01] Replace [sign] with [robust_sign] or [sign_exn]
val robust_sign : t ‑> Core_kernel.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.

val gen_uniform_excl : t ‑> t ‑> t Core_kernel.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.

val gen_incl : t ‑> t ‑> t Core_kernel.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.

val gen_finite : t Core_kernel.Quickcheck.Generator.t

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

val gen_positive : t Core_kernel.Quickcheck.Generator.t

gen_positive produces all (strictly) positive finite t values.

val gen_negative : t Core_kernel.Quickcheck.Generator.t

gen_negative produces all (strictly) negative finite t values.

val gen_without_nan : t Core_kernel.Quickcheck.Generator.t

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

include Extended_float

Extensions to Core.Float.

val pretty : ?⁠on_negative:[ `Blow_up | `Normal | `Print_dir ] ‑> float ‑> string

pretty-print a float using no more than five characters, using abberviations k, m, g, t.

if on_negative is not set to `Normal then the resulting is never over four chars but upon negative number we either:

  • raise a failure
  • or print "<0"
val to_string_hum : float ‑> string
val order_of_magnitude_difference : float ‑> float ‑> int

order_of_magnitude_difference a b by how many orders of magnitude do a and b differ? The return value is non-negative.

examples:

  • order_of_magnitude_difference 11. 1001. = 2
  • order_of_magnitude_difference 1001. 11. = 2
  • order_of_magnitude_difference 131. 11. = 1
  • order_of_magnitude_difference 200. 0.003 = 5
include Number.Verified_std with type repr = Core.Float.t
type repr = Core.Float.t
module type S : Number.S with type repr = repr

Abbreviations

module type S0 : Number.S0 with type repr = repr
module Pos : S with type t = private repr

Positive and negative numbers with and without zero.

module Pos0 : S0 with type t = private repr
module Neg : S with type t = private repr
module Neg0 : S0 with type t = private repr
module type Bounded_spec : sig ... end

Specification of bounded numbers

module type Bounded : sig ... end

Signature of bounded numbers

module Make_bounded : functor (Spec : Bounded_spec) -> Bounded with type t = private repr

Functor of creating bounded numbers

Unsafe modules and functors that still fully expose the representation for extensibility.

module Pos_unsafe : S with type t = repr
module Pos0_unsafe : S0 with type t = repr
module Neg_unsafe : S with type t = repr
module Neg0_unsafe : S0 with type t = repr
module Make_bounded_unsafe : functor (Spec : Bounded_spec) -> Bounded with type t = repr
module type Fraction : sig ... end
module Fraction = Extended_float.Fraction
module Fraction_unsafe = Extended_float.Fraction_unsafe