path: root/packages/gmp/src/gmp.pas

{
    This file is part of the Free Pascal packages
    Copyright (c) 2009 by Jan Mercl

    An header for the GMP library

    See the file COPYING.FPC, included in this distribution,
    for details about the copyright. (LGPL)

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

}

unit gmp;

{$mode objfpc}{$h+}
{$packrecords c}

//todo:windows link error on GMP global vars, reason not yet known
{$ifdef windows}
{$define NO_GMP_GLOBVARS}
{$endif}

{$ifdef darwin}
  {$linklib gmp.3}
{$endif}
{ Unused symbols exported from GMP:

  Marked preliminary in GMP manual
    __gmpn_bdivmod

  Marked obsolete in GMP manual
    __gmpn_divrem
    __gmpz_random
    __gmpz_random2
    __gmp_randinit

  Not documented in GMP manual
    __gmpf_size
    __gmpn_divrem_2
    __gmpn_pow_1
    __gmpn_preinv_mod_1
    __gmpz_millerrabin

  Marked for use only within GDB
    __gmpf_dump
    __gmpz_dump
}

interface

uses
  sysutils;

const
  BASE10 = 10;
  LIB = 'gmp';
  LOG_10_2 = 0.3010299956639812;
  ERROR_NONE = 0;
  ERROR_UNSUPPORTED_ARGUMENT = 1;
  ERROR_DIVISION_BY_ZERO = 2;
  ERROR_SQRT_OF_NEGATIVE = 4;
  ERROR_INVALID_ARGUMENT = 8;
  RAND_ALG_DEFAULT = 0;
  RAND_ALG_LC = RAND_ALG_DEFAULT;

type

  // ---- GMP types ----

  { low level multi precision integer atom = machine size uint }
  mp_limb_t = valuint;
  { ^array of mp_limb_t}
  mpn_ptr = ^mp_limb_t;
  mp_size_t = sizeint;
  mp_exp_t = valsint;
  randalg_t = longint;

  { multi precision integer number record }
  mpz_t = record
    alloc: longint;
    size: longint;
    data: mpn_ptr;
  end;
  mpz_ptr = ^mpz_t;

  { multi precision rational number record }
  mpq_t = record
    num: mpz_t;
    den: mpz_t;
  end;
  mpq_ptr = ^mpq_t;

  { multi precision real number record }
  mpf_t = record
    prec: longint;
    size: longint;
    exp: mp_exp_t;
    data: mpn_ptr;
  end;
  mpf_ptr = ^mpf_t;

  randstate_t = record
    seed: mpz_t;
    alg: randalg_t;
    algdata: record
      case longint of
        0 : (lc : pointer);
    end;
  end;
  randstate_ptr = ^randstate_t;

  { Return a pointer to newly allocated space with at least alloc size bytes }
  alloc_func_t = function(alloc_size: sizeuint): pointer; cdecl;
  { Resize a previously allocated block ptr of old size bytes to be new size bytes }
  reallocate_func_t = function(p: pointer; old_size, new_size: sizeuint): pointer; cdecl;
  { De-allocate the space pointed to by ptr }
  free_proc_t = procedure(p: pointer; size: sizeuint); cdecl;
  palloc_func = ^alloc_func_t;
  preallocate_func = ^reallocate_func_t;
  pfree_proc = ^free_proc_t;

  // ---- ext types with automatic mem mngmt & cow, ~ fpc string type style -----

  IMPBase = interface
    function refs: longint;
  end;

  MPInteger = interface(IMPBase)
    function ptr: mpz_ptr;
  end;

  MPFloat = interface(IMPBase)
    function ptr: mpf_ptr;
  end;

  MPRational = interface(IMPBase)
    function ptr: mpq_ptr;
  end;

  MPRandState = interface(IMPBase)
    function ptr: randstate_ptr;
  end;

  { TMPBase }

  TMPBase = class(TInterfacedObject, IMPBase)
  private
    function refs: longint;  inline;
  end;

  { TMPInteger }

  TMPInteger = class(TMPBase, MPInteger)
  private
    fmpz: mpz_t;
    function ptr: mpz_ptr;  inline;
  public
    destructor destroy; override;
  end;

  { TMPFloat }

  TMPFloat = class(TMPBase, MPFloat)
  private
    fmpf: mpf_t;
    function ptr: mpf_ptr;  inline;
  public
    destructor destroy; override;
  end;

  { TMPRational }

  TMPRational = class(TMPBase, MPRational)
  private
    fmpq: mpq_t;
    function ptr: mpq_ptr;  inline;
  public
    destructor destroy; override;
  end;

  { TMPRandState }

  TMPRandState = class(TMPBase, MPRandState)
  private
    frandstate: randstate_t;
    function ptr: randstate_ptr;  inline;
  public
    destructor destroy; override;
  end;

// ==== GMP bindings ====

// ---- Custom Allocation ----

{ Replace the current allocation functions from the arguments }
procedure mp_set_memory_functions(alloc_func_ptr: alloc_func_t; realloc_func_ptr: reallocate_func_t; free_func_ptr: free_proc_t); cdecl; external LIB name '__gmp_set_memory_functions';
{ Get the current allocation functions, storing function pointers to the locations given by the arguments }
procedure mp_get_memory_functions(alloc_func_ptr: palloc_func; realloc_func_ptr: preallocate_func; free_func_ptr: pfree_proc); cdecl; external LIB name '__gmp_get_memory_functions';

// ---- Random Number Functions ----

{ Obsolete: Initialize state with an algorithm selected by alg }
// procedure randinit(var state: randstate_t; alg: randalg_t; args: array of const); cdecl; external LIB name '__gmp_randinit';

{ Initialize state with a default algorithm }
procedure mp_randinit_default(out state: randstate_t); cdecl; external LIB name '__gmp_randinit_default';
{ Initialize state with a linear congruential algorithm X = (aX + c) mod 2^m2exp }
procedure mp_randinit_lc_2exp(out state: randstate_t; var a: mpz_t; c, m2exp: valuint); cdecl; external LIB name '__gmp_randinit_lc_2exp';
{ Initialize state for a linear congruential algorithm as per gmp_randinit_lc_2exp }
function mp_randinit_lc_2exp_size(out state: randstate_t; size: sizeuint): longint; cdecl; external LIB name '__gmp_randinit_lc_2exp_size';
{ Initialize state for a Mersenne Twister algorithm }
procedure mp_randinit_mt(out state: randstate_t); cdecl; external LIB name '__gmp_randinit_mt';
{ Initialize rop with a copy of the algorithm and state from op }
procedure mp_randinit_set(out rop: randstate_t; var op: randstate_t); cdecl; external LIB name '__gmp_randinit_set';
{ Set an initial seed value into state }
procedure mp_randseed(var state: randstate_t; var seed: mpz_t); cdecl; external LIB name '__gmp_randseed';
{ Set an initial seed value into state }
procedure mp_randseed_ui(var state: randstate_t; seed: valuint); cdecl; external LIB name '__gmp_randseed_ui';
{ Free all memory occupied by state }
procedure mp_randclear(var state: randstate_t); cdecl; external LIB name '__gmp_randclear';
{ Return an uniformly distributed random number of n bits, ie. in the range 0 to 2^n−1 inclusive }
function mp_urandomb_ui(var state: randstate_t; n: valuint): valuint; cdecl; external LIB name '__gmp_urandomb_ui';
{ Return an uniformly distributed random number in the range 0 to n − 1, inclusive }
function mp_urandomm_ui(var state: randstate_t; n: valuint): valuint; cdecl; external LIB name '__gmp_urandomm_ui';

// ---- Formatted Input/Output ----

{ Form a null-terminated string in a block of memory obtained from the current memory allocation function }
function mp_asprintf(out pp: pchar; fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_asprintf';
{ Form a null-terminated string in a block of memory obtained from the current memory allocation function }
function mp_asprintf(out pp: pchar; fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_asprintf';
{ Print to the standard output stdout. Return the number of characters written, or −1 if an error occurred. }
function mp_printf(fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_printf';
{ Print to the standard output stdout. Return the number of characters written, or −1 if an error occurred. }
function mp_printf(fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_printf';
{ Form a null-terminated string in buf. No more than size bytes will be written. }
function mp_snprintf(buf: pchar; size: sizeuint; fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_snprintf';
{ Form a null-terminated string in buf. No more than size bytes will be written. }
function mp_snprintf(buf: pchar; size: sizeuint; fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_snprintf';
{ Form a null-terminated string in buf. Return the number of characters written, excluding the terminating null. }
function mp_sprintf(buf, fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_sprintf';
{ Form a null-terminated string in buf. Return the number of characters written, excluding the terminating null. }
function mp_sprintf(buf, fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_sprintf';
{ Read from the standard input stdin }
function mp_scanf(fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_scanf';
{ Read from the standard input stdin }
function mp_scanf(fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_scanf';
{ Read from a null-terminated string s }
function mp_sscanf(s, fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_sscanf';
{ Read from a null-terminated string s }
function mp_sscanf(s, fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_sscanf';

// ---- integer Functions ----

{ Change the space for integer to new_alloc limbs }
function mpz_realloc(var integer_: mpz_t; new_alloc: mp_size_t): pointer; cdecl; external LIB name '__gmpz_realloc';
{ Set rop to the absolute value of op }
procedure mpz_abs(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_abs';
{ Set rop to op1 + op2 }
procedure mpz_add(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_add';
{ Set rop to op1 + op2 }
procedure mpz_add_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_add_ui';
{ Set rop to rop + op1 × op2 }
procedure mpz_addmul(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_addmul';
{ Set rop to rop + op1 × op2 }
procedure mpz_addmul_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_addmul_ui';
{ Set rop to op1 bitwise-and op2 }
procedure mpz_and(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_and';
{ _Fixed_ space of fixed_num_bits is allocated to each of the array size integers in integer array }
procedure mpz_array_init(var integer_array: mpz_t; array_size, fixed_num_bits: mp_size_t); cdecl; external LIB name '__gmpz_array_init';
{ Compute the binomial coefficient (n over k) and store the result in rop }
procedure mpz_bin_ui(var rop, n: mpz_t; k: valuint); cdecl; external LIB name '__gmpz_bin_ui';
{ Compute the binomial coefficient (n over k) and store the result in rop }
procedure mpz_bin_uiui(var rop: mpz_t; n, k: valuint); cdecl; external LIB name '__gmpz_bin_uiui';
{ Divide n by d, forming a quotient q. Round mode ceil. }
procedure mpz_cdiv_q(var q, n, d: mpz_t); cdecl; external LIB name '__gmpz_cdiv_q';
{ Divide n by d, forming a quotient q. d = 2^b. Round mode ceil. }
procedure mpz_cdiv_q_2exp(var q, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_cdiv_q_2exp';
{ Divide n by d, forming a quotient q. Round mode ceil. }
function mpz_cdiv_q_ui(var q, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_cdiv_q_ui';
{ Divide n by d, forming a quotient q and remainder r. Round mode ceil. }
procedure mpz_cdiv_qr(var q, r, n, d: mpz_t); cdecl; external LIB name '__gmpz_cdiv_qr';
{ Divide n by d, forming a quotient q and remainder r. Round mode ceil. }
function mpz_cdiv_qr_ui(var q, r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_cdiv_qr_ui';
{ Divide n by d, forming a remainder r. Round mode ceil. }
procedure mpz_cdiv_r(var r, n, d: mpz_t); cdecl; external LIB name '__gmpz_cdiv_r';
{ Divide n by d, forming a remainder r. d = 2^b. Round mode ceil. }
procedure mpz_cdiv_r_2exp(var r, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_cdiv_r_2exp';
{ Divide n by d, forming a remainder r. Round mode ceil. }
function mpz_cdiv_r_ui(var r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_cdiv_r_ui';
{ Divide n by d. Round mode ceil. }
function mpz_cdiv_ui(var n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_cdiv_ui';
{ Free the space occupied by integer. Call this function for all mpz_t variables when you are done with them. }
procedure mpz_clear(var integer_: mpz_t); cdecl; external LIB name '__gmpz_clear';
{ Clear bit bit_index in rop }
procedure mpz_clrbit(var rop: mpz_t; bit_index: valuint); cdecl; external LIB name '__gmpz_clrbit';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
function mpz_cmp(var op1, op2: mpz_t): longint; cdecl; external LIB name '__gmpz_cmp';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
function mpz_cmp_d(var op1: mpz_t; op2: double): longint; cdecl; external LIB name '__gmpz_cmp_d';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
function mpz_cmp_si(var op1: mpz_t; op2: valsint): longint; cdecl; external LIB name '__gmpz_cmp_si';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
function mpz_cmp_ui(var op1: mpz_t; op2: valuint): longint; cdecl; external LIB name '__gmpz_cmp_ui';
{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
function mpz_cmpabs(var op1, op2: mpz_t): longint; cdecl; external LIB name '__gmpz_cmpabs';
{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
function mpz_cmpabs_d(var op1: mpz_t; op2: double): longint; cdecl; external LIB name '__gmpz_cmpabs_d';
{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
function mpz_cmpabs_ui(var op1: mpz_t; op2: valuint): longint; cdecl; external LIB name '__gmpz_cmpabs_ui';
{ Set rop to the one’s complement of op }
procedure mpz_com(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_com';
{ Complement bit bit_index in rop }
procedure mpz_combit(var rop: mpz_t; bit_index: valuint); cdecl; external LIB name '__gmpz_combit';
{ Return non-zero if n is congruent to c modulo d }
function mpz_congruent_p(var n, c, d: mpz_t): longint; cdecl; external LIB name '__gmpz_congruent_p';
{ Return non-zero if n is congruent to c modulo 2^b }
function mpz_congruent_2exp_p(var n, c: mpz_t; b: valuint): longint; cdecl; external LIB name '__gmpz_congruent_2exp_p';
{ Return non-zero if n is congruent to c modulo d }
function mpz_congruent_ui_p(var n: mpz_t; c, d: valuint): longint; cdecl; external LIB name '__gmpz_congruent_ui_p';
{ Set q to n/d }
procedure mpz_divexact(var q, n, d: mpz_t); cdecl; external LIB name '__gmpz_divexact';
{ Set q to n/d }
procedure mpz_divexact_ui(var q, n: mpz_t; d: valuint); cdecl; external LIB name '__gmpz_divexact_ui';
{ Return non-zero if n is exactly divisible by d }
function mpz_divisible_p(var n, d: mpz_t): longint; cdecl; external LIB name '__gmpz_divisible_p';
{ Return non-zero if n is exactly divisible by d }
function mpz_divisible_ui_p(var n: mpz_t; d: valuint): longint; cdecl; external LIB name '__gmpz_divisible_ui_p';
{ Return non-zero if n is exactly divisible by by 2^b }
function mpz_divisible_2exp_p(var n: mpz_t; b: valuint): longint; cdecl; external LIB name '__gmpz_divisible_2exp_p';

// GDB only: procedure mpz_dump(var _para1: mpz_t); cdecl; external LIB name '__gmpz_dump';

{ Fill buf with word data from op }
function mpz_export(out buf; out countp: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; var op: mpz_t): pointer; cdecl; external LIB name '__gmpz_export';
{ Set rop to op!, the factorial of op }
procedure mpz_fac_ui(var rop: mpz_t; op: valuint); cdecl; external LIB name '__gmpz_fac_ui';
{ Divide n by d, forming a quotient q. Round mode floor. }
procedure mpz_fdiv_q(var q, n, d: mpz_t); cdecl; external LIB name '__gmpz_fdiv_q';
{ Divide n by d, forming a quotient q. d = 2^b. Round mode floor. }
procedure mpz_fdiv_q_2exp(var q, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_fdiv_q_2exp';
{ Divide n by d, forming a quotient q. Round mode floor. }
function mpz_fdiv_q_ui(var q, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_fdiv_q_ui';
{ Divide n by d, forming a quotient q and remainder r. Round mode floor. }
procedure mpz_fdiv_qr(var q, r, n, d: mpz_t); cdecl; external LIB name '__gmpz_fdiv_qr';
{ Divide n by d, forming a quotient q and remainder r. Round mode floor. }
function mpz_fdiv_qr_ui(var q, r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_fdiv_qr_ui';
{ Divide n by d, forming a remainder r. Round mode floor. }
procedure mpz_fdiv_r(var r, n, d: mpz_t); cdecl; external LIB name '__gmpz_fdiv_r';
{ Divide n by d, forming a remainder r. d = 2^b. Round mode floor. }
procedure mpz_fdiv_r_2exp(var r, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_fdiv_r_2exp';
{ Divide n by d, forming a remainder r. Round mode floor. }
function mpz_fdiv_r_ui(var r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_fdiv_r_ui';
{ Divide n by d. Round mode floor. }
function mpz_fdiv_ui(var n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_fdiv_ui';
{ Set fn to to Fn, the n’th Fibonacci number }
procedure mpz_fib_ui(var fn: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_fib_ui';
{ Set fn to Fn, and fnsub1 to Fn−1 }
procedure mpz_fib2_ui(var fn, fnsub1: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_fib2_ui';
{ Return non-zero iff the value of op fits in an signed int. Otherwise, return zero. }
function mpz_fits_sint_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_sint_p';
{ Return non-zero iff the value of op fits in an signed long int. Otherwise, return zero. }
function mpz_fits_slong_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_slong_p';
{ Return non-zero iff the value of op fits in an signed short int. Otherwise, return zero. }
function mpz_fits_sshort_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_sshort_p';
{ Return non-zero iff the value of op fits in an unsigned int. Otherwise, return zero. }
function mpz_fits_uint_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_uint_p';
{ Return non-zero iff the value of op fits in an unsigned long int. Otherwise, return zero. }
function mpz_fits_ulong_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_ulong_p';
{ Return non-zero iff the value of op fits in an unsigned short int. Otherwise, return zero. }
function mpz_fits_ushort_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_ushort_p';
{ Set rop to the greatest common divisor of op1 and op2 }
procedure mpz_gcd(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_gcd';
{ Compute the greatest common divisor of op1 and op2. If rop is not NULL, store the result there. }
function mpz_gcd_ui(var rop, op1: mpz_t; op2: valuint): valuint; cdecl; external LIB name '__gmpz_gcd_ui';
{ Set g to the greatest common divisor of a and b, and in addition set s and t to coefficients satisfying as + bt = g }
procedure mpz_gcdext(var g, s, t, a, b: mpz_t); cdecl; external LIB name '__gmpz_gcdext';
{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
function mpz_get_d(var op: mpz_t): double; cdecl; external LIB name '__gmpz_get_d';
{ Convert op to a double, truncating if necessary (ie. rounding towards zero), and returning the exponent separately }
function mpz_get_d_2exp(out exp: valsint; var op: mpz_t): double; cdecl; external LIB name '__gmpz_get_d_2exp';
{ Return the value of op as a signed long }
function mpz_get_si(var op: mpz_t): valsint; cdecl; external LIB name '__gmpz_get_si';
{ Convert op to a string of digits in base base. The base argument may vary from 2 to 62 or from −2 to −36. If str is NULL, the result string is allocated using the current allocation function }
function mpz_get_str(str: pchar; base: longint; var op: mpz_t): pchar; cdecl; external LIB name '__gmpz_get_str';
{ Return the value of op as an unsigned long }
function mpz_get_ui(var op: mpz_t): valuint; cdecl; external LIB name '__gmpz_get_ui';
{ Return limb number n from op }
function mpz_getlimbn(var op: mpz_t; n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpz_getlimbn';
{ If op1 and op2 are both >= 0 or both < 0, return the hamming distance between the two operands, which is the number of bit positions where op1 and op2 have different bit values }
function mpz_hamdist(var op1, op2: mpz_t): valuint; cdecl; external LIB name '__gmpz_hamdist';
{ Set rop from an array of word data at op }
procedure mpz_import(var rop: mpz_t; count: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; const op); cdecl; external LIB name '__gmpz_import';
{ Initialize integer, and set its value to 0 }
procedure mpz_init(out integer_: mpz_t); cdecl; external LIB name '__gmpz_init';
{ Initialize integer, with space for n bits, and set its value to 0 }
procedure mpz_init2(out integer_: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_init2';
{ Initialize rop with limb space and set the initial numeric value from op }
procedure mpz_init_set(out rop: mpz_t; var op: mpz_t); cdecl; external LIB name '__gmpz_init_set';
{ Initialize rop with limb space and set the initial numeric value from op }
procedure mpz_init_set_d(out rop: mpz_t; op: double); cdecl; external LIB name '__gmpz_init_set_d';
{ Initialize rop with limb space and set the initial numeric value from op }
procedure mpz_init_set_si(out rop: mpz_t; op: valsint); cdecl; external LIB name '__gmpz_init_set_si';
{ Initialize rop and set its value like mpz_set_str }
function mpz_init_set_str(out rop: mpz_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpz_init_set_str';
{ Initialize rop with limb space and set the initial numeric value from op }
procedure mpz_init_set_ui(out rop: mpz_t; op: valuint); cdecl; external LIB name '__gmpz_init_set_ui';
{ Compute the inverse of op1 modulo op2 and put the result in rop }
function mpz_invert(var rop, op1, op2: mpz_t): longint; cdecl; external LIB name '__gmpz_invert';
{ Set rop to op1 bitwise inclusive-or op2 }
procedure mpz_ior(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_ior';
{ Calculate the Jacobi symbol. This is defined only for b odd }
function mpz_jacobi(var a, b: mpz_t): longint; cdecl; external LIB name '__gmpz_jacobi';
{ Calculate the Jacobi symbol with the Kronecker extension }
function mpz_kronecker_si(var a: mpz_t; b: valsint): longint; cdecl; external LIB name '__gmpz_kronecker_si';
{ Calculate the Jacobi symbol with the Kronecker extension }
function mpz_kronecker_ui(var a: mpz_t; b: valuint): longint; cdecl; external LIB name '__gmpz_kronecker_ui';
{ Calculate the Jacobi symbol with the Kronecker extension }
function mpz_si_kronecker(a: valsint; var b: mpz_t): longint; cdecl; external LIB name '__gmpz_si_kronecker';
{ Calculate the Jacobi symbol with the Kronecker extension }
function mpz_ui_kronecker(a: valuint; var b: mpz_t): longint; cdecl; external LIB name '__gmpz_ui_kronecker';
{ Set rop to the least common multiple of op1 and op2 }
procedure mpz_lcm(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_lcm';
{ Set rop to the least common multiple of op1 and op2 }
procedure mpz_lcm_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_lcm_ui';
{ Set ln to to Ln, the n’th Lucas number }
procedure mpz_lucnum_ui(var ln: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_lucnum_ui';
{ Set ln to Ln, and lnsub1 to Ln−1 }
procedure mpz_lucnum2_ui(var ln, lnsub1: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_lucnum2_ui';

// No docs: function mpz_millerrabin(var _para1: mpz_t; _para2: longint): longint; cdecl; external LIB name '__gmpz_millerrabin';

{ Set r to n mod d. The sign of the divisor is ignored; the result is always non-negative. }
procedure mpz_mod(var r, n, d: mpz_t); cdecl; external LIB name '__gmpz_mod';
{ Set rop to op1 × op2 }
procedure mpz_mul(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_mul';
{ Set rop to op1 × 2^op2. This operation can also be defined as a left shift by op2 bits. }
procedure mpz_mul_2exp(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_mul_2exp';
{ Set rop to op1 × op2 }
procedure mpz_mul_si(var rop, op1: mpz_t; op2: valsint); cdecl; external LIB name '__gmpz_mul_si';
{ Set rop to op1 × op2 }
procedure mpz_mul_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_mul_ui';
{ Set rop to −op }
procedure mpz_neg(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_neg';
{ Set rop to the next prime greater than op }
procedure mpz_nextprime(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_nextprime';
{ Return non-zero if op is a perfect power, i.e., if there exist integers a and b, with b > 1, such that op = a^b }
function mpz_perfect_power_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_perfect_power_p';
{ Return non-zero if op is a perfect square, i.e., if the square root of op is an integer }
function mpz_perfect_square_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_perfect_square_p';
{ If op >= 0, return the population count of op, which is the number of 1 bits in the binary representation }
function mpz_popcount(var op: mpz_t): valuint; cdecl; external LIB name '__gmpz_popcount';
{ Set rop to base^exp. The case 0^0 yields 1. }
procedure mpz_pow_ui(var rop, base: mpz_t; exp: valuint); cdecl; external LIB name '__gmpz_pow_ui';
{ Set rop to base^exp mod mod_ }
procedure mpz_powm(var rop, base, exp, mod_: mpz_t); cdecl; external LIB name '__gmpz_powm';
{ Set rop to base^exp mod mod_ }
procedure mpz_powm_ui(var rop, base: mpz_t; exp: valuint; var mod_: mpz_t); cdecl; external LIB name '__gmpz_powm_ui';
{ Determine whether n is prime. Return 2 if n is definitely prime, return 1 if n is probably prime (without being certain), or return 0 if n is definitely composite. }
function mpz_probab_prime_p(var n: mpz_t; reps: longint): longint; cdecl; external LIB name '__gmpz_probab_prime_p';

{ Obsolete: Generate a random integer of at most max_size limbs }
// procedure mpz_random(var rop: mpz_t; max_size: mp_size_t); cdecl; external LIB name '__gmpz_random';
{ Obsolete: Generate a random integer of at most max_size limbs, with long strings of zeros and ones in the binary representation }
// procedure mpz_random2(var rop: mpz_t; max_size: mp_size_t); cdecl; external LIB name '__gmpz_random2';

{ Change the space allocated for integer to n bits. The value in integer is preserved if it fits, or is set to 0 if not. }
procedure mpz_realloc2(var integer_: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_realloc2';
{ Remove all occurrences of the factor f from op and store the result in rop }
function mpz_remove(var rop, op, f: mpz_t): valuint; cdecl; external LIB name '__gmpz_remove';
{ Set rop to trunc(op^(1/n)), the truncated integer part of the nth root of op. Return non-zero if the computation was exact, i.e., if op is rop to the nth power. }
function mpz_root(var rop, op: mpz_t; n: valuint): longint; cdecl; external LIB name '__gmpz_root';
{ Set root to trunc(u^(1/n)), the truncated integer part of the nth root of u. Set rem to the remainder, (u − root^n). }
procedure mpz_rootrem(var root, rem, u: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_rootrem';
{ Generate a random integer with long strings of zeros and ones in the binary representation }
procedure mpz_rrandomb(var rop: mpz_t; var state: randstate_t; n: valuint); cdecl; external LIB name '__gmpz_rrandomb';
{ Scan op, starting from bit starting_bit, towards more significant bits, until the first 0 bit is found }
function mpz_scan0(var op: mpz_t; starting_bit: valuint): valuint; cdecl; external LIB name '__gmpz_scan0';
{ Scan op, starting from bit starting_bit, towards more significant bits, until the first 1 bit is found }
function mpz_scan1(var op: mpz_t; starting_bit: valuint): valuint; cdecl; external LIB name '__gmpz_scan1';
{ Set the value of rop from op }
procedure mpz_set(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_set';
{ Set the value of rop from op }
procedure mpz_set_d(var rop: mpz_t; op: double); cdecl; external LIB name '__gmpz_set_d';
{ Set the value of rop from op }
procedure mpz_set_f(var rop: mpz_t; var op: mpf_t); cdecl; external LIB name '__gmpz_set_f';
{ Set the value of rop from op }
procedure mpz_set_q(var rop: mpz_t; var op: mpq_t); cdecl; external LIB name '__gmpz_set_q';
{ Set the value of rop from op }
procedure mpz_set_si(var rop: mpz_t; op: valsint); cdecl; external LIB name '__gmpz_set_si';
{ Set the value of rop from str, a null-terminated C string in base base. White space is allowed in the string, and is simply ignored. }
function mpz_set_str(var rop: mpz_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpz_set_str';
{ Set the value of rop from op }
procedure mpz_set_ui(var rop: mpz_t; op: valuint); cdecl; external LIB name '__gmpz_set_ui';
{ Set bit bit_index in rop }
procedure mpz_setbit(var rop: mpz_t; bit_index: valuint); cdecl; external LIB name '__gmpz_setbit';
{ Return the size of op measured in number of limbs }
function mpz_size(var op: mpz_t): sizeuint; cdecl; external LIB name '__gmpz_size';
{ Return the size of op measured in number of digits in the given base }
function mpz_sizeinbase(var op: mpz_t; base: longint): sizeuint; cdecl; external LIB name '__gmpz_sizeinbase';
{ Set rop to trunc(sqrt(op)), the truncated integer part of the square root of op }
procedure mpz_sqrt(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_sqrt';
{ Set rop1 to trunc(sqrt(op)), likempz_sqrt. Set rop2 to the remainder (op − rop1^2), which will be zero if op is a perfect square. }
procedure mpz_sqrtrem(var rop1, rop2, op: mpz_t); cdecl; external LIB name '__gmpz_sqrtrem';
{ Set rop to op1 − op2 }
procedure mpz_sub(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_sub';
{ Set rop to op1 − op2 }
procedure mpz_sub_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_sub_ui';
{ Set rop to op1 − op2 }
procedure mpz_ui_sub(var rop: mpz_t; op1: valuint; var op2: mpz_t); cdecl; external LIB name '__gmpz_ui_sub';
{ Set rop to rop − op1 × op2 }
procedure mpz_submul(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_submul';
{ Set rop to rop − op1 × op2 }
procedure mpz_submul_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_submul_ui';
{ Swap the values rop1 and rop2 efficiently }
procedure mpz_swap(var rop1, rop2: mpz_t); cdecl; external LIB name '__gmpz_swap';
{ Divide n by d, forming a quotient q. Round mode trunc. }
procedure mpz_tdiv_q(var q, n, d: mpz_t); cdecl; external LIB name '__gmpz_tdiv_q';
{ Divide n by d, forming a quotient q. d = 2^b. Round mode trunc. }
procedure mpz_tdiv_q_2exp(var q, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_tdiv_q_2exp';
{ Divide n by d, forming a quotient q. Round mode trunc. }
function mpz_tdiv_q_ui(var q, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_tdiv_q_ui';
{ Divide n by d, forming a quotient q and remainder r. Round mode trunc. }
procedure mpz_tdiv_qr(var q, r, n, d: mpz_t); cdecl; external LIB name '__gmpz_tdiv_qr';
{ Divide n by d, forming a quotient q and remainder r. Round mode trunc. }
function mpz_tdiv_qr_ui(var q, r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_tdiv_qr_ui';
{ Divide n by d, forming a remainder r. Round mode trunc. }
procedure mpz_tdiv_r(var r, n, d: mpz_t); cdecl; external LIB name '__gmpz_tdiv_r';
{ Divide n by d, forming a remainder r. d = 2^b. Round mode trunc. }
procedure mpz_tdiv_r_2exp(var r, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_tdiv_r_2exp';
{ Divide n by d, forming a remainder r. Round mode trunc. }
function mpz_tdiv_r_ui(var r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_tdiv_r_ui';
{ Divide n by d. Round mode trunc. }
function mpz_tdiv_ui(var n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_tdiv_ui';
{ Test bit bit_index in op and return 0 or 1 accordingly }
function mpz_tstbit(var rop: mpz_t; bit_index: valuint): longint; cdecl; external LIB name '__gmpz_tstbit';
{ Set rop to base^exp. The case 0^0 yields 1 }
procedure mpz_ui_pow_ui(var rop: mpz_t; base, exp: valuint); cdecl; external LIB name '__gmpz_ui_pow_ui';
{ Generate a uniformly distributed random integer in the range 0 to 2^n − 1, inclusive }
procedure mpz_urandomb(var rop: mpz_t; var state: randstate_t; n: valuint); cdecl; external LIB name '__gmpz_urandomb';
{ Generate a uniform random integer in the range 0 to n − 1, inclusive }
procedure mpz_urandomm(var rop: mpz_t; var state: randstate_t; var n: mpz_t); cdecl; external LIB name '__gmpz_urandomm';
{ Set rop to op1 bitwise exclusive-or op2 }
procedure mpz_xor(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_xor';

// ---- Rational Number Functions ----

{ Set rop to the absolute value of op }
procedure mpq_abs(var rop, op: mpq_t); cdecl; external LIB name '__gmpq_abs';
{ Set sum to addend1 + addend2 }
procedure mpq_add(var sum, addend1, addend2: mpq_t); cdecl; external LIB name '__gmpq_add';
{ Remove any factors that are common to the numerator and denominator of op, and make the denominator positive }
procedure mpq_canonicalize(var op: mpq_t); cdecl; external LIB name '__gmpq_canonicalize';
{ Free the space occupied by rational number }
procedure mpq_clear(var rational_number: mpq_t); cdecl; external LIB name '__gmpq_clear';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2 }
function mpq_cmp(var op1, op2: mpq_t): longint; cdecl; external LIB name '__gmpq_cmp';
{ Compare op1 and num2/den2. Return a positive value if op1 > num2/den2, zero if op1 = num2/den2, and a negative value if op1 < num2/den2 }
function mpq_cmp_si(var op1: mpq_t; num2: valsint; den2: valuint): longint; cdecl; external LIB name '__gmpq_cmp_si';
{ Compare op1 and num2/den2. Return a positive value if op1 > num2/den2, zero if op1 = num2/den2, and a negative value if op1 < num2/den2 }
function mpq_cmp_ui(var op1: mpq_t; num2, den2: valuint): longint; cdecl; external LIB name '__gmpq_cmp_ui';
{ Set quotient to dividend/divisor }
procedure mpq_div(var quotient, dividend, divisor: mpq_t); cdecl; external LIB name '__gmpq_div';
{ Set rop to op1/(2^op2) }
procedure mpq_div_2exp(var rop, op1: mpq_t; op2: valuint); cdecl; external LIB name '__gmpq_div_2exp';
{ Return non-zero if op1 and op2 are equal, zero if they are non-equal }
function mpq_equal(var op1, op2: mpq_t): longint; cdecl; external LIB name '__gmpq_equal';
{ Get the numerator of a rational }
procedure mpq_get_num(var numerator: mpz_t; var rational: mpq_t); cdecl; external LIB name '__gmpq_get_num';
{ Get the denominator of a rational }
procedure mpq_get_den(var denominator: mpz_t; var rational: mpq_t); cdecl; external LIB name '__gmpq_get_den';
{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
function mpq_get_d(var op: mpq_t): double; cdecl; external LIB name '__gmpq_get_d';
{ Convert op to a string of digits in base base }
function mpq_get_str(str: pchar; base: longint; var op: mpq_t): pchar; cdecl; external LIB name '__gmpq_get_str';
{ Initialize dest rational and set it to 0/1 }
procedure mpq_init(out dest_rational: mpq_t); cdecl; external LIB name '__gmpq_init';
{ Set inverted_number to 1/number }
procedure mpq_inv(var inverted_number, number: mpq_t); cdecl; external LIB name '__gmpq_inv';
{ Set product to multiplier × multiplicand }
procedure mpq_mul(var product, multiplier, multiplicand: mpq_t); cdecl; external LIB name '__gmpq_mul';
{ Set rop to op1 × (2^op2) }
procedure mpq_mul_2exp(var rop, op1: mpq_t; op2: valuint); cdecl; external LIB name '__gmpq_mul_2exp';
{ Set negated_operand to −operand }
procedure mpq_neg(var negated_operand, operand: mpq_t); cdecl; external LIB name '__gmpq_neg';
{ Assign rop from op }
procedure mpq_set(var rop, op: mpq_t); cdecl; external LIB name '__gmpq_set';
{ Set rop to the value of op. There is no rounding, this conversion is exact. }
procedure mpq_set_d(var rop: mpq_t; op: double); cdecl; external LIB name '__gmpq_set_d';
{ Set the denominator of a rational }
procedure mpq_set_den(var rational: mpq_t; var denominator: mpz_t); cdecl; external LIB name '__gmpq_set_den';
{ Set rop to the value of op. There is no rounding, this conversion is exact. }
procedure mpq_set_f(var rop: mpq_t; var op: mpf_t); cdecl; external LIB name '__gmpq_set_f';
{ Set the numerator of a rational }
procedure mpq_set_num(var rational: mpq_t; var numerator: mpz_t); cdecl; external LIB name '__gmpq_set_num';
{ Set the value of rop to op1/op2 }
procedure mpq_set_si(var rop: mpq_t; op1: valsint; op2: valuint); cdecl; external LIB name '__gmpq_set_si';
{ Set rop from a null-terminated string str in the given base }
function mpq_set_str(var rop: mpq_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpq_set_str';
{ Set the value of rop to op1/op2 }
procedure mpq_set_ui(var rop: mpq_t; op1, op2: valuint); cdecl; external LIB name '__gmpq_set_ui';
{ Assign rop from op }
procedure mpq_set_z(var rop: mpq_t; var op: mpz_t); cdecl; external LIB name '__gmpq_set_z';
{ Set difference to minuend − subtrahend }
procedure mpq_sub(var difference, minuend, subtrahend: mpq_t); cdecl; external LIB name '__gmpq_sub';
{ Swap the values rop1 and rop2 efficiently }
procedure mpq_swap(var rop1, rop2: mpq_t); cdecl; external LIB name '__gmpq_swap';

// ---- Floating-point Functions ----

{ Set rop to the absolute value of op }
procedure mpf_abs(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_abs';
{ Set rop to op1 + op2 }
procedure mpf_add(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_add';
{ Set rop to op1 + op2 }
procedure mpf_add_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_add_ui';
{ Set rop to op rounded to the next higher integer }
procedure mpf_ceil(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_ceil';
{ Free the space occupied by x }
procedure mpf_clear(var x: mpf_t); cdecl; external LIB name '__gmpf_clear';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
function mpf_cmp(var op1, op2: mpf_t): longint; cdecl; external LIB name '__gmpf_cmp';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
function mpf_cmp_d(var op1: mpf_t; op2: double): longint; cdecl; external LIB name '__gmpf_cmp_d';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
function mpf_cmp_si(var op1: mpf_t; op2: valsint): longint; cdecl; external LIB name '__gmpf_cmp_si';
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
function mpf_cmp_ui(var op1: mpf_t; op2: valuint): longint; cdecl; external LIB name '__gmpf_cmp_ui';
{ Set rop to op1/op2 }
procedure mpf_div(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_div';
{ Set rop to op1/(2^op2) }
procedure mpf_div_2exp(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_div_2exp';
{ Set rop to op1/op2 }
procedure mpf_div_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_div_ui';

// GDB only: procedure mpf_dump(var _para1: mpf_t); cdecl; external LIB name '__gmpf_dump';

{ Return non-zero if the first op3 bits of op1 and op2 are equal, zero otherwise }
function mpf_eq(var op1, op2: mpf_t; op3: valuint): longint; cdecl; external LIB name '__gmpf_eq';
{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
function mpf_fits_sint_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_sint_p';
{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
function mpf_fits_slong_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_slong_p';
{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
function mpf_fits_sshort_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_sshort_p';
{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
function mpf_fits_uint_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_uint_p';
{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
function mpf_fits_ulong_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_ulong_p';
{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
function mpf_fits_ushort_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_ushort_p';
{ Set rop to op rounded to the next lower }
procedure mpf_floor(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_floor';
{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
function mpf_get_d(var op: mpf_t): double; cdecl; external LIB name '__gmpf_get_d';
{ Convert op to a double, truncating if necessary (ie. rounding towards zero), and with an exponent returned separately }
function mpf_get_d_2exp(out exp: valsint; var op: mpf_t): double; cdecl; external LIB name '__gmpf_get_d_2exp';
{ Return the default precision actually used }
function mpf_get_default_prec: valuint; cdecl; external LIB name '__gmpf_get_default_prec';
{ Return the current precision of op, in bits }
function mpf_get_prec(var op: mpf_t): valuint; cdecl; external LIB name '__gmpf_get_prec';
{ Convert op to a long, truncating any fraction part }
function mpf_get_si(var op: mpf_t): valsint; cdecl; external LIB name '__gmpf_get_si';
{ Convert op to a string of digits in base base }
function mpf_get_str(str: pchar; out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: mpf_t): pchar; cdecl; external LIB name '__gmpf_get_str';
{ Convert op to a unsigned long, truncating any fraction part }
function mpf_get_ui(var op: mpf_t): valuint; cdecl; external LIB name '__gmpf_get_ui';
{ Initialize x to 0 }
procedure mpf_init(out x: mpf_t); cdecl; external LIB name '__gmpf_init';
{ Initialize x to 0 and set its precision to be at least prec bits }
procedure mpf_init2(out x: mpf_t; prec: valuint); cdecl; external LIB name '__gmpf_init2';
{ Initialize rop and set its value from op }
procedure mpf_init_set(out rop: mpf_t; var op: mpf_t); cdecl; external LIB name '__gmpf_init_set';
{ Initialize rop and set its value from op }
procedure mpf_init_set_d(out rop: mpf_t; op: double); cdecl; external LIB name '__gmpf_init_set_d';
{ Initialize rop and set its value from op }
procedure mpf_init_set_si(out rop: mpf_t; op: valsint); cdecl; external LIB name '__gmpf_init_set_si';
{ Initialize rop and set its value from the string in str }
function mpf_init_set_str(out rop: mpf_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpf_init_set_str';
{ Initialize rop and set its value from op }
procedure mpf_init_set_ui(out rop: mpf_t; op: valuint); cdecl; external LIB name '__gmpf_init_set_ui';
{ Return non-zero if op is an integer }
function mpf_integer_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_integer_p';
{ Set rop to op1 × op2 }
procedure mpf_mul(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_mul';
{ Set rop to op1 × (2^op2) }
procedure mpf_mul_2exp(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_mul_2exp';
{ Set rop to op1 × op2 }
procedure mpf_mul_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_mul_ui';
{ Set rop to −op }
procedure mpf_neg(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_neg';
{ Set rop to op1^op2 }
procedure mpf_pow_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_pow_ui';
{ Generate a random float of at most max_size limbs, with long strings of zeros and ones in the binary representation }
procedure mpf_random2(var rop: mpf_t; max_size: mp_size_t; exp: mp_exp_t); cdecl; external LIB name '__gmpf_random2';
{ Compute the relative difference between op1 and op2 and store the result in rop }
procedure mpf_reldiff(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_reldiff';
{ Set the value of rop from op }
procedure mpf_set(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_set';
{ Set the value of rop from op }
procedure mpf_set_d(var rop: mpf_t; op: double); cdecl; external LIB name '__gmpf_set_d';
{ Set the default precision to be at least prec bits }
procedure mpf_set_default_prec(prec: valuint); cdecl; external LIB name '__gmpf_set_default_prec';
{ Set the precision of rop to be at least prec bits }
procedure mpf_set_prec(var rop: mpf_t; prec: valuint); cdecl; external LIB name '__gmpf_set_prec';
{ Set the precision of rop to be at least prec bits, without changing the memory allocated }
procedure mpf_set_prec_raw(var rop: mpf_t; prec: valuint); cdecl; external LIB name '__gmpf_set_prec_raw';
{ Set the value of rop from op }
procedure mpf_set_q(var rop: mpf_t; var op: mpq_t); cdecl; external LIB name '__gmpf_set_q';
{ Set the value of rop from op }
procedure mpf_set_si(var rop: mpf_t; op: valsint); cdecl; external LIB name '__gmpf_set_si';
{ Set the value of rop from the string in str }
function mpf_set_str(var rop: mpf_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpf_set_str';
{ Set the value of rop from op }
procedure mpf_set_ui(var rop: mpf_t; op: valuint); cdecl; external LIB name '__gmpf_set_ui';
{ Set the value of rop from op }
procedure mpf_set_z(var rop: mpf_t; var op: mpz_t); cdecl; external LIB name '__gmpf_set_z';

// No docs: function mpf_size(var _para1: mpf_t): size_t; cdecl; external LIB name '__gmpf_size';

{ Set rop to op^(1/2) }
procedure mpf_sqrt(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_sqrt';
{ Set rop to op^(1/2) }
procedure mpf_sqrt_ui(var rop: mpf_t; op: valuint); cdecl; external LIB name '__gmpf_sqrt_ui';
{ Set rop to op1 − op2 }
procedure mpf_sub(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_sub';
{ Set rop to op1 − op2 }
procedure mpf_sub_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_sub_ui';
{ Swap rop1 and rop2 efficiently }
procedure mpf_swap(var rop1, rop2: mpf_t); cdecl; external LIB name '__gmpf_swap';
{ Set rop to op rounded to the integer towards zero }
procedure mpf_trunc(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_trunc';
{ Set rop to op1/op2 }
procedure mpf_ui_div(var rop: mpf_t; op1: valuint; var op2: mpf_t); cdecl; external LIB name '__gmpf_ui_div';
{ Set rop to op1 − op2 }
procedure mpf_ui_sub(var rop: mpf_t; op1: valuint; var op2: mpf_t); cdecl; external LIB name '__gmpf_ui_sub';
{ Generate a uniformly distributed random float in rop, such that 0 <= rop < 1, with nbits significant bits in the mantissa }
procedure mpf_urandomb(var rop: mpf_t; var state: randstate_t; nbits: valuint); cdecl; external LIB name '__gmpf_urandomb';

// ---- Low-level Functions ----

{ Add [s1p, s1n] and [s2p, s2n], and write the s1n least significant limbs of the result to rp. Return carry, either 0 or 1. }
function mpn_add(rop, s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_add';
{ Add [s1p, n] and s2limb, and write the n least significant limbs of the result to rp. Return carry, either 0 or 1. }
function mpn_add_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_add_1';
{ Add [s1p, n] and [s2p, n], and write the n least significant limbs of the result to rp. Return carry, either 0 or 1. }
function mpn_add_n(rop, s1p, s2p: mpn_ptr; n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_add_n';
{ Multiply [s1p, n] and s2limb, and add the n least significant limbs of the product to [rp, n] and write the result to rp. Return the most significant limb of the product, plus carry-out from the addition. }
function mpn_addmul_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_addmul_1';

{ Preliminary: This function puts the low floor(d/mp_bits_per_limb) limbs of q = [s1p, s1n]/[s2p, s2n] mod 2^d at rp, and returns the high d mod mp_bits_per_limb bits of q }
// function mpn_bdivmod(rp, s1p: mpn_t; s1n: mp_size_t; s2p: mpn_t; s2n: mp_size_t; d: valuint): mp_limb_t; cdecl; external LIB name '__gmpn_bdivmod';

{ Compare [s1p, n] and [s2p, n] and return a positive value if s1 > s2, 0 if they are equal, or a negative value if s1 < s2 }
function mpn_cmp(s1p, s2p: mpn_ptr; n: mp_size_t): longint; cdecl; external LIB name '__gmpn_cmp';
{ Divide [sp, n] by 3, expecting it to divide exactly, and writing the result to [rp, n] }
function mpn_divexact_by3c(rp, sp: mpn_ptr; n: mp_size_t; carry: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_divexact_by3c';

{ Obsolete: Divide [rs2p, rs2n] by [s3p, s3n], and write the quotient at r1p, with the exception of the most significant limb, which is returned }
// function mpn_divrem(r1p: mpn_t; qxn: mp_size_t; rs2p: mpn_t; rs2n: mp_size_t; s3p: mpn_t; s3n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_divrem';

{ Divide [s2p, s2n] by s3limb, and write the quotient at r1p. Return the remainder }
function mpn_divrem_1(r1p: mpn_ptr; qxn: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_divrem_1';

// No docs: function mpn_divrem_2(_para1: mpn_t; _para2: mp_size_t; _para3: mpn_t; _para4: mp_size_t; _para5: mpn_t): mp_limb_t; cdecl; external LIB name '__gmpn_divrem_2';

{ Set [rp, retval] to the greatest common divisor of [s1p, s1n] and [s2p, s2n] }
function mpn_gcd(rp, s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_size_t; cdecl; external LIB name '__gmpn_gcd';
{ Return the greatest common divisor of [s1p, s1n] and s2limb }
function mpn_gcd_1(s1p: mpn_ptr; s1n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_gcd_1';
{ Calculate the greatest common divisor of [s1p, s1n] and [s2p, s2n] }
function mpn_gcdext(r1p, r2p: mpn_ptr; out r2n: mp_size_t; s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_size_t; cdecl; external LIB name '__gmpn_gcdext';
{ Convert [s1p, s1n] to a raw unsigned char array at str in base base, and return the number of characters produced }
function mpn_get_str(str: pbyte; base: longint; s1p: mpn_ptr; s1n: mp_size_t):sizeuint; cdecl; external LIB name '__gmpn_get_str';
{ Compute the hamming distance between [s1p, n] and [s2p, n], which is the number of bit positions where the two operands have different bit values }
function mpn_hamdist(s1p, s2p: mpn_ptr; n: mp_size_t): valuint; cdecl; external LIB name '__gmpn_hamdist';
{ Shift [sp, n] left by count bits, and write the result to [rp, n] }
function mpn_lshift(rp, sp: mpn_ptr; n: mp_size_t; count: dword): mp_limb_t; cdecl; external LIB name '__gmpn_lshift';
{ Divide [s1p, s1n] by s2limb, and return the remainder. s1n can be zero. }
function mpn_mod_1(s1p: mpn_ptr; s1n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_mod_1';
{ Multiply [s1p, s1n] and [s2p, s2n], and write the result to rp. Return the most significant limb of the result. }
function mpn_mul(rp, s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_mul';
{ Multiply [s1p, n] by s2limb, and write the n least significant limbs of the product to rp. Return the most significant limb of the product. }
function mpn_mul_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_mul_1';
{ Multiply [s1p, n] and [s2p, n], and write the 2*n-limb result to rp }
procedure mpn_mul_n(rp, s1p, s2p: mpn_ptr; n: mp_size_t); cdecl; external LIB name '__gmpn_mul_n';
{ Return non-zero iff [s1p, n] is a perfect square }
function mpn_perfect_square_p(s1p: mpn_ptr; n: mp_size_t): longint; cdecl; external LIB name '__gmpn_perfect_square_p';
{ Count the number of set bits in [s1p, n] }
function mpn_popcount(s1p: mpn_ptr; n: mp_size_t): valuint; cdecl; external LIB name '__gmpn_popcount';

// No docs: function mpn_pow_1(_para1, _para2: mpn_t; _para3: mp_size_t; _para4, _para5: mpn_t): mp_size_t; cdecl; external LIB name '__gmpn_pow_1';
// No docs: function mpn_preinv_mod_1(_para1: mpn_t; _para2: mp_size_t; _para3, _para4: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_preinv_mod_1';

{ Generate a random number of length r1n and store it at r1p }
procedure mpn_random(r1p: mpn_ptr; r1n: mp_size_t); cdecl; external LIB name '__gmpn_random';
{ Generate a random number of length r1n and store it at r1p }
procedure mpn_random2(r1p: mpn_ptr; r1n: mp_size_t); cdecl; external LIB name '__gmpn_random2';
{ Shift [sp, n] right by count bits, and write the result to [rp, n] }
function mpn_rshift(rp, sp: mpn_ptr; n: mp_size_t; count: dword): mp_limb_t; cdecl; external LIB name '__gmpn_rshift';
{ Scan s1p from bit position bit for the next clear bit }
function mpn_scan0(s1p: mpn_ptr; bit: valuint): valuint; cdecl; external LIB name '__gmpn_scan0';
{ Scan s1p from bit position bit for the next set bit }
function mpn_scan1(s1p: mpn_ptr; bit: valuint): valuint; cdecl; external LIB name '__gmpn_scan1';
{ Convert bytes [str,strsize] in the given base to limbs at rp }
function mpn_set_str(rp: mpn_ptr; str: pbyte; strsize: sizeuint; base:longint): mp_size_t; cdecl; external LIB name '__gmpn_set_str';
{ Compute the square root of [sp, n] and put the result at [r1p, dn/2e] and the remainder at [r2p, retval] }
function mpn_sqrtrem(r1p, r2p, sp: mpn_ptr; n: mp_size_t): mp_size_t; cdecl; external LIB name '__gmpn_sqrtrem';
{ Subtract [s2p, s2n] from [s1p, s1n], and write the s1n least significant limbs of the result to rp. Return borrow, either 0 or 1. }
function mpn_sub(rp, s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_sub';
{ Subtract s2limb from [s1p, n], and write the n least significant limbs of the result to rp. Return borrow, either 0 or 1. }
function mpn_sub_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_sub_1';
{ Subtract [s2p, n] from [s1p, n], and write the n least significant limbs of the result to rp. Return borrow, either 0 or 1. }
function mpn_sub_n(rp, s1p, s2p: mpn_ptr; n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_sub_n';
{ Multiply [s1p, n] and s2limb, and subtract the n least significant limbs of the product from [rp, n] and write the result to rp. Return the most significant limb of the product, plus borrow-out from the subtraction. }
function mpn_submul_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_submul_1';
{ Divide [np, nn] by [dp, dn] and put the quotient at [qp, nn−dn+1] and the remainder at [rp, dn] }
procedure mpn_tdiv_qr(qp, rp: mpn_ptr; qxn: mp_size_t; np: mpn_ptr; nn: mp_size_t; dp: mpn_ptr; dn: mp_size_t); cdecl; external LIB name '__gmpn_tdiv_qr';

// ---- GMP properties ----

{ Size of a limb on this machine }
function bits_per_limb: longint;
{ Some GMP functions may set this thread unsafe variable. Better avoid using it. }
function errno: longint;
{ GMP version string a.b.c }
function version: string;

// ==== ext bindings =====

// ---- Random Number Functions ----

{ Initialize state with a default algorithm }
procedure randinit_default(out state: MPRandState);
{ Initialize state with a linear congruential algorithm X = (aX + c) mod 2^m2exp }
procedure randinit_lc_2exp(out state: MPRandState; var a: MPInteger; c, m2exp: valuint);
{ Initialize state for a linear congruential algorithm as per gmp_randinit_lc_2exp }
function randinit_lc_2exp_size(out state: MPRandState; size: sizeuint): boolean;
{ Initialize state for a Mersenne Twister algorithm }
procedure randinit_mt(out state: MPRandState);
{ Initialize rop with a copy of the algorithm and state from op }
procedure randinit_set(out rop: MPRandState; var op: MPRandState);
{ Set an initial seed value into state }
procedure randseed(var state: MPRandState; var seed: MPInteger);
{ Set an initial seed value into state }
procedure randseed_ui(var state: MPRandState; seed: valuint);
{ Free all memory occupied by state }
procedure randclear(var state: MPRandState);
{ Return an uniformly distributed random number of n bits, ie. in the range 0 to 2^n−1 inclusive }
function urandomb_ui(var state: MPRandState; n: valuint): valuint;
{ Return an uniformly distributed random number in the range 0 to n − 1, inclusive }
function urandomm_ui(var state: MPRandState; n: valuint): valuint;

// ---- integer Functions ----

{ Change the space for integer to new_alloc limbs }
function z_realloc(var integer_: MPInteger; new_alloc: mp_size_t): pointer;
{ Set rop to the absolute value of op }
procedure z_abs(var rop, op: MPInteger);
{ Return the absolute value of op }
function z_abs(var op: MPInteger): MPInteger;
{ Set rop to op1 + op2 }
procedure z_add(var rop, op1, op2: MPInteger);
{ Return op1 + op2 }
function z_add(var op1, op2: MPInteger): MPInteger;
{ Set rop to op1 + op2 }
procedure z_add_ui(var rop, op1: MPInteger; op2: valuint);
{ Return op1 + op2 }
function z_add_ui(var op1: MPInteger; op2: valuint): MPInteger;
{ Set rop to rop + op1 × op2 }
procedure z_addmul(var rop, op1, op2: MPInteger);
{ Set rop to rop + op1 × op2 }
procedure z_addmul_ui(var rop, op1: MPInteger; op2: valuint);
{ Set rop to op1 bitwise-and op2 }
procedure z_and(var rop, op1, op2: MPInteger);
{ Return op1 bitwise-and op2 }
function z_and(var op1, op2: MPInteger): MPInteger;
//{ _Fixed_ space of fixed_num_bits is allocated to each of the array size integers in integer array }
//procedure z_array_init(var integer_array: MPInteger; array_size, fixed_num_bits: mp_size_t);
{ Compute the binomial coefficient (n over k) and store the result in rop }
procedure z_bin_ui(var rop, n: MPInteger; k: valuint);
{ Return the binomial coefficient (n over k) }
function z_bin_ui(var n: MPInteger; k: valuint): MPInteger;
{ Compute the binomial coefficient (n over k) and store the result in rop }
procedure z_bin_uiui(var rop: MPInteger; n, k: valuint);
{ Return the binomial coefficient (n over k) }
function z_bin_uiui(n, k: valuint): MPInteger;
{ Divide n by d, forming a quotient q. Round mode ceil. }
procedure z_cdiv_q(var q, n, d: MPInteger);
{ Divide n by d, forming a return quotient. Round mode ceil. }
function z_cdiv_q(var n, d: MPInteger): MPInteger;
{ Divide n by d, forming a quotient q. d = 2^b. Round mode ceil. }
procedure z_cdiv_q_2exp(var q, n: MPInteger; b: valuint);
{ Divide n by d, forming a return quotient. d = 2^b. Round mode ceil. }
function z_cdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
{ Divide n by d, forming a quotient q. Round mode ceil. }
function z_cdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
{ Divide n by d, forming a quotient q and remainder r. Round mode ceil. }
procedure z_cdiv_qr(var q, r, n, d: MPInteger);
{ Divide n by d, forming a quotient q and remainder r. Round mode ceil. }
function z_cdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
{ Divide n by d, forming a remainder r. Round mode ceil. }
procedure z_cdiv_r(var r, n, d: MPInteger);
{ Divide n by d, forming a return remainder. Round mode ceil. }
function z_cdiv_r(var n, d: MPInteger): MPInteger;
{ Divide n by d, forming a remainder r. d = 2^b. Round mode ceil. }
procedure z_cdiv_r_2exp(var r, n: MPInteger; b: valuint);
{ Divide n by d, forming a return remainder. d = 2^b. Round mode ceil. }
function z_cdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
{ Divide n by d, forming a remainder r. Round mode ceil. }
function z_cdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
{ Divide n by d. Round mode ceil. }
function z_cdiv_ui(var n: MPInteger; d: valuint): valuint;
{ Free the space occupied by integer. Call this function for all MPInteger variables when you are done with them. }
procedure z_clear(var integer_: MPInteger);
{ Clear bit bit_index in rop }
procedure z_clrbit(var rop: MPInteger; bit_index: valuint);
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
function z_cmp(var op1, op2: MPInteger): longint;
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
function z_cmp_d(var op1: MPInteger; op2: double): longint;
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
function z_cmp_si(var op1: MPInteger; op2: valsint): longint;
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
function z_cmp_ui(var op1: MPInteger; op2: valuint): longint;
{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
function z_cmpabs(var op1, op2: MPInteger): longint;
{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
function z_cmpabs_d(var op1: MPInteger; op2: double): longint;
{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
function z_cmpabs_ui(var op1: MPInteger; op2: valuint): longint;
{ Set rop to the one’s complement of op }
procedure z_com(var rop, op: MPInteger);
{ Return the one’s complement of op }
function z_com(var op: MPInteger): MPInteger;
{ Complement bit bit_index in rop }
procedure z_combit(var rop: MPInteger; bit_index: valuint);
{ Return true if n is congruent to c modulo d }
function z_congruent_p(var n, c, d: MPInteger): boolean;
{ Return true if n is congruent to c modulo 2^b }
function z_congruent_2exp_p(var n, c: MPInteger; b: valuint): boolean;
{ Return true if n is congruent to c modulo d }
function z_congruent_ui_p(var n: MPInteger; c, d: valuint): boolean;
{ Set q to n/d }
procedure z_divexact(var q, n, d: MPInteger);
{ Return n/d }
function z_divexact(var n, d: MPInteger): MPInteger;
{ Set q to n/d }
procedure z_divexact_ui(var q, n: MPInteger; d: valuint);
{ Return n/d }
function z_divexact_ui(var n: MPInteger; d: valuint): MPInteger;
{ Return true if n is exactly divisible by d }
function z_divisible_p(var n, d: MPInteger): boolean;
{ Return true if n is exactly divisible by d }
function z_divisible_ui_p(var n: MPInteger; d: valuint): boolean;
{ Return true if n is exactly divisible by by 2^b }
function z_divisible_2exp_p(var n: MPInteger; b: valuint): boolean;
{ Fill buf with word data from op }
function z_export(out buf; out countp: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; var op: MPInteger): pointer;
{ Set rop to op!, the factorial of op }
procedure z_fac_ui(var rop: MPInteger; op: valuint);
{ Return op!, the factorial of op }
function z_fac_ui(op: valuint): MPInteger;
{ Divide n by d, forming a quotient q. Round mode floor. }
procedure z_fdiv_q(var q, n, d: MPInteger);
{ Divide n by d, forming a return quotient. Round mode floor. }
function z_fdiv_q(var n, d: MPInteger): MPInteger;
{ Divide n by d, forming a quotient q. d = 2^b. Round mode floor. }
procedure z_fdiv_q_2exp(var q, n: MPInteger; b: valuint);
{ Divide n by d, forming a return quotient. d = 2^b. Round mode floor. }
function z_fdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
{ Divide n by d, forming a quotient q. Round mode floor. }
function z_fdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
{ Divide n by d, forming a quotient q and remainder r. Round mode floor. }
procedure z_fdiv_qr(var q, r, n, d: MPInteger);
{ Divide n by d, forming a quotient q and remainder r. Round mode floor. }
function z_fdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
{ Divide n by d, forming a remainder r. Round mode floor. }
procedure z_fdiv_r(var r, n, d: MPInteger);
{ Divide n by d, forming a return remainder. Round mode floor. }
function z_fdiv_r(var n, d: MPInteger): MPInteger;
{ Divide n by d, forming a remainder r. d = 2^b. Round mode floor. }
procedure z_fdiv_r_2exp(var r, n: MPInteger; b: valuint);
{ Divide n by d, forming a return remainder. d = 2^b. Round mode floor. }
function z_fdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
{ Divide n by d, forming a remainder r. Round mode floor. }
function z_fdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
{ Divide n by d. Round mode floor. }
function z_fdiv_ui(var n: MPInteger; d: valuint): valuint;
{ Set fn to to Fn, the n’th Fibonacci number }
procedure z_fib_ui(var fn: MPInteger; n: valuint);
{ Return Fn, the n’th Fibonacci number }
function z_fib_ui(n: valuint): MPInteger;
{ Set fn to Fn, and fnsub1 to Fn−1 }
procedure z_fib2_ui(var fn, fnsub1: MPInteger; n: valuint);
{ Return Fn, and fnsub1 = Fn−1 }
function z_fib2_ui(var fnsub1: MPInteger; n: valuint): MPInteger;
{ Return true iff the value of op fits in an signed int }
function z_fits_sint_p(var op: MPInteger): boolean;
{ Return true iff the value of op fits in an signed long int }
function z_fits_slong_p(var op: MPInteger): boolean;
{ Return true iff the value of op fits in an signed short int }
function z_fits_sshort_p(var op: MPInteger): boolean;
{ Return true iff the value of op fits in an unsigned int }
function z_fits_uint_p(var op: MPInteger): boolean;
{ Return true iff the value of op fits in an unsigned long int }
function z_fits_ulong_p(var op: MPInteger): boolean;
{ Return true iff the value of op fits in an unsigned short int }
function z_fits_ushort_p(var op: MPInteger): boolean;
{ Set rop to the greatest common divisor of op1 and op2 }
procedure z_gcd(var rop, op1, op2: MPInteger);
{ Return the greatest common divisor of op1 and op2 }
function z_gcd(var op1, op2: MPInteger): MPInteger;
{ Compute the greatest common divisor of op1 and op2 }
function z_gcd_ui(var rop, op1: MPInteger; op2: valuint): valuint;
{ Set g to the greatest common divisor of a and b, and in addition set s and t to coefficients satisfying as + bt = g }
procedure z_gcdext(var g, s, t, a, b: MPInteger);
{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
function z_get_d(var op: MPInteger): double;
{ Convert op to a double, truncating if necessary (ie. rounding towards zero), and returning the exponent separately }
function z_get_d_2exp(out exp: valsint; var op: MPInteger): double;
{ Return the value of op as a signed long }
function z_get_si(op: MPInteger): valsint;
{ Convert op to a string of digits in base base. The base argument may vary from 2 to 62 or from −2 to −36. }
function z_get_str(base: longint; var op: MPInteger): string;
{ Convert op to a string of digits in base base. The base argument may vary from 2 to 62 or from −2 to −36. If str is NULL, the result string is allocated using the current allocation function }
function z_get_str(str: pchar; base: longint; var op: MPInteger): pchar;
{ Return the value of op as an unsigned long }
function z_get_ui(op: MPInteger): valuint;
{ Return limb number n from op }
function z_getlimbn(var op: MPInteger; n: mp_size_t): mp_limb_t;
{ If op1 and op2 are both >= 0 or both < 0, return the hamming distance between the two operands, which is the number of bit positions where op1 and op2 have different bit values }
function z_hamdist(var op1, op2: MPInteger): valuint;
{ Set rop from an array of word data at op }
procedure z_import(var rop: MPInteger; count: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; const op);
{ Initialize integer, and set its value to 0 }
procedure z_init(out integer_: MPInteger);
{ Initialize integer, with space for n bits, and set its value to 0 }
procedure z_init2(out integer_: MPInteger; n: valuint);
{ Initialize rop with limb space and set the initial numeric value from op }
procedure z_init_set(out rop: MPInteger; var op: MPInteger);
{ Initialize rop with limb space and set the initial numeric value from op }
procedure z_init_set_d(out rop: MPInteger; op: double);
{ Initialize rop with limb space and set the initial numeric value from op }
procedure z_init_set_si(out rop: MPInteger; op: valsint);
{ Initialize rop and set its value like z_set_str. If the string is a correct base base number, the function returns true. }
function z_init_set_str(out rop: MPInteger; str: string; base: longint): boolean;
{ Initialize rop with limb space and set the initial numeric value from op }
procedure z_init_set_ui(out rop: MPInteger; op: valuint);
{ Compute the inverse of op1 modulo op2 and put the result in rop }
function z_invert(var rop, op1, op2: MPInteger): longint;
{ Set rop to op1 bitwise inclusive-or op2 }
procedure z_ior(var rop, op1, op2: MPInteger);
{ Return bitwise inclusive-or op2 }
function z_ior(var op1, op2: MPInteger): MPInteger;
{ Calculate the Jacobi symbol. This is defined only for b odd }
function z_jacobi(var a, b: MPInteger): longint;
{ Calculate the Jacobi symbol with the Kronecker extension }
function z_kronecker_si(var a: MPInteger; b: valsint): longint;
{ Calculate the Jacobi symbol with the Kronecker extension }
function z_kronecker_ui(var a: MPInteger; b: valuint): longint;
{ Calculate the Jacobi symbol with the Kronecker extension }
function z_si_kronecker(a: valsint; var b: MPInteger): longint;
{ Calculate the Jacobi symbol with the Kronecker extension }
function z_ui_kronecker(a: valuint; var b: MPInteger): longint;
{ Set rop to the least common multiple of op1 and op2 }
procedure z_lcm(var rop, op1, op2: MPInteger);
{ Return the least common multiple of op1 and op2 }
function z_lcm(var op1, op2: MPInteger): MPInteger;
{ Set rop to the least common multiple of op1 and op2 }
procedure z_lcm_ui(var rop, op1: MPInteger; op2: valuint);
{ Return the least common multiple of op1 and op2 }
function z_lcm_ui(var op1: MPInteger; op2: valuint): MPInteger;
{ Set ln to to Ln, the n’th Lucas number }
procedure z_lucnum_ui(var ln: MPInteger; n: valuint);
{ Return Ln, the n’th Lucas number }
function z_lucnum_ui(n: valuint): MPInteger;
{ Set ln to Ln, and lnsub1 to Ln−1 }
procedure z_lucnum2_ui(var ln, lnsub1: MPInteger; n: valuint);
{ Return Ln, and lnsub1 to Ln−1 }
function z_lucnum2_ui(var lnsub1: MPInteger; n: valuint): MPInteger;
{ Set r to n mod d. The sign of the divisor is ignored; the result is always non-negative. }
procedure z_mod(var r, n, d: MPInteger);
{ Return n mod d. The sign of the divisor is ignored; the result is always non-negative. }
function z_mod(var n, d: MPInteger): MPInteger;
{ Set rop to op1 × op2 }
procedure z_mul(var rop, op1, op2: MPInteger);
{ Return op1 × op2 }
function z_mul(var op1, op2: MPInteger): MPInteger;
{ Set rop to op1 × 2^op2. This operation can also be defined as a left shift by op2 bits. }
procedure z_mul_2exp(var rop, op1: MPInteger; op2: valuint);
{ Return op1 × 2^op2. This operation can also be defined as a left shift by op2 bits. }
function z_mul_2exp(var op1: MPInteger; op2: valuint): MPInteger;
{ Set rop to op1 × op2 }
procedure z_mul_si(var rop, op1: MPInteger; op2: valsint);
{ Return op1 × op2 }
function z_mul_si(var op1: MPInteger; op2: valsint): MPInteger;
{ Set rop to op1 × op2 }
procedure z_mul_ui(var rop, op1: MPInteger; op2: valuint);
{ Return op1 × op2 }
function z_mul_ui(var op1: MPInteger; op2: valuint): MPInteger;
{ Set rop to −op }
procedure z_neg(var rop, op: MPInteger);
{ Return −op }
function z_neg(var op: MPInteger): MPInteger;
{ Set rop to the next prime greater than op }
procedure z_nextprime(var rop, op: MPInteger);
{ Return the next prime greater than op }
function z_nextprime(var op: MPInteger): MPInteger;
{ Return true if op is a perfect power, i.e., if there exist integers a and b, with b > 1, such that op = a^b }
function z_perfect_power_p(var op: MPInteger): boolean;
{ Return true if op is a perfect square, i.e., if the square root of op is an integer }
function z_perfect_square_p(var op: MPInteger): boolean;
{ If op >= 0, return the population count of op, which is the number of 1 bits in the binary representation }
function z_popcount(var op: MPInteger): valuint;
{ Set rop to base^exp. The case 0^0 yields 1. }
procedure z_pow_ui(var rop, base: MPInteger; exp: valuint);
{ Return base^exp. The case 0^0 yields 1. }
function z_pow_ui(var base: MPInteger; exp: valuint): MPInteger;
{ Set rop to base^exp mod mod_ }
procedure z_powm(var rop, base, exp, mod_: MPInteger);
{ Return base^exp mod mod_ }
function z_powm(var base, exp, mod_: MPInteger): MPInteger;
{ Set rop to base^exp mod mod_ }
procedure z_powm_ui(var rop, base: MPInteger; exp: valuint; var mod_: MPInteger);
{ Return base^exp mod mod_ }
function z_powm_ui(var base: MPInteger; exp: valuint; var mod_: MPInteger): MPInteger;
{ Determine whether n is prime. Return 2 if n is definitely prime, return 1 if n is probably prime (without being certain), or return 0 if n is definitely composite. }
function z_probab_prime_p(var n: MPInteger; reps: longint): longint;
{ Change the space allocated for integer to n bits. The value in integer is preserved if it fits, or is set to 0 if not. }
procedure z_realloc2(var integer_: MPInteger; n: valuint);
{ Remove all occurrences of the factor f from op and store the result in rop }
function z_remove(var rop, op, f: MPInteger): valuint;
{ Set rop to trunc(op^(1/n)), the truncated integer part of the nth root of op. Return true if the computation was exact, i.e., if op is rop to the nth power. }
function z_root(var rop, op: MPInteger; n: valuint): boolean;
{ Set root to trunc(u^(1/n)), the truncated integer part of the nth root of u. Set rem to the remainder, (u − root^n). }
procedure z_rootrem(var root, rem, u: MPInteger; n: valuint);
{ Generate a random integer with long strings of zeros and ones in the binary representation }
procedure z_rrandomb(var rop: MPInteger; var state: MPRandState; n: valuint);
{ Return a random integer with long strings of zeros and ones in the binary representation }
function z_rrandomb(var state: MPRandState; n: valuint): MPInteger;
{ Scan op, starting from bit starting_bit, towards more significant bits, until the first 0 bit is found }
function z_scan0(var op: MPInteger; starting_bit: valuint): valuint;
{ Scan op, starting from bit starting_bit, towards more significant bits, until the first 1 bit is found }
function z_scan1(var op: MPInteger; starting_bit: valuint): valuint;
{ Set the value of rop from op }
procedure z_set(var rop, op: MPInteger);
{ Set the value of rop from op }
procedure z_set_d(var rop: MPInteger; op: double);
{ Set the value of rop from op }
procedure z_set_f(var rop: MPInteger; var op: MPFloat);
{ Set the value of rop from op }
procedure z_set_q(var rop: MPInteger; var op: MPRational);
{ Set the value of rop from op }
procedure z_set_si(var rop: MPInteger; op: valsint);
{ Set the value of rop from str, a null-terminated C string in base base. If the string is a correct base base number, the function returns true. }
function z_set_str(var rop: MPInteger; str: string; base: longint): boolean;
{ Set the value of rop from op }
procedure z_set_ui(var rop: MPInteger; op: valuint);
{ Set bit bit_index in rop }
procedure z_setbit(var rop: MPInteger; bit_index: valuint);
{ Return the size of op measured in number of limbs }
function z_size(var op: MPInteger): sizeuint;
{ Return the size of op measured in number of digits in the given base }
function z_sizeinbase(var op: MPInteger; base: longint): sizeuint;
{ Set rop to trunc(sqrt(op)), the truncated integer part of the square root of op }
procedure z_sqrt(var rop, op: MPInteger);
{ Return trunc(sqrt(op)), the truncated integer part of the square root of op }
function z_sqrt(var op: MPInteger): MPInteger;
{ Set rop1 to trunc(sqrt(op)), like z_sqrt. Set rop2 to the remainder (op − rop1^2), which will be zero if op is a perfect square. }
procedure z_sqrtrem(var rop1, rop2, op: MPInteger);
{ Set rop to op1 − op2 }
procedure z_sub(var rop, op1, op2: MPInteger);
{ Return op1 − op2 }
function z_sub(var op1, op2: MPInteger): MPInteger;
{ Set rop to op1 − op2 }
procedure z_sub_ui(var rop, op1: MPInteger; op2: valuint);
{ Return op1 − op2 }
function z_sub_ui(var op1: MPInteger; op2: valuint): MPInteger;
{ Set rop to op1 − op2 }
procedure z_ui_sub(var rop: MPInteger; op1: valuint; var op2: MPInteger);
{ Return op1 − op2 }
function z_ui_sub(op1: valuint; var op2: MPInteger): MPInteger;
{ Set rop to rop − op1 × op2 }
procedure z_submul(var rop, op1, op2: MPInteger);
{ Set rop to rop − op1 × op2 }
procedure z_submul_ui(var rop, op1: MPInteger; op2: valuint);
{ Swap the values rop1 and rop2 efficiently }
procedure z_swap(var rop1, rop2: MPInteger);
{ Divide n by d, forming a quotient q. Round mode trunc. }
procedure z_tdiv_q(var q, n, d: MPInteger);
{ Divide n by d, forming a return quotient. Round mode trunc. }
function z_tdiv_q(var n, d: MPInteger): MPInteger;
{ Divide n by d, forming a quotient q. d = 2^b. Round mode trunc. }
procedure z_tdiv_q_2exp(var q, n: MPInteger; b: valuint);
{ Divide n by d, forming a return quotient. d = 2^b. Round mode trunc. }
function z_tdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
{ Divide n by d, forming a quotient q. Round mode trunc. }
function z_tdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
{ Divide n by d, forming a quotient q and remainder r. Round mode trunc. }
procedure z_tdiv_qr(var q, r, n, d: MPInteger);
{ Divide n by d, forming a quotient q and remainder r. Round mode trunc. }
function z_tdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
{ Divide n by d, forming a remainder r. Round mode trunc. }
procedure z_tdiv_r(var r, n, d: MPInteger);
{ Divide n by d, forming a return remainder. Round mode trunc. }
function z_tdiv_r(var n, d: MPInteger): MPInteger;
{ Divide n by d, forming a remainder r. d = 2^b. Round mode trunc. }
procedure z_tdiv_r_2exp(var r, n: MPInteger; b: valuint);
{ Divide n by d, forming a return remainder. d = 2^b. Round mode trunc. }
function z_tdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
{ Divide n by d, forming a remainder r. Round mode trunc. }
function z_tdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
{ Divide n by d. Round mode trunc. }
function z_tdiv_ui(var n: MPInteger; d: valuint): valuint;
{ Test bit bit_index in op and return true or false accordingly }
function z_tstbit(var rop: MPInteger; bit_index: valuint): boolean;
{ Set rop to base^exp. The case 0^0 yields 1 }
procedure z_ui_pow_ui(var rop: MPInteger; base, exp: valuint);
{ Return base^exp. The case 0^0 yields 1 }
function z_ui_pow_ui(base, exp: valuint): MPInteger;
{ Generate a uniformly distributed random integer in the range 0 to 2^n − 1, inclusive }
procedure z_urandomb(var rop: MPInteger; var state: MPRandState; n: valuint);
{ Return a uniformly distributed random integer in the range 0 to 2^n − 1, inclusive }
function z_urandomb(var state: MPRandState; n: valuint): MPInteger;
{ Generate a uniform random integer in the range 0 to n − 1, inclusive }
procedure z_urandomm(var rop: MPInteger; var state: MPRandState; var n: MPInteger);
{ Return a uniform random integer in the range 0 to n − 1, inclusive }
function z_urandomm(var state: MPRandState; var n: MPInteger): MPInteger;
{ Set rop to op1 bitwise exclusive-or op2 }
procedure z_xor(var rop, op1, op2: MPInteger);
{ Retuen op1 bitwise exclusive-or op2 }
function z_xor(var op1, op2: MPInteger): MPInteger;

// ---- Rational Number Functions ----

{ Set rop to the absolute value of op }
procedure q_abs(var rop, op: MPRational);
{ Return absolute value of op }
function q_abs(var op: MPRational): MPRational;
{ Set sum to addend1 + addend2 }
procedure q_add(var sum, addend1, addend2: MPRational);
{ Return addend1 + addend2 }
function q_add(var addend1, addend2: MPRational): MPRational;
{ Remove any factors that are common to the numerator and denominator of op, and make the denominator positive }
procedure q_canonicalize(var op: MPRational);
{ Free the space occupied by rational number }
procedure q_clear(var rational_number: MPRational);
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2 }
function q_cmp(var op1, op2: MPRational): longint;
{ Compare op1 and num2/den2. Return a positive value if op1 > num2/den2, zero if op1 = num2/den2, and a negative value if op1 < num2/den2 }
function q_cmp_si(var op1: MPRational; num2: valsint; den2: valuint): longint;
{ Compare op1 and num2/den2. Return a positive value if op1 > num2/den2, zero if op1 = num2/den2, and a negative value if op1 < num2/den2 }
function q_cmp_ui(var op1: MPRational; num2, den2: valuint): longint;
{ Set quotient to dividend/divisor }
procedure q_div(var quotient, dividend, divisor: MPRational);
{ Return dividend/divisor }
function q_div(var dividend, divisor: MPRational): MPRational;
{ Set rop to op1/(2^op2) }
procedure q_div_2exp(var rop, op1: MPRational; op2: valuint);
{ Return op1/(2^op2) }
function q_div_2exp(var op1: MPRational; op2: valuint): MPRational;
{ Return true if op1 and op2 are equal, false if they are non-equal }
function q_equal(var op1, op2: MPRational): boolean;
{ Get the numerator of a rational }
procedure q_get_num(var numerator: MPInteger; var rational: MPRational);
{ Return the numerator of a rational }
function q_get_num(var rational: MPRational): MPInteger;
{ Get the denominator of a rational }
procedure q_get_den(var denominator: MPInteger; var rational: MPRational);
{ Return the denominator of a rational }
function q_get_den(var rational: MPRational): MPInteger;
{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
function q_get_d(var op: MPRational): double;
{ Convert op to a string of digits in base base }
function q_get_str(base: longint; var op: MPRational): string;
{ Convert op to a string of digits in base base. If str is NULL, the result string is allocated using the current allocation function. }
function q_get_str(str: pchar; base: longint; var op: MPRational): pchar;
{ Initialize dest rational and set it to 0/1 }
procedure q_init(out dest_rational: MPRational);
{ Set inverted_number to 1/number }
procedure q_inv(var inverted_number, number: MPRational);
{ Return 1/number }
function q_inv(var number: MPRational): MPRational;
{ Set product to multiplier × multiplicand }
procedure q_mul(var product, multiplier, multiplicand: MPRational);
{ Return multiplier × multiplicand }
function q_mul(var multiplier, multiplicand: MPRational): MPRational;
{ Set rop to op1 × (2^op2) }
procedure q_mul_2exp(var rop, op1: MPRational; op2: valuint);
{ Return op1 × (2^op2) }
function q_mul_2exp(var op1: MPRational; op2: valuint): MPRational;
{ Set negated_operand to −operand }
procedure q_neg(var negated_operand, operand: MPRational);
{ Return −operand }
function q_neg(var operand: MPRational): MPRational;
{ Assign rop from op }
procedure q_set(var rop, op: MPRational);
{ Set rop to the value of op. There is no rounding, this conversion is exact. }
procedure q_set_d(var rop: MPRational; op: double);
{ Set the denominator of a rational }
procedure q_set_den(var rational: MPRational; var denominator: MPInteger);
{ Set rop to the value of op. There is no rounding, this conversion is exact. }
procedure q_set_f(var rop: MPRational; var op: MPFloat);
{ Set the numerator of a rational }
procedure q_set_num(var rational: MPRational; var numerator: MPInteger);
{ Set the value of rop to op1/op2 }
procedure q_set_si(var rop: MPRational; op1: valsint; op2: valuint);
{ Set rop from a null-terminated string str in the given base. The return value is true if the entire string is a valid number. }
function q_set_str(var rop: MPRational; str: string; base: longint): boolean;
{ Set the value of rop to op1/op2 }
procedure q_set_ui(var rop: MPRational; op1, op2: valuint);
{ Assign rop from op }
procedure q_set_z(var rop: MPRational; var op: MPInteger);
{ Set difference to minuend − subtrahend }
procedure q_sub(var difference, minuend, subtrahend: MPRational);
{ Return minuend − subtrahend }
function q_sub(var minuend, subtrahend: MPRational): MPRational;
{ Swap the values rop1 and rop2 efficiently }
procedure q_swap(var rop1, rop2: MPRational);

// ---- Floating-point Functions ----

{ Set rop to the absolute value of op }
procedure f_abs(var rop, op: MPFloat);
{ Return the absolute value of op }
function f_abs(var op: MPFloat): MPFloat;
{ Set rop to op1 + op2 }
procedure f_add(var rop, op1, op2: MPFloat);
{ Return op1 + op2 }
function f_add(var op1, op2: MPFloat): MPFloat;
{ Set rop to op1 + op2 }
procedure f_add_ui(var rop, op1: MPFloat; op2: valuint);
{ Return op1 + op2 }
function f_add_ui(var op1: MPFloat; op2: valuint): MPFloat;
{ Set rop to op rounded to the next higher integer }
procedure f_ceil(var rop, op: MPFloat);
{ Return op rounded to the next higher integer }
function f_ceil(var op: MPFloat): MPFloat;
{ Free the space occupied by x }
procedure f_clear(var x: MPFloat);
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
function f_cmp(var op1, op2: MPFloat): longint;
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
function f_cmp_d(var op1: MPFloat; op2: double): longint;
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
function f_cmp_si(var op1: MPFloat; op2: valsint): longint;
{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
function f_cmp_ui(var op1: MPFloat; op2: valuint): longint;
{ Set rop to op1/op2 }
procedure f_div(var rop, op1, op2: MPFloat);
{ Return op1/op2 }
function f_div(var op1, op2: MPFloat): MPFloat;
{ Set rop to op1/(2^op2) }
procedure f_div_2exp(var rop, op1: MPFloat; op2: valuint);
{ Return op1/(2^op2) }
function f_div_2exp(var op1: MPFloat; op2: valuint): MPFloat;
{ Set rop to op1/op2 }
procedure f_div_ui(var rop, op1: MPFloat; op2: valuint);
{ Return op1/op2 }
function f_div_ui(var op1: MPFloat; op2: valuint): MPFloat;
{ Return true if the first op3 bits of op1 and op2 are equal, false otherwise }
function f_eq(var op1, op2: MPFloat; op3: valuint): boolean;
{ Return true if op would fit in the respective C data type, when truncated to an integer }
function f_fits_sint_p(var op: MPFloat): boolean;
{ Return true if op would fit in the respective C data type, when truncated to an integer }
function f_fits_slong_p(var op: MPFloat): boolean;
{ Return true if op would fit in the respective C data type, when truncated to an integer }
function f_fits_sshort_p(var op: MPFloat): boolean;
{ Return true if op would fit in the respective C data type, when truncated to an integer }
function f_fits_uint_p(var op: MPFloat): boolean;
{ Return true if op would fit in the respective C data type, when truncated to an integer }
function f_fits_ulong_p(var op: MPFloat): boolean;
{ Return true if op would fit in the respective C data type, when truncated to an integer }
function f_fits_ushort_p(var op: MPFloat): boolean;
{ Set rop to op rounded to the next lower }
procedure f_floor(var rop, op: MPFloat);
{ Return op rounded to the next lower }
function f_floor(var op: MPFloat): MPFloat;
{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
function f_get_d(var op: MPFloat): double;
{ Convert op to a double, truncating if necessary (ie. rounding towards zero), and with an exponent returned separately }
function f_get_d_2exp(out exp: valsint; var op: MPFloat): double;
{ Return the default precision actually used }
function f_get_default_prec: valuint;
{ Return the current precision of op, in bits }
function f_get_prec(var op: MPFloat): valuint;
{ Convert op to a long, truncating any fraction part }
function f_get_si(var op: MPFloat): valsint;
{ Convert op to a string of digits in base base }
function f_get_str(out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: MPFloat): string;
{ Convert op to a string of digits in base base. If str is NULL, the result string is allocated using the current allocation function. }
function f_get_str(str: pchar; out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: MPFloat): pchar;
{ Convert op to a unsigned long, truncating any fraction part }
function f_get_ui(var op: MPFloat): valuint;
{ Initialize x to 0 }
procedure f_init(out x: MPFloat);
{ Initialize x to 0 and set its precision to be at least prec bits }
procedure f_init2(out x: MPFloat; prec: valuint);
{ Initialize rop and set its value from op }
procedure f_init_set(out rop: MPFloat; var op: MPFloat);
{ Initialize rop and set its value from op }
procedure f_init_set_d(out rop: MPFloat; op: double);
{ Initialize rop and set its value from op }
procedure f_init_set_si(out rop: MPFloat; op: valsint);
{ Initialize rop and set its value from the string in str. Returns true if the entire string is a valid number in base base. }
function f_init_set_str(out rop: MPFloat; str: string; base: longint): boolean;
{ Initialize rop and set its value from op }
procedure f_init_set_ui(out rop: MPFloat; op: valuint);
{ Return true if op is an integer }
function f_integer_p(var op: MPFloat): boolean;
{ Set rop to op1 × op2 }
procedure f_mul(var rop, op1, op2: MPFloat);
{ Return op1 × op2 }
function f_mul(var op1, op2: MPFloat): MPFloat;
{ Set rop to op1 × (2^op2) }
procedure f_mul_2exp(var rop, op1: MPFloat; op2: valuint);
{ Return op1 × (2^op2) }
function f_mul_2exp(var op1: MPFloat; op2: valuint): MPFloat;
{ Set rop to op1 × op2 }
procedure f_mul_ui(var rop, op1: MPFloat; op2: valuint);
{ Return op1 × op2 }
function f_mul_ui(var op1: MPFloat; op2: valuint): MPFloat;
{ Set rop to −op }
procedure f_neg(var rop, op: MPFloat);
{ Return −op }
function f_neg(var op: MPFloat): MPFloat;
{ Set rop to op1^op2 }
procedure f_pow_ui(var rop, op1: MPFloat; op2: valuint);
{ Return op1^op2 }
function f_pow_ui(var op1: MPFloat; op2: valuint): MPFloat;
{ Generate a random float of at most max_size limbs, with long strings of zeros and ones in the binary representation }
procedure f_random2(var rop: MPFloat; max_size: mp_size_t; exp: mp_exp_t);
{ Return a random float of at most max_size limbs, with long strings of zeros and ones in the binary representation }
function f_random2(max_size: mp_size_t; exp: mp_exp_t): MPFloat;
{ Compute the relative difference between op1 and op2 and store the result in rop }
procedure f_reldiff(var rop, op1, op2: MPFloat);
{ Return the relative difference between op1 and op2 }
function f_reldiff(var op1, op2: MPFloat): MPFloat;
{ Set the value of rop from op }
procedure f_set(var rop, op: MPFloat);
{ Set the value of rop from op }
procedure f_set_d(var rop: MPFloat; op: double);
{ Set the default precision to be at least prec bits }
procedure f_set_default_prec(prec: valuint);
{ Set the precision of rop to be at least prec bits }
procedure f_set_prec(var rop: MPFloat; prec: valuint);
{ Set the precision of rop to be at least prec bits, without changing the memory allocated }
procedure f_set_prec_raw(var rop: MPFloat; prec: valuint);
{ Set the value of rop from op }
procedure f_set_q(var rop: MPFloat; var op: MPRational);
{ Set the value of rop from op }
procedure f_set_si(var rop: MPFloat; op: valsint);
{ Set the value of rop from the string in str. Returns true if the entire string is a valid number in base base. }
function f_set_str(var rop: MPFloat; str: string; base: longint): boolean;
{ Set the value of rop from op }
procedure f_set_ui(var rop: MPFloat; op: valuint);
{ Set the value of rop from op }
procedure f_set_z(var rop: MPFloat; var op: MPInteger);
{ Set rop to op^(1/2) }
procedure f_sqrt(var rop, op: MPFloat);
{ Return op^(1/2) }
function f_sqrt(var op: MPFloat): MPFloat;
{ Set rop to op^(1/2) }
procedure f_sqrt_ui(var rop: MPFloat; op: valuint);
{ Return op^(1/2) }
function f_sqrt_ui(op: valuint): MPFloat;
{ Set rop to op1 − op2 }
procedure f_sub(var rop, op1, op2: MPFloat);
{ Return op1 − op2 }
function f_sub(var op1, op2: MPFloat): MPFloat;
{ Set rop to op1 − op2 }
procedure f_sub_ui(var rop, op1: MPFloat; op2: valuint);
{ Return op1 − op2 }
function f_sub_ui(var op1: MPFloat; op2: valuint): MPFloat;
{ Swap rop1 and rop2 efficiently }
procedure f_swap(var rop1, rop2: MPFloat);
{ Set rop to op rounded to the integer towards zero }
procedure f_trunc(var rop, op: MPFloat);
{ Return op rounded to the integer towards zero }
function f_trunc(var op: MPFloat): MPFloat;
{ Set rop to op1/op2 }
procedure f_ui_div(var rop: MPFloat; op1: valuint; var op2: MPFloat);
{ Return op1/op2 }
function f_ui_div(op1: valuint; var op2: MPFloat): MPFloat;
{ Set rop to op1 − op2 }
procedure f_ui_sub(var rop: MPFloat; op1: valuint; var op2: MPFloat);
{ Return op1 − op2 }
function f_ui_sub(op1: valuint; var op2: MPFloat): MPFloat;
{ Generate a uniformly distributed random float in rop, such that 0 <= rop < 1, with nbits significant bits in the mantissa }
procedure f_urandomb(var rop: MPFloat; var state: MPRandState; nbits: valuint);
{ Return a uniformly distributed random float, such that 0 <= result < 1, with nbits significant bits in the mantissa }
function f_urandomb(var state: MPRandState; nbits: valuint): MPFloat;

// ---- operators ----

operator * (op1: MPFloat; op2: MPFloat): MPFloat; inline;
operator * (op1: MPInteger; op2: MPInteger): MPInteger; inline;
operator * (op1: MPRational; op2: MPRational): MPRational; inline;
operator ** (op1: MPFloat; op2: valuint): MPFloat; inline;
operator ** (op1: MPInteger; op2: valuint): MPInteger; inline;
operator + (op1: MPFloat; op2: MPFloat): MPFloat; inline;
operator + (op1: MPInteger; op2: MPInteger): MPInteger; inline;
operator + (op1: MPRational; op2: MPRational): MPRational; inline;
operator - (op: MPFloat): MPFloat; inline;
operator - (op: MPInteger): MPInteger; inline;
operator - (op: MPRational): MPRational; inline;
operator - (op1: MPFloat; op2: MPFloat): MPFloat; inline;
operator - (op1: MPInteger; op2: MPInteger): MPInteger; inline;
operator - (op1: MPRational; op2: MPRational): MPRational; inline;
operator / (op1: MPFloat; op2: MPFloat): MPFloat; inline;
operator / (op1: MPInteger; op2: MPInteger): MPInteger; inline;
operator / (op1: MPRational; op2: MPRational): MPRational; inline;
operator := (op: double): MPFloat; inline;
operator := (op: double): MPInteger; inline;
operator := (op: double): MPRational; inline;
operator := (op: MPFloat): Cardinal; inline;
operator := (op: MPFloat): double; inline;
operator := (op: MPFloat): integer; inline;
operator := (op: MPFloat): mpf_t; inline;
operator := (op: MPFloat): MPInteger; inline;
operator := (op: MPFloat): MPRational; inline;
operator := (op: MPFloat): string; inline;
{$ifdef CPU64}
operator := (op: MPFloat): valsint; inline;
operator := (op: MPFloat): valuint; inline;
{$endif}
operator := (var op: mpf_t): MPFloat; inline;
operator := (op: MPInteger): cardinal; inline;
operator := (op: MPInteger): double; inline;
operator := (op: MPInteger): integer; inline;
operator := (op: MPInteger): MPFloat; inline;
operator := (op: MPInteger): MPRational; inline;
operator := (op: MPInteger): mpz_t; inline;
operator := (op: MPInteger): string; inline;
{$ifdef CPU64}
operator := (op: MPInteger): valsint; inline;
operator := (op: MPInteger): valuint; inline;
{$endif}
operator := (var op: mpq_t): MPRational; inline;
operator := (op: MPRandState): randstate_t; inline;
operator := (op: MPRational): double; inline;
operator := (op: MPRational): MPFloat; inline;
operator := (op: MPRational): MPInteger; inline;
operator := (op: MPRational): mpq_t; inline;
operator := (op: MPRational): string; inline;
operator := (var op: mpz_t): MPInteger; inline;
operator := (var op: randstate_t): MPRandState; inline;
operator := (op: string): MPFloat; inline;
operator := (op: string): MPInteger; inline;
operator := (op: string): MPRational; inline;
operator := (op: valsint): MPFloat; inline;
operator := (op: valsint): MPInteger; inline;
operator := (op: valsint): MPRational; inline;
operator := (op: valuint): MPFloat; inline;
operator := (op: valuint): MPInteger; inline;
operator := (op: valuint): MPRational; inline;
operator < (op1: MPFloat; op2: MPFloat): boolean; inline;
operator < (op1: MPInteger; op2: MPInteger): boolean; inline;
operator < (op1: MPRational; op2: MPRational): boolean; inline;
operator <= (op1: MPFloat; op2: MPFloat): boolean; inline;
operator <= (op1: MPInteger; op2: MPInteger): boolean; inline;
operator <= (op1: MPRational; op2: MPRational): boolean; inline;
operator > (op1: MPFloat; op2: MPFloat): boolean; inline;
operator > (op1: MPInteger; op2: MPInteger): boolean; inline;
operator > (op1: MPRational; op2: MPRational): boolean; inline;
operator >= (op1: MPFloat; op2: MPFloat): boolean; inline;
operator >= (op1: MPInteger; op2: MPInteger): boolean; inline;
operator >= (op1: MPRational; op2: MPRational): boolean; inline;
// compiler doesn't like theese
// operator = (op1: MPFloat; op2: MPFloat): boolean; inline;
// operator = (op1: MPInteger; op2: MPInteger): boolean; inline;
// operator = (op1: MPRational; op2: MPRational): boolean; inline;

implementation

uses
  math;

{$ifndef NO_GMP_GLOBVARS}
var
  __gmp_bits_per_limb: longint; cvar; external;
  __gmp_errno: longint; cvar; external;
  __gmp_version: pchar; cvar; external;

function bits_per_limb: longint;
begin
  result := __gmp_bits_per_limb;
end;

function errno: longint;
begin
  result := __gmp_errno;
end;

function version: string;
begin
  result := __gmp_version;
end;

{$else NO_GMP_GLOBVARS}
function bits_per_limb: longint;
const BITS_PER_BYTE = 8;
begin
  result := sizeof(mp_limb_t) * BITS_PER_BYTE;
end;

function errno: longint;
begin
  result := 0;
end;

function version: string;
const NO_VER = '0.0.0';
begin
  result := NO_VER;
end;
{$endif NO_GMP_GLOBVARS}

// ---- ext types ----

{ TMPBase }

function TMPBase.refs: longint;
begin
  result := frefcount;
end;

{ TMPInteger }

function TMPInteger.ptr: mpz_ptr;
begin
  result := @fmpz
end;

destructor TMPInteger.destroy;
begin
  mpz_clear(fmpz);
  inherited destroy;
end;

{ TMPFloat }

function TMPFloat.ptr: mpf_ptr;
begin
  result := @fmpf;
end;

destructor TMPFloat.destroy;
begin
  mpf_clear(fmpf);
  inherited destroy;
end;

{ TMPRational }

function TMPRational.ptr: mpq_ptr;
begin
  result := @fmpq;
end;

destructor TMPRational.destroy;
begin
  mpq_clear(fmpq);
  inherited destroy;
end;

{ TMPRandState }

function TMPRandState.ptr: randstate_ptr;
begin
  result := @frandstate;
end;

destructor TMPRandState.destroy;
begin
  mp_randclear(frandstate);
  inherited destroy;
end;

// --- helpers ----

function dest(var rop: MPInteger): mpz_ptr;
begin
  if (not assigned(rop)) or (rop.refs > 1) then
    z_init(rop);
  result := rop.ptr;
end;

function dest(var rop: MPFloat): mpf_ptr;
begin
  if (not assigned(rop)) or (rop.refs > 1) then
    f_init(rop);
  result := rop.ptr;
end;

function dest(var rop: MPRational): mpq_ptr;
begin
  if (not assigned(rop)) or (rop.refs > 1) then
    q_init(rop);
  result := rop.ptr;
end;

function dest(var rop: MPRandState): randstate_ptr;
begin
  if (not assigned(rop)) or (rop.refs > 1) then
    randinit_default(rop);
  result := rop.ptr;
end;

function src(var rop: MPInteger): mpz_ptr;
begin
  if not assigned(rop) then
    z_init(rop);
  result := rop.ptr;
end;

function src(var rop: MPFloat): mpf_ptr;
begin
  if not assigned(rop) then
    f_init(rop);
  result := rop.ptr;
end;

function src(var rop: MPRational): mpq_ptr;
begin
  if not assigned(rop) then
    q_init(rop);
  result := rop.ptr;
end;

function src(var rop: MPRandState): randstate_ptr;
begin
  if not assigned(rop) then
    randinit_default(rop);
  result := rop.ptr;
end;

procedure propagate_prec(var result, op: MPFloat);
begin
  f_set_prec(result, f_get_prec(op));
end;

procedure propagate_prec(var result, op1, op2: MPFloat);
begin
  f_set_prec(result, max(valsint(f_get_prec(op1)), f_get_prec(op2)));
end;

// --- ext bindings ----

procedure randinit_default(out state: MPRandState);
begin
  state := TMPRandState.Create;
  mp_randinit_default(state.ptr^);
end;

procedure randinit_lc_2exp(out state: MPRandState; var a: MPInteger; c, m2exp: valuint);
begin
  state := TMPRandState.Create;
  mp_randinit_lc_2exp(state.ptr^, src(a)^, c, m2exp);
end;

function randinit_lc_2exp_size(out state: MPRandState; size: sizeuint): boolean;
begin
  state := TMPRandState.Create;
  result := mp_randinit_lc_2exp_size(state.ptr^, size) <> 0;
end;

procedure randinit_mt(out state: MPRandState);
begin
  state := TMPRandState.Create;
  mp_randinit_mt(state.ptr^);
end;

procedure randinit_set(out rop: MPRandState; var op: MPRandState);
begin
  rop := TMPRandState.Create;
  mp_randinit_set(rop.ptr^, src(op)^);
end;

procedure randseed(var state: MPRandState; var seed: MPInteger);
begin
  mp_randseed(dest(state)^, src(seed)^);
end;

procedure randseed_ui(var state: MPRandState; seed: valuint);
begin
  mp_randseed_ui(dest(state)^, seed);
end;

procedure randclear(var state: MPRandState);
begin
  state := nil;
end;

function urandomb_ui(var state: MPRandState; n: valuint): valuint;
begin
  result := mp_urandomb_ui(dest(state)^, n);
end;

function urandomm_ui(var state: MPRandState; n: valuint): valuint;
begin
  result := mp_urandomb_ui(dest(state)^, n);
end;

function z_realloc(var integer_: MPInteger; new_alloc: mp_size_t): pointer;
begin
  result := mpz_realloc(dest(integer_)^, new_alloc);
end;

procedure z_abs(var rop, op: MPInteger);
begin
  mpz_abs(dest(rop)^, src(op)^);
end;

function z_abs(var op: MPInteger): MPInteger;
begin
  mpz_abs(dest(result)^, src(op)^);
end;

procedure z_add(var rop, op1, op2: MPInteger);
begin
  mpz_add(dest(rop)^, src(op1)^, src(op2)^);
end;

function z_add(var op1, op2: MPInteger): MPInteger;
begin
  mpz_add(dest(result)^, src(op1)^, src(op2)^);
end;

procedure z_add_ui(var rop, op1: MPInteger; op2: valuint);
begin
  mpz_add_ui(dest(rop)^, src(op1)^, op2);
end;

function z_add_ui(var op1: MPInteger; op2: valuint): MPInteger;
begin
  mpz_add_ui(dest(result)^, src(op1)^, op2);
end;

procedure z_addmul(var rop, op1, op2: MPInteger);
begin
  mpz_addmul(dest(rop)^, src(op1)^, src(op2)^);
end;

procedure z_addmul_ui(var rop, op1: MPInteger; op2: valuint);
begin
  mpz_addmul_ui(dest(rop)^, src(op1)^, op2);
end;

procedure z_and(var rop, op1, op2: MPInteger);
begin
  mpz_and(dest(rop)^, src(op1)^, src(op2)^);
end;

function z_and(var op1, op2: MPInteger): MPInteger;
begin
  mpz_and(dest(result)^, src(op1)^, src(op2)^);
end;

procedure z_bin_ui(var rop, n: MPInteger; k: valuint);
begin
  mpz_bin_ui(dest(rop)^, src(n)^, k);
end;

function z_bin_ui(var n: MPInteger; k: valuint): MPInteger;
begin
  mpz_bin_ui(dest(result)^, src(n)^, k);
end;

procedure z_bin_uiui(var rop: MPInteger; n, k: valuint);
begin
  mpz_bin_uiui(dest(rop)^, n, k);
end;

function z_bin_uiui(n, k: valuint): MPInteger;
begin
  mpz_bin_uiui(dest(result)^, n, k);
end;

procedure z_cdiv_q(var q, n, d: MPInteger);
begin
  mpz_cdiv_q(dest(q)^, src(n)^, src(d)^);
end;

function z_cdiv_q(var n, d: MPInteger): MPInteger;
begin
  mpz_cdiv_q(dest(result)^, src(n)^, src(d)^);
end;

procedure z_cdiv_q_2exp(var q, n: MPInteger; b: valuint);
begin
  mpz_cdiv_q_2exp(dest(q)^, src(n)^, b);
end;

function z_cdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
begin
  mpz_cdiv_q_2exp(dest(result)^, src(n)^, b);
end;

function z_cdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_cdiv_q_ui(dest(q)^, src(n)^, d);
end;

procedure z_cdiv_qr(var q, r, n, d: MPInteger);
begin
  mpz_cdiv_qr(dest(q)^, dest(r)^, src(n)^, src(d)^);
end;

function z_cdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_cdiv_qr_ui(dest(q)^, dest(r)^, src(n)^, d);
end;

procedure z_cdiv_r(var r, n, d: MPInteger);
begin
  mpz_cdiv_r(dest(r)^, src(n)^, src(d)^);
end;

function z_cdiv_r(var n, d: MPInteger): MPInteger;
begin
  mpz_cdiv_r(dest(result)^, src(n)^, src(d)^);
end;

procedure z_cdiv_r_2exp(var r, n: MPInteger; b: valuint);
begin
  mpz_cdiv_r_2exp(dest(r)^, src(n)^, b);
end;

function z_cdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
begin
  mpz_cdiv_r_2exp(dest(result)^, src(n)^, b);
end;

function z_cdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_cdiv_r_ui(dest(r)^, src(n)^, d);
end;

function z_cdiv_ui(var n: MPInteger; d: valuint): valuint;
begin
  result := mpz_cdiv_ui(src(n)^, d);
end;

procedure z_clear(var integer_: MPInteger);
begin
  integer_ := nil;
end;

procedure z_clrbit(var rop: MPInteger; bit_index: valuint);
begin
  mpz_clrbit(dest(rop)^, bit_index);
end;

function z_cmp(var op1, op2: MPInteger): longint;
begin
  result := mpz_cmp(src(op1)^, src(op2)^);
end;

function z_cmp_d(var op1: MPInteger; op2: double): longint;
begin
  result := mpz_cmp_d(src(op1)^, op2);
end;

function z_cmp_si(var op1: MPInteger; op2: valsint): longint;
begin
  result := mpz_cmp_si(src(op1)^, op2);
end;

function z_cmp_ui(var op1: MPInteger; op2: valuint): longint;
begin
  result := mpz_cmp_ui(src(op1)^, op2);
end;

function z_cmpabs(var op1, op2: MPInteger): longint;
begin
  result := mpz_cmpabs(src(op1)^, src(op2)^);
end;

function z_cmpabs_d(var op1: MPInteger; op2: double): longint;
begin
  result := mpz_cmpabs_d(src(op1)^, op2);
end;

function z_cmpabs_ui(var op1: MPInteger; op2: valuint): longint;
begin
  result := mpz_cmpabs_ui(src(op1)^, op2);
end;

procedure z_com(var rop, op: MPInteger);
begin
  mpz_com(dest(rop)^, src(op)^);
end;

function z_com(var op: MPInteger): MPInteger;
begin
  mpz_com(dest(result)^, src(op)^);
end;

procedure z_combit(var rop: MPInteger; bit_index: valuint);
begin
  mpz_combit(dest(rop)^, bit_index);
end;

function z_congruent_p(var n, c, d: MPInteger): boolean;
begin
  result := mpz_congruent_p(src(n)^, src(c)^, src(d)^) <> 0;
end;

function z_congruent_2exp_p(var n, c: MPInteger; b: valuint): boolean;
begin
  result := mpz_congruent_2exp_p(src(n)^, src(c)^, b) <> 0;
end;

function z_congruent_ui_p(var n: MPInteger; c, d: valuint): boolean;
begin
  result := mpz_congruent_ui_p(src(n)^, c, d) <> 0;
end;

procedure z_divexact(var q, n, d: MPInteger);
begin
  mpz_divexact(dest(q)^, src(n)^, src(d)^);
end;

function z_divexact(var n, d: MPInteger): MPInteger;
begin
  mpz_divexact(dest(result)^, src(n)^, src(d)^);
end;

procedure z_divexact_ui(var q, n: MPInteger; d: valuint);
begin
  mpz_divexact_ui(dest(q)^, src(n)^, d);
end;

function z_divexact_ui(var n: MPInteger; d: valuint): MPInteger;
begin
  mpz_divexact_ui(dest(result)^, src(n)^, d);
end;

function z_divisible_p(var n, d: MPInteger): boolean;
begin
  result := mpz_divisible_p(src(n)^, src(d)^) <> 0;
end;

function z_divisible_ui_p(var n: MPInteger; d: valuint): boolean;
begin
  result := mpz_divisible_ui_p(src(n)^, d) <> 0;
end;

function z_divisible_2exp_p(var n: MPInteger; b: valuint): boolean;
begin
  result := mpz_divisible_2exp_p(src(n)^, b) <> 0;
end;

function z_export(out buf; out countp: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; var op: MPInteger): pointer;
begin
  result := mpz_export(buf, countp, order, size, endian, nails, src(op)^);
end;

procedure z_fac_ui(var rop: MPInteger; op: valuint);
begin
  mpz_fac_ui(dest(rop)^, op);
end;

function z_fac_ui(op: valuint): MPInteger;
begin
  mpz_fac_ui(dest(result)^, op);
end;

procedure z_fdiv_q(var q, n, d: MPInteger);
begin
  mpz_fdiv_q(dest(q)^, src(n)^, src(d)^);
end;

function z_fdiv_q(var n, d: MPInteger): MPInteger;
begin
  mpz_fdiv_q(dest(result)^, src(n)^, src(d)^);
end;

procedure z_fdiv_q_2exp(var q, n: MPInteger; b: valuint);
begin
  mpz_fdiv_q_2exp(dest(q)^, src(n)^, b);
end;

function z_fdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
begin
  mpz_fdiv_q_2exp(dest(result)^, src(n)^, b);
end;

function z_fdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_fdiv_q_ui(dest(q)^, src(n)^, d);
end;

procedure z_fdiv_qr(var q, r, n, d: MPInteger);
begin
  mpz_fdiv_qr(dest(q)^, dest(r)^, src(n)^, src(d)^);
end;

function z_fdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_fdiv_qr_ui(dest(q)^, dest(r)^, src(n)^, d);
end;

procedure z_fdiv_r(var r, n, d: MPInteger);
begin
  mpz_fdiv_r(dest(r)^, src(n)^, src(d)^);
end;

function z_fdiv_r(var n, d: MPInteger): MPInteger;
begin
  mpz_fdiv_r(dest(result)^, src(n)^, src(d)^);
end;

procedure z_fdiv_r_2exp(var r, n: MPInteger; b: valuint);
begin
  mpz_fdiv_r_2exp(dest(r)^, src(n)^, b);
end;

function z_fdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
begin
  mpz_fdiv_r_2exp(dest(result)^, src(n)^, b);
end;

function z_fdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_fdiv_r_ui(dest(r)^, src(n)^, d);
end;

function z_fdiv_ui(var n: MPInteger; d: valuint): valuint;
begin
  result := mpz_fdiv_ui(src(n)^, d);
end;

procedure z_fib_ui(var fn: MPInteger; n: valuint);
begin
  mpz_fib_ui(dest(fn)^, n);
end;

function z_fib_ui(n: valuint): MPInteger;
begin
  mpz_fib_ui(dest(result)^, n);
end;

procedure z_fib2_ui(var fn, fnsub1: MPInteger; n: valuint);
begin
  mpz_fib2_ui(dest(fn)^, dest(fnsub1)^, n);
end;

function z_fib2_ui(var fnsub1: MPInteger; n: valuint): MPInteger;
begin
  mpz_fib2_ui(dest(result)^, dest(fnsub1)^, n);
end;

function z_fits_sint_p(var op: MPInteger): boolean;
begin
  result := mpz_fits_sint_p(src(op)^) <> 0;
end;

function z_fits_slong_p(var op: MPInteger): boolean;
begin
  result := mpz_fits_slong_p(src(op)^) <> 0;
end;

function z_fits_sshort_p(var op: MPInteger): boolean;
begin
  result := mpz_fits_sshort_p(src(op)^) <> 0;
end;

function z_fits_uint_p(var op: MPInteger): boolean;
begin
  result := mpz_fits_uint_p(src(op)^) <> 0;
end;

function z_fits_ulong_p(var op: MPInteger): boolean;
begin
  result := mpz_fits_ulong_p(src(op)^) <> 0;
end;

function z_fits_ushort_p(var op: MPInteger): boolean;
begin
  result := mpz_fits_ushort_p(src(op)^) <> 0;
end;

procedure z_gcd(var rop, op1, op2: MPInteger);
begin
  mpz_gcd(dest(rop)^, src(op1)^, src(op2)^);
end;

function z_gcd(var op1, op2: MPInteger): MPInteger;
begin
  mpz_gcd(dest(result)^, src(op1)^, src(op2)^);
end;

function z_gcd_ui(var rop, op1: MPInteger; op2: valuint): valuint;
begin
  result := mpz_gcd_ui(dest(rop)^, src(op1)^, op2)
end;

procedure z_gcdext(var g, s, t, a, b: MPInteger);
begin
  mpz_gcdext(dest(g)^, dest(s)^, dest(t)^, src(a)^, src(b)^);
end;

function z_get_d(var op: MPInteger): double;
begin
  result := mpz_get_d(src(op)^);
end;

function z_get_d_2exp(out exp: valsint; var op: MPInteger): double;
begin
  result := mpz_get_d_2exp(exp, src(op)^);
end;

function z_get_si(op: MPInteger): valsint;
begin
  result := mpz_get_si(src(op)^);
end;

function z_get_str(base: longint; var op: MPInteger): string;
var p: pchar;
begin
  p := mpz_get_str(nil, base, src(op)^);
  result := p;
  freemem(p);
end;

function z_get_str(str: pchar; base: longint; var op: MPInteger): pchar;
begin
  result := mpz_get_str(str, base, src(op)^);
end;

function z_get_ui(op: MPInteger): valuint;
begin
  result := mpz_get_ui(src(op)^);
end;

function z_getlimbn(var op: MPInteger; n: mp_size_t): mp_limb_t;
begin
  result := mpz_getlimbn(src(op)^, n);
end;

function z_hamdist(var op1, op2: MPInteger): valuint;
begin
  result := mpz_hamdist(src(op1)^, src(op2)^);
end;

procedure z_import(var rop: MPInteger; count: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; const op);
begin
  mpz_import(dest(rop)^, count, order, size, endian, nails, op);
end;

procedure z_init(out integer_: MPInteger);
begin
  integer_ := TMPInteger.Create;
  mpz_init(integer_.ptr^);
end;

procedure z_init2(out integer_: MPInteger; n: valuint);
begin
  integer_ := TMPInteger.Create;
  mpz_init2(integer_.ptr^, n);
end;

procedure z_init_set(out rop: MPInteger; var op: MPInteger);
begin
  rop := TMPInteger.Create;
  mpz_init_set(rop.ptr^, src(op)^);
end;

procedure z_init_set_d(out rop: MPInteger; op: double);
begin
  rop := TMPInteger.Create;
  mpz_init_set_d(rop.ptr^, op);
end;

procedure z_init_set_si(out rop: MPInteger; op: valsint);
begin
  rop := TMPInteger.Create;
  mpz_init_set_si(rop.ptr^, op);
end;

function z_init_set_str(out rop: MPInteger; str: string; base: longint): boolean;
begin
  rop := TMPInteger.Create;
  result := mpz_set_str(rop.ptr^, pchar(str), base) = 0;
end;

procedure z_init_set_ui(out rop: MPInteger; op: valuint);
begin
  rop := TMPInteger.Create;
  mpz_init_set_ui(rop.ptr^, op);
end;

function z_invert(var rop, op1, op2: MPInteger): longint;
begin
  result := mpz_invert(dest(rop)^, src(op1)^, src(op2)^);
end;

procedure z_ior(var rop, op1, op2: MPInteger);
begin
  mpz_ior(dest(rop)^, src(op1)^, src(op2)^);
end;

function z_ior(var op1, op2: MPInteger): MPInteger;
begin
  mpz_ior(dest(result)^, src(op1)^, src(op2)^);
end;

function z_jacobi(var a, b: MPInteger): longint;
begin
  result := mpz_jacobi(src(a)^, src(b)^);
end;

function z_kronecker_si(var a: MPInteger; b: valsint): longint;
begin
  result := mpz_kronecker_si(src(a)^, b);
end;

function z_kronecker_ui(var a: MPInteger; b: valuint): longint;
begin
  result := mpz_kronecker_ui(src(a)^, b);
end;

function z_si_kronecker(a: valsint; var b: MPInteger): longint;
begin
  result := mpz_si_kronecker(a, src(b)^);
end;

function z_ui_kronecker(a: valuint; var b: MPInteger): longint;
begin
  result := mpz_ui_kronecker(a, src(b)^);
end;

procedure z_lcm(var rop, op1, op2: MPInteger);
begin
  mpz_lcm(dest(rop)^, src(op1)^, src(op2)^);
end;

function z_lcm(var op1, op2: MPInteger): MPInteger;
begin
  mpz_lcm(dest(result)^, src(op1)^, src(op2)^);
end;

procedure z_lcm_ui(var rop, op1: MPInteger; op2: valuint);
begin
  mpz_lcm_ui(dest(rop)^, src(op1)^, op2);
end;

function z_lcm_ui(var op1: MPInteger; op2: valuint): MPInteger;
begin
  mpz_lcm_ui(dest(result)^, src(op1)^, op2);
end;

procedure z_lucnum_ui(var ln: MPInteger; n: valuint);
begin
  mpz_lucnum_ui(dest(ln)^, n);
end;

function z_lucnum_ui(n: valuint): MPInteger;
begin
  mpz_lucnum_ui(dest(result)^, n);
end;

procedure z_lucnum2_ui(var ln, lnsub1: MPInteger; n: valuint);
begin
  mpz_lucnum2_ui(dest(ln)^, dest(lnsub1)^, n);
end;

function z_lucnum2_ui(var lnsub1: MPInteger; n: valuint): MPInteger;
begin
  mpz_lucnum2_ui(dest(result)^, dest(lnsub1)^, n);
end;

procedure z_mod(var r, n, d: MPInteger);
begin
  mpz_mod(dest(r)^, src(n)^, src(d)^);
end;

function z_mod(var n, d: MPInteger): MPInteger;
begin
  mpz_mod(dest(result)^, src(n)^, src(d)^);
end;

procedure z_mul(var rop, op1, op2: MPInteger);
begin
  mpz_mul(dest(rop)^, src(op1)^, src(op2)^);
end;

function z_mul(var op1, op2: MPInteger): MPInteger;
begin
  mpz_mul(dest(result)^, src(op1)^, src(op2)^);
end;

procedure z_mul_2exp(var rop, op1: MPInteger; op2: valuint);
begin
  mpz_mul_2exp(dest(rop)^, src(op1)^, op2);
end;

function z_mul_2exp(var op1: MPInteger; op2: valuint): MPInteger;
begin
  mpz_mul_2exp(dest(result)^, src(op1)^, op2);
end;

procedure z_mul_si(var rop, op1: MPInteger; op2: valsint);
begin
  mpz_mul_si(dest(rop)^, src(op1)^, op2);
end;

function z_mul_si(var op1: MPInteger; op2: valsint): MPInteger;
begin
  mpz_mul_si(dest(result)^, src(op1)^, op2);
end;

procedure z_mul_ui(var rop, op1: MPInteger; op2: valuint);
begin
  mpz_mul_ui(dest(rop)^, src(op1)^, op2);
end;

function z_mul_ui(var op1: MPInteger; op2: valuint): MPInteger;
begin
  mpz_mul_ui(dest(result)^, src(op1)^, op2);
end;

procedure z_neg(var rop, op: MPInteger);
begin
  mpz_neg(dest(rop)^, src(op)^);
end;

function z_neg(var op: MPInteger): MPInteger;
begin
  mpz_neg(dest(result)^, src(op)^);
end;

procedure z_nextprime(var rop, op: MPInteger);
begin
  mpz_nextprime(dest(rop)^, src(op)^);
end;

function z_nextprime(var op: MPInteger): MPInteger;
begin
  mpz_nextprime(dest(result)^, src(op)^);
end;

function z_perfect_power_p(var op: MPInteger): boolean;
begin
  result := mpz_perfect_power_p(src(op)^) <> 0;
end;

function z_perfect_square_p(var op: MPInteger): boolean;
begin
  result := mpz_perfect_square_p(src(op)^) <> 0;
end;

function z_popcount(var op: MPInteger): valuint;
begin
  result := mpz_popcount(src(op)^);
end;

procedure z_pow_ui(var rop, base: MPInteger; exp: valuint);
begin
  mpz_pow_ui(dest(rop)^, src(base)^, exp);
end;

function z_pow_ui(var base: MPInteger; exp: valuint): MPInteger;
begin
  mpz_pow_ui(dest(result)^, src(base)^, exp);
end;

procedure z_powm(var rop, base, exp, mod_: MPInteger);
begin
  mpz_powm(dest(rop)^, src(base)^, src(exp)^, src(mod_)^);
end;

function z_powm(var base, exp, mod_: MPInteger): MPInteger;
begin
  mpz_powm(dest(result)^, src(base)^, src(exp)^, src(mod_)^);
end;

procedure z_powm_ui(var rop, base: MPInteger; exp: valuint; var mod_: MPInteger);
begin
  mpz_powm_ui(dest(rop)^, src(base)^, exp, src(mod_)^);
end;

function z_powm_ui(var base: MPInteger; exp: valuint; var mod_: MPInteger): MPInteger;
begin
  mpz_powm_ui(dest(result)^, src(base)^, exp, src(mod_)^);
end;

function z_probab_prime_p(var n: MPInteger; reps: longint): longint;
begin
  result := mpz_probab_prime_p(src(n)^, reps);
end;

procedure z_realloc2(var integer_: MPInteger; n: valuint);
begin
  mpz_realloc2(dest(integer_)^, n);
end;

function z_remove(var rop, op, f: MPInteger): valuint;
begin
  result := mpz_remove(dest(rop)^, src(op)^, src(f)^);
end;

function z_root(var rop, op: MPInteger; n: valuint): boolean;
begin
  result := mpz_root(dest(rop)^, src(op)^, n) <> 0;
end;

procedure z_rootrem(var root, rem, u: MPInteger; n: valuint);
begin
  mpz_rootrem(dest(root)^, dest(rem)^, src(u)^, n);
end;

procedure z_rrandomb(var rop: MPInteger; var state: MPRandState; n: valuint);
begin
  mpz_rrandomb(dest(rop)^, src(state)^, n);
end;

function z_rrandomb(var state: MPRandState; n: valuint): MPInteger;
begin
  mpz_rrandomb(dest(result)^, src(state)^, n);
end;

function z_scan0(var op: MPInteger; starting_bit: valuint): valuint;
begin
  result := mpz_scan0(src(op)^, starting_bit);
end;

function z_scan1(var op: MPInteger; starting_bit: valuint): valuint;
begin
  result := mpz_scan1(src(op)^, starting_bit);
end;

procedure z_set(var rop, op: MPInteger);
begin
  mpz_set(dest(rop)^, src(op)^);
end;

procedure z_set_d(var rop: MPInteger; op: double);
begin
  mpz_set_d(dest(rop)^, op);
end;

procedure z_set_f(var rop: MPInteger; var op: MPFloat);
begin
  mpz_set_f(dest(rop)^, src(op)^);
end;

procedure z_set_q(var rop: MPInteger; var op: MPRational);
begin
  mpz_set_q(dest(rop)^, src(op)^);
end;

procedure z_set_si(var rop: MPInteger; op: valsint);
begin
  mpz_set_si(dest(rop)^, op);
end;

function z_set_str(var rop: MPInteger; str: string; base: longint): boolean;
begin
  result := mpz_set_str(dest(rop)^, pchar(str), base) = 0;
end;

procedure z_set_ui(var rop: MPInteger; op: valuint);
begin
  mpz_set_ui(dest(rop)^, op);
end;

procedure z_setbit(var rop: MPInteger; bit_index: valuint);
begin
  mpz_setbit(dest(rop)^, bit_index);
end;

function z_size(var op: MPInteger): sizeuint;
begin
  result := mpz_size(src(op)^);
end;

function z_sizeinbase(var op: MPInteger; base: longint): sizeuint;
begin
  result := mpz_sizeinbase(src(op)^, base);
end;

procedure z_sqrt(var rop, op: MPInteger);
begin
  mpz_sqrt(dest(rop)^, src(op)^);
end;

function z_sqrt(var op: MPInteger): MPInteger;
begin
  mpz_sqrt(dest(result)^, src(op)^);
end;

procedure z_sqrtrem(var rop1, rop2, op: MPInteger);
begin
  mpz_sqrtrem(dest(rop1)^, dest(rop2)^, src(op)^);
end;

procedure z_sub(var rop, op1, op2: MPInteger);
begin
  mpz_sub(dest(rop)^, src(op1)^, src(op2)^);
end;

function z_sub(var op1, op2: MPInteger): MPInteger;
begin
  mpz_sub(dest(result)^, src(op1)^, src(op2)^);
end;

procedure z_sub_ui(var rop, op1: MPInteger; op2: valuint);
begin
  mpz_sub_ui(dest(rop)^, src(op1)^, op2);
end;

function z_sub_ui(var op1: MPInteger; op2: valuint): MPInteger;
begin
  mpz_sub_ui(dest(result)^, src(op1)^, op2);
end;

procedure z_ui_sub(var rop: MPInteger; op1: valuint; var op2: MPInteger);
begin
  mpz_ui_sub(dest(rop)^, op1, src(op2)^);
end;

function z_ui_sub(op1: valuint; var op2: MPInteger): MPInteger;
begin
  mpz_ui_sub(dest(result)^, op1, src(op2)^);
end;

procedure z_submul(var rop, op1, op2: MPInteger);
begin
  mpz_submul(dest(rop)^, src(op1)^, src(op2)^);
end;

procedure z_submul_ui(var rop, op1: MPInteger; op2: valuint);
begin
  mpz_submul_ui(dest(rop)^, src(op1)^, op2);
end;

procedure z_swap(var rop1, rop2: MPInteger);
begin
  mpz_swap(dest(rop1)^, dest(rop2)^);
end;

procedure z_tdiv_q(var q, n, d: MPInteger);
begin
  mpz_tdiv_q(dest(q)^, src(n)^, src(d)^);
end;

function z_tdiv_q(var n, d: MPInteger): MPInteger;
begin
  mpz_tdiv_q(dest(result)^, src(n)^, src(d)^);
end;

procedure z_tdiv_q_2exp(var q, n: MPInteger; b: valuint);
begin
  mpz_tdiv_q_2exp(dest(q)^, src(n)^, b);
end;

function z_tdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
begin
  mpz_tdiv_q_2exp(dest(result)^, src(n)^, b);
end;

function z_tdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_tdiv_q_ui(dest(q)^, src(n)^, d);
end;

procedure z_tdiv_qr(var q, r, n, d: MPInteger);
begin
  mpz_tdiv_qr(dest(q)^, dest(r)^, src(n)^, src(d)^);
end;

function z_tdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_tdiv_qr_ui(dest(q)^, dest(r)^, src(n)^, d);
end;

procedure z_tdiv_r(var r, n, d: MPInteger);
begin
  mpz_tdiv_r(dest(r)^, src(n)^, src(d)^);
end;

function z_tdiv_r(var n, d: MPInteger): MPInteger;
begin
  mpz_tdiv_r(dest(result)^, src(n)^, src(d)^);
end;

procedure z_tdiv_r_2exp(var r, n: MPInteger; b: valuint);
begin
  mpz_tdiv_r_2exp(dest(r)^, src(n)^, b);
end;

function z_tdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
begin
  mpz_tdiv_r_2exp(dest(result)^, src(n)^, b);
end;

function z_tdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
begin
  result := mpz_tdiv_r_ui(dest(r)^, src(n)^, d);
end;

function z_tdiv_ui(var n: MPInteger; d: valuint): valuint;
begin
  result := mpz_tdiv_ui(src(n)^, d);
end;

function z_tstbit(var rop: MPInteger; bit_index: valuint): boolean;
begin
  result := mpz_tstbit(src(rop)^, bit_index) <> 0;
end;

procedure z_ui_pow_ui(var rop: MPInteger; base, exp: valuint);
begin
  mpz_ui_pow_ui(dest(rop)^, base, exp);
end;

function z_ui_pow_ui(base, exp: valuint): MPInteger;
begin
  mpz_ui_pow_ui(dest(result)^, base, exp);
end;

procedure z_urandomb(var rop: MPInteger; var state: MPRandState; n: valuint);
begin
  mpz_urandomb(dest(rop)^, src(state)^, n);
end;

function z_urandomb(var state: MPRandState; n: valuint): MPInteger;
begin
  mpz_urandomb(dest(result)^, src(state)^, n);
end;

procedure z_urandomm(var rop: MPInteger; var state: MPRandState; var n: MPInteger);
begin
  mpz_urandomm(dest(rop)^, src(state)^, src(n)^);
end;

function z_urandomm(var state: MPRandState; var n: MPInteger): MPInteger;
begin
  mpz_urandomm(dest(result)^, src(state)^, src(n)^);
end;

procedure z_xor(var rop, op1, op2: MPInteger);
begin
  mpz_xor(dest(rop)^, src(op1)^, src(op2)^);
end;

function z_xor(var op1, op2: MPInteger): MPInteger;
begin
  mpz_xor(dest(result)^, src(op1)^, src(op2)^);
end;

procedure q_abs(var rop, op: MPRational);
begin
  mpq_abs(dest(rop)^, src(op)^);
end;

function q_abs(var op: MPRational): MPRational;
begin
  mpq_abs(dest(result)^, src(op)^);
end;

procedure q_add(var sum, addend1, addend2: MPRational);
begin
  mpq_add(dest(sum)^, src(addend1)^, src(addend2)^);
end;

function q_add(var addend1, addend2: MPRational): MPRational;
begin
  mpq_add(dest(result)^, src(addend1)^, src(addend2)^);
end;

procedure q_canonicalize(var op: MPRational);
begin
  mpq_canonicalize(dest(op)^);
end;

procedure q_clear(var rational_number: MPRational);
begin
  rational_number := nil;
end;

function q_cmp(var op1, op2: MPRational): longint;
begin
  result := mpq_cmp(src(op1)^, src(op2)^);
end;

function q_cmp_si(var op1: MPRational; num2: valsint; den2: valuint): longint;
begin
  result := mpq_cmp_si(src(op1)^, num2, den2);
end;

function q_cmp_ui(var op1: MPRational; num2, den2: valuint): longint;
begin
  result := mpq_cmp_ui(src(op1)^, num2, den2);
end;

procedure q_div(var quotient, dividend, divisor: MPRational);
begin
  mpq_div(dest(quotient)^, src(dividend)^, src(divisor)^);
end;

function q_div(var dividend, divisor: MPRational): MPRational;
begin
  mpq_div(dest(result)^, src(dividend)^, src(divisor)^);
end;

procedure q_div_2exp(var rop, op1: MPRational; op2: valuint);
begin
  mpq_div_2exp(dest(rop)^, src(op1)^, op2);
end;

function q_div_2exp(var op1: MPRational; op2: valuint): MPRational;
begin
  mpq_div_2exp(dest(result)^, src(op1)^, op2);
end;

function q_equal(var op1, op2: MPRational): boolean;
begin
  result := mpq_equal(src(op1)^, src(op2)^) <> 0;
end;

procedure q_get_num(var numerator: MPInteger; var rational: MPRational);
begin
  mpq_get_num(dest(numerator)^, src(rational)^);
end;

function q_get_num(var rational: MPRational): MPInteger;
begin
  mpq_get_num(dest(result)^, src(rational)^);
end;

procedure q_get_den(var denominator: MPInteger; var rational: MPRational);
begin
  mpq_get_den(dest(denominator)^, src(rational)^);
end;

function q_get_den(var rational: MPRational): MPInteger;
begin
  mpq_get_den(dest(result)^, src(rational)^);
end;

function q_get_d(var op: MPRational): double;
begin
  result := mpq_get_d(src(op)^);
end;

function q_get_str(base: longint; var op: MPRational): string;
var p: pchar;
begin
  p := mpq_get_str(nil, base, src(op)^);
  result := p;
  freemem(p);
end;

function q_get_str(str: pchar; base: longint; var op: MPRational): pchar;
begin
  result := mpq_get_str(str, base, src(op)^);
end;

procedure q_init(out dest_rational: MPRational);
begin
  dest_rational := TMPRational.Create;
  mpq_init(dest_rational.ptr^);
end;

procedure q_inv(var inverted_number, number: MPRational);
begin
  mpq_inv(dest(inverted_number)^, src(number)^);
end;

function q_inv(var number: MPRational): MPRational;
begin
  mpq_inv(dest(result)^, src(number)^);
end;

procedure q_mul(var product, multiplier, multiplicand: MPRational);
begin
  mpq_mul(dest(product)^, src(multiplier)^, src(multiplicand)^);
end;

function q_mul(var multiplier, multiplicand: MPRational): MPRational;
begin
  mpq_mul(dest(result)^, src(multiplier)^, src(multiplicand)^);
end;

procedure q_mul_2exp(var rop, op1: MPRational; op2: valuint);
begin
  mpq_mul_2exp(dest(rop)^, src(op1)^, op2);
end;

function q_mul_2exp(var op1: MPRational; op2: valuint): MPRational;
begin
  mpq_mul_2exp(dest(result)^, src(op1)^, op2);
end;

procedure q_neg(var negated_operand, operand: MPRational);
begin
  mpq_neg(dest(negated_operand)^, src(operand)^);
end;

function q_neg(var operand: MPRational): MPRational;
begin
  mpq_neg(dest(result)^, src(operand)^);
end;

procedure q_set(var rop, op: MPRational);
begin
  mpq_set(dest(rop)^, src(op)^);
end;

procedure q_set_d(var rop: MPRational; op: double);
begin
  mpq_set_d(dest(rop)^, op);
end;

procedure q_set_den(var rational: MPRational; var denominator: MPInteger);
begin
  mpq_set_den(dest(rational)^, src(denominator)^);
end;

procedure q_set_f(var rop: MPRational; var op: MPFloat);
begin
  mpq_set_f(dest(rop)^, src(op)^);
end;

procedure q_set_num(var rational: MPRational; var numerator: MPInteger);
begin
  mpq_set_num(dest(rational)^, src(numerator)^);
end;

procedure q_set_si(var rop: MPRational; op1: valsint; op2: valuint);
begin
  mpq_set_si(dest(rop)^, op1, op2);
end;

function q_set_str(var rop: MPRational; str: string; base: longint): boolean;
begin
  result := mpq_set_str(dest(rop)^, pchar(str), base) = 0;
end;

procedure q_set_ui(var rop: MPRational; op1, op2: valuint);
begin
  mpq_set_ui(dest(rop)^, op1, op2);
end;

procedure q_set_z(var rop: MPRational; var op: MPInteger);
begin
  mpq_set_z(dest(rop)^, src(op)^);
end;

procedure q_sub(var difference, minuend, subtrahend: MPRational);
begin
  mpq_sub(dest(difference)^, src(minuend)^, src(subtrahend)^);
end;

function q_sub(var minuend, subtrahend: MPRational): MPRational;
begin
  mpq_sub(dest(result)^, src(minuend)^, src(subtrahend)^);
end;

procedure q_swap(var rop1, rop2: MPRational);
begin
  mpq_swap(dest(rop1)^, dest(rop2)^);
end;

procedure f_abs(var rop, op: MPFloat);
begin
  mpf_abs(dest(rop)^, src(op)^);
end;

function f_abs(var op: MPFloat): MPFloat;
begin
  mpf_abs(dest(result)^, src(op)^);
end;

procedure f_add(var rop, op1, op2: MPFloat);
begin
  mpf_add(dest(rop)^, src(op1)^, src(op2)^);
end;

function f_add(var op1, op2: MPFloat): MPFloat;
begin
  mpf_add(dest(result)^, src(op1)^, src(op2)^);
end;

procedure f_add_ui(var rop, op1: MPFloat; op2: valuint);
begin
  mpf_add_ui(dest(rop)^, src(op1)^, op2);
end;

function f_add_ui(var op1: MPFloat; op2: valuint): MPFloat;
begin
  mpf_add_ui(dest(result)^, src(op1)^, op2);
end;

procedure f_ceil(var rop, op: MPFloat);
begin
  mpf_ceil(dest(rop)^, src(op)^);
end;

function f_ceil(var op: MPFloat): MPFloat;
begin
  mpf_ceil(dest(result)^, src(op)^);
end;

procedure f_clear(var x: MPFloat);
begin
  x := nil;
end;

function f_cmp(var op1, op2: MPFloat): longint;
begin
  result := mpf_cmp(src(op1)^, src(op2)^);
end;

function f_cmp_d(var op1: MPFloat; op2: double): longint;
begin
  result := mpf_cmp_d(src(op1)^, op2);
end;

function f_cmp_si(var op1: MPFloat; op2: valsint): longint;
begin
  result := mpf_cmp_si(src(op1)^, op2);
end;

function f_cmp_ui(var op1: MPFloat; op2: valuint): longint;
begin
  result := mpf_cmp_ui(src(op1)^, op2);
end;

procedure f_div(var rop, op1, op2: MPFloat);
begin
  mpf_div(dest(rop)^, src(op1)^, src(op2)^);
end;

function f_div(var op1, op2: MPFloat): MPFloat;
begin
  mpf_div(dest(result)^, src(op1)^, src(op2)^);
end;

procedure f_div_2exp(var rop, op1: MPFloat; op2: valuint);
begin
  mpf_div_2exp(dest(rop)^, src(op1)^, op2);
end;

function f_div_2exp(var op1: MPFloat; op2: valuint): MPFloat;
begin
  mpf_div_2exp(dest(result)^, src(op1)^, op2);
end;

procedure f_div_ui(var rop, op1: MPFloat; op2: valuint);
begin
  mpf_div_ui(dest(rop)^, src(op1)^, op2);
end;

function f_div_ui(var op1: MPFloat; op2: valuint): MPFloat;
begin
  mpf_div_ui(dest(result)^, src(op1)^, op2);
end;

function f_eq(var op1, op2: MPFloat; op3: valuint): boolean;
begin
  result := mpf_eq(src(op1)^, src(op2)^, op3) <> 0;
end;

function f_fits_sint_p(var op: MPFloat): boolean;
begin
  result := mpf_fits_sint_p(src(op)^) <> 0;
end;

function f_fits_slong_p(var op: MPFloat): boolean;
begin
  result := mpf_fits_slong_p(src(op)^) <> 0;
end;

function f_fits_sshort_p(var op: MPFloat): boolean;
begin
  result := mpf_fits_sshort_p(src(op)^) <> 0;
end;

function f_fits_uint_p(var op: MPFloat): boolean;
begin
  result := mpf_fits_uint_p(src(op)^) <> 0;
end;

function f_fits_ulong_p(var op: MPFloat): boolean;
begin
  result := mpf_fits_ulong_p(src(op)^) <> 0;
end;

function f_fits_ushort_p(var op: MPFloat): boolean;
begin
  result := mpf_fits_ushort_p(src(op)^) <> 0;
end;

procedure f_floor(var rop, op: MPFloat);
begin
  mpf_floor(dest(rop)^, src(op)^);
end;

function f_floor(var op: MPFloat): MPFloat;
begin
  mpf_floor(dest(result)^, src(op)^);
end;

function f_get_d(var op: MPFloat): double;
begin
  result := mpf_get_d(src(op)^);
end;

function f_get_d_2exp(out exp: valsint; var op: MPFloat): double;
begin
  result := mpf_get_d_2exp(exp, src(op)^);
end;

function f_get_default_prec: valuint;
begin
  result := mpf_get_default_prec;
end;

function f_get_prec(var op: MPFloat): valuint;
begin
  result := mpf_get_prec(src(op)^);
end;

function f_get_si(var op: MPFloat): valsint;
begin
  result := mpf_get_si(src(op)^);
end;

function f_get_str(out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: MPFloat): string;
var p: pchar;
begin
  p := mpf_get_str(nil, exp, base, ndigits, src(op)^);
  result := p;
  freemem(p);
end;

function f_get_str(str: pchar; out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: MPFloat): pchar;
begin
  result := mpf_get_str(str, exp, base, ndigits, src(op)^);
end;

function f_get_ui(var op: MPFloat): valuint;
begin
  result := mpf_get_ui(src(op)^);
end;

procedure f_init(out x: MPFloat);
begin
  x := TMPFloat.Create;
  mpf_init(x.ptr^);
end;

procedure f_init2(out x: MPFloat; prec: valuint);
begin
  x := TMPFloat.Create;
  mpf_init2(x.ptr^, prec);
end;

procedure f_init_set(out rop: MPFloat; var op: MPFloat);
begin
  rop := TMPFloat.Create;
  mpf_init_set(rop.ptr^, src(op)^);
end;

procedure f_init_set_d(out rop: MPFloat; op: double);
begin
  rop := TMPFloat.Create;
  mpf_init_set_d(rop.ptr^, op);
end;

procedure f_init_set_si(out rop: MPFloat; op: valsint);
begin
  rop := TMPFloat.Create;
  mpf_init_set_si(rop.ptr^, op);
end;

function f_init_set_str(out rop: MPFloat; str: string; base: longint): boolean;
begin
  rop := TMPFloat.Create;
  result := mpf_init_set_str(rop.ptr^, pchar(str), base) = 0;
end;

procedure f_init_set_ui(out rop: MPFloat; op: valuint);
begin
  rop := TMPFloat.Create;
  mpf_init_set_ui(rop.ptr^, op);
end;

function f_integer_p(var op: MPFloat): boolean;
begin
  result := mpf_integer_p(src(op)^) <> 0;
end;

procedure f_mul(var rop, op1, op2: MPFloat);
begin
  mpf_mul(dest(rop)^, src(op1)^, src(op2)^);
end;

function f_mul(var op1, op2: MPFloat): MPFloat;
begin
  mpf_mul(dest(result)^, src(op1)^, src(op2)^);
end;

procedure f_mul_2exp(var rop, op1: MPFloat; op2: valuint);
begin
  mpf_mul_2exp(dest(rop)^, src(op1)^, op2);
end;

function f_mul_2exp(var op1: MPFloat; op2: valuint): MPFloat;
begin
  mpf_mul_2exp(dest(result)^, src(op1)^, op2);
end;

procedure f_mul_ui(var rop, op1: MPFloat; op2: valuint);
begin
  mpf_mul_ui(dest(rop)^, src(op1)^, op2);
end;

function f_mul_ui(var op1: MPFloat; op2: valuint): MPFloat;
begin
  mpf_mul_ui(dest(result)^, src(op1)^, op2);
end;

procedure f_neg(var rop, op: MPFloat);
begin
  mpf_neg(dest(rop)^, src(op)^);
end;

function f_neg(var op: MPFloat): MPFloat;
begin
  mpf_neg(dest(result)^, src(op)^);
end;

procedure f_pow_ui(var rop, op1: MPFloat; op2: valuint);
begin
  mpf_pow_ui(dest(rop)^, src(op1)^, op2);
end;

function f_pow_ui(var op1: MPFloat; op2: valuint): MPFloat;
begin
  mpf_pow_ui(dest(result)^, src(op1)^, op2);
end;

procedure f_random2(var rop: MPFloat; max_size: mp_size_t; exp: mp_exp_t);
begin
  mpf_random2(dest(rop)^, max_size, exp);
end;

function f_random2(max_size: mp_size_t; exp: mp_exp_t): MPFloat;
begin
  mpf_random2(dest(result)^, max_size, exp);
end;

procedure f_reldiff(var rop, op1, op2: MPFloat);
begin
  mpf_reldiff(dest(rop)^, src(op1)^, src(op2)^);
end;

function f_reldiff(var op1, op2: MPFloat): MPFloat;
begin
  mpf_reldiff(dest(result)^, src(op1)^, src(op2)^);
end;

procedure f_set(var rop, op: MPFloat);
begin
  mpf_set(dest(rop)^, src(op)^);
end;

procedure f_set_d(var rop: MPFloat; op: double);
begin
  mpf_set_d(dest(rop)^, op);
end;

procedure f_set_default_prec(prec: valuint);
begin
  mpf_set_default_prec(prec);
end;

procedure f_set_prec(var rop: MPFloat; prec: valuint);
begin
  mpf_set_prec(dest(rop)^, prec);
end;

procedure f_set_prec_raw(var rop: MPFloat; prec: valuint);
begin
  mpf_set_prec_raw(dest(rop)^, prec);
end;

procedure f_set_q(var rop: MPFloat; var op: MPRational);
begin
  mpf_set_q(dest(rop)^, src(op)^);
end;

procedure f_set_si(var rop: MPFloat; op: valsint);
begin
  mpf_set_si(dest(rop)^, op);
end;

function f_set_str(var rop: MPFloat; str: string; base: longint): boolean;
begin
  result := mpf_set_str(dest(rop)^, pchar(str), base) = 0;
end;

procedure f_set_ui(var rop: MPFloat; op: valuint);
begin
  mpf_set_ui(dest(rop)^, op);
end;

procedure f_set_z(var rop: MPFloat; var op: MPInteger);
begin
  mpf_set_z(dest(rop)^, src(op)^);
end;

procedure f_sqrt(var rop, op: MPFloat);
begin
  mpf_sqrt(dest(rop)^, src(op)^);
end;

function f_sqrt(var op: MPFloat): MPFloat;
begin
  mpf_sqrt(dest(result)^, src(op)^);
end;

procedure f_sqrt_ui(var rop: MPFloat; op: valuint);
begin
  mpf_sqrt_ui(dest(rop)^, op);
end;

function f_sqrt_ui(op: valuint): MPFloat;
begin
  mpf_sqrt_ui(dest(result)^, op);
end;

procedure f_sub(var rop, op1, op2: MPFloat);
begin
  mpf_sub(dest(rop)^, src(op1)^, src(op2)^);
end;

function f_sub(var op1, op2: MPFloat): MPFloat;
begin
  mpf_sub(dest(result)^, src(op1)^, src(op2)^);
end;

procedure f_sub_ui(var rop, op1: MPFloat; op2: valuint);
begin
  mpf_sub_ui(dest(rop)^, src(op1)^, op2);
end;

function f_sub_ui(var op1: MPFloat; op2: valuint): MPFloat;
begin
  mpf_sub_ui(dest(result)^, src(op1)^, op2);
end;

procedure f_swap(var rop1, rop2: MPFloat);
begin
  mpf_swap(dest(rop1)^, dest(rop2)^);
end;

procedure f_trunc(var rop, op: MPFloat);
begin
  mpf_trunc(dest(rop)^, src(op)^);
end;

function f_trunc(var op: MPFloat): MPFloat;
begin
  mpf_trunc(dest(result)^, src(op)^);
end;

procedure f_ui_div(var rop: MPFloat; op1: valuint; var op2: MPFloat);
begin
  mpf_ui_div(dest(rop)^, op1, src(op2)^);
end;

function f_ui_div(op1: valuint; var op2: MPFloat): MPFloat;
begin
  mpf_ui_div(dest(result)^, op1, src(op2)^);
end;

procedure f_ui_sub(var rop: MPFloat; op1: valuint; var op2: MPFloat);
begin
  mpf_ui_sub(dest(rop)^, op1, src(op2)^);
end;

function f_ui_sub(op1: valuint; var op2: MPFloat): MPFloat;
begin
  mpf_ui_sub(dest(result)^, op1, src(op2)^);
end;

procedure f_urandomb(var rop: MPFloat; var state: MPRandState; nbits: valuint);
begin
  mpf_urandomb(dest(rop)^, src(state)^, nbits);
end;

function f_urandomb(var state: MPRandState; nbits: valuint): MPFloat;
begin
  mpf_urandomb(dest(result)^, src(state)^, nbits);
end;

// ---- operators ----

operator * (op1: MPFloat; op2: MPFloat): MPFloat;
begin
  propagate_prec(result, op1, op2);
  f_mul(result, op1, op2);
end;

operator * (op1: MPInteger; op2: MPInteger): MPInteger;
begin
  z_mul(result, op1, op2);
end;

operator * (op1: MPRational; op2: MPRational): MPRational;
begin
  q_mul(result, op1, op2);
end;

operator ** (op1: MPFloat; op2: valuint): MPFloat;
begin
  propagate_prec(result, op1);
  f_pow_ui(result, op1, op2);
end;

operator ** (op1: MPInteger; op2: valuint): MPInteger;
begin
  z_pow_ui(result, op1, op2);
end;

operator + (op1: MPFloat; op2: MPFloat): MPFloat;
begin
  propagate_prec(result, op1, op2);
  f_add(result, op1, op2);
end;

operator + (op1: MPInteger; op2: MPInteger): MPInteger;
begin
  z_add(result, op1, op2);
end;

operator + (op1: MPRational; op2: MPRational): MPRational;
begin
  q_add(result, op1, op2);
end;

operator - (op: MPFloat): MPFloat;
begin
  propagate_prec(result, op);
  f_neg(result, op);
end;

operator - (op: MPInteger): MPInteger;
begin
  z_neg(result, op);
end;

operator - (op: MPRational): MPRational;
begin
  q_neg(result, op);
end;

operator - (op1: MPFloat; op2: MPFloat): MPFloat;
begin
  propagate_prec(result, op1, op2);
  f_sub(result, op1, op2);
end;

operator - (op1: MPInteger; op2: MPInteger): MPInteger;
begin
  z_sub(result, op1, op2);
end;

operator - (op1: MPRational; op2: MPRational): MPRational;
begin
  q_sub(result, op1, op2);
end;

operator / (op1: MPFloat; op2: MPFloat): MPFloat;
begin
  propagate_prec(result, op1, op2);
  f_div(result, op1, op2);
end;

operator / (op1: MPInteger; op2: MPInteger): MPInteger;
begin
  z_tdiv_q(result, op1, op2);
end;

operator / (op1: MPRational; op2: MPRational): MPRational;
begin
  q_div(result, op1, op2);
end;

operator := (op: double): MPFloat;
begin
  f_set_d(result, op);
end;

operator := (op: double): MPInteger;
begin
  z_set_d(result, op);
end;

operator := (op: double): MPRational;
begin
  q_set_d(result, op);
end;

operator := (op: MPFloat): cardinal;
begin
  result := f_get_ui(op);
end;

operator := (op: MPFloat): double;
begin
  result := f_get_d(op);
end;

operator := (op: MPFloat): integer;
begin
  result := f_get_si(op);
end;

operator := (op: MPFloat): mpf_t;
begin
  mpf_init_set(result, src(op)^);
end;

operator := (op: MPFloat): MPInteger;
begin
  z_set_f(result, op);
end;

operator := (op: MPFloat): MPRational;
begin
  q_set_f(result, op);
end;

operator := (op: MPFloat): string;
const FMT = '%.*Fg';
var p: pchar;
begin
  mp_asprintf(p, FMT, floor(f_get_prec(op) * LOG_10_2), src(op));
  result := p;
  freemem(p);
end;

{$ifdef CPU64}
operator := (op: MPFloat): valsint;
begin
  result := f_get_si(op);
end;

operator := (op: MPFloat): valuint;
begin
  result := f_get_ui(op);
end;
{$endif}

operator := (var op: mpf_t): MPFloat;
begin
  mpf_set(dest(result)^, op);
end;

operator := (op: MPInteger): cardinal;
begin
  result := z_get_ui(op);
end;

operator := (op: MPInteger): double;
begin
  result := z_get_d(op);
end;

operator := (op: MPInteger): integer;
begin
  result := z_get_si(op);
end;

operator := (op: MPInteger): MPFloat;
begin
  f_set_z(result, op);
end;

operator := (op: MPInteger): MPRational;
begin
  q_set_z(result, op);
end;

operator := (op: MPInteger): mpz_t;
begin
  mpz_init_set(result, src(op)^);
end;

operator := (op: MPInteger): string;
const FMT = '%Zd';
var p: pchar;
begin
  mp_asprintf(p, FMT, src(op));
  result := p;
  freemem(p);
end;

{$ifdef CPU64}
operator := (op: MPInteger): valsint;
begin
  result := z_get_si(op);
end;

operator := (op: MPInteger): valuint;
begin
  result := z_get_ui(op);
end;
{$endif}

operator := (var op: mpq_t): MPRational;
begin
  mpq_set(dest(result)^, op);
end;

operator := (op: MPRandState): randstate_t;
begin
  mp_randinit_set(result, src(op)^);
end;

operator := (op: MPRational): double;
begin
  result := q_get_d(op);
end;

operator := (op: MPRational): MPFloat;
begin
  f_set_q(result, op);
end;

operator := (op: MPRational): MPInteger;
begin
  z_set_q(result, op);
end;

operator := (op: MPRational): mpq_t;
begin
  mpq_init(result);
  mpq_set(result, src(op)^);
end;

operator := (op: MPRational): string;
const FMT = '%Qd';
var p: pchar;
begin
  mp_asprintf(p, FMT, src(op));
  result := p;
  freemem(p);
end;

operator := (var op: mpz_t): MPInteger;
begin
  mpz_set(dest(result)^, op);
end;

operator := (var op: randstate_t): MPRandState;
begin
  result := TMPRandState.Create;
  mp_randinit_set(result.ptr^, op);
end;

operator := (op: string): MPFloat;
begin
  f_set_prec(result, ceil(length(op) / LOG_10_2));
  f_set_str(result, op, BASE10);
end;

operator := (op: string): MPInteger;
begin
  z_set_str(result, op, BASE10);
end;

operator := (op: string): MPRational;
begin
  q_set_str(result, op, BASE10);
end;

operator := (op: valsint): MPFloat;
begin
  f_set_si(result, op);
end;

operator := (op: valsint): MPInteger;
begin
  z_set_si(result, op);
end;

operator := (op: valsint): MPRational;
begin
  q_set_si(result, op, 1);
end;

operator := (op: valuint): MPFloat;
begin
  f_set_ui(result, op);
end;

operator := (op: valuint): MPInteger;
begin
  z_set_ui(result, op);
end;

operator := (op: valuint): MPRational;
begin
  q_set_ui(result, op, 1);
end;

operator < (op1: MPFloat; op2: MPFloat): boolean;
begin
  result := f_cmp(op1, op2) < 0;
end;

operator < (op1: MPInteger; op2: MPInteger): boolean;
begin
  result := z_cmp(op1, op2) < 0;
end;

operator < (op1: MPRational; op2: MPRational): boolean;
begin
  result := q_cmp(op1, op2) < 0;
end;

operator <= (op1: MPFloat; op2: MPFloat): boolean;
begin
  result := f_cmp(op1, op2) <= 0;
end;

operator <= (op1: MPInteger; op2: MPInteger): boolean;
begin
  result := z_cmp(op1, op2) <= 0;
end;

operator <= (op1: MPRational; op2: MPRational): boolean;
begin
  result := q_cmp(op1, op2) <= 0;
end;

//operator = (op1: MPFloat; op2: MPFloat): boolean;
//begin
//  result := f_cmp(op1, op2) = 0;
//end;

//operator = (op1: MPInteger; op2: MPInteger): boolean;
//begin
//  result := z_cmp(op1, op2) = 0;
//end;

//operator = (op1: MPRational; op2: MPRational): boolean;
//begin
//  result := q_cmp(op1, op2) = 0;
//end;

operator > (op1: MPFloat; op2: MPFloat): boolean;
begin
  result := f_cmp(op1, op2) > 0;
end;

operator > (op1: MPInteger; op2: MPInteger): boolean;
begin
  result := z_cmp(op1, op2) > 0;
end;

operator > (op1: MPRational; op2: MPRational): boolean;
begin
  result := q_cmp(op1, op2) > 0;
end;

operator >= (op1: MPFloat; op2: MPFloat): boolean;
begin
  result := f_cmp(op1, op2) >= 0;
end;

operator >= (op1: MPInteger; op2: MPInteger): boolean;
begin
  result := z_cmp(op1, op2) >= 0;
end;

operator >= (op1: MPRational; op2: MPRational): boolean;
begin
  result := q_cmp(op1, op2) >= 0;
end;

// ==== init stuff ====

function alloc_func(alloc_size: sizeuint): pointer; cdecl;
begin
  result := getmem(alloc_size);
end;

procedure free_proc(p: pointer; size: sizeuint); cdecl;
begin
  assert(size = size); // hint off
  freemem(p);
end;

function reallocate_func(p: pointer; old_size, new_size: sizeuint): pointer; cdecl;
begin
  assert(old_size = old_size); // hint off
  result := reallocmem(p, new_size);
end;

var r1: mp_limb_t;

initialization
  // prealloc the GMP's global PRNG state, get rid of the (pseudo) mem leak report
  mpn_random(@r1, 1);
  mp_set_memory_functions(@alloc_func, @reallocate_func, @free_proc);

end.