package mlgmp

You can search for identifiers within the package.

in-package search v0.2.0

gmp
- Gmp
  - F
  - FR
  - Q
    
    Infixes
  - Q2
  - RNG
  - Z
    
    Infixes
  - Z2

Legend:
Library
Module
Module type
Parameter
Class
Class type

type t = Z2.t

val from_int : int -> t

val of_int : int -> t

val from_string_base : base:int -> string -> t

val from_float : float -> t

val of_float : float -> t

val to_string_base : base:int -> t -> string

val to_int : t -> int

val to_float : t -> float

val int_from : t -> int

val float_from : t -> float

val add : t -> t -> t

val sub : t -> t -> t

val mul : t -> t -> t

val add_ui : t -> int -> t

val sub_ui : t -> int -> t

val mul_ui : t -> int -> t

val neg : t -> t

val abs : t -> t

val tdiv_qr : t -> t -> t * t

val tdiv_q : t -> t -> t

val tdiv_r : t -> t -> t

val cdiv_qr : t -> t -> t * t

val cdiv_q : t -> t -> t

val cdiv_r : t -> t -> t

val fdiv_qr : t -> t -> t * t

val fdiv_q : t -> t -> t

val fdiv_r : t -> t -> t

val dmod : t -> t -> t

val dmod_ui : t -> int -> t

val euclidean_division : t -> t -> t * t

val modulo : t -> t -> t

val tdiv_qr_ui : t -> int -> t * t

val tdiv_q_ui : t -> int -> t

val tdiv_r_ui : t -> int -> t

val tdiv_ui : t -> int -> int

val cdiv_qr_ui : t -> int -> t * t

val cdiv_q_ui : t -> int -> t

val cdiv_r_ui : t -> int -> t

val cdiv_ui : t -> int -> int

val fdiv_qr_ui : t -> int -> t * t

val fdiv_q_ui : t -> int -> t

val fdiv_r_ui : t -> int -> t

val fdiv_ui : t -> int -> int

val divexact : t -> t -> t

val mul_2exp : t -> int -> t

val mul2exp : t -> int -> t

val tdiv_q_2exp : t -> int -> t

val tdiv_r_2exp : t -> int -> t

val fdiv_q_2exp : t -> int -> t

val fdiv_r_2exp : t -> int -> t

val cdiv_q_2exp : t -> int -> t

val cdiv_r_2exp : t -> int -> t

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

val powm_ui : t -> int -> t -> t

val pow_ui : t -> int -> t

val ui_pow_ui : int -> int -> t

val pow_ui_ui : int -> int -> t

val sqrt : t -> t

val sqrtrem : t -> t * t

val root : t -> int -> t

val perfect_power_p : t -> bool

val perfect_square_p : t -> bool

val is_perfect_power : t -> bool

val is_perfect_square : t -> bool

val probab_prime_p : t -> int -> bool

val is_probab_prime : t -> int -> bool

val nextprime : t -> t

val gcd : t -> t -> t

val gcd_ui : t -> t -> t

val lcm : t -> t -> t

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

val inverse : t -> t -> t option

val legendre : t -> t -> int

val jacobi : t -> t -> int

val kronecker_si : t -> int -> int

val si_kronecker : int -> t -> int

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

val fac_ui : int -> t

val fib_ui : int -> t

val bin_ui : n:t -> k:int -> t

val bin_uiui : n:int -> k:int -> t

val cmp : t -> t -> int

val cmp_si : t -> int -> int

val compare : t -> t -> int

val compare_si : t -> int -> int

val compare_int : t -> int -> int

val sgn : t -> int

val band : t -> t -> t

val bior : t -> t -> t

val bxor : t -> t -> t

val bcom : t -> t

val popcount : t -> int

val hamdist : t -> t -> int

val scan0 : t -> int -> int

val scan1 : t -> int -> int

val urandomb : state:RNG.randstate_t -> nbits:int -> t

val urandomm : state:RNG.randstate_t -> n:t -> t

val rrandomb : state:RNG.randstate_t -> nbits:int -> t

val zero : t

val one : t

val is_prime : ?prec:int -> t -> bool

val equal : t -> t -> bool

val equal_int : t -> int -> bool

val is_zero : t -> bool

val to_string : t -> string

val from_string : string -> t

val string_from : t -> string

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

val sprintf : unit -> t -> string

val print : Format.formatter -> t -> unit

val succ : t -> t

val pred : t -> t

val min : t -> t -> t

val max : t -> t -> t

module Infixes : sig ... end