Module Bignum.Bignum0

type t
include sig ... end

Sexp conversions represent values as decimals of up to nine decimal places if possible, or else as (x + y/z) where x is decimal and y and z are integers. So for example, 1/3 <-> (0.333333333 + 1/3000000000). In string and sexp conversions, values with denominator of zero are special-cased: 0/0 <-> "nan", 1/0 <-> "inf", and -1/0 <-> "-inf".

include Core_kernel.Sexpable with type t := t
type t
val t_of_sexp : Base__.Sexplib.Sexp.t ‑> t
val sexp_of_t : t ‑> Base__.Sexplib.Sexp.t
include Core_kernel.Comparable with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable_intf.S
include Base.Comparable_intf.Polymorphic_compare
include Base.Polymorphic_compare_intf.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

-1 means "less than", 0 means "equal", 1 means "greater than", and other values should not be returned

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 ~cmp: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
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.Floatable with type t := t
type t
val of_float : float ‑> t
val to_float : t ‑> float
include Core_kernel.Hashable with type t := t
include Core_kernel.Hashable.Common
type t
val hash : t ‑> Core_kernel__.Import.int
val compare : t ‑> t ‑> Core_kernel__.Import.int
module Hash_set : Core_kernel.Hash_set.S with type elt = t

gen produces values with an order of magnitude (roughly the number of digits) in the numerator and denominator proportional to Quickcheck.Generator.size. Also includes values with zero in the denominator.

include Core_kernel.Binable with type t := t
type t
include Core_kernel__.Binable0.S_only_functions with type t := t
type t
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__ : (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.

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

gen produces values with an order of magnitude (roughly the number of digits) in the numerator and denominator proportional to Quickcheck.Generator.size. Also includes values with zero in the denominator.

include Core_kernel.Quickcheckable 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 zero : t
val one : t
val ten : t
val hundred : t
val thousand : t
val million : t
val billion : t
val trillion : t
val tenth : t
val hundredth : t
val thousandth : t
val millionth : t
val billionth : t
val trillionth : t
val (+) : t ‑> t ‑> t
val (-) : t ‑> t ‑> t
val (/) : t ‑> t ‑> t
val (*) : t ‑> t ‑> t

Beware: 2 ** 8_000_000 will take at least a megabyte to store the result, and multiplying numbers a megabyte long is slow no matter how clever your algorithm. Be careful to ensure the second argument is reasonably-sized.

val (**) : t ‑> int ‑> t

Beware: 2 ** 8_000_000 will take at least a megabyte to store the result, and multiplying numbers a megabyte long is slow no matter how clever your algorithm. Be careful to ensure the second argument is reasonably-sized.

val abs : t ‑> t
val neg : t ‑> t
val inverse : t ‑> t
val sum : t list ‑> t
val round : ?dir:[ `Down | `Up | `Nearest | `Zero ] ‑> ?to_multiple_of:t ‑> t ‑> t

Default rounding direction is `Nearest. to_multiple_of defaults to one and must not be zero.

val iround : ?dir:[ `Down | `Up | `Nearest | `Zero ] ‑> ?to_multiple_of:int ‑> t ‑> int option

None if the result would overflow or to_multiple_of is zero.

val round_as_bigint : ?dir:[ `Down | `Up | `Nearest | `Zero ] ‑> ?to_multiple_of:Bigint.t ‑> t ‑> Bigint.t option
val iround_exn : ?dir:[ `Down | `Up | `Nearest | `Zero ] ‑> ?to_multiple_of:int ‑> t ‑> int

Exception if the result would overflow or to_multiple_of is zero.

val round_as_bigint_exn : ?dir:[ `Down | `Up | `Nearest | `Zero ] ‑> ?to_multiple_of:Bigint.t ‑> t ‑> Bigint.t
val round_decimal : ?dir:[ `Down | `Up | `Nearest | `Zero ] ‑> digits:int ‑> t ‑> t

Convenience wrapper around round to round to the specified number of decimal digits.

val to_string : t ‑> string

Decimal. Output is truncated (not rounded) to nine decimal places, so may be lossy. Consider using sexp_of_t if you need lossless stringification.

val to_float : t ‑> float

Rounds toward zero. None if the conversion would overflow

val to_int : t ‑> int option

Rounds toward zero. None if the conversion would overflow

val to_int_exn : t ‑> int
val is_zero : t ‑> bool
val sign : t ‑> int
val of_string : string ‑> t
val of_int : int ‑> t
val of_float : float ‑> t
val num : t ‑> t

num t returns the numerator of the numeric

val den : t ‑> t

den t returns the denominator of the numeric

val of_bigint : Bigint.t ‑> t
val num_as_bigint : t ‑> Bigint.t
val den_as_bigint : t ‑> Bigint.t
val pp : Format.formatter ‑> t ‑> unit
val gen_finite : t Core_kernel.Quickcheck.Generator.t

gen_finite is like gen but excludes values with zero in the denominator.

val gen_uniform_excl : t ‑> t ‑> t Core_kernel.Quickcheck.Generator.t

gen_uniform_excl lower_bound upper_bound produces a uniform distribution between lower_bound and upper_bound, exclusive, in units based on the fractional parts of the bounds plus a number of decimal places proportional to Quickcheck.Generator.size.

val gen_incl : t ‑> t ‑> t Core_kernel.Quickcheck.Generator.t

gen_incl lower_bound upper_bound produces a distribution of values between lower_bound and upper_bound, inclusive, that is approximately uniform with extra weight given to producing the endpoints lower_bound and upper_bound.

module Stable : sig ... end
module O : sig ... end