GNU MP 4.1.2

(mpz_t `integer`) · free

`COPYING.LIB'
`COPYING'
http://swox.com/gmp/

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

./configure
make

make check

`/usr/local'
make install

`INSTALL.autoconf'
http://www.cygnus.com/cygwin
http://www.delorie.com/djgpp
http://www.mingw.org

`macos'
`macos/README'
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

`libgmp'
`configure.in'
./configure --host=none-unknown-freebsd3.5

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

`Makefile'
`libgmpxx.la'
`gmpxx.h'
`libgmpxx.la'
`libgmp.la'
`libgmpxx.la'
`libgmp.la'
`libgmp.la'
`libgmpxx.la'
`foo.cc'
`libmp'
`mp.h'
`libmpfr.a'
MPN_PATH="sparc32/v8 sparc32 generic"

`gmp.texi'
`gmp.ps'
`gmp.dvi'
`doc'
./configure ABI=32

`gmp.h'
`gmp.h'
`gmp.h'
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

`libgmpxx.la'
`libgmp.la'
`libgmpxx'
`gmp.h'
./configure --enable-shared --disable-static

`libgmp.a'
`libgmp.so'
`.a'
./configure --enable-cxx CPPFLAGS=-D__USE_STD_IOSTREAM

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

`gmp.h'
`.lib'
`.exp'
`/my/inst/dir'
`lib'
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

`.asm'
`config.sub'
`.asm'
./configure CC=gcc-with-my-options

`config.log'
`libgmp.la'
`libgmpxx'
`libgmpxx'
`libgmp'
`libgmpxx'
`libgmp'
`libgmpxx'
`libgmp'
LD_LIBRARY_PATH=/my/staging/area/usr/lib \
  make install DESTDIR=/my/staging/area

`libgmp.a'
`libmp.a'
`init.o'
`libgmp.a'
`libgmp.so'
`libmp.so'
`libgmp.la'
`Makefile'
libgmp.la: $(libgmp_la_OBJECTS) $(libgmp_la_DEPENDENCIES) 

`libgmp.la'
`cc'
`libgmp.la'
`libgmp'
`t-mul'
`t-mul.exe'
`t-mul.exe'
`gmp.h'
#include <gmp.h>

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

`libgmp'
gcc myprogram.c -lgmp

`libgmpxx'
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;
}

`libmp'
`demos'
`Makefile'
make pexpr
./pexpr 68^975+10

`demos/expr/README'
`demos/perl/INSTALL'
`demos/perl/GMP.pm'
`libgmp.a'
`libgmp.so'
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

`memory.c'
`.gdbinit'
`mpz'
`mpq'
`mpf'
`mpfr'
`init.c'
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

`libc'
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])])

`gmp.h'
`libgmp2'
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>])

`libmpfr.a'
`libmpfr'
`libgmp'
`libmpfr.a'
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])

`.emacs'
(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)))))

`config.log'
`asm'
`config.m4'
`mpn/tmp-<file>.s'
{
  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);
}

`demos/qcn.c'
`stdio.h'
`gmp.h'
`gmp.h'
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

`stdio.h'
`gmp.h'
`gmp.h'
{
  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);
}

`stdio.h'
`gmp.h'
`gmp.h'
cy = mpn_add_n (destp, s1p, s2p, n)

GMP_LIMB_BITS == GMP_NAIL_BITS + GMP_NUMB_BITS

`/dev/random'
% [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);

`libgmpxx'
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);

`libgmpxx'
mpz_t  z;
...
cin >> z;

`gmp.h'
#include <gmpxx.h>

`libgmpxx'
`libgmp'
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);

`gmpxx.h'
`gmp.h'
`gmpxx.h'
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
}

`libm.a'
`mp.h'
`mp.h'
`libmp.a'
`mp.h'
`demos/perl'
`mpn/generic/mul_basecase.c'
`mpn/generic/sqr_basecase.c'
     u0  u1  u2  u3  u4
   +---+---+---+---+---+
u0 | d |   |   |   |   |
   +---+---+---+---+---+
u1 |   | d |   |   |   |
   +---+---+---+---+---+
u2 |   |   | d |   |   |
   +---+---+---+---+---+
u3 |   |   |   | d |   |
   +---+---+---+---+---+
u4 |   |   |   |   | d |
   +---+---+---+---+---+

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

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

@m{xy = (b^2+b)x_1y_1 - b(x_1-x_0)(y_1-y_0) + (b+1)x_0y_0,
  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) |
          +--------+--------+

@m{x^2 = (b^2+b)x_1^2 - b(x_1-x_0)^2 + (b+1)x_0^2,
   x^2 = (b^2+b)*x1^2 - b*(x1-x0)^2 + (b+1)*x0^2}

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

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

@m{X(t) = x_2t^2 + x_1t + x_0,
   X(t) = x2*t^2 + x1*t + x0}
@m{Y(t) = y_2t^2 + y_1t + y_0,
   Y(t) = y2*t^2 + y1*t + y0}

@m{W(t) = w_4t^4 + w_3t^3 + w_2t^2 + w_1t + w_0,
   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|        
      --      --      --

`mpn/generic/mul_n.c'
`tune/README'
           ---
           \         b
w[n] =     /     (-1) * x[i] * y[j]
           ---
       i+j==b*2^k+n
          b=0,1

`gmp-impl.h'
`mpn/generic/sb_divrem_mn.c'
`gmp-impl.h'
`tune/modlinv.c'
a = q*d + r*b^n

`mpn/generic/gcd.c'
`mpn/generic/gcdext.c'
         1         A
a[i+1] = - * ( --------- + (n-1)*a[i] )
         n     a[i]^(n-1)

`gmp-impl.h'
                      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

`longlong.h'
`mpn'
`mpn/generic'
`mpn'
`mpn/generic/aors_n.c'
`mpn/cray/add_n.c'
                +---+---+---+---+
                |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());
}

`mpn/m68k/lshift.S'
`mpn/m68k/rshift.S'
`.asm'
`gmpasm-mode.el'
`gmpxx.h'
Copyright (C) 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''.

`gmp.h'
`mp.h'