GNU MP 4.1.2

http://swox.com/gmp/

ftp://ftp.gnu.org/gnu/gmp

./configure
make

make check

make install

http://www.cygnus.com/cygwin
http://www.delorie.com/djgpp
http://www.mingw.org

cd /my/build/dir
/my/sources/gmp-4.1.2/configure

./configure --build=ultrasparc-sun-solaris2.7

./configure --build=athlon-pc-freebsd3.5 --host=m68k-mac-linux-gnu

./configure --host=none-unknown-freebsd3.5

./configure --host=mips64-sgi-irix6 ABI=n32

MPN_PATH="sparc32/v8 sparc32 generic"

./configure ABI=32

cc  +DD64

cc  +DA2.0 +e

gcc  -mabi=n32
cc   -n32

gcc  -mabi=64
cc   -64

gcc  -maix64
xlc  -q64

gcc  -m64 -mptr64 -Wa,-xarch=v9 -mcpu=v9
cc   -xarch=v9

gcc  -mv8plus
cc   -xarch=v8plus

./configure --build=none --host=sparcv9-sun-solaris2.7 ABI=64

./configure --enable-shared --disable-static

./configure --enable-cxx CPPFLAGS=-D__USE_STD_IOSTREAM

./configure --disable-static --enable-shared

lib /machine:IX86 /def:_libs/libgmp-3.dll-def
cp libgmp-3.lib /my/inst/dir/lib
cp _libs/libgmp-3.dll-exp /my/inst/dir/lib/libgmp-3.exp

./configure CC=gcc-with-my-options

LD_LIBRARY_PATH=/my/staging/area/usr/lib \
  make install DESTDIR=/my/staging/area

libgmp.la: $(libgmp_la_OBJECTS) $(libgmp_la_DEPENDENCIES)

#include <gmp.h>

#include <stdio.h>
#include <gmp.h>

gcc myprogram.c -lgmp

g++ mycxxprog.cc -lgmpxx -lgmp

mpz_t sum;

struct foo { mpz_t x, y; };

mpz_t vec[20];

mpq_t quotient;

mpz_mul (x, x, x);

void
foo (void)
{
  mpz_t  n;
  int    i;
  mpz_init (n);
  for (i = 1; i < 100; i++)
    {
      mpz_mul (n, ...);
      mpz_fdiv_q (n, ...);
      ...
    }
  mpz_clear (n);
}

void
foo (mpz_t result, const mpz_t param, unsigned long n)
{
  unsigned long  i;
  mpz_mul_ui (result, param, n);
  for (i = 1; i < n; i++)
    mpz_add_ui (result, result, i*7);
}

int
main (void)
{
  mpz_t  r, n;
  mpz_init (r);
  mpz_init_set_str (n, "123456", 0);
  foo (r, n, 20L);
  gmp_printf ("%Zd\n", r);
  return 0;
}

make pexpr
./pexpr 68^975+10

if (x != y)
  mpz_set (x, y);

/* mpq increment */
mpz_add (mpq_numref(q), mpq_numref(q), mpq_denref(q));

/* mpq += unsigned long */
mpz_addmul_ui (mpq_numref(q), mpq_denref(q), 123UL);

/* mpq -= mpz */
mpz_submul (mpq_numref(q), mpq_denref(q), z);

http://www.inf.ethz.ch/personal/biere/projects/ccmalloc
http://quorum.tamu.edu/jon/gnu  (debauch)
http://dmalloc.com
http://www.perens.com/FreeSoftware  (electric fence)
http://packages.debian.org/fda
http://www.gnupdate.org/components/leakbug
http://people.redhat.com/~otaylor/memprof
http://www.cbmamiga.demon.co.uk/mpatrol

cd /my/build/dir
/my/source/dir/gmp-4.1.2/configure

./configure --disable-shared --enable-assert \
  --enable-alloca=debug --host=none CFLAGS=-g

./configure --host=none-pc-linux-gnu CC=checkergcc

AC_CHECK_LIB(gmp, __gmpz_init)

AC_CHECK_LIB(gmp, __gmpz_init, , [AC_MSG_ERROR(
[GNU MP not found, see http://swox.com/gmp])])

AC_CHECK_LIB(gmp, __gmpz_mul_si, , [AC_MSG_ERROR(
[GNU MP not found, or not 3.1 or up, see http://swox.com/gmp])])

AC_CHECK_LIB(gmp, __gmpz_init, ,
  [AC_CHECK_LIB(gmp, mpz_init, ,
    [AC_CHECK_LIB(gmp2, mpz_init)])])

AC_CHECK_SIZEOF(mp_limb_t, , [#include <gmp.h>])

AC_CHECK_LIB(mpfr, mpfr_add, , [AC_MSG_ERROR(
[Need MPFR either from GNU MP 4 or separate MPFR package.
See http://www.mpfr.org or http://swox.com/gmp])

(eval-after-load "info-look"
  '(let ((mode-value (assoc 'c-mode (assoc 'symbol info-lookup-alist))))
     (setcar (nthcdr 3 mode-value)
             (cons '("(gmp)Function Index" nil "^ -.* " "\\>")
                   (nth 3 mode-value)))))

{
  mpz_t integ;
  mpz_init (integ);
  ...
  mpz_add (integ, ...);
  ...
  mpz_sub (integ, ...);

  /* Unless the program is about to exit, do ... */
  mpz_clear (integ);
}

{
  mpz_t pie;
  mpz_init_set_str (pie, "3141592653589793238462643383279502884", 10);
  ...
  mpz_sub (pie, ...);
  ...
  mpz_clear (pie);
}

unsigned long  a[20];
mpz_t          z;
mpz_import (z, 20, 1, sizeof(a[0]), 0, 0, a);

numb = 8*size - nail;
count = (mpz_sizeinbase (z, 2) + numb-1) / numb;
p = malloc (count * size);

mpz_sizeinbase (mpq_numref(op), base)
+ mpz_sizeinbase (mpq_denref(op), base) + 3

{
  mpf_t x, y;
  mpf_init (x);           /* use default precision */
  mpf_init2 (y, 256);     /* precision at least 256 bits */
  ...
  /* Unless the program is about to exit, do ... */
  mpf_clear (x);
  mpf_clear (y);
}

cy = mpn_add_n (destp, s1p, s2p, n)

GMP_LIMB_BITS == GMP_NAIL_BITS + GMP_NUMB_BITS

% [flags] [width] [.[precision]] [type] conv

mpz_t z;
gmp_printf ("%s is an mpz %Zd\n", "here", z);

mpq_t q;
gmp_printf ("a hex rational: %#40Qx\n", q);

mpf_t f;
int   n;
gmp_printf ("fixed point mpf %.*Ff with %d digits\n", n, f, n);

const mp_limb_t *ptr;
mp_size_t       size;
gmp_printf ("limb array %Nx\n", ptr, size);

mpz_t  z;
int    n;
...
cout << "iteration " << n << " value " << z << "\n";

% [flags] [width] [type] conv

/* to read say "a(5) = 1234" */
int   n;
mpz_t z;
gmp_scanf ("a(%d) = %Zd\n", &n, z);

mpq_t q1, q2;
gmp_sscanf ("0377 + 0x10/0x11", "%Qi + %Qi", q1, q2);

/* to read say "topleft (1.55,-2.66)" */
mpf_t x, y;
char  buf[32];
gmp_scanf ("%31s (%Ff,%Ff)", buf, x, y);

mpz_t  z;
...
cin >> z;

#include <gmpxx.h>

g++ mycxxprog.cc -lgmpxx -lgmp

int
main (void)
{
  mpz_class a, b, c;

  a = 1234;
  b = "-5678";
  c = a+b;
  cout << "sum is " << c << "\n";
  cout << "absolute value is " << abs(c) << "\n";

  return 0;
}

mpz_class a, b, c;
...
mpz_gcd (a.get_mpz_t(), b.get_mpz_t(), c.get_mpz_t());

mpz_t z;
// ... init and calculate z ...
mpz_class x(z);
mpz_class y;
y = mpz_class (z);

mpz_class q, a, d;
...
mpz_fdiv_q (q.get_mpz_t(), a.get_mpz_t(), d.get_mpz_t());

mpq_class q (99);
mpq_class q (1.75);
mpq_class q (1, 3);

mpf_class f(1.5);        // default precision
mpf_class f(1.5, 500);   // 500 bits (at least)
mpf_class f(x);          // precision of x
mpf_class f(abs(x));     // precision of x
mpf_class f(-g, 1000);   // 1000 bits (at least)
mpf_class f(x+y);        // greater of precisions of x and y

#include <mpfrxx.h>

gmp_randclass r1 (gmp_randinit_default);
gmp_randclass r2 (gmp_randinit_lc_2exp_size, 32);
gmp_randclass r3 (gmp_randinit_lc_2exp, a, c, m2exp);

gmp_randclass  r;
...
mpf_class  f (0, 512);   // 512 bits precision
f = r.get_f();           // random number, 512 bits

template <class T>
T fun (const T &, const T &);

mpz_class f(1), g(2);
fun (f, g);    // Good

mpz_class f(1), g(2), h(3);
fun (f, g+h);  // Bad

mpz_class f(1), g(2), h(3);
fun (f, mpz_class(g+h));  // Good

template <class T>
void fun (T f, T g)
{
  fun2 (f, f+g);     // Bad
}

template <class T>
void fun (T f, T g)
{
  fun2 (f, T(f+g));  // Good
}

     u0  u1  u2  u3  u4
   +---+---+---+---+---+
u0 | d |   |   |   |   |
   +---+---+---+---+---+
u1 |   | d |   |   |   |
   +---+---+---+---+---+
u2 |   |   | d |   |   |
   +---+---+---+---+---+
u3 |   |   |   | d |   |
   +---+---+---+---+---+
u4 |   |   |   |   | d |
   +---+---+---+---+---+

 high              low
+----------+----------+
|    x1    |    x0    |
+----------+----------+

+----------+----------+
|    y1    |    y0    |
+----------+----------+

x*y = (b^2+b)*x1*y1 - b*(x1-x0)*(y1-y0) + (b+1)*x0*y0

 high                              low
+--------+--------+ +--------+--------+
|      x1*y1      | |      x0*y0      |
+--------+--------+ +--------+--------+
          +--------+--------+
      add |      x1*y1      |
          +--------+--------+
          +--------+--------+
      add |      x0*y0      |
          +--------+--------+
          +--------+--------+
      sub | (x1-x0)*(y1-y0) |
          +--------+--------+

x^2 = (b^2+b)*x1^2 - b*(x1-x0)^2 + (b+1)*x0^2

 high                         low
+----------+----------+----------+
|    x2    |    x1    |    x0    |
+----------+----------+----------+

+----------+----------+----------+
|    y2    |    y1    |    y0    |
+----------+----------+----------+

X(t) = x2*t^2 + x1*t + x0
Y(t) = y2*t^2 + y1*t + y0

W(t) = w4*t^4 + w3*t^3 + w2*t^2 + w1*t + w0

 high                                        low
+-------+-------+
|       w4      |
+-------+-------+
       +--------+-------+
       |        w3      |
       +--------+-------+
               +--------+-------+
               |        w2      |
               +--------+-------+
                       +--------+-------+
                       |        w1      |
                       +--------+-------+
                                +-------+-------+
                                |       w0      |
                                +-------+-------+

   W(0)   =                                 w0
16*W(1/2) =    w4 + 2*w3 + 4*w2 + 8*w1 + 16*w0
   W(1)   =    w4 +   w3 +   w2 +   w1 +    w0
   W(2)   = 16*w4 + 8*w3 + 4*w2 + 2*w1 +    w0
   W(inf) =    w4

 high                                        low
+-------+-------+-------+-------+-------+-------+
|       E       |       C       |       A       |
+-------+-------+-------+-------+-------+-------+
         +------+-------++------+-------+
         |      D       ||      B       |
         +------+-------++------+-------+
      --      --      --
     |tD|    |tC|    |tB|
      --      --      --

           ---
           \         b
w[n] =     /     (-1) * x[i] * y[j]
           ---
       i+j==b*2^k+n
          b=0,1

a = q*d + r*b^n

         1         A
a[i+1] = - * ( --------- + (n-1)*a[i] )
         n     a[i]^(n-1)

                      k  (n-k+i)
C(n,k) =  (n-k+1) * prod -------
                     i=2    i

F[2k+1] = 4*F[k]^2 - F[k-1]^2 + 2*(-1)^k
F[2k-1] =   F[k]^2 + F[k-1]^2

F[2k] = F[2k+1] - F[2k-1]

F[2k]   = F[k]*(F[k]+2F[k-1])

F[2k+1] = (2F[k]+F[k-1])*(2F[k]-F[k-1]) + 2*(-1)^k

L[k]   =   F[k] + 2*F[k-1]
L[k-1] = 2*F[k] -   F[k-1]

L[2k] = L[k]^2 - 2*(-1)^k

L[2k+1] = 5*F[k-1]*(2*F[k]+F[k-1]) - 4*(-1)^k

                +---+---+---+---+
                |v48|v32|v16|v00|    V operand
                +---+---+---+---+

                +-------+---+---+
            x   |  u32  |  u00  |    U operand (one limb)
                +---------------+

---------------------------------

                    +-----------+
                    | u00 x v00 |    p00    48-bit products
                    +-----------+
                +-----------+
                | u00 x v16 |        p16
                +-----------+
            +-----------+
            | u00 x v32 |            p32
            +-----------+
        +-----------+
        | u00 x v48 |                p48
        +-----------+
            +-----------+
            | u32 x v00 |            r32
            +-----------+
        +-----------+
        | u32 x v16 |                r48
        +-----------+
    +-----------+
    | u32 x v32 |                    r64
    +-----------+
+-----------+
| u32 x v48 |                        r80
+-----------+

|-----64bits----|-----64bits----|
                   +------------+
                   | p00 + r64' |    i00
                   +------------+
               +------------+
               | p16 + r80' |        i16
               +------------+
           +------------+
           | p32 + r32  |            i32
           +------------+
       +------------+
       | p48 + r48  |                i48
       +------------+

   most                   least
significant            significant
   limb                   limb

                            _mp_d
 |---- _mp_exp --->           |
  _____ _____ _____ _____ _____
 |_____|_____|_____|_____|_____|
                   . <------------ radix point

  <-------- _mp_size --------->

+------+------------------------+
| size |       data bytes       |
+------+------------------------+

struct __gmp_binary_plus
{
  static void eval(mpf_t f, mpf_t g, mpf_t h) { mpf_add(f, g, h); }
};

__gmp_expr<__gmp_binary_expr<mpf_class, mpf_class, __gmp_binary_plus> >
operator+(const mpf_class &f, const mpf_class &g)
{
  return __gmp_expr
    <__gmp_binary_expr<mpf_class, mpf_class, __gmp_binary_plus> >(f, g);
}

template <class T>
mpf_class & mpf_class::operator=(const __gmp_expr<T> &expr)
{
  expr.eval(this->get_mpf_t(), this->precision());
  return *this;
}

template <class Op>
void __gmp_expr<__gmp_binary_expr<mpf_class, mpf_class, Op> >::eval
(mpf_t f, unsigned long int precision)
{
  Op::eval(f, expr.val1.get_mpf_t(), expr.val2.get_mpf_t());
}

template <class T, class U>
__gmp_expr
<__gmp_binary_expr<__gmp_expr<T>, __gmp_expr<U>, __gmp_binary_plus> >
operator+(const __gmp_expr<T> &expr1, const __gmp_expr<U> &expr2)
{
  return __gmp_expr
    <__gmp_binary_expr<__gmp_expr<T>, __gmp_expr<U>, __gmp_binary_plus> >
    (expr1, expr2);
}

template <class T, class U, class Op>
void __gmp_expr
<__gmp_binary_expr<__gmp_expr<T>, __gmp_expr<U>, Op> >::eval
(mpf_t f, unsigned long int precision)
{
  // declare two temporaries
  mpf_class temp1(expr.val1, precision), temp2(expr.val2, precision);
  Op::eval(f, temp1.get_mpf_t(), temp2.get_mpf_t());
}

Copyright © 2000 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA  02111-1307, USA

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

  Copyright (C)  year  your name.
  Permission is granted to copy, distribute and/or modify this document
  under the terms of the GNU Free Documentation License, Version 1.1
  or any later version published by the Free Software Foundation;
  with the Invariant Sections being list their titles, with the
  Front-Cover Texts being list, and with the Back-Cover Texts being list.
  A copy of the license is included in the section entitled ``GNU
  Free Documentation License''.

__GNU_MP_VERSION	Macro
__GNU_MP_VERSION_MINOR	Macro
__GNU_MP_VERSION_PATCHLEVEL	Macro

int mpz_cmp (mpz_t `op1`, mpz_t `op2`)	Function
int mpz_cmp_d (mpz_t `op1`, double `op2`)	Function
int mpz_cmp_si (mpz_t `op1`, signed long int `op2`)	Macro
int mpz_cmp_ui (mpz_t `op1`, unsigned long int `op2`)	Macro

int mpz_odd_p (mpz_t `op`)	Macro
int mpz_even_p (mpz_t `op`)	Macro

int mpq_cmp_ui (mpq_t `op1`, unsigned long int `num2`, unsigned long int `den2`)	Macro
int mpq_cmp_si (mpq_t `op1`, long int `num2`, unsigned long int `den2`)	Macro

mpz_t mpq_numref (mpq_t `op`)	Macro
mpz_t mpq_denref (mpq_t `op`)	Macro

void mpz_set (mpz_t `rop`, mpz_t `op`)	Function
void mpz_set_ui (mpz_t `rop`, unsigned long int `op`)	Function
void mpz_set_si (mpz_t `rop`, signed long int `op`)	Function
void mpz_set_d (mpz_t `rop`, double `op`)	Function
void mpz_set_q (mpz_t `rop`, mpq_t `op`)	Function
void mpz_set_f (mpz_t `rop`, mpf_t `op`)	Function

void mpz_init_set (mpz_t `rop`, mpz_t `op`)	Function
void mpz_init_set_ui (mpz_t `rop`, unsigned long int `op`)	Function
void mpz_init_set_si (mpz_t `rop`, signed long int `op`)	Function
void mpz_init_set_d (mpz_t `rop`, double `op`)	Function

void mpz_add (mpz_t `rop`, mpz_t `op1`, mpz_t `op2`)	Function
void mpz_add_ui (mpz_t `rop`, mpz_t `op1`, unsigned long int `op2`)	Function

void mpz_sub (mpz_t `rop`, mpz_t `op1`, mpz_t `op2`)	Function
void mpz_sub_ui (mpz_t `rop`, mpz_t `op1`, unsigned long int `op2`)	Function
void mpz_ui_sub (mpz_t `rop`, unsigned long int `op1`, mpz_t `op2`)	Function

void mpz_mul (mpz_t `rop`, mpz_t `op1`, mpz_t `op2`)	Function
void mpz_mul_si (mpz_t `rop`, mpz_t `op1`, long int `op2`)	Function
void mpz_mul_ui (mpz_t `rop`, mpz_t `op1`, unsigned long int `op2`)	Function

void mpz_addmul (mpz_t `rop`, mpz_t `op1`, mpz_t `op2`)	Function
void mpz_addmul_ui (mpz_t `rop`, mpz_t `op1`, unsigned long int `op2`)	Function

void mpz_submul (mpz_t `rop`, mpz_t `op1`, mpz_t `op2`)	Function
void mpz_submul_ui (mpz_t `rop`, mpz_t `op1`, unsigned long int `op2`)	Function

void mpz_cdiv_q (mpz_t `q`, mpz_t `n`, mpz_t `d`)	Function
void mpz_cdiv_r (mpz_t `r`, mpz_t `n`, mpz_t `d`)	Function
void mpz_cdiv_qr (mpz_t `q`, mpz_t `r`, mpz_t `n`, mpz_t `d`)	Function


unsigned long int mpz_cdiv_q_ui (mpz_t `q`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_cdiv_r_ui (mpz_t `r`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_cdiv_qr_ui (mpz_t `q`, mpz_t `r`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_cdiv_ui (mpz_t `n`, unsigned long int `d`)	Function


void mpz_cdiv_q_2exp (mpz_t `q`, mpz_t `n`, unsigned long int `b`)	Function
void mpz_cdiv_r_2exp (mpz_t `r`, mpz_t `n`, unsigned long int `b`)	Function

void mpz_fdiv_q (mpz_t `q`, mpz_t `n`, mpz_t `d`)	Function
void mpz_fdiv_r (mpz_t `r`, mpz_t `n`, mpz_t `d`)	Function
void mpz_fdiv_qr (mpz_t `q`, mpz_t `r`, mpz_t `n`, mpz_t `d`)	Function


unsigned long int mpz_fdiv_q_ui (mpz_t `q`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_fdiv_r_ui (mpz_t `r`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_fdiv_qr_ui (mpz_t `q`, mpz_t `r`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_fdiv_ui (mpz_t `n`, unsigned long int `d`)	Function


void mpz_fdiv_q_2exp (mpz_t `q`, mpz_t `n`, unsigned long int `b`)	Function
void mpz_fdiv_r_2exp (mpz_t `r`, mpz_t `n`, unsigned long int `b`)	Function

void mpz_tdiv_q (mpz_t `q`, mpz_t `n`, mpz_t `d`)	Function
void mpz_tdiv_r (mpz_t `r`, mpz_t `n`, mpz_t `d`)	Function
void mpz_tdiv_qr (mpz_t `q`, mpz_t `r`, mpz_t `n`, mpz_t `d`)	Function


unsigned long int mpz_tdiv_q_ui (mpz_t `q`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_tdiv_r_ui (mpz_t `r`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_tdiv_qr_ui (mpz_t `q`, mpz_t `r`, mpz_t `n`, unsigned long int `d`)	Function
unsigned long int mpz_tdiv_ui (mpz_t `n`, unsigned long int `d`)	Function


void mpz_tdiv_q_2exp (mpz_t `q`, mpz_t `n`, unsigned long int `b`)	Function
void mpz_tdiv_r_2exp (mpz_t `r`, mpz_t `n`, unsigned long int `b`)	Function

void mpz_mod (mpz_t `r`, mpz_t `n`, mpz_t `d`)	Function
unsigned long int mpz_mod_ui (mpz_t `r`, mpz_t `n`, unsigned long int `d`)	Function

void mpz_divexact (mpz_t `q`, mpz_t `n`, mpz_t `d`)	Function
void mpz_divexact_ui (mpz_t `q`, mpz_t `n`, unsigned long `d`)	Function

int mpz_divisible_p (mpz_t `n`, mpz_t `d`)	Function
int mpz_divisible_ui_p (mpz_t `n`, unsigned long int `d`)	Function
int mpz_divisible_2exp_p (mpz_t `n`, unsigned long int `b`)	Function

int mpz_congruent_p (mpz_t `n`, mpz_t `c`, mpz_t `d`)	Function
int mpz_congruent_ui_p (mpz_t `n`, unsigned long int `c`, unsigned long int `d`)	Function
int mpz_congruent_2exp_p (mpz_t `n`, mpz_t `c`, unsigned long int `b`)	Function

GNU MP 4.1.2

GNU MP

GNU MP Copying Conditions

Introduction to GNU MP

How to use this Manual

Installing GMP

Build Options

ABI and ISA

Notes for Package Builds

Notes for Particular Systems

Known Build Problems

GMP Basics

Headers and Libraries

Nomenclature and Types

Function Classes

Variable Conventions

Parameter Conventions

Memory Management

Reentrancy

Useful Macros and Constants

Compatibility with older versions

Demonstration programs

Efficiency

Debugging

Profiling

Autoconf

Emacs

Reporting Bugs

Integer Functions

Initialization Functions

Assignment Functions

Combined Initialization and Assignment Functions

Conversion Functions

Arithmetic Functions

Division Functions

Exponentiation Functions

Root Extraction Functions

Number Theoretic Functions

Comparison Functions

Logical and Bit Manipulation Functions

Input and Output Functions

Random Number Functions

Integer Import and Export

Miscellaneous Functions

Rational Number Functions

Initialization and Assignment Functions

Conversion Functions

Arithmetic Functions

Comparison Functions

Applying Integer Functions to Rationals

Input and Output Functions

Floating-point Functions

Initialization Functions

Assignment Functions

Combined Initialization and Assignment Functions

Conversion Functions

Arithmetic Functions

Comparison Functions

Input and Output Functions

Miscellaneous Functions

Low-level Functions

Nails

Random Number Functions

Random State Initialization

Random State Seeding

Formatted Output

Format Strings

Functions

C++ Formatted Output

Formatted Input

Formatted Input Strings

Formatted Input Functions

C++ Formatted Input

C++ Class Interface

C++ Interface General

C++ Interface Integers

C++ Interface Rationals

C++ Interface Floats

C++ Interface MPFR

C++ Interface Random Numbers

void mpz_powm (mpz_t `rop`, mpz_t `base`, mpz_t `exp`, mpz_t `mod`)	Function
void mpz_powm_ui (mpz_t `rop`, mpz_t `base`, unsigned long int `exp`, mpz_t `mod`)	Function

void mpz_pow_ui (mpz_t `rop`, mpz_t `base`, unsigned long int `exp`)	Function
void mpz_ui_pow_ui (mpz_t `rop`, unsigned long int `base`, unsigned long int `exp`)	Function

void mpz_lcm (mpz_t `rop`, mpz_t `op1`, mpz_t `op2`)	Function
void mpz_lcm_ui (mpz_t `rop`, mpz_t `op1`, unsigned long `op2`)	Function

int mpz_kronecker (mpz_t `a`, mpz_t `b`)	Function
int mpz_kronecker_si (mpz_t `a`, long `b`)	Function
int mpz_kronecker_ui (mpz_t `a`, unsigned long `b`)	Function
int mpz_si_kronecker (long `a`, mpz_t `b`)	Function
int mpz_ui_kronecker (unsigned long `a`, mpz_t `b`)	Function

void mpz_bin_ui (mpz_t `rop`, mpz_t `n`, unsigned long int `k`)	Function
void mpz_bin_uiui (mpz_t `rop`, unsigned long int `n`, unsigned long int `k`)	Function

void mpz_fib_ui (mpz_t `fn`, unsigned long int `n`)	Function
void mpz_fib2_ui (mpz_t `fn`, mpz_t `fnsub1`, unsigned long int `n`)	Function

void mpz_lucnum_ui (mpz_t `ln`, unsigned long int `n`)	Function
void mpz_lucnum2_ui (mpz_t `ln`, mpz_t `lnsub1`, unsigned long int `n`)	Function

int mpz_cmpabs (mpz_t `op1`, mpz_t `op2`)	Function
int mpz_cmpabs_d (mpz_t `op1`, double `op2`)	Function
int mpz_cmpabs_ui (mpz_t `op1`, unsigned long int `op2`)	Function

unsigned long int mpz_scan0 (mpz_t `op`, unsigned long int `starting_bit`)	Function
unsigned long int mpz_scan1 (mpz_t `op`, unsigned long int `starting_bit`)	Function

int mpz_fits_ulong_p (mpz_t `op`)	Function
int mpz_fits_slong_p (mpz_t `op`)	Function
int mpz_fits_uint_p (mpz_t `op`)	Function
int mpz_fits_sint_p (mpz_t `op`)	Function
int mpz_fits_ushort_p (mpz_t `op`)	Function
int mpz_fits_sshort_p (mpz_t `op`)	Function