contrib/libgmp/gmp.h

   1 /* gmp.h -- Definitions for GNU multiple precision functions.
   2
   3 Copyright (C) 1991, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
   4
   5 This file is part of the GNU MP Library.
   6
   7 The GNU MP Library is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU Library General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or (at your
  10 option) any later version.
  11
  12 The GNU MP Library is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
  15 License for more details.
  16
  17 You should have received a copy of the GNU Library General Public License
  18 along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  20 MA 02111-1307, USA. */
  21
  22 #ifndef __GMP_H__
  23
  24 #ifndef __GNU_MP__
  25 #define __GNU_MP__ 2
  26 #define __need_size_t
  27 #include <stddef.h>
  28 #undef __need_size_t
  29
  30 #if defined (__STDC__) || defined (__cplusplus)
  31 #define __gmp_const const
  32 #else
  33 #define __gmp_const
  34 #endif
  35
  36 #if defined (__GNUC__)
  37 #define __gmp_inline __inline__
  38 #else
  39 #define __gmp_inline
  40 #endif
  41
  42 #ifndef _EXTERN_INLINE
  43 #ifdef __GNUC__
  44 #define _EXTERN_INLINE extern __inline__
  45 #else
  46 #define _EXTERN_INLINE static
  47 #endif
  48 #endif
  49
  50 #ifdef _SHORT_LIMB
  51 typedef unsigned int            mp_limb_t;
  52 typedef int                     mp_limb_signed_t;
  53 #else
  54 #ifdef _LONG_LONG_LIMB
  55 typedef unsigned long long int  mp_limb_t;
  56 typedef long long int           mp_limb_signed_t;
  57 #else
  58 typedef unsigned long int       mp_limb_t;
  59 typedef long int                mp_limb_signed_t;
  60 #endif
  61 #endif
  62
  63 typedef mp_limb_t *             mp_ptr;
  64 typedef __gmp_const mp_limb_t * mp_srcptr;
  65 typedef long int                mp_size_t;
  66 typedef long int                mp_exp_t;
  67
  68 #ifndef __MP_SMALL__
  69 typedef struct
  70 {
  71   int _mp_alloc;                /* Number of *limbs* allocated and pointed
  72                                    to by the D field.  */
  73   int _mp_size;                 /* abs(SIZE) is the number of limbs
  74                                    the last field points to.  If SIZE
  75                                    is negative this is a negative
  76                                    number.  */
  77   mp_limb_t *_mp_d;             /* Pointer to the limbs.  */
  78 } __mpz_struct;
  79 #else
  80 typedef struct
  81 {
  82   short int _mp_alloc;          /* Number of *limbs* allocated and pointed
  83                                    to by the D field.  */
  84   short int _mp_size;           /* abs(SIZE) is the number of limbs
  85                                    the last field points to.  If SIZE
  86                                    is negative this is a negative
  87                                    number.  */
  88   mp_limb_t *_mp_d;             /* Pointer to the limbs.  */
  89 } __mpz_struct;
  90 #endif
  91 #endif /* __GNU_MP__ */
  92
  93 /* User-visible types.  */
  94 typedef __mpz_struct MP_INT;
  95 typedef __mpz_struct mpz_t[1];
  96
  97 /* Structure for rational numbers.  Zero is represented as 0/any, i.e.
  98    the denominator is ignored.  Negative numbers have the sign in
  99    the numerator.  */
 100 typedef struct
 101 {
 102   __mpz_struct _mp_num;
 103   __mpz_struct _mp_den;
 104 #if 0
 105   int _mp_num_alloc;            /* Number of limbs allocated
 106                                    for the numerator.  */
 107   int _mp_num_size;             /* The absolute value of this field is the
 108                                    length of the numerator; the sign is the
 109                                    sign of the entire rational number.  */
 110   mp_ptr _mp_num;               /* Pointer to the numerator limbs.  */
 111   int _mp_den_alloc;            /* Number of limbs allocated
 112                                    for the denominator.  */
 113   int _mp_den_size;             /* Length of the denominator.  (This field
 114                                    should always be positive.) */
 115   mp_ptr _mp_den;               /* Pointer to the denominator limbs.  */
 116 #endif
 117 } __mpq_struct;
 118
 119 typedef __mpq_struct MP_RAT;
 120 typedef __mpq_struct mpq_t[1];
 121
 122 typedef struct
 123 {
 124   int _mp_prec;                 /* Max precision, in number of `mp_limb_t's.
 125                                    Set by mpf_init and modified by
 126                                    mpf_set_prec.  The area pointed to
 127                                    by the `d' field contains `prec' + 1
 128                                    limbs.  */
 129   int _mp_size;                 /* abs(SIZE) is the number of limbs
 130                                    the last field points to.  If SIZE
 131                                    is negative this is a negative
 132                                    number.  */
 133   mp_exp_t _mp_exp;             /* Exponent, in the base of `mp_limb_t'.  */
 134   mp_limb_t *_mp_d;             /* Pointer to the limbs.  */
 135 } __mpf_struct;
 136
 137 /* typedef __mpf_struct MP_FLOAT; */
 138 typedef __mpf_struct mpf_t[1];
 139
 140 /* Types for function declarations in gmp files.  */
 141 /* ??? Should not pollute user name space with these ??? */
 142 typedef __gmp_const __mpz_struct *mpz_srcptr;
 143 typedef __mpz_struct *mpz_ptr;
 144 typedef __gmp_const __mpf_struct *mpf_srcptr;
 145 typedef __mpf_struct *mpf_ptr;
 146 typedef __gmp_const __mpq_struct *mpq_srcptr;
 147 typedef __mpq_struct *mpq_ptr;
 148
 149 #ifndef _PROTO
 150 #if defined (__STDC__) || defined (__cplusplus)
 151 #define _PROTO(x) x
 152 #else
 153 #define _PROTO(x) ()
 154 #endif
 155 #endif
 156
 157 #ifndef __MPN
 158 #if defined (__STDC__) || defined (__cplusplus)
 159 #define __MPN(x) __mpn_##x
 160 #else
 161 #include <sys/cdefs.h>
 162 #define __MPN(x) __CONCAT(__mpn_,x)
 163 #endif
 164 #endif
 165
 166 #if defined (FILE) || defined (H_STDIO) || defined (_H_STDIO) \
 167  || defined (_STDIO_H) || defined (_STDIO_H_) || defined (__STDIO_H__) \
 168  || defined (_STDIO_INCLUDED)
 169 #define _GMP_H_HAVE_FILE 1
 170 #endif
 171
 172 void mp_set_memory_functions _PROTO ((void *(*) (size_t),
 173                                       void *(*) (void *, size_t, size_t),
 174                                       void (*) (void *, size_t)));
 175 extern __gmp_const int mp_bits_per_limb;
 176
 177 /**************** Integer (i.e. Z) routines.  ****************/
 178
 179 #if defined (__cplusplus)
 180 extern "C" {
 181 #endif
 182 void *_mpz_realloc _PROTO ((mpz_ptr, mp_size_t));
 183
 184 void mpz_abs _PROTO ((mpz_ptr, mpz_srcptr));
 185 void mpz_add _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 186 void mpz_add_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 187 void mpz_and _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 188 void mpz_array_init _PROTO ((mpz_ptr, mp_size_t, mp_size_t));
 189 void mpz_cdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 190 unsigned long int mpz_cdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 191 void mpz_cdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
 192 unsigned long int mpz_cdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
 193 void mpz_cdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 194 unsigned long int mpz_cdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 195 unsigned long int mpz_cdiv_ui _PROTO ((mpz_srcptr, unsigned long int));
 196 void mpz_clear _PROTO ((mpz_ptr));
 197 void mpz_clrbit _PROTO ((mpz_ptr, unsigned long int));
 198 int mpz_cmp _PROTO ((mpz_srcptr, mpz_srcptr));
 199 int mpz_cmp_si _PROTO ((mpz_srcptr, signed long int));
 200 int mpz_cmp_ui _PROTO ((mpz_srcptr, unsigned long int));
 201 void mpz_com _PROTO ((mpz_ptr, mpz_srcptr));
 202 void mpz_divexact _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 203 void mpz_fac_ui _PROTO ((mpz_ptr, unsigned long int));
 204 void mpz_fdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 205 void mpz_fdiv_q_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 206 unsigned long int mpz_fdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 207 void mpz_fdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
 208 unsigned long int mpz_fdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
 209 void mpz_fdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 210 void mpz_fdiv_r_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 211 unsigned long int mpz_fdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 212 unsigned long int mpz_fdiv_ui _PROTO ((mpz_srcptr, unsigned long int));
 213 void mpz_gcd _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 214 unsigned long int mpz_gcd_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 215 void mpz_gcdext _PROTO ((mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
 216 double mpz_get_d _PROTO ((mpz_srcptr));
 217 /* signed */ long int mpz_get_si _PROTO ((mpz_srcptr));
 218 char *mpz_get_str _PROTO ((char *, int, mpz_srcptr));
 219 unsigned long int mpz_get_ui _PROTO ((mpz_srcptr));
 220 mp_limb_t mpz_getlimbn _PROTO ((mpz_srcptr, mp_size_t));
 221 unsigned long int mpz_hamdist _PROTO ((mpz_srcptr, mpz_srcptr));
 222 void mpz_init _PROTO ((mpz_ptr));
 223 #ifdef _GMP_H_HAVE_FILE
 224 size_t mpz_inp_binary _PROTO ((mpz_ptr, FILE *));
 225 size_t mpz_inp_raw _PROTO ((mpz_ptr, FILE *));
 226 size_t mpz_inp_str _PROTO ((mpz_ptr, FILE *, int));
 227 #endif
 228 void mpz_init_set _PROTO ((mpz_ptr, mpz_srcptr));
 229 void mpz_init_set_d _PROTO ((mpz_ptr, double));
 230 void mpz_init_set_si _PROTO ((mpz_ptr, signed long int));
 231 int mpz_init_set_str _PROTO ((mpz_ptr, const char *, int));
 232 void mpz_init_set_ui _PROTO ((mpz_ptr, unsigned long int));
 233 int mpz_invert _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 234 void mpz_ior _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 235 int mpz_jacobi _PROTO ((mpz_srcptr, mpz_srcptr));
 236 int mpz_legendre _PROTO ((mpz_srcptr, mpz_srcptr));
 237 void mpz_mod _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 238 void mpz_mul _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 239 void mpz_mul_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 240 void mpz_mul_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 241 void mpz_neg _PROTO ((mpz_ptr, mpz_srcptr));
 242 #ifdef _GMP_H_HAVE_FILE
 243 size_t mpz_out_binary _PROTO ((FILE *, mpz_srcptr));
 244 size_t mpz_out_raw _PROTO ((FILE *, mpz_srcptr));
 245 size_t mpz_out_str _PROTO ((FILE *, int, mpz_srcptr));
 246 #endif
 247 int mpz_perfect_square_p _PROTO ((mpz_srcptr));
 248 unsigned long int mpz_popcount _PROTO ((mpz_srcptr));
 249 void mpz_pow_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 250 void mpz_powm _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr));
 251 void mpz_powm_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr));
 252 int mpz_probab_prime_p _PROTO ((mpz_srcptr, int));
 253 void mpz_random _PROTO ((mpz_ptr, mp_size_t));
 254 void mpz_random2 _PROTO ((mpz_ptr, mp_size_t));
 255 unsigned long int mpz_scan0 _PROTO ((mpz_srcptr, unsigned long int));
 256 unsigned long int mpz_scan1 _PROTO ((mpz_srcptr, unsigned long int));
 257 void mpz_set _PROTO ((mpz_ptr, mpz_srcptr));
 258 void mpz_set_d _PROTO ((mpz_ptr, double));
 259 void mpz_set_f _PROTO ((mpz_ptr, mpf_srcptr));
 260 void mpz_set_q _PROTO ((mpz_ptr, mpq_srcptr));
 261 void mpz_set_si _PROTO ((mpz_ptr, signed long int));
 262 int mpz_set_str _PROTO ((mpz_ptr, const char *, int));
 263 void mpz_set_ui _PROTO ((mpz_ptr, unsigned long int));
 264 void mpz_setbit _PROTO ((mpz_ptr, unsigned long int));
 265 size_t mpz_size _PROTO ((mpz_srcptr));
 266 size_t mpz_sizeinbase _PROTO ((mpz_srcptr, int));
 267 void mpz_sqrt _PROTO ((mpz_ptr, mpz_srcptr));
 268 void mpz_sqrtrem _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr));
 269 void mpz_sub _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 270 void mpz_sub_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 271 void mpz_tdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 272 void mpz_tdiv_q_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 273 void mpz_tdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 274 void mpz_tdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
 275 void mpz_tdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
 276 void mpz_tdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 277 void mpz_tdiv_r_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 278 void mpz_tdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 279 void mpz_ui_pow_ui _PROTO ((mpz_ptr, unsigned long int, unsigned long int));
 280
 281 /**************** Rational (i.e. Q) routines.  ****************/
 282
 283 void mpq_init _PROTO ((mpq_ptr));
 284 void mpq_clear _PROTO ((mpq_ptr));
 285 void mpq_set _PROTO ((mpq_ptr, mpq_srcptr));
 286 void mpq_set_ui _PROTO ((mpq_ptr, unsigned long int, unsigned long int));
 287 void mpq_set_si _PROTO ((mpq_ptr, signed long int, unsigned long int));
 288 void mpq_set_z _PROTO ((mpq_ptr, mpz_srcptr));
 289 void mpq_add _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 290 void mpq_sub _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 291 void mpq_mul _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 292 void mpq_div _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 293 void mpq_neg _PROTO ((mpq_ptr, mpq_srcptr));
 294 int mpq_cmp _PROTO ((mpq_srcptr, mpq_srcptr));
 295 int mpq_cmp_ui _PROTO ((mpq_srcptr, unsigned long int, unsigned long int));
 296 int mpq_equal _PROTO ((mpq_srcptr, mpq_srcptr));
 297 void mpq_inv _PROTO ((mpq_ptr, mpq_srcptr));
 298 void mpq_set_num _PROTO ((mpq_ptr, mpz_srcptr));
 299 void mpq_set_den _PROTO ((mpq_ptr, mpz_srcptr));
 300 void mpq_get_num _PROTO ((mpz_ptr, mpq_srcptr));
 301 void mpq_get_den _PROTO ((mpz_ptr, mpq_srcptr));
 302 double mpq_get_d _PROTO ((mpq_srcptr));
 303 void mpq_canonicalize _PROTO ((mpq_ptr));
 304
 305 /**************** Float (i.e. F) routines.  ****************/
 306
 307 void mpf_abs _PROTO ((mpf_ptr, mpf_srcptr));
 308 void mpf_add _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 309 void mpf_add_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 310 void mpf_clear _PROTO ((mpf_ptr));
 311 int mpf_cmp _PROTO ((mpf_srcptr, mpf_srcptr));
 312 int mpf_cmp_si _PROTO ((mpf_srcptr, signed long int));
 313 int mpf_cmp_ui _PROTO ((mpf_srcptr, unsigned long int));
 314 void mpf_div _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 315 void mpf_div_2exp _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 316 void mpf_div_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 317 void mpf_dump _PROTO ((mpf_srcptr));
 318 int mpf_eq _PROTO ((mpf_srcptr, mpf_srcptr, unsigned long int));
 319 double mpf_get_d _PROTO ((mpf_srcptr));
 320 unsigned long int mpf_get_prec _PROTO ((mpf_srcptr));
 321 char *mpf_get_str _PROTO ((char *, mp_exp_t *, int, size_t, mpf_srcptr));
 322 void mpf_init _PROTO ((mpf_ptr));
 323 void mpf_init2 _PROTO ((mpf_ptr, unsigned long int));
 324 #ifdef _GMP_H_HAVE_FILE
 325 size_t mpf_inp_str _PROTO ((mpf_ptr, FILE *, int));
 326 #endif
 327 void mpf_init_set _PROTO ((mpf_ptr, mpf_srcptr));
 328 void mpf_init_set_d _PROTO ((mpf_ptr, double));
 329 void mpf_init_set_si _PROTO ((mpf_ptr, signed long int));
 330 int mpf_init_set_str _PROTO ((mpf_ptr, const char *, int));
 331 void mpf_init_set_ui _PROTO ((mpf_ptr, unsigned long int));
 332 void mpf_mul _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 333 void mpf_mul_2exp _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 334 void mpf_mul_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 335 void mpf_neg _PROTO ((mpf_ptr, mpf_srcptr));
 336 #ifdef _GMP_H_HAVE_FILE
 337 size_t mpf_out_str _PROTO ((FILE *, int, size_t, mpf_srcptr));
 338 #endif
 339 void mpf_random2 _PROTO ((mpf_ptr, mp_size_t, mp_exp_t));
 340 void mpf_reldiff _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 341 void mpf_set _PROTO ((mpf_ptr, mpf_srcptr));
 342 void mpf_set_d _PROTO ((mpf_ptr, double));
 343 void mpf_set_default_prec _PROTO ((unsigned long int));
 344 void mpf_set_prec _PROTO ((mpf_ptr, unsigned long int));
 345 void mpf_set_prec_raw _PROTO ((mpf_ptr, unsigned long int));
 346 void mpf_set_q _PROTO ((mpf_ptr, mpq_srcptr));
 347 void mpf_set_si _PROTO ((mpf_ptr, signed long int));
 348 int mpf_set_str _PROTO ((mpf_ptr, const char *, int));
 349 void mpf_set_ui _PROTO ((mpf_ptr, unsigned long int));
 350 void mpf_set_z _PROTO ((mpf_ptr, mpz_srcptr));
 351 size_t mpf_size _PROTO ((mpf_srcptr));
 352 void mpf_sqrt _PROTO ((mpf_ptr, mpf_srcptr));
 353 void mpf_sqrt_ui _PROTO ((mpf_ptr, unsigned long int));
 354 void mpf_sub _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 355 void mpf_sub_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 356 void mpf_ui_div _PROTO ((mpf_ptr, unsigned long int, mpf_srcptr));
 357 void mpf_ui_sub _PROTO ((mpf_ptr, unsigned long int, mpf_srcptr));
 358 #if defined (__cplusplus)
 359 }
 360 #endif
 361 /************ Low level positive-integer (i.e. N) routines.  ************/
 362
 363 /* This is ugly, but we need to make usr calls reach the prefixed function.  */
 364 #define mpn_add                 __MPN(add)
 365 #define mpn_add_1               __MPN(add_1)
 366 #define mpn_add_n               __MPN(add_n)
 367 #define mpn_addmul_1            __MPN(addmul_1)
 368 #define mpn_bdivmod             __MPN(bdivmod)
 369 #define mpn_cmp                 __MPN(cmp)
 370 #define mpn_divmod_1            __MPN(divmod_1)
 371 #define mpn_divrem              __MPN(divrem)
 372 #define mpn_divrem_1            __MPN(divrem_1)
 373 #define mpn_dump                __MPN(dump)
 374 #define mpn_gcd                 __MPN(gcd)
 375 #define mpn_gcd_1               __MPN(gcd_1)
 376 #define mpn_gcdext              __MPN(gcdext)
 377 #define mpn_get_str             __MPN(get_str)
 378 #define mpn_hamdist             __MPN(hamdist)
 379 #define mpn_lshift              __MPN(lshift)
 380 #define mpn_mod_1               __MPN(mod_1)
 381 #define mpn_mul                 __MPN(mul)
 382 #define mpn_mul_1               __MPN(mul_1)
 383 #define mpn_mul_n               __MPN(mul_n)
 384 #define mpn_perfect_square_p    __MPN(perfect_square_p)
 385 #define mpn_popcount            __MPN(popcount)
 386 #define mpn_preinv_mod_1        __MPN(preinv_mod_1)
 387 #define mpn_random2             __MPN(random2)
 388 #define mpn_rshift              __MPN(rshift)
 389 #define mpn_scan0               __MPN(scan0)
 390 #define mpn_scan1               __MPN(scan1)
 391 #define mpn_set_str             __MPN(set_str)
 392 #define mpn_sqrtrem             __MPN(sqrtrem)
 393 #define mpn_sub                 __MPN(sub)
 394 #define mpn_sub_1               __MPN(sub_1)
 395 #define mpn_sub_n               __MPN(sub_n)
 396 #define mpn_submul_1            __MPN(submul_1)
 397 #define mpn_udiv_w_sdiv         __MPN(udiv_w_sdiv)
 398
 399 #if defined (__cplusplus)
 400 extern "C" {
 401 #endif
 402 mp_limb_t mpn_add _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t));
 403 mp_limb_t mpn_add_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t));
 404 mp_limb_t mpn_add_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
 405 mp_limb_t mpn_addmul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t));
 406 mp_limb_t mpn_bdivmod _PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, unsigned long int));
 407 int mpn_cmp _PROTO ((mp_srcptr, mp_srcptr, mp_size_t));
 408 mp_limb_t mpn_divmod_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t));
 409 mp_limb_t mpn_divrem _PROTO ((mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t));
 410 mp_limb_t mpn_divrem_1 _PROTO ((mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t));
 411 void mpn_dump _PROTO ((mp_srcptr, mp_size_t));
 412 mp_size_t mpn_gcd _PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t));
 413 mp_limb_t mpn_gcd_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb_t));
 414 mp_size_t mpn_gcdext _PROTO ((mp_ptr, mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t));
 415 size_t mpn_get_str _PROTO ((unsigned char *, int, mp_ptr, mp_size_t));
 416 unsigned long int mpn_hamdist _PROTO ((mp_srcptr, mp_srcptr, mp_size_t));
 417 mp_limb_t mpn_lshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int));
 418 mp_limb_t mpn_mod_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb_t));
 419 mp_limb_t mpn_mul _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t));
 420 mp_limb_t mpn_mul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t));
 421 void mpn_mul_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
 422 int mpn_perfect_square_p _PROTO ((mp_srcptr, mp_size_t));
 423 unsigned long int mpn_popcount _PROTO ((mp_srcptr, mp_size_t));
 424 mp_limb_t mpn_preinv_mod_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t));
 425 void mpn_random2 _PROTO ((mp_ptr, mp_size_t));
 426 mp_limb_t mpn_rshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int));
 427 unsigned long int mpn_scan0 _PROTO ((mp_srcptr, unsigned long int));
 428 unsigned long int mpn_scan1 _PROTO ((mp_srcptr, unsigned long int));
 429 mp_size_t mpn_set_str _PROTO ((mp_ptr, const unsigned char *, size_t, int));
 430 mp_size_t mpn_sqrtrem _PROTO ((mp_ptr, mp_ptr, mp_srcptr, mp_size_t));
 431 mp_limb_t mpn_sub _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t));
 432 mp_limb_t mpn_sub_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t));
 433 mp_limb_t mpn_sub_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
 434 mp_limb_t mpn_submul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t));
 435 #if defined (__cplusplus)
 436 }
 437 #endif
 438
 439 #if defined (__GNUC__) || defined (_FORCE_INLINES)
 440 _EXTERN_INLINE mp_limb_t
 441 #if defined (__STDC__) || defined (__cplusplus)
 442 mpn_add_1 (register mp_ptr res_ptr,
 443            register mp_srcptr s1_ptr,
 444            register mp_size_t s1_size,
 445            register mp_limb_t s2_limb)
 446 #else
 447 mpn_add_1 (res_ptr, s1_ptr, s1_size, s2_limb)
 448      register mp_ptr res_ptr;
 449      register mp_srcptr s1_ptr;
 450      register mp_size_t s1_size;
 451      register mp_limb_t s2_limb;
 452 #endif
 453 {
 454   register mp_limb_t x;
 455
 456   x = *s1_ptr++;
 457   s2_limb = x + s2_limb;
 458   *res_ptr++ = s2_limb;
 459   if (s2_limb < x)
 460     {
 461       while (--s1_size != 0)
 462         {
 463           x = *s1_ptr++ + 1;
 464           *res_ptr++ = x;
 465           if (x != 0)
 466             goto fin;
 467         }
 468
 469       return 1;
 470     }
 471
 472  fin:
 473   if (res_ptr != s1_ptr)
 474     {
 475       mp_size_t i;
 476       for (i = 0; i < s1_size - 1; i++)
 477         res_ptr[i] = s1_ptr[i];
 478     }
 479   return 0;
 480 }
 481
 482 _EXTERN_INLINE mp_limb_t
 483 #if defined (__STDC__) || defined (__cplusplus)
 484 mpn_add (register mp_ptr res_ptr,
 485          register mp_srcptr s1_ptr,
 486          register mp_size_t s1_size,
 487          register mp_srcptr s2_ptr,
 488          register mp_size_t s2_size)
 489 #else
 490 mpn_add (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
 491      register mp_ptr res_ptr;
 492      register mp_srcptr s1_ptr;
 493      register mp_size_t s1_size;
 494      register mp_srcptr s2_ptr;
 495      register mp_size_t s2_size;
 496 #endif
 497 {
 498   mp_limb_t cy_limb = 0;
 499
 500   if (s2_size != 0)
 501     cy_limb = mpn_add_n (res_ptr, s1_ptr, s2_ptr, s2_size);
 502
 503   if (s1_size - s2_size != 0)
 504     cy_limb = mpn_add_1 (res_ptr + s2_size,
 505                          s1_ptr + s2_size,
 506                          s1_size - s2_size,
 507                          cy_limb);
 508   return cy_limb;
 509 }
 510
 511 _EXTERN_INLINE mp_limb_t
 512 #if defined (__STDC__) || defined (__cplusplus)
 513 mpn_sub_1 (register mp_ptr res_ptr,
 514            register mp_srcptr s1_ptr,
 515            register mp_size_t s1_size,
 516            register mp_limb_t s2_limb)
 517 #else
 518 mpn_sub_1 (res_ptr, s1_ptr, s1_size, s2_limb)
 519      register mp_ptr res_ptr;
 520      register mp_srcptr s1_ptr;
 521      register mp_size_t s1_size;
 522      register mp_limb_t s2_limb;
 523 #endif
 524 {
 525   register mp_limb_t x;
 526
 527   x = *s1_ptr++;
 528   s2_limb = x - s2_limb;
 529   *res_ptr++ = s2_limb;
 530   if (s2_limb > x)
 531     {
 532       while (--s1_size != 0)
 533         {
 534           x = *s1_ptr++;
 535           *res_ptr++ = x - 1;
 536           if (x != 0)
 537             goto fin;
 538         }
 539
 540       return 1;
 541     }
 542
 543  fin:
 544   if (res_ptr != s1_ptr)
 545     {
 546       mp_size_t i;
 547       for (i = 0; i < s1_size - 1; i++)
 548         res_ptr[i] = s1_ptr[i];
 549     }
 550   return 0;
 551 }
 552
 553 _EXTERN_INLINE mp_limb_t
 554 #if defined (__STDC__) || defined (__cplusplus)
 555 mpn_sub (register mp_ptr res_ptr,
 556          register mp_srcptr s1_ptr,
 557          register mp_size_t s1_size,
 558          register mp_srcptr s2_ptr,
 559          register mp_size_t s2_size)
 560 #else
 561 mpn_sub (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
 562      register mp_ptr res_ptr;
 563      register mp_srcptr s1_ptr;
 564      register mp_size_t s1_size;
 565      register mp_srcptr s2_ptr;
 566      register mp_size_t s2_size;
 567 #endif
 568 {
 569   mp_limb_t cy_limb = 0;
 570
 571   if (s2_size != 0)
 572     cy_limb = mpn_sub_n (res_ptr, s1_ptr, s2_ptr, s2_size);
 573
 574   if (s1_size - s2_size != 0)
 575     cy_limb = mpn_sub_1 (res_ptr + s2_size,
 576                          s1_ptr + s2_size,
 577                          s1_size - s2_size,
 578                          cy_limb);
 579   return cy_limb;
 580 }
 581 #endif /* __GNUC__ */
 582
 583 /* Allow faster testing for negative, zero, and positive.  */
 584 #define mpz_sgn(Z) ((Z)->_mp_size < 0 ? -1 : (Z)->_mp_size > 0)
 585 #define mpf_sgn(F) ((F)->_mp_size < 0 ? -1 : (F)->_mp_size > 0)
 586 #define mpq_sgn(Q) ((Q)->_mp_num._mp_size < 0 ? -1 : (Q)->_mp_num._mp_size > 0)
 587
 588 /* Allow direct user access to numerator and denominator of a mpq_t object.  */
 589 #define mpq_numref(Q) (&((Q)->_mp_num))
 590 #define mpq_denref(Q) (&((Q)->_mp_den))
 591
 592 /* When using GCC, optimize certain common comparisons.  */
 593 #if defined (__GNUC__)
 594 #define mpz_cmp_ui(Z,UI) \
 595   (__builtin_constant_p (UI) && (UI) == 0                               \
 596    ? mpz_sgn (Z) : mpz_cmp_ui (Z,UI))
 597 #define mpz_cmp_si(Z,UI) \
 598   (__builtin_constant_p (UI) && (UI) == 0 ? mpz_sgn (Z)                 \
 599    : __builtin_constant_p (UI) && (UI) > 0 ? mpz_cmp_ui (Z,UI)          \
 600    : mpz_cmp_si (Z,UI))
 601 #define mpq_cmp_ui(Q,NUI,DUI) \
 602   (__builtin_constant_p (NUI) && (NUI) == 0                             \
 603    ? mpq_sgn (Q) : mpq_cmp_ui (Q,NUI,DUI))
 604 #endif
 605
 606 #define mpn_divmod(qp,np,nsize,dp,dsize) mpn_divrem (qp,0,np,nsize,dp,dsize)
 607 #if 0
 608 #define mpn_divmod_1(qp,np,nsize,dlimb) mpn_divrem_1 (qp,0,np,nsize,dlimb)
 609 #endif
 610
 611 /* Compatibility with GMP 1.  */
 612 #define mpz_mdiv        mpz_fdiv_q
 613 #define mpz_mdivmod     mpz_fdiv_qr
 614 #define mpz_mmod        mpz_fdiv_r
 615 #define mpz_mdiv_ui     mpz_fdiv_q_ui
 616 #define mpz_mdivmod_ui(q,r,n,d) \
 617   ((r == 0) ? mpz_fdiv_q_ui (q,n,d) : mpz_fdiv_qr_ui (q,r,n,d))
 618 #define mpz_mmod_ui(r,n,d) \
 619   ((r == 0) ? mpz_fdiv_ui (n,d) : mpz_fdiv_r_ui (r,n,d))
 620
 621 /* Useful synonyms, but not quite compatible with GMP 1.  */
 622 #define mpz_div         mpz_fdiv_q
 623 #define mpz_divmod      mpz_fdiv_qr
 624 #define mpz_div_ui      mpz_fdiv_q_ui
 625 #define mpz_divmod_ui   mpz_fdiv_qr_ui
 626 #define mpz_mod_ui      mpz_fdiv_r_ui
 627 #define mpz_div_2exp    mpz_fdiv_q_2exp
 628 #define mpz_mod_2exp    mpz_fdiv_r_2exp
 629
 630 #define __GNU_MP_VERSION 2
 631 #define __GNU_MP_VERSION_MINOR 0
 632 #define __GMP_H__
 633 #endif /* __GMP_H__ */