package obeam

You can search for identifiers within the package.

in-package search v0.2.0

package obeam

obeam
- Obeam
  - Abstract_format
  - Aux
    
    Z
  - Beam
  - Err
  - External_term_format
  - Parser
    
    Combinator
  - Simple_term_format

Legend:
Library
Module
Module type
Parameter
Class
Class type

val sexp_of_t : Z.t -> Base.Sexp.t

val of_bitstring : (bytes * Base__Int.t * Base__Int.t) -> Z.t

include module type of struct include Z end

type t = Z.t

exception Overflow

val zero : t

val one : t

val minus_one : t

val of_int : int -> t

val of_int32 : int32 -> t

val of_int64 : int64 -> t

val of_nativeint : nativeint -> t

val of_int32_unsigned : int32 -> t

val of_int64_unsigned : int64 -> t

val of_nativeint_unsigned : nativeint -> t

val of_float : float -> t

val of_string : string -> t

val of_substring : string -> pos:int -> len:int -> t

val of_string_base : int -> string -> t

val of_substring_base : int -> string -> pos:int -> len:int -> t

val succ : t -> t

val pred : t -> t

val abs : t -> t

val neg : t -> t

val add : t -> t -> t

val sub : t -> t -> t

val mul : t -> t -> t

val div : t -> t -> t

val rem : t -> t -> t

val div_rem : t -> t -> t * t

val cdiv : t -> t -> t

val fdiv : t -> t -> t

val ediv_rem : t -> t -> t * t

val ediv : t -> t -> t

val erem : t -> t -> t

val divexact : t -> t -> t

val divisible : t -> t -> bool

val congruent : t -> t -> t -> bool

val logand : t -> t -> t

val logor : t -> t -> t

val logxor : t -> t -> t

val lognot : t -> t

val shift_left : t -> int -> t

val shift_right : t -> int -> t

val shift_right_trunc : t -> int -> t

val numbits : t -> int

val trailing_zeros : t -> int

val testbit : t -> int -> bool

val popcount : t -> int

val hamdist : t -> t -> int

val to_int : t -> int

val to_int32 : t -> int32

val to_int64 : t -> int64

val to_nativeint : t -> nativeint

val to_int32_unsigned : t -> int32

val to_int64_unsigned : t -> int64

val to_nativeint_unsigned : t -> nativeint

val to_float : t -> float

val to_string : t -> string

val format : string -> t -> string

val fits_int : t -> bool

val fits_int32 : t -> bool

val fits_int64 : t -> bool

val fits_nativeint : t -> bool

val fits_int32_unsigned : t -> bool

val fits_int64_unsigned : t -> bool

val fits_nativeint_unsigned : t -> bool

val print : t -> unit

val output : Stdlib.out_channel -> t -> unit

val sprint : unit -> t -> string

val bprint : Stdlib.Buffer.t -> t -> unit

val pp_print : Stdlib.Format.formatter -> t -> unit

val compare : t -> t -> int

val equal : t -> t -> bool

val leq : t -> t -> bool

val geq : t -> t -> bool

val lt : t -> t -> bool

val gt : t -> t -> bool

val sign : t -> int

val min : t -> t -> t

val max : t -> t -> t

val is_even : t -> bool

val is_odd : t -> bool

val hash : t -> int

val seeded_hash : int -> t -> int

val gcd : t -> t -> t

val gcdext : t -> t -> t * t * t

val lcm : t -> t -> t

val powm : t -> t -> t -> t

val powm_sec : t -> t -> t -> t

val invert : t -> t -> t

val probab_prime : t -> int -> int

val nextprime : t -> t

val jacobi : t -> t -> int

val legendre : t -> t -> int

val kronecker : t -> t -> int

val remove : t -> t -> t * int

val fac : int -> t

val fac2 : int -> t

val facM : int -> int -> t

val primorial : int -> t

val bin : t -> int -> t

val fib : int -> t

val lucnum : int -> t

val pow : t -> int -> t

val sqrt : t -> t

val sqrt_rem : t -> t * t

val root : t -> int -> t

val rootrem : t -> int -> t * t

val perfect_power : t -> bool

val perfect_square : t -> bool

val log2 : t -> int

val log2up : t -> int

val size : t -> int

val extract : t -> int -> int -> t

val signed_extract : t -> int -> int -> t

val to_bits : t -> string

val of_bits : string -> t

val random_int : ?rng:Stdlib.Random.State.t -> t -> t

val random_bits : ?rng:Stdlib.Random.State.t -> int -> t

val random_int_gen : fill:(bytes -> int -> int -> unit) -> t -> t

val random_bits_gen : fill:(bytes -> int -> int -> unit) -> int -> t

val (~-) : t -> t

val (~+) : 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 -> t

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

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

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

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

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

val (~!) : t -> t

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

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

val (~$) : int -> t

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

module Compare = Z.Compare

val version : string

val round_to_float : t -> bool -> float