Percent (core.core.Core.Percent)

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

include Ppx_compare_lib.Comparable.S with type t := t

include Ppx_compare_lib.Comparable.S__local with type t := t

include Ppx_compare_lib.Equal.S with type t := t

include Ppx_compare_lib.Equal.S__local with type t := t

val globalize : t @ local -> t

include Ppx_hash_lib.Hashable.S_any with type t := t

val hash_fold_t : t Ppx_hash_lib.hash_fold

val hash : t -> Ppx_hash_lib.Std.Hash.hash_value

include Typerep_lib.Typerepable.S with type t := t

val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t @@ portable

val typename_of_t : t Typerep_lib.Typename.t @@ portable

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

val of_string : string -> t

val to_string : t @ local -> Base.String.t @@ portable

to_string can accept a locally-allocated argument.

val to_string_round_trippable : t @ local -> Base.String.t @@ portable

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

include Sexplib0.Sexpable.Of_sexp with type t := t

val t_of_sexp : Sexplib0.Sexp.t -> t

include Sexplib0.Sexpable.Sexp_of with type t := t

include Sexplib0.Sexpable.Sexp_of__stack with type t := t

val sexp_of_t : t -> Sexplib0.Sexp.t

include Sexplib.Sexp_grammar.S with type t := t

val t_sexp_grammar : t Sexplib0.Sexp_grammar.t @@ portable

include Bin_prot.Binable.S__local with type t := t

include Bin_prot.Binable.S_only_functions__local with type t := t

include sig ... end

val bin_size_t : t Bin_prot.Size.sizer

val bin_write_t : t Bin_prot.Write.writer

val bin_read_t : t Bin_prot.Read.reader

val __bin_read_t__ : t Bin_prot.Read.vtag_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.

val bin_shape_t : Bin_prot.Shape.t

val bin_writer_t : t Bin_prot.Type_class.writer

val bin_reader_t : t Bin_prot.Type_class.reader

val bin_t : t Bin_prot.Type_class.t

include Base.Comparable.S__local__portable with type t := t

include Base.Comparisons.S__local with type t := t

include Base.Comparisons.Infix with type t := 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 @@ portable

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 @@ portable

val between : t -> low:t -> high:t -> bool @@ portable

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

val clamp_exn : t -> min:t -> max:t -> t @@ portable

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 @@ portable

include Base.Comparator.S__portable with type t := t

type comparator_witness

module Replace_polymorphic_compare : 
  Base.Comparable.Comparisons__local with type t := t

include Comparator.S__portable
  with type t := t
  with type comparator_witness := comparator_witness

val comparator : (t, comparator_witness) Base.Comparator.T.comparator

module Map : 
  Map_intf.S_binable__portable
    with type Key.t = t
    with type Key.comparator_witness = comparator_witness

module Set : 
  Set_intf.S_binable__portable
    with type Elt.t = t
    with type Elt.comparator_witness = comparator_witness

include Comparable.With_zero with type t := t

include Base.Comparable.With_zero with type t := t

val is_positive : t -> bool

val is_non_negative : t -> bool

val is_negative : t -> bool

val is_non_positive : t -> bool

val validate_lbound : min:t Maybe_bound.t -> t Validate.check

val validate_ubound : max:t Maybe_bound.t -> t Validate.check

val validate_bound : 
  min:t Maybe_bound.t ->
  max:t Maybe_bound.t ->
  t Validate.check

val validate_positive : t Validate.check

val validate_non_negative : t Validate.check

val validate_negative : t Validate.check

val validate_non_positive : t Validate.check

include Diffable.S_atomic with type t := t

module Diff : sig ... end

include Robustly_comparable.S with type t := t

val (>=.) : t @ local -> (t @ local -> bool) @ local

val (<=.) : t @ local -> (t @ local -> bool) @ local

val (=.) : t @ local -> (t @ local -> bool) @ local

val (>.) : t @ local -> (t @ local -> bool) @ local

val (<.) : t @ local -> (t @ local -> bool) @ local

val (<>.) : t @ local -> (t @ local -> bool) @ local

val robustly_compare : t @ local -> (t @ local -> int) @ local

include Quickcheckable.S with type t := t

val quickcheck_generator : t Base_quickcheck.Generator.t

val quickcheck_observer : t Base_quickcheck.Observer.t

val quickcheck_shrinker : t Base_quickcheck.Shrinker.t

module Option : sig ... end

The value nan cannot be represented as an Option.t

val (*) : t -> t -> t @@ portable

val (+) : t -> t -> t @@ portable

val (-) : t -> t -> t @@ portable

val (/) : t -> t -> t @@ portable

val (//) : t -> t -> Base.Float.t @@ portable

val zero : t @@ portable

val one_hundred_percent : t @@ portable

val neg : t -> t @@ portable

val abs : t -> t @@ portable

The functions below come from a Comparable functor and do not handle NaN in any principled way. As of 2025-06-06, the non-legacy versions are updated to match the behavior of their Float counterparts w.r.t. NaN.

val min_legacy : t -> t -> t @@ portable

val max_legacy : t -> t -> t @@ portable

val clamp_legacy : t -> min:t -> max:t -> t Or_error.t @@ portable

val clamp_exn_legacy : t -> min:t -> max:t -> t @@ portable

val is_positive_legacy : t -> Base.Bool.t @@ portable

val is_non_negative_legacy : t -> Base.Bool.t @@ portable

val is_negative_legacy : t -> Base.Bool.t @@ portable

val is_non_positive_legacy : t -> Base.Bool.t @@ portable

val is_zero : t @ local -> Base.Bool.t @@ portable

val is_nan : t @ local -> Base.Bool.t @@ portable

val is_inf : t @ local -> Base.Bool.t @@ portable

val apply : t -> Base.Float.t -> Base.Float.t @@ portable

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

val scale : t -> Base.Float.t -> t @@ portable

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

val of_mult : Base.Float.t -> t @@ portable

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

val to_mult : t -> Base.Float.t @@ portable

val of_percentage : Base.Float.t @ local -> t @@ portable

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.

val of_percentage_slow_more_accurate : Base.Float.t -> t @@ portable

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 ^ "%")

val to_percentage : t @ local -> Base.Float.t @@ portable

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.

val to_percentage_slow_more_accurate : t -> Base.Float.t @@ portable

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

val of_bp : Base.Float.t @ local -> t @@ portable

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.

val of_bp_slow_more_accurate : Base.Float.t -> t @@ portable

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")

val to_bp : t @ local -> Base.Float.t @@ portable

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.

val to_bp_slow_more_accurate : t -> Base.Float.t @@ portable

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

val of_bp_int : Base.Int.t -> t @@ portable

val to_bp_int : t @ local -> Base.Int.t @@ portable

rounds down

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

0.0123456% ~significant_digits:4 is 1.235bp

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

0.0123456% ~decimal_digits:4 is 0.0001 = 1bp

val round_decimal_percentage : 
  t @ local ->
  (decimal_digits:Base.Int.t ->
  t) @ local @@ portable

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

val round_decimal_bp : 
  t @ local ->
  (decimal_digits:Base.Int.t ->
  t) @ local @@ portable

0.0123456% ~decimal_digits:4 is 1.2346bp

val t_of_sexp_allow_nan_and_inf : Sexp.t -> t @@ portable

val of_string_allow_nan_and_inf : Base.String.t -> t @@ portable

module Format : sig ... end

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

val format : t -> Format.t -> Base.String.t @@ portable

val validate : t -> Validate.t @@ portable

val sign : t -> Sign.t @@ portable

deprecated [since 2016-01] Replace [sign] with [sign_exn]

val sign_exn : t @ local -> Sign.t @@ portable

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

val arg_type : t Command.Arg_type.t @@ portable

val arg_type_allow_nan_and_inf : t Command.Arg_type.t @@ portable

module Stable : sig ... end

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

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