glib2 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

data/vendor/local/share/info/gmp.info-1

@@ -2,7 +2,7 @@ This is ../../gmp/doc/gmp.info, produced by makeinfo version 4.13 from
 ../../gmp/doc/gmp.texi.
 
 This manual describes how to install and use the GNU multiple precision
-arithmetic library, version 5.1.2.
+arithmetic library, version 5.1.3.
 
    Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012,
@@ -28,7 +28,7 @@ GNU MP
 ******
 
    This manual describes how to install and use the GNU multiple
-precision arithmetic library, version 5.1.2.
+precision arithmetic library, version 5.1.3.
 
    Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012,
@@ -229,7 +229,7 @@ Build Directory
      directory.  For example
 
           cd /my/build/dir
-          /my/sources/gmp-5.1.2/configure
+          /my/sources/gmp-5.1.3/configure
 
      Not all `make' programs have the necessary features (`VPATH') to
      support this.  In particular, SunOS and Slowaris `make' have bugs
@@ -320,7 +320,7 @@ CPU types
      The best idea is always to build GMP for the exact machine type
      you intend to run it on.
 
-     The following CPUs have specific support.  See `configure.in' for
+     The following CPUs have specific support.  See `configure.ac' for
      details of what code and compiler options they select.
 
         * Alpha: alpha, alphaev5, alphaev56, alphapca56, alphapca57,
@@ -1478,7 +1478,7 @@ File: gmp.info,  Node: Useful Macros and Constants,  Next: Compatibility with ol
 
  -- Global Constant: const char * const gmp_version
      The GMP version number, as a null-terminated string, in the form
-     "i.j.k".  This release is "5.1.2".  Note that the format "i.j" was
+     "i.j.k".  This release is "5.1.3".  Note that the format "i.j" was
      used, before version 4.3.0, when k was zero.
 
  -- Macro: __GMP_CC
@@ -1794,7 +1794,7 @@ Source File Paths
      path to the source directory.
 
           cd /my/build/dir
-          /my/source/dir/gmp-5.1.2/configure
+          /my/source/dir/gmp-5.1.3/configure
 
      This works via `VPATH', and might require GNU `make'.  Alternately
      it might be possible to change the `.c.lo' rules appropriately.
@@ -1851,21 +1851,23 @@ Checker
      support the standard C++ library.
 
 Valgrind
-     The valgrind program (`http://valgrind.org/') is a memory checker
-     for x86s.  It translates and emulates machine instructions to do
-     strong checks for uninitialized data (at the level of individual
-     bits), memory accesses through bad pointers, and memory leaks.
+     Valgrind (`http://valgrind.org/') is a memory checker for x86,
+     ARM, MIPS, PowerPC, and S/390.  It translates and emulates machine
+     instructions to do strong checks for uninitialized data (at the
+     level of individual bits), memory accesses through bad pointers,
+     and memory leaks.
 
-     Recent versions of Valgrind are getting support for MMX and
-     SSE/SSE2 instructions, for past versions GMP will need to be
-     configured not to use those, i.e. for an x86 without them (for
-     instance plain `i486').
+     Valgrind does not always support every possible instruction, in
+     particular ones recently added to an ISA.  Valgrind might
+     therefore be incompatible with a recent GMP or even a less recent
+     GMP which is compiled using a recent GCC.
 
      GMP's assembly code sometimes promotes a read of the limbs to some
      larger size, for efficiency.  GMP will do this even at the start
-     and end of a multilimb operand, using naturaly aligned operations
+     and end of a multilimb operand, using naturally aligned operations
      on the larger type.  This may lead to benign reads outside of
-     allocated areas, triggering complants from Valgrind.
+     allocated areas, triggering complaints from Valgrind.  Valgrind's
+     option `--partial-loads-ok=yes' should help.
 
 Other Problems
      Any suspected bug in GMP itself should be isolated to make sure
@@ -2059,7 +2061,10 @@ for this release.
 
    * Please do not send core dumps, executables or `strace's.
 
-   * The configuration options you used when building GMP, if any.
+   * The `configure' options you used when building GMP, if any.
+
+   * The output from `configure', as printed to stdout, with any
+     options used.
 
    * The name of the compiler and its version.  For `gcc', get the
      version with `gcc -v', otherwise perhaps `what `which cc`', or
@@ -2201,18 +2206,18 @@ File: gmp.info,  Node: Assigning Integers,  Next: Simultaneous Integer Init & As
 These functions assign new values to already initialized integers
 (*note Initializing Integers::).
 
- -- Function: void mpz_set (mpz_t ROP, mpz_t OP)
+ -- Function: void mpz_set (mpz_t ROP, const 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_set_q (mpz_t ROP, const mpq_t OP)
+ -- Function: void mpz_set_f (mpz_t ROP, const mpf_t OP)
      Set the value of ROP from OP.
 
      `mpz_set_d', `mpz_set_q' and `mpz_set_f' truncate OP to make it an
      integer.
 
- -- Function: int mpz_set_str (mpz_t ROP, char *STR, int BASE)
+ -- Function: int mpz_set_str (mpz_t ROP, const char *STR, int BASE)
      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.
 
@@ -2257,14 +2262,15 @@ functions, it can be used as the source or destination operand for the
 ordinary integer functions.  Don't use an initialize-and-set function
 on a variable already initialized!
 
- -- Function: void mpz_init_set (mpz_t ROP, mpz_t OP)
+ -- Function: void mpz_init_set (mpz_t ROP, const 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)
      Initialize ROP with limb space and set the initial numeric value
      from OP.
 
- -- Function: int mpz_init_set_str (mpz_t ROP, char *STR, int BASE)
+ -- Function: int mpz_init_set_str (mpz_t ROP, const char *STR, int
+          BASE)
      Initialize ROP and set its value like `mpz_set_str' (see its
      documentation above for details).
 
@@ -2282,14 +2288,14 @@ This section describes functions for converting GMP integers to
 standard C types.  Functions for converting _to_ GMP integers are
 described in *note Assigning Integers:: and *note I/O of Integers::.
 
- -- Function: unsigned long int mpz_get_ui (mpz_t OP)
+ -- Function: unsigned long int mpz_get_ui (const mpz_t OP)
      Return the value of OP as an `unsigned long'.
 
      If OP is too big to fit an `unsigned long' then just the least
      significant bits that do fit are returned.  The sign of OP is
      ignored, only the absolute value is used.
 
- -- Function: signed long int mpz_get_si (mpz_t OP)
+ -- Function: signed long int mpz_get_si (const mpz_t OP)
      If OP fits into a `signed long int' return the value of OP.
      Otherwise return the least significant part of OP, with the same
      sign as OP.
@@ -2298,7 +2304,7 @@ described in *note Assigning Integers:: and *note I/O of Integers::.
      result is probably not very useful.  To find out if the value will
      fit, use the function `mpz_fits_slong_p'.
 
- -- Function: double mpz_get_d (mpz_t OP)
+ -- Function: double mpz_get_d (const mpz_t OP)
      Convert OP to a `double', truncating if necessary (i.e. rounding
      towards zero).
 
@@ -2306,7 +2312,8 @@ described in *note Assigning Integers:: and *note I/O of Integers::.
      system dependent.  An infinity is returned where available.  A
      hardware overflow trap may or may not occur.
 
- -- Function: double mpz_get_d_2exp (signed long int *EXP, mpz_t OP)
+ -- Function: double mpz_get_d_2exp (signed long int *EXP, const mpz_t
+          OP)
      Convert OP to a `double', truncating if necessary (i.e. rounding
      towards zero), and returning the exponent separately.
 
@@ -2317,7 +2324,7 @@ described in *note Assigning Integers:: and *note I/O of Integers::.
      This is similar to the standard C `frexp' function (*note
      Normalization Functions: (libc)Normalization Functions.).
 
- -- Function: char * mpz_get_str (char *STR, int BASE, mpz_t OP)
+ -- Function: char * mpz_get_str (char *STR, int BASE, const mpz_t OP)
      Convert OP to a string of digits in base BASE.  The base argument
      may vary from 2 to 62 or from -2 to -36.
 
@@ -2345,42 +2352,45 @@ File: gmp.info,  Node: Integer Arithmetic,  Next: Integer Division,  Prev: Conve
 5.5 Arithmetic Functions
 ========================
 
- -- 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_add (mpz_t ROP, const mpz_t OP1, const mpz_t OP2)
+ -- Function: void mpz_add_ui (mpz_t ROP, const mpz_t OP1, unsigned
+          long int OP2)
      Set ROP to OP1 + 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_sub (mpz_t ROP, const mpz_t OP1, const mpz_t OP2)
+ -- Function: void mpz_sub_ui (mpz_t ROP, const mpz_t OP1, unsigned
+          long int OP2)
+ -- Function: void mpz_ui_sub (mpz_t ROP, unsigned long int OP1, const
+          mpz_t OP2)
      Set ROP to OP1 - 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_mul (mpz_t ROP, const mpz_t OP1, const mpz_t OP2)
+ -- Function: void mpz_mul_si (mpz_t ROP, const mpz_t OP1, long int OP2)
+ -- Function: void mpz_mul_ui (mpz_t ROP, const mpz_t OP1, unsigned
+          long int OP2)
      Set ROP to OP1 times 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_addmul (mpz_t ROP, const mpz_t OP1, const mpz_t
+          OP2)
+ -- Function: void mpz_addmul_ui (mpz_t ROP, const mpz_t OP1, unsigned
+          long int OP2)
      Set ROP to ROP + OP1 times 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_submul (mpz_t ROP, const mpz_t OP1, const mpz_t
+          OP2)
+ -- Function: void mpz_submul_ui (mpz_t ROP, const mpz_t OP1, unsigned
+          long int OP2)
      Set ROP to ROP - OP1 times OP2.
 
- -- Function: void mpz_mul_2exp (mpz_t ROP, mpz_t OP1, mp_bitcnt_t OP2)
+ -- Function: void mpz_mul_2exp (mpz_t ROP, const mpz_t OP1,
+          mp_bitcnt_t OP2)
      Set ROP to OP1 times 2 raised to OP2.  This operation can also be
      defined as a left shift by OP2 bits.
 
- -- Function: void mpz_neg (mpz_t ROP, mpz_t OP)
+ -- Function: void mpz_neg (mpz_t ROP, const mpz_t OP)
      Set ROP to -OP.
 
- -- Function: void mpz_abs (mpz_t ROP, mpz_t OP)
+ -- Function: void mpz_abs (mpz_t ROP, const mpz_t OP)
      Set ROP to the absolute value of OP.
 
 
@@ -2395,47 +2405,56 @@ functions `mpz_powm' and `mpz_powm_ui'), will cause an intentional
 division by zero.  This lets a program handle arithmetic exceptions in
 these functions the same way as for normal C `int' arithmetic.
 
- -- 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,
+ -- Function: void mpz_cdiv_q (mpz_t Q, const mpz_t N, const mpz_t D)
+ -- Function: void mpz_cdiv_r (mpz_t R, const mpz_t N, const mpz_t D)
+ -- Function: void mpz_cdiv_qr (mpz_t Q, mpz_t R, const mpz_t N, const
+          mpz_t D)
+ -- Function: unsigned long int mpz_cdiv_q_ui (mpz_t Q, const mpz_t N,
           unsigned long int D)
- -- Function: unsigned long int mpz_cdiv_r_ui (mpz_t R, mpz_t N,
+ -- Function: unsigned long int mpz_cdiv_r_ui (mpz_t R, const 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,
+          const mpz_t N, unsigned long int D)
+ -- Function: unsigned long int mpz_cdiv_ui (const mpz_t N,
           unsigned long int D)
- -- Function: void mpz_cdiv_q_2exp (mpz_t Q, mpz_t N, mp_bitcnt_t B)
- -- Function: void mpz_cdiv_r_2exp (mpz_t R, mpz_t N, mp_bitcnt_t 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,
+ -- Function: void mpz_cdiv_q_2exp (mpz_t Q, const mpz_t N,
+          mp_bitcnt_t B)
+ -- Function: void mpz_cdiv_r_2exp (mpz_t R, const mpz_t N,
+          mp_bitcnt_t B)
+
+ -- Function: void mpz_fdiv_q (mpz_t Q, const mpz_t N, const mpz_t D)
+ -- Function: void mpz_fdiv_r (mpz_t R, const mpz_t N, const mpz_t D)
+ -- Function: void mpz_fdiv_qr (mpz_t Q, mpz_t R, const mpz_t N, const
+          mpz_t D)
+ -- Function: unsigned long int mpz_fdiv_q_ui (mpz_t Q, const mpz_t N,
           unsigned long int D)
- -- Function: unsigned long int mpz_fdiv_r_ui (mpz_t R, mpz_t N,
+ -- Function: unsigned long int mpz_fdiv_r_ui (mpz_t R, const 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,
+          const mpz_t N, unsigned long int D)
+ -- Function: unsigned long int mpz_fdiv_ui (const mpz_t N,
           unsigned long int D)
- -- Function: void mpz_fdiv_q_2exp (mpz_t Q, mpz_t N, mp_bitcnt_t B)
- -- Function: void mpz_fdiv_r_2exp (mpz_t R, mpz_t N, mp_bitcnt_t 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,
+ -- Function: void mpz_fdiv_q_2exp (mpz_t Q, const mpz_t N,
+          mp_bitcnt_t B)
+ -- Function: void mpz_fdiv_r_2exp (mpz_t R, const mpz_t N,
+          mp_bitcnt_t B)
+
+ -- Function: void mpz_tdiv_q (mpz_t Q, const mpz_t N, const mpz_t D)
+ -- Function: void mpz_tdiv_r (mpz_t R, const mpz_t N, const mpz_t D)
+ -- Function: void mpz_tdiv_qr (mpz_t Q, mpz_t R, const mpz_t N, const
+          mpz_t D)
+ -- Function: unsigned long int mpz_tdiv_q_ui (mpz_t Q, const mpz_t N,
           unsigned long int D)
- -- Function: unsigned long int mpz_tdiv_r_ui (mpz_t R, mpz_t N,
+ -- Function: unsigned long int mpz_tdiv_r_ui (mpz_t R, const 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,
+          const mpz_t N, unsigned long int D)
+ -- Function: unsigned long int mpz_tdiv_ui (const mpz_t N,
           unsigned long int D)
- -- Function: void mpz_tdiv_q_2exp (mpz_t Q, mpz_t N, mp_bitcnt_t B)
- -- Function: void mpz_tdiv_r_2exp (mpz_t R, mpz_t N, mp_bitcnt_t B)
+ -- Function: void mpz_tdiv_q_2exp (mpz_t Q, const mpz_t N,
+          mp_bitcnt_t B)
+ -- Function: void mpz_tdiv_r_2exp (mpz_t R, const mpz_t N,
+          mp_bitcnt_t B)
 
      Divide N by D, forming a quotient Q and/or remainder R.  For the
      `2exp' functions, D=2^B.  The rounding is in three styles, each
@@ -2473,8 +2492,8 @@ these functions the same way as for normal C `int' arithmetic.
      the same as the bitwise logical functions do, whereas
      `mpz_tdiv_q_2exp' effectively treats N as sign and magnitude.
 
- -- 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,
+ -- Function: void mpz_mod (mpz_t R, const mpz_t N, const mpz_t D)
+ -- Function: unsigned long int mpz_mod_ui (mpz_t R, const mpz_t N,
           unsigned long int D)
      Set R to N `mod' D.  The sign of the divisor is ignored; the
      result is always non-negative.
@@ -2483,8 +2502,9 @@ these functions the same way as for normal C `int' arithmetic.
      remainder as well as setting R.  See `mpz_fdiv_ui' above if only
      the return value is wanted.
 
- -- 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: void mpz_divexact (mpz_t Q, const mpz_t N, const mpz_t D)
+ -- Function: void mpz_divexact_ui (mpz_t Q, const mpz_t N, unsigned
+          long D)
      Set Q to N/D.  These functions produce correct results only when
      it is known in advance that D divides N.
 
@@ -2492,9 +2512,10 @@ these functions the same way as for normal C `int' arithmetic.
      and are the best choice when exact division is known to occur, for
      example reducing a rational to lowest terms.
 
- -- 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, mp_bitcnt_t B)
+ -- Function: int mpz_divisible_p (const mpz_t N, const mpz_t D)
+ -- Function: int mpz_divisible_ui_p (const mpz_t N, unsigned long int
+          D)
+ -- Function: int mpz_divisible_2exp_p (const mpz_t N, mp_bitcnt_t B)
      Return non-zero if N is exactly divisible by D, or in the case of
      `mpz_divisible_2exp_p' by 2^B.
 
@@ -2503,10 +2524,12 @@ these functions the same way as for normal C `int' arithmetic.
      following the rule it can be seen that only 0 is considered
      divisible by 0.
 
- -- 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, mp_bitcnt_t B)
+ -- Function: int mpz_congruent_p (const mpz_t N, const mpz_t C, const
+          mpz_t D)
+ -- Function: int mpz_congruent_ui_p (const mpz_t N, unsigned long int
+          C, unsigned long int D)
+ -- Function: int mpz_congruent_2exp_p (const mpz_t N, const mpz_t C,
+          mp_bitcnt_t B)
      Return non-zero if N is congruent to C modulo D, or in the case of
      `mpz_congruent_2exp_p' modulo 2^B.
 
@@ -2521,18 +2544,18 @@ File: gmp.info,  Node: Integer Exponentiation,  Next: Integer Roots,  Prev: Inte
 5.7 Exponentiation Functions
 ============================
 
- -- Function: 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_powm (mpz_t ROP, const mpz_t BASE, const mpz_t
+          EXP, const mpz_t MOD)
+ -- Function: void mpz_powm_ui (mpz_t ROP, const mpz_t BASE, unsigned
+          long int EXP, const mpz_t MOD)
      Set ROP to (BASE raised to EXP) modulo MOD.
 
      Negative EXP is supported if an inverse BASE^-1 mod MOD exists
      (see `mpz_invert' in *note Number Theoretic Functions::).  If an
      inverse doesn't exist then a divide by zero is raised.
 
- -- Function: void mpz_powm_sec (mpz_t ROP, mpz_t BASE, mpz_t EXP,
-          mpz_t MOD)
+ -- Function: void mpz_powm_sec (mpz_t ROP, const mpz_t BASE, const
+          mpz_t EXP, const mpz_t MOD)
      Set ROP to (BASE raised to EXP) modulo MOD.
 
      It is required that EXP > 0 and that MOD is odd.
@@ -2544,8 +2567,8 @@ File: gmp.info,  Node: Integer Exponentiation,  Next: Integer Roots,  Prev: Inte
      is intended for cryptographic purposes, where resilience to
      side-channel attacks is desired.
 
- -- Function: void mpz_pow_ui (mpz_t ROP, mpz_t BASE, unsigned long int
-          EXP)
+ -- Function: void mpz_pow_ui (mpz_t ROP, const mpz_t BASE, unsigned
+          long int EXP)
  -- Function: void mpz_ui_pow_ui (mpz_t ROP, unsigned long int BASE,
           unsigned long int EXP)
      Set ROP to BASE raised to EXP.  The case 0^0 yields 1.
@@ -2556,27 +2579,28 @@ File: gmp.info,  Node: Integer Roots,  Next: Number Theoretic Functions,  Prev:
 5.8 Root Extraction Functions
 =============================
 
- -- Function: int mpz_root (mpz_t ROP, mpz_t OP, unsigned long int N)
+ -- Function: int mpz_root (mpz_t ROP, const mpz_t OP, unsigned long
+          int N)
      Set ROP to  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: void mpz_rootrem (mpz_t ROOT, mpz_t REM, mpz_t U,
+ -- Function: void mpz_rootrem (mpz_t ROOT, mpz_t REM, const mpz_t U,
           unsigned long int N)
      Set ROOT to  the truncated integer part of the Nth root of U.  Set
      REM to the remainder, U-ROOT**N.
 
- -- Function: void mpz_sqrt (mpz_t ROP, mpz_t OP)
+ -- Function: void mpz_sqrt (mpz_t ROP, const mpz_t OP)
      Set ROP to  the truncated integer part of the square root of OP.
 
- -- Function: void mpz_sqrtrem (mpz_t ROP1, mpz_t ROP2, mpz_t OP)
+ -- Function: void mpz_sqrtrem (mpz_t ROP1, mpz_t ROP2, const mpz_t OP)
      Set ROP1 to the truncated integer part of the square root of OP,
      like `mpz_sqrt'.  Set ROP2 to the remainder OP-ROP1*ROP1, which
      will be zero if OP is a perfect square.
 
      If ROP1 and ROP2 are the same variable, the results are undefined.
 
- -- Function: int mpz_perfect_power_p (mpz_t OP)
+ -- Function: int mpz_perfect_power_p (const mpz_t OP)
      Return non-zero if OP is a perfect power, i.e., if there exist
      integers A and B, with B>1, such that OP equals A raised to the
      power B.
@@ -2585,7 +2609,7 @@ File: gmp.info,  Node: Integer Roots,  Next: Number Theoretic Functions,  Prev:
      powers.  Negative values of OP are accepted, but of course can
      only be odd perfect powers.
 
- -- Function: int mpz_perfect_square_p (mpz_t OP)
+ -- Function: int mpz_perfect_square_p (const mpz_t OP)
      Return non-zero if OP is a perfect square, i.e., if the square
      root of OP is an integer.  Under this definition both 0 and 1 are
      considered to be perfect squares.
@@ -2596,7 +2620,7 @@ File: gmp.info,  Node: Number Theoretic Functions,  Next: Integer Comparisons,
 5.9 Number Theoretic Functions
 ==============================
 
- -- Function: int mpz_probab_prime_p (mpz_t N, int REPS)
+ -- Function: int mpz_probab_prime_p (const mpz_t N, int REPS)
      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.
@@ -2614,20 +2638,20 @@ File: gmp.info,  Node: Number Theoretic Functions,  Next: Integer Comparisons,
      few composites pass, hence those which pass are considered
      probably prime.
 
- -- Function: void mpz_nextprime (mpz_t ROP, mpz_t OP)
+ -- Function: void mpz_nextprime (mpz_t ROP, const mpz_t OP)
      Set ROP to the next prime greater than OP.
 
      This function uses a probabilistic algorithm to identify primes.
      For practical purposes it's adequate, the chance of a composite
      passing will be extremely small.
 
- -- Function: void mpz_gcd (mpz_t ROP, mpz_t OP1, mpz_t OP2)
+ -- Function: void mpz_gcd (mpz_t ROP, const mpz_t OP1, const mpz_t OP2)
      Set ROP to the greatest common divisor of OP1 and OP2.  The result
      is always positive even if one or both input operands are negative.
      Except if both inputs are zero; then this function defines
      gcd(0,0) = 0.
 
- -- Function: unsigned long int mpz_gcd_ui (mpz_t ROP, mpz_t OP1,
+ -- Function: unsigned long int mpz_gcd_ui (mpz_t ROP, const mpz_t OP1,
           unsigned long int OP2)
      Compute the greatest common divisor of OP1 and OP2.  If ROP is not
      `NULL', store the result there.
@@ -2637,8 +2661,8 @@ File: gmp.info,  Node: Number Theoretic Functions,  Next: Integer Comparisons,
      result is equal to the argument OP1.  Note that the result will
      always fit if OP2 is non-zero.
 
- -- Function: void mpz_gcdext (mpz_t G, mpz_t S, mpz_t T, mpz_t A,
-          mpz_t B)
+ -- Function: void mpz_gcdext (mpz_t G, mpz_t S, mpz_t T, const mpz_t
+          A, const mpz_t B)
      Set G to the greatest common divisor of A and B, and in addition
      set S and T to coefficients satisfying A*S + B*T = G.  The value
      in G is always positive, even if one or both of A and B are
@@ -2657,32 +2681,34 @@ File: gmp.info,  Node: Number Theoretic Functions,  Next: Integer Comparisons,
 
      If T is `NULL' then that value is not computed.
 
- -- 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: void mpz_lcm (mpz_t ROP, const mpz_t OP1, const mpz_t OP2)
+ -- Function: void mpz_lcm_ui (mpz_t ROP, const mpz_t OP1, unsigned
+          long OP2)
      Set ROP to the least common multiple of OP1 and OP2.  ROP is
      always positive, irrespective of the signs of OP1 and OP2.  ROP
      will be zero if either OP1 or OP2 is zero.
 
- -- Function: int mpz_invert (mpz_t ROP, mpz_t OP1, mpz_t OP2)
+ -- Function: int mpz_invert (mpz_t ROP, const mpz_t OP1, const mpz_t
+          OP2)
      Compute the inverse of OP1 modulo OP2 and put the result in ROP.
      If the inverse exists, the return value is non-zero and ROP will
      satisfy 0 < ROP < abs(OP2).  If an inverse doesn't exist the
      return value is zero and ROP is undefined.  The behaviour of this
      function is undefined when OP2 is zero.
 
- -- Function: int mpz_jacobi (mpz_t A, mpz_t B)
+ -- Function: int mpz_jacobi (const mpz_t A, const mpz_t B)
      Calculate the Jacobi symbol (A/B).  This is defined only for B odd.
 
- -- Function: int mpz_legendre (mpz_t A, mpz_t P)
+ -- Function: int mpz_legendre (const mpz_t A, const mpz_t P)
      Calculate the Legendre symbol (A/P).  This is defined only for P
      an odd positive prime, and for such P it's identical to the Jacobi
      symbol.
 
- -- 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: int mpz_kronecker (const mpz_t A, const mpz_t B)
+ -- Function: int mpz_kronecker_si (const mpz_t A, long B)
+ -- Function: int mpz_kronecker_ui (const mpz_t A, unsigned long B)
+ -- Function: int mpz_si_kronecker (long A, const mpz_t B)
+ -- Function: int mpz_ui_kronecker (unsigned long A, const mpz_t B)
      Calculate the Jacobi symbol (A/B) with the Kronecker extension
      (a/2)=(2/a) when a odd, or (a/2)=0 when a even.
 
@@ -2694,7 +2720,8 @@ File: gmp.info,  Node: Number Theoretic Functions,  Next: Integer Comparisons,
      References::), or any number theory textbook.  See also the
      example program `demos/qcn.c' which uses `mpz_kronecker_ui'.
 
- -- Function: mp_bitcnt_t mpz_remove (mpz_t ROP, mpz_t OP, mpz_t F)
+ -- Function: mp_bitcnt_t mpz_remove (mpz_t ROP, const mpz_t OP, const
+          mpz_t F)
      Remove all occurrences of the factor F from OP and store the
      result in ROP.  The return value is how many such occurrences were
      removed.
@@ -2711,7 +2738,8 @@ File: gmp.info,  Node: Number Theoretic Functions,  Next: Integer Comparisons,
      Set ROP to the primorial of N, i.e. the product of all positive
      prime numbers <=N.
 
- -- Function: void mpz_bin_ui (mpz_t ROP, mpz_t N, unsigned long int K)
+ -- Function: void mpz_bin_ui (mpz_t ROP, const mpz_t N, unsigned long
+          int K)
  -- Function: void mpz_bin_uiui (mpz_t ROP, unsigned long int N,
           unsigned long int K)
      Compute the binomial coefficient N over K and store the result in
@@ -2753,10 +2781,10 @@ File: gmp.info,  Node: Integer Comparisons,  Next: Integer Logic and Bit Fiddlin
 5.10 Comparison Functions
 =========================
 
- -- Function: int mpz_cmp (mpz_t OP1, mpz_t OP2)
- -- Function: int mpz_cmp_d (mpz_t OP1, double OP2)
- -- Macro: int mpz_cmp_si (mpz_t OP1, signed long int OP2)
- -- Macro: int mpz_cmp_ui (mpz_t OP1, unsigned long int OP2)
+ -- Function: int mpz_cmp (const mpz_t OP1, const mpz_t OP2)
+ -- Function: int mpz_cmp_d (const mpz_t OP1, double OP2)
+ -- Macro: int mpz_cmp_si (const mpz_t OP1, signed long int OP2)
+ -- Macro: int mpz_cmp_ui (const mpz_t OP1, unsigned long int OP2)
      Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero
      if OP1 = OP2, or a negative value if OP1 < OP2.
 
@@ -2764,9 +2792,9 @@ File: gmp.info,  Node: Integer Comparisons,  Next: Integer Logic and Bit Fiddlin
      arguments more than once.  `mpz_cmp_d' can be called with an
      infinity, but results are undefined for a NaN.
 
- -- 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: int mpz_cmpabs (const mpz_t OP1, const mpz_t OP2)
+ -- Function: int mpz_cmpabs_d (const mpz_t OP1, double OP2)
+ -- Function: int mpz_cmpabs_ui (const mpz_t OP1, unsigned long int OP2)
      Compare the absolute values of OP1 and OP2.  Return a positive
      value if abs(OP1) > abs(OP2), zero if abs(OP1) = abs(OP2), or a
      negative value if abs(OP1) < abs(OP2).
@@ -2774,7 +2802,7 @@ File: gmp.info,  Node: Integer Comparisons,  Next: Integer Logic and Bit Fiddlin
      `mpz_cmpabs_d' can be called with an infinity, but results are
      undefined for a NaN.
 
- -- Macro: int mpz_sgn (mpz_t OP)
+ -- Macro: int mpz_sgn (const mpz_t OP)
      Return +1 if OP > 0, 0 if OP = 0, and -1 if OP < 0.
 
      This function is actually implemented as a macro.  It evaluates
@@ -2790,25 +2818,25 @@ These functions behave as if twos complement arithmetic were used
 (although sign-magnitude is the actual implementation).  The least
 significant bit is number 0.
 
- -- Function: void mpz_and (mpz_t ROP, mpz_t OP1, mpz_t OP2)
+ -- Function: void mpz_and (mpz_t ROP, const mpz_t OP1, const mpz_t OP2)
      Set ROP to OP1 bitwise-and OP2.
 
- -- Function: void mpz_ior (mpz_t ROP, mpz_t OP1, mpz_t OP2)
+ -- Function: void mpz_ior (mpz_t ROP, const mpz_t OP1, const mpz_t OP2)
      Set ROP to OP1 bitwise inclusive-or OP2.
 
- -- Function: void mpz_xor (mpz_t ROP, mpz_t OP1, mpz_t OP2)
+ -- Function: void mpz_xor (mpz_t ROP, const mpz_t OP1, const mpz_t OP2)
      Set ROP to OP1 bitwise exclusive-or OP2.
 
- -- Function: void mpz_com (mpz_t ROP, mpz_t OP)
+ -- Function: void mpz_com (mpz_t ROP, const mpz_t OP)
      Set ROP to the one's complement of OP.
 
- -- Function: mp_bitcnt_t mpz_popcount (mpz_t OP)
+ -- Function: mp_bitcnt_t mpz_popcount (const mpz_t OP)
      If OP>=0, return the population count of OP, which is the number
      of 1 bits in the binary representation.  If OP<0, the number of 1s
      is infinite, and the return value is the largest possible
      `mp_bitcnt_t'.
 
- -- Function: mp_bitcnt_t mpz_hamdist (mpz_t OP1, mpz_t OP2)
+ -- Function: mp_bitcnt_t mpz_hamdist (const mpz_t OP1, const mpz_t OP2)
      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.  If one
@@ -2816,8 +2844,10 @@ significant bit is number 0.
      is infinite, and the return value is the largest possible
      `mp_bitcnt_t'.
 
- -- Function: mp_bitcnt_t mpz_scan0 (mpz_t OP, mp_bitcnt_t STARTING_BIT)
- -- Function: mp_bitcnt_t mpz_scan1 (mpz_t OP, mp_bitcnt_t STARTING_BIT)
+ -- Function: mp_bitcnt_t mpz_scan0 (const mpz_t OP, mp_bitcnt_t
+          STARTING_BIT)
+ -- Function: mp_bitcnt_t mpz_scan1 (const mpz_t OP, mp_bitcnt_t
+          STARTING_BIT)
      Scan OP, starting from bit STARTING_BIT, towards more significant
      bits, until the first 0 or 1 bit (respectively) is found.  Return
      the index of the found bit.
@@ -2839,7 +2869,7 @@ significant bit is number 0.
  -- Function: void mpz_combit (mpz_t ROP, mp_bitcnt_t BIT_INDEX)
      Complement bit BIT_INDEX in ROP.
 
- -- Function: int mpz_tstbit (mpz_t OP, mp_bitcnt_t BIT_INDEX)
+ -- Function: int mpz_tstbit (const mpz_t OP, mp_bitcnt_t BIT_INDEX)
      Test bit BIT_INDEX in OP and return 0 or 1 accordingly.
 
 
@@ -2859,7 +2889,8 @@ prototypes for these functions.
 
    See also *note Formatted Output:: and *note Formatted Input::.
 
- -- Function: size_t mpz_out_str (FILE *STREAM, int BASE, mpz_t OP)
+ -- Function: size_t mpz_out_str (FILE *STREAM, int BASE, const mpz_t
+          OP)
      Output OP on stdio stream STREAM, as a string of digits in base
      BASE.  The base argument may vary from 2 to 62 or from -2 to -36.
 
@@ -2886,7 +2917,7 @@ prototypes for these functions.
 
      Return the number of bytes read, or if an error occurred, return 0.
 
- -- Function: size_t mpz_out_raw (FILE *STREAM, mpz_t OP)
+ -- Function: size_t mpz_out_raw (FILE *STREAM, const mpz_t OP)
      Output OP on stdio stream STREAM, in raw binary format.  The
      integer is written in a portable format, with 4 bytes of size
      information, and that many bytes of limbs.  Both the size and the
@@ -2933,7 +2964,7 @@ random number functions.
      before invoking this function.
 
  -- Function: void mpz_urandomm (mpz_t ROP, gmp_randstate_t STATE,
-          mpz_t N)
+          const mpz_t N)
      Generate a uniform random integer in the range 0 to N-1, inclusive.
 
      The variable STATE must be initialized by calling one of the
@@ -3014,7 +3045,7 @@ data with the following functions.
      instance `8*sizeof(int)-INT_BIT'.
 
  -- Function: void * mpz_export (void *ROP, size_t *COUNTP, int ORDER,
-          size_t SIZE, int ENDIAN, size_t NAILS, mpz_t OP)
+          size_t SIZE, int ENDIAN, size_t NAILS, const mpz_t OP)
      Fill ROP with word data from OP.
 
      The parameters specify the format of the data produced.  Each word
@@ -3061,23 +3092,23 @@ File: gmp.info,  Node: Miscellaneous Integer Functions,  Next: Integer Special F
 5.15 Miscellaneous Functions
 ============================
 
- -- 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: int mpz_fits_ulong_p (const mpz_t OP)
+ -- Function: int mpz_fits_slong_p (const mpz_t OP)
+ -- Function: int mpz_fits_uint_p (const mpz_t OP)
+ -- Function: int mpz_fits_sint_p (const mpz_t OP)
+ -- Function: int mpz_fits_ushort_p (const mpz_t OP)
+ -- Function: int mpz_fits_sshort_p (const mpz_t OP)
      Return non-zero iff the value of OP fits in an `unsigned long int',
      `signed long int', `unsigned int', `signed int', `unsigned short
      int', or `signed short int', respectively.  Otherwise, return zero.
 
- -- Macro: int mpz_odd_p (mpz_t OP)
- -- Macro: int mpz_even_p (mpz_t OP)
+ -- Macro: int mpz_odd_p (const mpz_t OP)
+ -- Macro: int mpz_even_p (const mpz_t OP)
      Determine whether OP is odd or even, respectively.  Return
      non-zero if yes, zero if no.  These macros evaluate their argument
      more than once.
 
- -- Function: size_t mpz_sizeinbase (mpz_t OP, int BASE)
+ -- Function: size_t mpz_sizeinbase (const mpz_t OP, int BASE)
      Return the size of OP measured in number of digits in the given
      BASE.  BASE can vary from 2 to 62.  The sign of OP is ignored,
      just the absolute value is used.  The result will be either exact
@@ -3153,7 +3184,7 @@ applications will not need them.
      changes like this.  `mpz_realloc2' and `_mpz_realloc' are the same
      except that `_mpz_realloc' takes its size in limbs.
 
- -- Function: mp_limb_t mpz_getlimbn (mpz_t OP, mp_size_t N)
+ -- Function: mp_limb_t mpz_getlimbn (const mpz_t OP, mp_size_t N)
      Return limb number N from OP.  The sign of OP is ignored, just the
      absolute value is used.  The least significant limb is number 0.
 
@@ -3161,7 +3192,7 @@ applications will not need them.
      `mpz_getlimbn' returns zero if N is outside the range 0 to
      `mpz_size(OP)-1'.
 
- -- Function: size_t mpz_size (mpz_t OP)
+ -- Function: size_t mpz_size (const mpz_t OP)
      Return the size of OP measured in number of limbs.  If OP is zero,
      the returned value will be zero.
 
@@ -3222,8 +3253,8 @@ File: gmp.info,  Node: Initializing Rationals,  Next: Rational Conversions,  Pre
      Free the space occupied by a NULL-terminated list of `mpq_t'
      variables.
 
- -- Function: void mpq_set (mpq_t ROP, mpq_t OP)
- -- Function: void mpq_set_z (mpq_t ROP, mpz_t OP)
+ -- Function: void mpq_set (mpq_t ROP, const mpq_t OP)
+ -- Function: void mpq_set_z (mpq_t ROP, const mpz_t OP)
      Assign ROP from OP.
 
  -- Function: void mpq_set_ui (mpq_t ROP, unsigned long int OP1,
@@ -3234,7 +3265,7 @@ File: gmp.info,  Node: Initializing Rationals,  Next: Rational Conversions,  Pre
      common factors, ROP has to be passed to `mpq_canonicalize' before
      any operations are performed on ROP.
 
- -- Function: int mpq_set_str (mpq_t ROP, char *STR, int BASE)
+ -- Function: int mpq_set_str (mpq_t ROP, const char *STR, int BASE)
      Set ROP from a null-terminated string STR in the given BASE.
 
      The string can be an integer like "41" or a fraction like
@@ -3263,7 +3294,7 @@ File: gmp.info,  Node: Rational Conversions,  Next: Rational Arithmetic,  Prev:
 6.2 Conversion Functions
 ========================
 
- -- Function: double mpq_get_d (mpq_t OP)
+ -- Function: double mpq_get_d (const mpq_t OP)
      Convert OP to a `double', truncating if necessary (i.e. rounding
      towards zero).
 
@@ -3274,11 +3305,11 @@ File: gmp.info,  Node: Rational Conversions,  Next: Rational Arithmetic,  Prev:
      may or may not occur.
 
  -- Function: void mpq_set_d (mpq_t ROP, double OP)
- -- Function: void mpq_set_f (mpq_t ROP, mpf_t OP)
+ -- Function: void mpq_set_f (mpq_t ROP, const mpf_t OP)
      Set ROP to the value of OP.  There is no rounding, this conversion
      is exact.
 
- -- Function: char * mpq_get_str (char *STR, int BASE, mpq_t OP)
+ -- Function: char * mpq_get_str (char *STR, int BASE, const mpq_t OP)
      Convert OP to a string of digits in base BASE.  The base may vary
      from 2 to 36.  The string will be of the form `num/den', or if the
      denominator is 1 then just `num'.
@@ -3306,34 +3337,37 @@ File: gmp.info,  Node: Rational Arithmetic,  Next: Comparing Rationals,  Prev: R
 6.3 Arithmetic Functions
 ========================
 
- -- Function: void mpq_add (mpq_t SUM, mpq_t ADDEND1, mpq_t ADDEND2)
+ -- Function: void mpq_add (mpq_t SUM, const mpq_t ADDEND1, const mpq_t
+          ADDEND2)
      Set SUM to ADDEND1 + ADDEND2.
 
- -- Function: void mpq_sub (mpq_t DIFFERENCE, mpq_t MINUEND, mpq_t
-          SUBTRAHEND)
+ -- Function: void mpq_sub (mpq_t DIFFERENCE, const mpq_t MINUEND,
+          const mpq_t SUBTRAHEND)
      Set DIFFERENCE to MINUEND - SUBTRAHEND.
 
- -- Function: void mpq_mul (mpq_t PRODUCT, mpq_t MULTIPLIER, mpq_t
-          MULTIPLICAND)
+ -- Function: void mpq_mul (mpq_t PRODUCT, const mpq_t MULTIPLIER,
+          const mpq_t MULTIPLICAND)
      Set PRODUCT to MULTIPLIER times MULTIPLICAND.
 
- -- Function: void mpq_mul_2exp (mpq_t ROP, mpq_t OP1, mp_bitcnt_t OP2)
+ -- Function: void mpq_mul_2exp (mpq_t ROP, const mpq_t OP1,
+          mp_bitcnt_t OP2)
      Set ROP to OP1 times 2 raised to OP2.
 
- -- Function: void mpq_div (mpq_t QUOTIENT, mpq_t DIVIDEND, mpq_t
-          DIVISOR)
+ -- Function: void mpq_div (mpq_t QUOTIENT, const mpq_t DIVIDEND, const
+          mpq_t DIVISOR)
      Set QUOTIENT to DIVIDEND/DIVISOR.
 
- -- Function: void mpq_div_2exp (mpq_t ROP, mpq_t OP1, mp_bitcnt_t OP2)
+ -- Function: void mpq_div_2exp (mpq_t ROP, const mpq_t OP1,
+          mp_bitcnt_t OP2)
      Set ROP to OP1 divided by 2 raised to OP2.
 
- -- Function: void mpq_neg (mpq_t NEGATED_OPERAND, mpq_t OPERAND)
+ -- Function: void mpq_neg (mpq_t NEGATED_OPERAND, const mpq_t OPERAND)
      Set NEGATED_OPERAND to -OPERAND.
 
- -- Function: void mpq_abs (mpq_t ROP, mpq_t OP)
+ -- Function: void mpq_abs (mpq_t ROP, const mpq_t OP)
      Set ROP to the absolute value of OP.
 
- -- Function: void mpq_inv (mpq_t INVERTED_NUMBER, mpq_t NUMBER)
+ -- Function: void mpq_inv (mpq_t INVERTED_NUMBER, const mpq_t NUMBER)
      Set INVERTED_NUMBER to 1/NUMBER.  If the new denominator is zero,
      this routine will divide by zero.
 
@@ -3343,17 +3377,17 @@ File: gmp.info,  Node: Comparing Rationals,  Next: Applying Integer Functions,
 6.4 Comparison Functions
 ========================
 
- -- Function: int mpq_cmp (mpq_t OP1, mpq_t OP2)
+ -- Function: int mpq_cmp (const mpq_t OP1, const mpq_t OP2)
      Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero
      if OP1 = OP2, and a negative value if OP1 < OP2.
 
      To determine if two rationals are equal, `mpq_equal' is faster than
      `mpq_cmp'.
 
- -- Macro: int mpq_cmp_ui (mpq_t OP1, unsigned long int NUM2, unsigned
+ -- Macro: int mpq_cmp_ui (const mpq_t OP1, unsigned long int NUM2,
+          unsigned long int DEN2)
+ -- Macro: int mpq_cmp_si (const mpq_t OP1, long int NUM2, unsigned
           long int DEN2)
- -- Macro: int mpq_cmp_si (mpq_t OP1, long int NUM2, unsigned long int
-          DEN2)
      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.
@@ -3363,13 +3397,13 @@ File: gmp.info,  Node: Comparing Rationals,  Next: Applying Integer Functions,
      These functions are implemented as a macros and evaluate their
      arguments multiple times.
 
- -- Macro: int mpq_sgn (mpq_t OP)
+ -- Macro: int mpq_sgn (const mpq_t OP)
      Return +1 if OP > 0, 0 if OP = 0, and -1 if OP < 0.
 
      This function is actually implemented as a macro.  It evaluates its
      argument multiple times.
 
- -- Function: int mpq_equal (mpq_t OP1, mpq_t OP2)
+ -- Function: int mpq_equal (const mpq_t OP1, const mpq_t OP2)
      Return non-zero if OP1 and OP2 are equal, zero if they are
      non-equal.  Although `mpq_cmp' can be used for the same purpose,
      this function is much faster.
@@ -3390,16 +3424,16 @@ this chapter (*note Rational Number Functions::) then
 `mpq_canonicalize' must be called before any other `mpq' functions are
 applied to that `mpq_t'.
 
- -- Macro: mpz_t mpq_numref (mpq_t OP)
- -- Macro: mpz_t mpq_denref (mpq_t OP)
+ -- Macro: mpz_t mpq_numref (const mpq_t OP)
+ -- Macro: mpz_t mpq_denref (const mpq_t OP)
      Return a reference to the numerator and denominator of OP,
      respectively.  The `mpz' functions can be used on the result of
      these macros.
 
- -- Function: void mpq_get_num (mpz_t NUMERATOR, mpq_t RATIONAL)
- -- Function: void mpq_get_den (mpz_t DENOMINATOR, mpq_t RATIONAL)
- -- Function: void mpq_set_num (mpq_t RATIONAL, mpz_t NUMERATOR)
- -- Function: void mpq_set_den (mpq_t RATIONAL, mpz_t DENOMINATOR)
+ -- Function: void mpq_get_num (mpz_t NUMERATOR, const mpq_t RATIONAL)
+ -- Function: void mpq_get_den (mpz_t DENOMINATOR, const mpq_t RATIONAL)
+ -- Function: void mpq_set_num (mpq_t RATIONAL, const mpz_t NUMERATOR)
+ -- Function: void mpq_set_den (mpq_t RATIONAL, const mpz_t DENOMINATOR)
      Get or set the numerator or denominator of a rational.  These
      functions are equivalent to calling `mpz_set' with an appropriate
      `mpq_numref' or `mpq_denref'.  Direct use of `mpq_numref' or
@@ -3422,7 +3456,8 @@ prototypes for these functions.
 
    See also *note Formatted Output:: and *note Formatted Input::.
 
- -- Function: size_t mpq_out_str (FILE *STREAM, int BASE, mpq_t OP)
+ -- Function: size_t mpq_out_str (FILE *STREAM, int BASE, const mpq_t
+          OP)
      Output OP on stdio stream STREAM, as a string of digits in base
      BASE.  The base may vary from 2 to 36.  Output is in the form
      `num/den' or if the denominator is 1 then just `num'.
@@ -3577,7 +3612,7 @@ precision gradually in iterative algorithms like Newton-Raphson, making
 the computation precision closely match the actual accurate part of the
 numbers.
 
- -- Function: mp_bitcnt_t mpf_get_prec (mpf_t OP)
+ -- Function: mp_bitcnt_t mpf_get_prec (const mpf_t OP)
      Return the current precision of OP, in bits.
 
  -- Function: void mpf_set_prec (mpf_t ROP, mp_bitcnt_t PREC)
@@ -3622,15 +3657,15 @@ File: gmp.info,  Node: Assigning Floats,  Next: Simultaneous Float Init & Assign
 These functions assign new values to already initialized floats (*note
 Initializing Floats::).
 
- -- Function: void mpf_set (mpf_t ROP, mpf_t OP)
+ -- Function: void mpf_set (mpf_t ROP, const mpf_t OP)
  -- Function: void mpf_set_ui (mpf_t ROP, unsigned long int OP)
  -- Function: void mpf_set_si (mpf_t ROP, signed long int OP)
  -- Function: void mpf_set_d (mpf_t ROP, double OP)
- -- Function: void mpf_set_z (mpf_t ROP, mpz_t OP)
- -- Function: void mpf_set_q (mpf_t ROP, mpq_t OP)
+ -- Function: void mpf_set_z (mpf_t ROP, const mpz_t OP)
+ -- Function: void mpf_set_q (mpf_t ROP, const mpq_t OP)
      Set the value of ROP from OP.
 
- -- Function: int mpf_set_str (mpf_t ROP, char *STR, int BASE)
+ -- Function: int mpf_set_str (mpf_t ROP, const char *STR, int BASE)
      Set the value of ROP from the string in STR.  The string is of the
      form `M@N' or, if the base is 10 or less, alternatively `MeN'.
      `M' is the mantissa and `N' is the exponent.  The mantissa is
@@ -3683,7 +3718,7 @@ functions, it can be used as the source or destination operand for the
 ordinary float functions.  Don't use an initialize-and-set function on
 a variable already initialized!
 
- -- Function: void mpf_init_set (mpf_t ROP, mpf_t OP)
+ -- Function: void mpf_init_set (mpf_t ROP, const mpf_t OP)
  -- Function: void mpf_init_set_ui (mpf_t ROP, unsigned long int OP)
  -- Function: void mpf_init_set_si (mpf_t ROP, signed long int OP)
  -- Function: void mpf_init_set_d (mpf_t ROP, double OP)
@@ -3692,7 +3727,8 @@ a variable already initialized!
      The precision of ROP will be taken from the active default
      precision, as set by `mpf_set_default_prec'.
 
- -- Function: int mpf_init_set_str (mpf_t ROP, char *STR, int BASE)
+ -- Function: int mpf_init_set_str (mpf_t ROP, const char *STR, int
+          BASE)
      Initialize ROP and set its value from the string in STR.  See
      `mpf_set_str' above for details on the assignment operation.
 
@@ -3708,7 +3744,7 @@ File: gmp.info,  Node: Converting Floats,  Next: Float Arithmetic,  Prev: Simult
 7.4 Conversion Functions
 ========================
 
- -- Function: double mpf_get_d (mpf_t OP)
+ -- Function: double mpf_get_d (const mpf_t OP)
      Convert OP to a `double', truncating if necessary (i.e. rounding
      towards zero).
 
@@ -3717,7 +3753,8 @@ File: gmp.info,  Node: Converting Floats,  Next: Float Arithmetic,  Prev: Simult
      returned when available.  For too small 0.0 is normally returned.
      Hardware overflow, underflow and denorm traps may or may not occur.
 
- -- Function: double mpf_get_d_2exp (signed long int *EXP, mpf_t OP)
+ -- Function: double mpf_get_d_2exp (signed long int *EXP, const mpf_t
+          OP)
      Convert OP to a `double', truncating if necessary (i.e. rounding
      towards zero), and with an exponent returned separately.
 
@@ -3728,8 +3765,8 @@ File: gmp.info,  Node: Converting Floats,  Next: Float Arithmetic,  Prev: Simult
      This is similar to the standard C `frexp' function (*note
      Normalization Functions: (libc)Normalization Functions.).
 
- -- Function: long mpf_get_si (mpf_t OP)
- -- Function: unsigned long mpf_get_ui (mpf_t OP)
+ -- Function: long mpf_get_si (const mpf_t OP)
+ -- Function: unsigned long mpf_get_ui (const mpf_t OP)
      Convert OP to a `long' or `unsigned long', truncating any fraction
      part.  If OP is too big for the return type, the result is
      undefined.
@@ -3738,7 +3775,7 @@ File: gmp.info,  Node: Converting Floats,  Next: Float Arithmetic,  Prev: Simult
      Miscellaneous Float Functions::).
 
  -- Function: char * mpf_get_str (char *STR, mp_exp_t *EXPPTR, int
-          BASE, size_t N_DIGITS, mpf_t OP)
+          BASE, size_t N_DIGITS, const mpf_t OP)
      Convert OP to a string of digits in base BASE.  The base argument
      may vary from 2 to 62 or from -2 to -36.  Up to N_DIGITS digits
      will be generated.  Trailing zeros are not returned.  No more
@@ -3779,21 +3816,21 @@ File: gmp.info,  Node: Float Arithmetic,  Next: Float Comparison,  Prev: Convert
 7.5 Arithmetic Functions
 ========================
 
- -- Function: void mpf_add (mpf_t ROP, mpf_t OP1, mpf_t OP2)
- -- Function: void mpf_add_ui (mpf_t ROP, mpf_t OP1, unsigned long int
-          OP2)
+ -- Function: void mpf_add (mpf_t ROP, const mpf_t OP1, const mpf_t OP2)
+ -- Function: void mpf_add_ui (mpf_t ROP, const mpf_t OP1, unsigned
+          long int OP2)
      Set ROP to OP1 + OP2.
 
- -- Function: void mpf_sub (mpf_t ROP, mpf_t OP1, mpf_t OP2)
- -- Function: void mpf_ui_sub (mpf_t ROP, unsigned long int OP1, mpf_t
-          OP2)
- -- Function: void mpf_sub_ui (mpf_t ROP, mpf_t OP1, unsigned long int
-          OP2)
+ -- Function: void mpf_sub (mpf_t ROP, const mpf_t OP1, const mpf_t OP2)
+ -- Function: void mpf_ui_sub (mpf_t ROP, unsigned long int OP1, const
+          mpf_t OP2)
+ -- Function: void mpf_sub_ui (mpf_t ROP, const mpf_t OP1, unsigned
+          long int OP2)
      Set ROP to OP1 - OP2.
 
- -- Function: void mpf_mul (mpf_t ROP, mpf_t OP1, mpf_t OP2)
- -- Function: void mpf_mul_ui (mpf_t ROP, mpf_t OP1, unsigned long int
-          OP2)
+ -- Function: void mpf_mul (mpf_t ROP, const mpf_t OP1, const mpf_t OP2)
+ -- Function: void mpf_mul_ui (mpf_t ROP, const mpf_t OP1, unsigned
+          long int OP2)
      Set ROP to OP1 times OP2.
 
    Division is undefined if the divisor is zero, and passing a zero
@@ -3801,31 +3838,33 @@ divisor to the divide functions will make these functions intentionally
 divide by zero.  This lets the user handle arithmetic exceptions in
 these functions in the same manner as other arithmetic exceptions.
 
- -- Function: void mpf_div (mpf_t ROP, mpf_t OP1, mpf_t OP2)
- -- Function: void mpf_ui_div (mpf_t ROP, unsigned long int OP1, mpf_t
-          OP2)
- -- Function: void mpf_div_ui (mpf_t ROP, mpf_t OP1, unsigned long int
-          OP2)
+ -- Function: void mpf_div (mpf_t ROP, const mpf_t OP1, const mpf_t OP2)
+ -- Function: void mpf_ui_div (mpf_t ROP, unsigned long int OP1, const
+          mpf_t OP2)
+ -- Function: void mpf_div_ui (mpf_t ROP, const mpf_t OP1, unsigned
+          long int OP2)
      Set ROP to OP1/OP2.
 
- -- Function: void mpf_sqrt (mpf_t ROP, mpf_t OP)
+ -- Function: void mpf_sqrt (mpf_t ROP, const mpf_t OP)
  -- Function: void mpf_sqrt_ui (mpf_t ROP, unsigned long int OP)
      Set ROP to the square root of OP.
 
- -- Function: void mpf_pow_ui (mpf_t ROP, mpf_t OP1, unsigned long int
-          OP2)
+ -- Function: void mpf_pow_ui (mpf_t ROP, const mpf_t OP1, unsigned
+          long int OP2)
      Set ROP to OP1 raised to the power OP2.
 
- -- Function: void mpf_neg (mpf_t ROP, mpf_t OP)
+ -- Function: void mpf_neg (mpf_t ROP, const mpf_t OP)
      Set ROP to -OP.
 
- -- Function: void mpf_abs (mpf_t ROP, mpf_t OP)
+ -- Function: void mpf_abs (mpf_t ROP, const mpf_t OP)
      Set ROP to the absolute value of OP.
 
- -- Function: void mpf_mul_2exp (mpf_t ROP, mpf_t OP1, mp_bitcnt_t OP2)
+ -- Function: void mpf_mul_2exp (mpf_t ROP, const mpf_t OP1,
+          mp_bitcnt_t OP2)
      Set ROP to OP1 times 2 raised to OP2.
 
- -- Function: void mpf_div_2exp (mpf_t ROP, mpf_t OP1, mp_bitcnt_t OP2)
+ -- Function: void mpf_div_2exp (mpf_t ROP, const mpf_t OP1,
+          mp_bitcnt_t OP2)
      Set ROP to OP1 divided by 2 raised to OP2.
 
 
@@ -3834,17 +3873,18 @@ File: gmp.info,  Node: Float Comparison,  Next: I/O of Floats,  Prev: Float Arit
 7.6 Comparison Functions
 ========================
 
- -- Function: int mpf_cmp (mpf_t OP1, mpf_t OP2)
- -- Function: int mpf_cmp_d (mpf_t OP1, double OP2)
- -- Function: int mpf_cmp_ui (mpf_t OP1, unsigned long int OP2)
- -- Function: int mpf_cmp_si (mpf_t OP1, signed long int OP2)
+ -- Function: int mpf_cmp (const mpf_t OP1, const mpf_t OP2)
+ -- Function: int mpf_cmp_d (const mpf_t OP1, double OP2)
+ -- Function: int mpf_cmp_ui (const mpf_t OP1, unsigned long int OP2)
+ -- Function: int mpf_cmp_si (const mpf_t OP1, signed long int OP2)
      Compare OP1 and OP2.  Return a positive value if OP1 > OP2, zero
      if OP1 = OP2, and a negative value if OP1 < OP2.
 
      `mpf_cmp_d' can be called with an infinity, but results are
      undefined for a NaN.
 
- -- Function: int mpf_eq (mpf_t OP1, mpf_t OP2, mp_bitcnt_t op3)
+ -- Function: int mpf_eq (const mpf_t OP1, const mpf_t OP2, mp_bitcnt_t
+          op3)
      Return non-zero if the first OP3 bits of OP1 and OP2 are equal,
      zero otherwise.  I.e., test if OP1 and OP2 are approximately equal.
 
@@ -3856,11 +3896,12 @@ File: gmp.info,  Node: Float Comparison,  Next: I/O of Floats,  Prev: Float Arit
      bits.  Such numbers are really just one ulp off, and should be
      considered equal.
 
- -- Function: void mpf_reldiff (mpf_t ROP, mpf_t OP1, mpf_t OP2)
+ -- Function: void mpf_reldiff (mpf_t ROP, const mpf_t OP1, const mpf_t
+          OP2)
      Compute the relative difference between OP1 and OP2 and store the
      result in ROP.  This is abs(OP1-OP2)/OP1.
 
- -- Macro: int mpf_sgn (mpf_t OP)
+ -- Macro: int mpf_sgn (const mpf_t OP)
      Return +1 if OP > 0, 0 if OP = 0, and -1 if OP < 0.
 
      This function is actually implemented as a macro.  It evaluates
@@ -3884,7 +3925,7 @@ prototypes for these functions.
    See also *note Formatted Output:: and *note Formatted Input::.
 
  -- Function: size_t mpf_out_str (FILE *STREAM, int BASE, size_t
-          N_DIGITS, mpf_t OP)
+          N_DIGITS, const mpf_t OP)
      Print OP to STREAM, as a string of digits.  Return the number of
      bytes written, or if an error occurred, return 0.
 
@@ -3929,22 +3970,22 @@ File: gmp.info,  Node: Miscellaneous Float Functions,  Prev: I/O of Floats,  Up:
 7.8 Miscellaneous Functions
 ===========================
 
- -- Function: void mpf_ceil (mpf_t ROP, mpf_t OP)
- -- Function: void mpf_floor (mpf_t ROP, mpf_t OP)
- -- Function: void mpf_trunc (mpf_t ROP, mpf_t OP)
+ -- Function: void mpf_ceil (mpf_t ROP, const mpf_t OP)
+ -- Function: void mpf_floor (mpf_t ROP, const mpf_t OP)
+ -- Function: void mpf_trunc (mpf_t ROP, const mpf_t OP)
      Set ROP to OP rounded to an integer.  `mpf_ceil' rounds to the
      next higher integer, `mpf_floor' to the next lower, and `mpf_trunc'
      to the integer towards zero.
 
- -- Function: int mpf_integer_p (mpf_t OP)
+ -- Function: int mpf_integer_p (const mpf_t OP)
      Return non-zero if OP is an integer.
 
- -- Function: int mpf_fits_ulong_p (mpf_t OP)
- -- Function: int mpf_fits_slong_p (mpf_t OP)
- -- Function: int mpf_fits_uint_p (mpf_t OP)
- -- Function: int mpf_fits_sint_p (mpf_t OP)
- -- Function: int mpf_fits_ushort_p (mpf_t OP)
- -- Function: int mpf_fits_sshort_p (mpf_t OP)
+ -- Function: int mpf_fits_ulong_p (const mpf_t OP)
+ -- Function: int mpf_fits_slong_p (const mpf_t OP)
+ -- Function: int mpf_fits_uint_p (const mpf_t OP)
+ -- Function: int mpf_fits_sint_p (const mpf_t OP)
+ -- Function: int mpf_fits_ushort_p (const mpf_t OP)
+ -- Function: int mpf_fits_sshort_p (const mpf_t OP)
      Return non-zero if OP would fit in the respective C data type, when
      truncated to an integer.
 
@@ -4559,8 +4600,8 @@ File: gmp.info,  Node: Random State Initialization,  Next: Random State Seeding,
      Initialize STATE for a Mersenne Twister algorithm.  This algorithm
      is fast and has good randomness properties.
 
- -- Function: void gmp_randinit_lc_2exp (gmp_randstate_t STATE, mpz_t
-          A, unsigned long C, mp_bitcnt_t M2EXP)
+ -- Function: void gmp_randinit_lc_2exp (gmp_randstate_t STATE, const
+          mpz_t A, unsigned long C, mp_bitcnt_t M2EXP)
      Initialize STATE with a linear congruential algorithm X = (A*X +
      C) mod 2^M2EXP.
 
@@ -4613,7 +4654,8 @@ File: gmp.info,  Node: Random State Seeding,  Next: Random State Miscellaneous,
 9.2 Random State Seeding
 ========================
 
- -- Function: void gmp_randseed (gmp_randstate_t STATE, mpz_t SEED)
+ -- Function: void gmp_randseed (gmp_randstate_t STATE, const mpz_t
+          SEED)
  -- Function: void gmp_randseed_ui (gmp_randstate_t STATE,
           unsigned long int SEED)
      Set an initial seed value into STATE.
@@ -7028,31 +7070,6 @@ Lehmer's algorithm is used for the rest of the work.
    The asymptotic running time of both HGCD and GCD is O(M(N)*log(N)),
 where M(N) is the time for multiplying two N-limb numbers.
 
-
-File: gmp.info,  Node: Extended GCD,  Next: Jacobi Symbol,  Prev: Subquadratic GCD,  Up: Greatest Common Divisor Algorithms
-
-15.3.4 Extended GCD
--------------------
-
-The extended GCD function, or GCDEXT, calculates gcd(a,b) and also
-cofactors x and y satisfying a*x+b*y=gcd(a,b). All the algorithms used
-for plain GCD are extended to handle this case. The binary algorithm is
-used only for single-limb GCDEXT.  Lehmer's algorithm is used for sizes
-up to `GCDEXT_DC_THRESHOLD'. Above this threshold, GCDEXT is
-implemented as a loop around HGCD, but with more book-keeping to keep
-track of the cofactors. This gives the same asymptotic running time as
-for GCD and HGCD, O(M(N)*log(N))
-
-   One difference to plain GCD is that while the inputs a and b are
-reduced as the algorithm proceeds, the cofactors x and y grow in size.
-This makes the tuning of the chopping-point more difficult. The current
-code chops off the most significant half of the inputs for the call to
-HGCD in the first iteration, and the most significant two thirds for
-the remaining calls. This strategy could surely be improved. Also the
-stop condition for the loop, where Lehmer's algorithm is invoked once
-the inputs are reduced below `GCDEXT_DC_THRESHOLD', could maybe be
-improved by taking into account the current size of the cofactors.
-
 
 
 Local Variables: