package core

  1. Overview
  2. Docs

Module Core.PercentSource

A scale factor, not bounded between 0% and 100%, represented as a float.

Sourcetype t = private Base.Float.t

Exposing that this is a float allows for more optimization. E.g. compiler can optimize some local refs and not box them.

Sourceval globalize : t -> t
include Ppx_hash_lib.Hashable.S with type t := t
Sourceval hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
include Typerep_lib.Typerepable.S with type t := t
Sourceval typename_of_t : t Typerep_lib.Typename.t

of_string and t_of_sexp disallow nan, inf, etc. Furthermore, they round to 6 significant digits. They are equivalent to Stable.V2 sexp conversion.

include Interfaces.Stringable with type t := t
Sourceval of_string : string -> t
Sourceval to_string : t -> string
Sourceval to_string_round_trippable : t -> Base.String.t

Equivalent to Stable.V3.to_string

Sexps are of the form 5bp or 0.05% or 0.0005x.

Warning: equal (t) (t_of_sexp (sexp_of_t t)) is not guaranteed.

First, sexp_of_t truncates to 6 significant digits. Second, multiple serialization round-trips may cause further multiple small drifts.

The sexp conversion here is V2 and not V3 to avoid breaking existing code at the time V3 was introduced (Nov 2022).

New code should explicitly use Percent.Stable.V3 for faithful round-trippable sexp conversion.

include Interfaces.Sexpable with type t := t
Sourceval t_of_sexp : Sexplib0.Sexp.t -> t
Sourceval sexp_of_t : t -> Sexplib0.Sexp.t
include Sexplib.Sexp_grammar.S with type t := t
Sourceval t_sexp_grammar : t Sexplib0.Sexp_grammar.t
include Interfaces.Binable 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 Interfaces.Comparable_binable with type t := t
include Base.Comparable.S with type t := t
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 Base.Comparator.S with type t := t
Sourcetype comparator_witness
include Comparator.S with type t := t with type comparator_witness := comparator_witness
include Comparable.With_zero with type t := t
include Base.Comparable.With_zero with type t := t
Sourceval is_positive : t -> bool
Sourceval is_non_negative : t -> bool
Sourceval is_negative : t -> bool
Sourceval is_non_positive : t -> bool
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
include Diffable.S_atomic with type t := t
Sourcemodule Diff : sig ... end
include Robustly_comparable.S 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 robustly_compare : t -> t -> int
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
Sourcemodule Option : sig ... end

The value nan cannot be represented as an Option.t

Sourceval (*) : t -> t -> t
Sourceval (+) : t -> t -> t
Sourceval (-) : t -> t -> t
Sourceval (/) : t -> t -> t
Sourceval (//) : t -> t -> Base.Float.t
Sourceval zero : t
Sourceval one_hundred_percent : t
Sourceval neg : t -> t
Sourceval abs : t -> t
Sourceval is_zero : t -> Base.Bool.t
Sourceval is_nan : t -> Base.Bool.t
Sourceval is_inf : t -> Base.Bool.t

apply t x multiplies the percent t by x, returning a float.

Sourceval scale : t -> Base.Float.t -> t

scale t x scales the percent t by x, returning a new t.

Sourceval of_mult : Base.Float.t -> t

of_mult 5. is 5x = 500% = 50_000bp

Sourceval to_mult : t -> Base.Float.t
Sourceval of_percentage : Base.Float.t -> t

of_percentage 5. is 5% = 0.05x = 500bp. Note: this function performs float division by 100.0 and it may introduce rounding errors, for example:

 of_percentage 70.18 |> to_mult = 0.70180000000000009

It is also not consistent with of_string or t_of_sexp for "%"-ending strings. The results can be off by an ulp. If this matters to you, use of_percentage_slow_more_accurate instead.

Sourceval of_percentage_slow_more_accurate : Base.Float.t -> t

Like of_percentage, but consistent with of_string and t_of_sexp, that is, of_percentage_slow_more_accurate x = of_string (Float.to_string x ^ "%")

Sourceval to_percentage : t -> Base.Float.t

to_percentage (Percent.of_string "5%") is 5.0. Note: this function performs float multiplication by 100.0 and it may introduce rounding errors, for example:

 to_percentage (Percent.of_mult 0.56) = 56.000000000000007

It is also not consistent with Stable.V3.sexp_of_t or to_string_round_trippable. If this matters to you, use to_percentage_slow_more_accurate instead.

Sourceval to_percentage_slow_more_accurate : t -> Base.Float.t

Like to_percentage, but consistent with Stable.V3.sexp_of_t and to_string_round_trippable.

Sourceval of_bp : Base.Float.t -> t

of_bp 5. is 5bp = 0.05% = 0.0005x. Note: this function performs float division by 10,000.0 and it may introduce rounding errors, for example:

 of_bp 70.18 |> to_mult = 0.0070180000000000008

It is also not consistent with of_string or t_of_sexp for "bp"-ending strings. The results can be off by an ulp. If this matters to you, use of_bp_slow_more_accurate instead.

Sourceval of_bp_slow_more_accurate : Base.Float.t -> t

Like of_bp, but consistent with of_string and t_of_sexp, that is, of_bp_slow_more_accurate x = of_string (Float.to_string x ^ "bp")

Sourceval to_bp : t -> Base.Float.t

to_bp (Percent.of_bp "4bp") is 4.0. Note: this function performs float multiplication by 10000.0 and and it may introduce rounding errors, for example:

 to_bp (Percent.of_mult 0.56) = 5600.0000000000009

It is also not consistent with Stable.V3.sexp_of_t or to_string_round_trippable. If this matters to you, use to_bp_slow_more_accurate instead.

Sourceval to_bp_slow_more_accurate : t -> Base.Float.t

Like to_bp, but consistent with Stable.V3.sexp_of_t and to_string_round_trippable.

Sourceval of_bp_int : Base.Int.t -> t
Sourceval to_bp_int : t -> Base.Int.t

rounds down

Sourceval round_significant : t -> significant_digits:Base.Int.t -> t

0.0123456% ~significant_digits:4 is 1.235bp

Sourceval round_decimal_mult : t -> decimal_digits:Base.Int.t -> t

0.0123456% ~decimal_digits:4 is 0.0001 = 1bp

Sourceval round_decimal_percentage : t -> decimal_digits:Base.Int.t -> t

0.0123456% ~decimal_digits:4 is 0.0123% = 1.23bp

Sourceval round_decimal_bp : t -> decimal_digits:Base.Int.t -> t

0.0123456% ~decimal_digits:4 is 1.2346bp

Sourceval t_of_sexp_allow_nan_and_inf : Sexp.t -> t
Sourceval of_string_allow_nan_and_inf : Base.String.t -> t
Sourcemodule Format : sig ... end

A Format.t tells Percent.format how to render a floating-point value as a string, like a printf conversion specification.

Sourceval format : t -> Format.t -> Base.String.t
Sourceval validate : t -> Validate.t
Sourceval sign : t -> Sign.t
  • deprecated [since 2016-01] Replace [sign] with [sign_exn]
Sourceval sign_exn : t -> Sign.t

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

Sourcemodule Stable : sig ... end
Sourcemodule Always_percentage : sig ... end

Does not format small values as "3bp" or large ones as "2x"; always uses percentages ("0.0003%" or "200%"). The standard of_sexp can read these just fine.

Sourcemodule Almost_round_trippable : sig ... end

Similar to Stable.V3, but rounds to 14 significant digits in order to make the output more palatable to humans, at the cost of making it not exactly round-trippable, e.g.