| /* gmp.h -- Definitions for GNU multiple precision functions. |
| |
| Copyright (C) 1991-2018 Free Software Foundation, Inc. |
| |
| This file is part of the GNU MP Library. |
| |
| The GNU MP Library is free software; you can redistribute it and/or modify |
| it under the terms of the GNU Lesser General Public License as published by |
| the Free Software Foundation; either version 2.1 of the License, or (at your |
| option) any later version. |
| |
| The GNU MP Library is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
| or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public |
| License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with the GNU MP Library; see the file COPYING.LIB. If not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #ifndef __GMP_H__ |
| |
| #include <features.h> |
| |
| #ifndef __GNU_MP__ |
| #define __GNU_MP__ 2 |
| #define __need_size_t |
| #include <stddef.h> |
| #undef __need_size_t |
| |
| #if defined (__STDC__) || defined (__cplusplus) |
| #define __gmp_const const |
| #else |
| #define __gmp_const |
| #endif |
| |
| #if defined (__GNUC__) |
| #define __gmp_inline __inline__ |
| #else |
| #define __gmp_inline |
| #endif |
| |
| #ifndef _EXTERN_INLINE |
| #ifdef __GNUC__ |
| #define _EXTERN_INLINE __extern_inline |
| #else |
| #define _EXTERN_INLINE static |
| #endif |
| #endif |
| |
| #ifdef _SHORT_LIMB |
| typedef unsigned int mp_limb_t; |
| typedef int mp_limb_signed_t; |
| #else |
| #ifdef _LONG_LONG_LIMB |
| typedef unsigned long long int mp_limb_t; |
| typedef long long int mp_limb_signed_t; |
| #else |
| typedef unsigned long int mp_limb_t; |
| typedef long int mp_limb_signed_t; |
| #endif |
| #endif |
| |
| typedef mp_limb_t * mp_ptr; |
| typedef __gmp_const mp_limb_t * mp_srcptr; |
| typedef long int mp_size_t; |
| typedef long int mp_exp_t; |
| |
| #ifndef __MP_SMALL__ |
| typedef struct |
| { |
| int _mp_alloc; /* Number of *limbs* allocated and pointed |
| to by the D field. */ |
| int _mp_size; /* abs(SIZE) is the number of limbs |
| the last field points to. If SIZE |
| is negative this is a negative |
| number. */ |
| mp_limb_t *_mp_d; /* Pointer to the limbs. */ |
| } __mpz_struct; |
| #else |
| typedef struct |
| { |
| short int _mp_alloc; /* Number of *limbs* allocated and pointed |
| to by the D field. */ |
| short int _mp_size; /* abs(SIZE) is the number of limbs |
| the last field points to. If SIZE |
| is negative this is a negative |
| number. */ |
| mp_limb_t *_mp_d; /* Pointer to the limbs. */ |
| } __mpz_struct; |
| #endif |
| #endif /* __GNU_MP__ */ |
| |
| /* User-visible types. */ |
| typedef __mpz_struct MP_INT; |
| typedef __mpz_struct mpz_t[1]; |
| |
| /* Structure for rational numbers. Zero is represented as 0/any, i.e. |
| the denominator is ignored. Negative numbers have the sign in |
| the numerator. */ |
| typedef struct |
| { |
| __mpz_struct _mp_num; |
| __mpz_struct _mp_den; |
| #if 0 |
| int _mp_num_alloc; /* Number of limbs allocated |
| for the numerator. */ |
| int _mp_num_size; /* The absolute value of this field is the |
| length of the numerator; the sign is the |
| sign of the entire rational number. */ |
| mp_ptr _mp_num; /* Pointer to the numerator limbs. */ |
| int _mp_den_alloc; /* Number of limbs allocated |
| for the denominator. */ |
| int _mp_den_size; /* Length of the denominator. (This field |
| should always be positive.) */ |
| mp_ptr _mp_den; /* Pointer to the denominator limbs. */ |
| #endif |
| } __mpq_struct; |
| |
| typedef __mpq_struct MP_RAT; |
| typedef __mpq_struct mpq_t[1]; |
| |
| typedef struct |
| { |
| int _mp_prec; /* Max precision, in number of `mp_limb_t's. |
| Set by mpf_init and modified by |
| mpf_set_prec. The area pointed to |
| by the `d' field contains `prec' + 1 |
| limbs. */ |
| int _mp_size; /* abs(SIZE) is the number of limbs |
| the last field points to. If SIZE |
| is negative this is a negative |
| number. */ |
| mp_exp_t _mp_exp; /* Exponent, in the base of `mp_limb_t'. */ |
| mp_limb_t *_mp_d; /* Pointer to the limbs. */ |
| } __mpf_struct; |
| |
| /* typedef __mpf_struct MP_FLOAT; */ |
| typedef __mpf_struct mpf_t[1]; |
| |
| /* Types for function declarations in gmp files. */ |
| /* ??? Should not pollute user name space with these ??? */ |
| typedef __gmp_const __mpz_struct *mpz_srcptr; |
| typedef __mpz_struct *mpz_ptr; |
| typedef __gmp_const __mpf_struct *mpf_srcptr; |
| typedef __mpf_struct *mpf_ptr; |
| typedef __gmp_const __mpq_struct *mpq_srcptr; |
| typedef __mpq_struct *mpq_ptr; |
| |
| #ifndef _PROTO |
| #if defined (__STDC__) || defined (__cplusplus) |
| #define _PROTO(x) x |
| #else |
| #define _PROTO(x) () |
| #endif |
| #endif |
| |
| #ifndef __MPN |
| #if defined (__STDC__) || defined (__cplusplus) |
| #define __MPN(x) __mpn_##x |
| #else |
| #define __MPN(x) __mpn_/**/x |
| #endif |
| #endif |
| |
| #if defined (FILE) || defined (_STDIO_H_) || defined (__STDIO_H__) || defined (H_STDIO) |
| #define _GMP_H_HAVE_FILE 1 |
| #endif |
| |
| void mp_set_memory_functions _PROTO ((void *(*) (size_t), |
| void *(*) (void *, size_t, size_t), |
| void (*) (void *, size_t))); |
| extern const int mp_bits_per_limb; |
| |
| /**************** Integer (i.e. Z) routines. ****************/ |
| |
| #if defined (__cplusplus) |
| extern "C" { |
| #endif |
| void *_mpz_realloc _PROTO ((mpz_ptr, mp_size_t)); |
| |
| void mpz_abs _PROTO ((mpz_ptr, mpz_srcptr)); |
| void mpz_add _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_add_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_and _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_array_init _PROTO ((mpz_ptr, mp_size_t, mp_size_t)); |
| void mpz_cdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| unsigned long int mpz_cdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_cdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| unsigned long int mpz_cdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_cdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| unsigned long int mpz_cdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| unsigned long int mpz_cdiv_ui _PROTO ((mpz_srcptr, unsigned long int)); |
| void mpz_clear _PROTO ((mpz_ptr)); |
| void mpz_clrbit _PROTO ((mpz_ptr, unsigned long int)); |
| int mpz_cmp _PROTO ((mpz_srcptr, mpz_srcptr)); |
| int mpz_cmp_si _PROTO ((mpz_srcptr, signed long int)); |
| int mpz_cmp_ui _PROTO ((mpz_srcptr, unsigned long int)); |
| void mpz_com _PROTO ((mpz_ptr, mpz_srcptr)); |
| void mpz_divexact _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_fac_ui _PROTO ((mpz_ptr, unsigned long int)); |
| void mpz_fdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_fdiv_q_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| unsigned long int mpz_fdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_fdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| unsigned long int mpz_fdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_fdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_fdiv_r_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| unsigned long int mpz_fdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| unsigned long int mpz_fdiv_ui _PROTO ((mpz_srcptr, unsigned long int)); |
| void mpz_gcd _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| unsigned long int mpz_gcd_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_gcdext _PROTO ((mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| /* signed */ long int mpz_get_si _PROTO ((mpz_srcptr)); |
| char *mpz_get_str _PROTO ((char *, int, mpz_srcptr)); |
| unsigned long int mpz_get_ui _PROTO ((mpz_srcptr)); |
| mp_limb_t mpz_getlimbn _PROTO ((mpz_srcptr, mp_size_t)); |
| unsigned long int mpz_hamdist _PROTO ((mpz_srcptr, mpz_srcptr)); |
| void mpz_init _PROTO ((mpz_ptr)); |
| #ifdef _GMP_H_HAVE_FILE |
| size_t mpz_inp_binary _PROTO ((mpz_ptr, FILE *)); |
| size_t mpz_inp_raw _PROTO ((mpz_ptr, FILE *)); |
| size_t mpz_inp_str _PROTO ((mpz_ptr, FILE *, int)); |
| #endif |
| void mpz_init_set _PROTO ((mpz_ptr, mpz_srcptr)); |
| void mpz_init_set_d _PROTO ((mpz_ptr, double)); |
| void mpz_init_set_si _PROTO ((mpz_ptr, signed long int)); |
| int mpz_init_set_str _PROTO ((mpz_ptr, const char *, int)); |
| void mpz_init_set_ui _PROTO ((mpz_ptr, unsigned long int)); |
| int mpz_invert _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_ior _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| int mpz_jacobi _PROTO ((mpz_srcptr, mpz_srcptr)); |
| int mpz_legendre _PROTO ((mpz_srcptr, mpz_srcptr)); |
| void mpz_mod _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_mul _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_mul_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_mul_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_neg _PROTO ((mpz_ptr, mpz_srcptr)); |
| #ifdef _GMP_H_HAVE_FILE |
| size_t mpz_out_binary _PROTO ((FILE *, mpz_srcptr)); |
| size_t mpz_out_raw _PROTO ((FILE *, mpz_srcptr)); |
| size_t mpz_out_str _PROTO ((FILE *, int, mpz_srcptr)); |
| #endif |
| int mpz_perfect_square_p _PROTO ((mpz_srcptr)); |
| unsigned long int mpz_popcount _PROTO ((mpz_srcptr)); |
| void mpz_pow_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_powm _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_powm_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr)); |
| int mpz_probab_prime_p _PROTO ((mpz_srcptr, int)); |
| void mpz_random _PROTO ((mpz_ptr, mp_size_t)); |
| void mpz_random2 _PROTO ((mpz_ptr, mp_size_t)); |
| unsigned long int mpz_scan0 _PROTO ((mpz_srcptr, unsigned long int)); |
| unsigned long int mpz_scan1 _PROTO ((mpz_srcptr, unsigned long int)); |
| void mpz_set _PROTO ((mpz_ptr, mpz_srcptr)); |
| void mpz_set_d _PROTO ((mpz_ptr, double)); |
| void mpz_set_si _PROTO ((mpz_ptr, signed long int)); |
| int mpz_set_str _PROTO ((mpz_ptr, const char *, int)); |
| void mpz_set_ui _PROTO ((mpz_ptr, unsigned long int)); |
| void mpz_setbit _PROTO ((mpz_ptr, unsigned long int)); |
| size_t mpz_size _PROTO ((mpz_srcptr)); |
| size_t mpz_sizeinbase _PROTO ((mpz_srcptr, int)); |
| void mpz_sqrt _PROTO ((mpz_ptr, mpz_srcptr)); |
| void mpz_sqrtrem _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr)); |
| void mpz_sub _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_sub_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_tdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_tdiv_q_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_tdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_tdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_tdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_tdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr)); |
| void mpz_tdiv_r_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_tdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int)); |
| void mpz_ui_pow_ui _PROTO ((mpz_ptr, unsigned long int, unsigned long int)); |
| |
| /**************** Rational (i.e. Q) routines. ****************/ |
| |
| void mpq_init _PROTO ((mpq_ptr)); |
| void mpq_clear _PROTO ((mpq_ptr)); |
| void mpq_set _PROTO ((mpq_ptr, mpq_srcptr)); |
| void mpq_set_ui _PROTO ((mpq_ptr, unsigned long int, unsigned long int)); |
| void mpq_set_si _PROTO ((mpq_ptr, signed long int, unsigned long int)); |
| void mpq_add _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); |
| void mpq_sub _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); |
| void mpq_mul _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); |
| void mpq_div _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr)); |
| void mpq_neg _PROTO ((mpq_ptr, mpq_srcptr)); |
| int mpq_cmp _PROTO ((mpq_srcptr, mpq_srcptr)); |
| int mpq_cmp_ui _PROTO ((mpq_srcptr, unsigned long int, unsigned long int)); |
| void mpq_inv _PROTO ((mpq_ptr, mpq_srcptr)); |
| void mpq_set_num _PROTO ((mpq_ptr, mpz_srcptr)); |
| void mpq_set_den _PROTO ((mpq_ptr, mpz_srcptr)); |
| void mpq_get_num _PROTO ((mpz_ptr, mpq_srcptr)); |
| void mpq_get_den _PROTO ((mpz_ptr, mpq_srcptr)); |
| double mpq_get_d _PROTO ((mpq_srcptr)); |
| void mpq_canonicalize _PROTO ((mpq_ptr)); |
| |
| /**************** Float (i.e. F) routines. ****************/ |
| |
| void mpf_abs _PROTO ((mpf_ptr, mpf_srcptr)); |
| void mpf_add _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); |
| void mpf_add_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); |
| void mpf_clear _PROTO ((mpf_ptr)); |
| int mpf_cmp _PROTO ((mpf_srcptr, mpf_srcptr)); |
| int mpf_cmp_si _PROTO ((mpf_srcptr, signed long int)); |
| int mpf_cmp_ui _PROTO ((mpf_srcptr, unsigned long int)); |
| void mpf_div _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); |
| void mpf_div_2exp _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); |
| void mpf_div_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); |
| void mpf_dump _PROTO ((mpf_srcptr)); |
| int mpf_eq _PROTO ((mpf_srcptr, mpf_srcptr, unsigned long int)); |
| unsigned long int mpf_get_prec _PROTO ((mpf_srcptr)); |
| char *mpf_get_str _PROTO ((char *, mp_exp_t *, int, size_t, mpf_srcptr)); |
| void mpf_init _PROTO ((mpf_ptr)); |
| void mpf_init2 _PROTO ((mpf_ptr, unsigned long int)); |
| #ifdef _GMP_H_HAVE_FILE |
| size_t mpf_inp_str _PROTO ((mpf_ptr, FILE *, int)); |
| #endif |
| void mpf_init_set _PROTO ((mpf_ptr, mpf_srcptr)); |
| void mpf_init_set_d _PROTO ((mpf_ptr, double)); |
| void mpf_init_set_si _PROTO ((mpf_ptr, signed long int)); |
| int mpf_init_set_str _PROTO ((mpf_ptr, char *, int)); |
| void mpf_init_set_ui _PROTO ((mpf_ptr, unsigned long int)); |
| void mpf_mul _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); |
| void mpf_mul_2exp _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); |
| void mpf_mul_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); |
| void mpf_neg _PROTO ((mpf_ptr, mpf_srcptr)); |
| #ifdef _GMP_H_HAVE_FILE |
| size_t mpf_out_str _PROTO ((FILE *, int, size_t, mpf_srcptr)); |
| #endif |
| void mpf_random2 _PROTO ((mpf_ptr, mp_size_t, mp_exp_t)); |
| void mpf_reldiff _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); |
| void mpf_set _PROTO ((mpf_ptr, mpf_srcptr)); |
| void mpf_set_d _PROTO ((mpf_ptr, double)); |
| void mpf_set_default_prec _PROTO ((unsigned long int)); |
| void mpf_set_prec _PROTO ((mpf_ptr, unsigned long int)); |
| void mpf_set_prec_raw _PROTO ((mpf_ptr, unsigned long int)); |
| void mpf_set_si _PROTO ((mpf_ptr, signed long int)); |
| int mpf_set_str _PROTO ((mpf_ptr, const char *, int)); |
| void mpf_set_ui _PROTO ((mpf_ptr, unsigned long int)); |
| size_t mpf_size _PROTO ((mpf_srcptr)); |
| void mpf_sqrt _PROTO ((mpf_ptr, mpf_srcptr)); |
| void mpf_sqrt_ui _PROTO ((mpf_ptr, unsigned long int)); |
| void mpf_sub _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr)); |
| void mpf_sub_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int)); |
| void mpf_ui_div _PROTO ((mpf_ptr, unsigned long int, mpf_srcptr)); |
| void mpf_ui_sub _PROTO ((mpf_ptr, unsigned long int, mpf_srcptr)); |
| #if defined (__cplusplus) |
| } |
| #endif |
| /************ Low level positive-integer (i.e. N) routines. ************/ |
| |
| /* This is ugly, but we need to make usr calls reach the prefixed function. */ |
| #define mpn_add __MPN(add) |
| #define mpn_add_1 __MPN(add_1) |
| #define mpn_add_n __MPN(add_n) |
| #define mpn_addmul_1 __MPN(addmul_1) |
| #define mpn_bdivmod __MPN(bdivmod) |
| #define mpn_cmp __MPN(cmp) |
| #define mpn_divmod_1 __MPN(divmod_1) |
| #define mpn_divrem __MPN(divrem) |
| #define mpn_divrem_1 __MPN(divrem_1) |
| #define mpn_dump __MPN(dump) |
| #define mpn_gcd __MPN(gcd) |
| #define mpn_gcd_1 __MPN(gcd_1) |
| #define mpn_gcdext __MPN(gcdext) |
| #define mpn_get_str __MPN(get_str) |
| #define mpn_hamdist __MPN(hamdist) |
| #define mpn_lshift __MPN(lshift) |
| #define mpn_mod_1 __MPN(mod_1) |
| #define mpn_mul __MPN(mul) |
| #define mpn_mul_1 __MPN(mul_1) |
| #define mpn_mul_n __MPN(mul_n) |
| #define mpn_perfect_square_p __MPN(perfect_square_p) |
| #define mpn_popcount __MPN(popcount) |
| #define mpn_preinv_mod_1 __MPN(preinv_mod_1) |
| #define mpn_random2 __MPN(random2) |
| #define mpn_rshift __MPN(rshift) |
| #define mpn_scan0 __MPN(scan0) |
| #define mpn_scan1 __MPN(scan1) |
| #define mpn_set_str __MPN(set_str) |
| #define mpn_sqrtrem __MPN(sqrtrem) |
| #define mpn_sub __MPN(sub) |
| #define mpn_sub_1 __MPN(sub_1) |
| #define mpn_sub_n __MPN(sub_n) |
| #define mpn_submul_1 __MPN(submul_1) |
| #define mpn_udiv_w_sdiv __MPN(udiv_w_sdiv) |
| |
| #if defined (__cplusplus) |
| extern "C" { |
| #endif |
| mp_limb_t mpn_add _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t)); |
| mp_limb_t mpn_add_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); |
| mp_limb_t mpn_add_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); |
| mp_limb_t mpn_addmul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); |
| mp_limb_t mpn_bdivmod _PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, unsigned long int)); |
| int mpn_cmp _PROTO ((mp_srcptr, mp_srcptr, mp_size_t)); |
| mp_limb_t mpn_divmod_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); |
| mp_limb_t mpn_divrem _PROTO ((mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t)); |
| mp_limb_t mpn_divrem_1 _PROTO ((mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t)); |
| void mpn_dump _PROTO ((mp_srcptr, mp_size_t)); |
| mp_size_t mpn_gcd _PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t)); |
| mp_limb_t mpn_gcd_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb_t)); |
| mp_size_t mpn_gcdext _PROTO ((mp_ptr, mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t)); |
| size_t mpn_get_str _PROTO ((unsigned char *, int, mp_ptr, mp_size_t)); |
| unsigned long int mpn_hamdist _PROTO ((mp_srcptr, mp_srcptr, mp_size_t)); |
| mp_limb_t mpn_lshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int)); |
| mp_limb_t mpn_mod_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb_t)); |
| mp_limb_t mpn_mul _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t)); |
| mp_limb_t mpn_mul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); |
| void mpn_mul_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); |
| int mpn_perfect_square_p _PROTO ((mp_srcptr, mp_size_t)); |
| unsigned long int mpn_popcount _PROTO ((mp_srcptr, mp_size_t)); |
| mp_limb_t mpn_preinv_mod_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t)); |
| void mpn_random2 _PROTO ((mp_ptr, mp_size_t)); |
| mp_limb_t mpn_rshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int)); |
| unsigned long int mpn_scan0 _PROTO ((mp_srcptr, unsigned long int)); |
| unsigned long int mpn_scan1 _PROTO ((mp_srcptr, unsigned long int)); |
| mp_size_t mpn_set_str _PROTO ((mp_ptr, const unsigned char *, size_t, int)); |
| mp_size_t mpn_sqrtrem _PROTO ((mp_ptr, mp_ptr, mp_srcptr, mp_size_t)); |
| mp_limb_t mpn_sub _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t)); |
| mp_limb_t mpn_sub_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); |
| mp_limb_t mpn_sub_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t)); |
| mp_limb_t mpn_submul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb_t)); |
| #if defined (__cplusplus) |
| } |
| #endif |
| |
| #if defined (__GNUC__) || defined (_FORCE_INLINES) |
| _EXTERN_INLINE mp_limb_t |
| #if defined (__STDC__) || defined (__cplusplus) |
| mpn_add_1 (register mp_ptr res_ptr, |
| register mp_srcptr s1_ptr, |
| register mp_size_t s1_size, |
| register mp_limb_t s2_limb) |
| #else |
| mpn_add_1 (res_ptr, s1_ptr, s1_size, s2_limb) |
| register mp_ptr res_ptr; |
| register mp_srcptr s1_ptr; |
| register mp_size_t s1_size; |
| register mp_limb_t s2_limb; |
| #endif |
| { |
| register mp_limb_t x; |
| |
| x = *s1_ptr++; |
| s2_limb = x + s2_limb; |
| *res_ptr++ = s2_limb; |
| if (s2_limb < x) |
| { |
| while (--s1_size != 0) |
| { |
| x = *s1_ptr++ + 1; |
| *res_ptr++ = x; |
| if (x != 0) |
| goto fin; |
| } |
| |
| return 1; |
| } |
| |
| fin: |
| if (res_ptr != s1_ptr) |
| { |
| mp_size_t i; |
| for (i = 0; i < s1_size - 1; i++) |
| res_ptr[i] = s1_ptr[i]; |
| } |
| return 0; |
| } |
| |
| _EXTERN_INLINE mp_limb_t |
| #if defined (__STDC__) || defined (__cplusplus) |
| mpn_add (register mp_ptr res_ptr, |
| register mp_srcptr s1_ptr, |
| register mp_size_t s1_size, |
| register mp_srcptr s2_ptr, |
| register mp_size_t s2_size) |
| #else |
| mpn_add (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size) |
| register mp_ptr res_ptr; |
| register mp_srcptr s1_ptr; |
| register mp_size_t s1_size; |
| register mp_srcptr s2_ptr; |
| register mp_size_t s2_size; |
| #endif |
| { |
| mp_limb_t cy_limb = 0; |
| |
| if (s2_size != 0) |
| cy_limb = mpn_add_n (res_ptr, s1_ptr, s2_ptr, s2_size); |
| |
| if (s1_size - s2_size != 0) |
| cy_limb = mpn_add_1 (res_ptr + s2_size, |
| s1_ptr + s2_size, |
| s1_size - s2_size, |
| cy_limb); |
| return cy_limb; |
| } |
| |
| _EXTERN_INLINE mp_limb_t |
| #if defined (__STDC__) || defined (__cplusplus) |
| mpn_sub_1 (register mp_ptr res_ptr, |
| register mp_srcptr s1_ptr, |
| register mp_size_t s1_size, |
| register mp_limb_t s2_limb) |
| #else |
| mpn_sub_1 (res_ptr, s1_ptr, s1_size, s2_limb) |
| register mp_ptr res_ptr; |
| register mp_srcptr s1_ptr; |
| register mp_size_t s1_size; |
| register mp_limb_t s2_limb; |
| #endif |
| { |
| register mp_limb_t x; |
| |
| x = *s1_ptr++; |
| s2_limb = x - s2_limb; |
| *res_ptr++ = s2_limb; |
| if (s2_limb > x) |
| { |
| while (--s1_size != 0) |
| { |
| x = *s1_ptr++; |
| *res_ptr++ = x - 1; |
| if (x != 0) |
| goto fin; |
| } |
| |
| return 1; |
| } |
| |
| fin: |
| if (res_ptr != s1_ptr) |
| { |
| mp_size_t i; |
| for (i = 0; i < s1_size - 1; i++) |
| res_ptr[i] = s1_ptr[i]; |
| } |
| return 0; |
| } |
| |
| _EXTERN_INLINE mp_limb_t |
| #if defined (__STDC__) || defined (__cplusplus) |
| mpn_sub (register mp_ptr res_ptr, |
| register mp_srcptr s1_ptr, |
| register mp_size_t s1_size, |
| register mp_srcptr s2_ptr, |
| register mp_size_t s2_size) |
| #else |
| mpn_sub (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size) |
| register mp_ptr res_ptr; |
| register mp_srcptr s1_ptr; |
| register mp_size_t s1_size; |
| register mp_srcptr s2_ptr; |
| register mp_size_t s2_size; |
| #endif |
| { |
| mp_limb_t cy_limb = 0; |
| |
| if (s2_size != 0) |
| cy_limb = mpn_sub_n (res_ptr, s1_ptr, s2_ptr, s2_size); |
| |
| if (s1_size - s2_size != 0) |
| cy_limb = mpn_sub_1 (res_ptr + s2_size, |
| s1_ptr + s2_size, |
| s1_size - s2_size, |
| cy_limb); |
| return cy_limb; |
| } |
| #endif /* __GNUC__ */ |
| |
| /* Allow faster testing for negative, zero, and positive. */ |
| #define mpz_sgn(Z) ((Z)->_mp_size < 0 ? -1 : (Z)->_mp_size > 0) |
| #define mpf_sgn(F) ((F)->_mp_size < 0 ? -1 : (F)->_mp_size > 0) |
| #define mpq_sgn(Q) ((Q)->_mp_num._mp_size < 0 ? -1 : (Q)->_mp_num._mp_size > 0) |
| |
| /* Allow direct user access to numerator and denominator of a mpq_t object. */ |
| #define mpq_numref(Q) (&((Q)->_mp_num)) |
| #define mpq_denref(Q) (&((Q)->_mp_den)) |
| |
| /* When using GCC, optimize certain common comparisons. */ |
| #if defined (__GNUC__) |
| #define mpz_cmp_ui(Z,UI) \ |
| (__builtin_constant_p (UI) && (UI) == 0 \ |
| ? mpz_sgn (Z) : mpz_cmp_ui (Z,UI)) |
| #define mpz_cmp_si(Z,UI) \ |
| (__builtin_constant_p (UI) && (UI) == 0 ? mpz_sgn (Z) \ |
| : __builtin_constant_p (UI) && (UI) > 0 ? mpz_cmp_ui (Z,UI) \ |
| : mpz_cmp_si (Z,UI)) |
| #define mpq_cmp_ui(Q,NUI,DUI) \ |
| (__builtin_constant_p (NUI) && (NUI) == 0 \ |
| ? mpq_sgn (Q) : mpq_cmp_ui (Q,NUI,DUI)) |
| #endif |
| |
| #define mpn_divmod(qp,np,nsize,dp,dsize) mpn_divrem (qp,0,np,nsize,dp,dsize) |
| #if 0 |
| #define mpn_divmod_1(qp,np,nsize,dlimb) mpn_divrem_1 (qp,0,np,nsize,dlimb) |
| #endif |
| |
| /* Compatibility with GMP 1. */ |
| #define mpz_mdiv mpz_fdiv_q |
| #define mpz_mdivmod mpz_fdiv_qr |
| #define mpz_mmod mpz_fdiv_r |
| #define mpz_mdiv_ui mpz_fdiv_q_ui |
| #define mpz_mdivmod_ui(q,r,n,d) \ |
| ((r == 0) ? mpz_fdiv_q_ui (q,n,d) : mpz_fdiv_qr_ui (q,r,n,d)) |
| #define mpz_mmod_ui(r,n,d) \ |
| ((r == 0) ? mpz_fdiv_ui (n,d) : mpz_fdiv_r_ui (r,n,d)) |
| |
| /* Useful synonyms, but not quite compatible with GMP 1. */ |
| #define mpz_div mpz_fdiv_q |
| #define mpz_divmod mpz_fdiv_qr |
| #define mpz_div_ui mpz_fdiv_q_ui |
| #define mpz_divmod_ui mpz_fdiv_qr_ui |
| #define mpz_mod_ui mpz_fdiv_r_ui |
| #define mpz_div_2exp mpz_fdiv_q_2exp |
| #define mpz_mod_2exp mpz_fdiv_r_2exp |
| |
| #define __GNU_MP_VERSION 2 |
| #define __GNU_MP_VERSION_MINOR 0 |
| #define __GMP_H__ |
| #endif /* __GMP_H__ */ |