package bignum

You can search for identifiers within the package.

in-package search v0.2.0

package bignum

bignum
- Bignum
  - For_testing
  - Hash_queue
  - Hash_set
    
    Provide_bin_io
    
    X
    
    Provide_of_sexp
    
    X
  - Map
    
    Diff
    
    Key
    
    Provide_hash
    
    Provide_of_sexp
    
    Key
  - O
  - Set
    
    Diff
    
    Elt
    
    Provide_hash
    
    Provide_of_sexp
    
    Elt
  - Stable
    
    V1
    
    For_testing
    
    V2
    
    For_testing
    
    V3
    
    For_testing
  - Table
    
    Provide_bin_io
    
    Key
    
    Provide_of_sexp
    
    Key
  - Unstable
bignum.bigint
- Bigint
  - Binary
  - Hash_queue
  - Hash_set
    
    Provide_bin_io
    
    X
    
    Provide_of_sexp
    
    X
  - Hex
  - Map
    
    Diff
    
    Key
    
    Provide_hash
    
    Provide_of_sexp
    
    Key
  - O
  - Set
    
    Diff
    
    Elt
    
    Provide_hash
    
    Provide_of_sexp
    
    Elt
  - Stable
    
    V1
    
    V2
  - Table
    
    Provide_bin_io
    
    Key
    
    Provide_of_sexp
    
    Key
  - Unstable

Legend:
Library
Module
Module type
Parameter
Class
Class type

type t

gen produces integers representable within Quickcheck.size bytes, with a random sign.

include Core.Int_intf.S_unbounded with type t := t

include Base.Int.S_unbounded with type t := t

val t_sexp_grammar : t Sexplib0.Sexp_grammar.t

val of_float : float -> t

val to_float : t -> float

val of_int_exn : int -> t

val to_int_exn : t -> int

type comparator_witness

val is_positive : t -> bool

val is_non_negative : t -> bool

val is_negative : t -> bool

val is_non_positive : t -> bool

val sign : t -> Base__Comparable_intf.Sign.t

val compare__local : t Base__Ppx_compare_lib.compare__local

val equal__local : t Base__Ppx_compare_lib.equal__local

val invariant : t Base__Invariant_intf.inv

val of_string_opt : string -> t option

val to_string_hum : ?delimiter:char -> t -> string

val zero : t

val one : t

val minus_one : t

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

val (-) : t -> t -> t

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

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

val neg : t -> t

val (~-) : t -> t

val (/%) : t -> t -> t

val (%) : t -> t -> t

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

val rem : t -> t -> t

val (//) : t -> t -> float

val (land) : t -> t -> t

val (lor) : t -> t -> t

val (lxor) : t -> t -> t

val lnot : t -> t

val (lsl) : t -> int -> t

val (asr) : t -> int -> t

val round : 
  ?dir:[ `Down | `Nearest | `Up | `Zero ] ->
  t ->
  to_multiple_of:t ->
  t

val round_towards_zero : t -> to_multiple_of:t -> t

val round_down : t -> to_multiple_of:t -> t

val round_up : t -> to_multiple_of:t -> t

val round_nearest : t -> to_multiple_of:t -> t

val abs : t -> t

val succ : t -> t

val pred : t -> t

val pow : t -> t -> t

val bit_and : t -> t -> t

val bit_or : t -> t -> t

val bit_xor : t -> t -> t

val bit_not : t -> t

val popcount : t -> int

val shift_left : t -> int -> t

val shift_right : t -> int -> t

val decr : t Base__.Import.ref -> unit

val incr : t Base__.Import.ref -> unit

val of_int32_exn : int32 -> t

val to_int32_exn : t -> int32

val of_int64_exn : int64 -> t

val of_nativeint_exn : nativeint -> t

val to_nativeint_exn : t -> nativeint

val of_float_unchecked : float -> t

module O : sig ... end

include Core.Int_intf.Extension
  with type t := t
  with type comparator_witness := comparator_witness

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

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

val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t

val typename_of_t : t Typerep_lib.Typename.t

include Core.Int_intf.Binaryable with type t := t

module Binary : sig ... end

include Base.Int.Binaryable with type t := t and module Binary := Binary

include Core.Int_intf.Hexable with type t := t

module Hex : sig ... end

include Base.Int.Hexable with type t := t and module Hex := Hex

include Core.Identifiable.S
  with type t := t
  with type comparator_witness := comparator_witness

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

val 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

val 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

val sexp_of_t : t -> Sexplib0.Sexp.t

val of_string : string -> t

val to_string : t -> string

val pp : Base__.Formatter.t -> t -> unit

include Core.Comparable.S_binable
  with type t := t
  with type comparator_witness := comparator_witness

include Base.Comparable.S
  with type t := t
  with type comparator_witness := comparator_witness

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

module Replace_polymorphic_compare : sig ... end

include Core.Comparator.S
  with type t := t
  with type comparator_witness := comparator_witness

val comparator : (t, comparator_witness) Core.Comparator.comparator

module Map : 
  Core.Map.S_binable
    with type Key.t = t
    with type Key.comparator_witness = comparator_witness

module Set : 
  Core.Set.S_binable
    with type Elt.t = t
    with type Elt.comparator_witness = comparator_witness

include Core.Hashable.S_binable with type t := t

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

val hash_fold_t : t Base__Ppx_hash_lib.hash_fold

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

val hashable : t Core__.Hashtbl.Hashable.t

module Table : Core.Hashtbl.S_binable with type key = t

module Hash_set : Core.Hash_set.S_binable with type elt = t

module Hash_queue : Core.Hash_queue.S with type key = t

include Core.Comparable.Validate_with_zero with type t := t

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

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

val validate_bound : 
  min:t Core.Maybe_bound.t ->
  max:t Core.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 Core.Quickcheckable.S_int with type t := t

include Core.Quickcheck_intf.S_range with type t := t

include Core.Quickcheck_intf.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

val gen_incl : t -> t -> t Base_quickcheck.Generator.t

gen_incl lower_bound upper_bound produces values between lower_bound and upper_bound, inclusive. It uses an ad hoc distribution that stresses boundary conditions more often than a uniform distribution, while still able to produce any value in the range. Raises if lower_bound > upper_bound.

val gen_uniform_incl : t -> t -> t Base_quickcheck.Generator.t

gen_uniform_incl lower_bound upper_bound produces a generator for values uniformly distributed between lower_bound and upper_bound, inclusive. Raises if lower_bound > upper_bound.

val gen_log_uniform_incl : t -> t -> t Base_quickcheck.Generator.t

gen_log_uniform_incl lower_bound upper_bound produces a generator for values between lower_bound and upper_bound, inclusive, where the number of bits used to represent the value is uniformly distributed. Raises if (lower_bound < 0) || (lower_bound > upper_bound).

val gen_log_incl : t -> t -> t Base_quickcheck.Generator.t

gen_log_incl lower_bound upper_bound is like gen_log_uniform_incl, but weighted slightly more in favor of generating lower_bound and upper_bound specifically.

val to_int64_exn : t -> Core.Int64.t

val to_int : t -> int option

val to_int32 : t -> Core.Int32.t option

val to_int64 : t -> Core.Int64.t option

val to_nativeint : t -> nativeint option

val of_int : int -> t

val of_int32 : Core.Int32.t -> t

val of_int64 : Core.Int64.t -> t

val of_nativeint : nativeint -> t

val to_zarith_bigint : t -> Bigint__.Zarith.Z.t

val of_zarith_bigint : Bigint__.Zarith.Z.t -> t

val random : ?state:Core.Random.State.t -> t -> t

random t produces a value uniformly distributed between zero (inclusive) and t (exclusive), or raises if t <= zero.

val gen_positive : t Core.Quickcheck.Generator.t

val gen_negative : t Core.Quickcheck.Generator.t

module Stable : sig ... end

module Unstable : sig ... end

val bin_size_t : t Core.Bin_prot.Size.sizer

deprecated [since 2019-10] use module V1 or Unstable instead

val bin_write_t : t Core.Bin_prot.Write.writer

deprecated [since 2019-10] use module V1 or Unstable instead

val bin_read_t : t Core.Bin_prot.Read.reader

deprecated [since 2019-10] use module V1 or Unstable instead

val __bin_read_t__ : (int -> t) Core.Bin_prot.Read.reader

deprecated [since 2019-10] use module V1 or Unstable instead

val bin_writer_t : t Core.Bin_prot.Type_class.writer

deprecated [since 2019-10] use module V1 or Unstable instead

val bin_reader_t : t Core.Bin_prot.Type_class.reader

deprecated [since 2019-10] use module V1 or Unstable instead

val bin_t : t Core.Bin_prot.Type_class.t

deprecated [since 2019-10] use module V1 or Unstable instead