passagemath-objects 10.6.47__cp311-cp311-macosx_13_0_x86_64.whl

sage/libs/gmp/mpf.pxd

@@ -0,0 +1,88 @@
+# sage_setup: distribution = sagemath-objects
+# distutils: libraries = gmp
+
+from sage.libs.gmp.types cimport *
+
+cdef extern from "gmp.h":
+
+    ### Floating-point Functions ###
+
+    # Initialization Functions
+    void mpf_set_default_prec (unsigned long int prec)
+    unsigned long int mpf_get_default_prec ()
+    void mpf_init (mpf_t x)
+    void mpf_init2 (mpf_t x, unsigned long int prec)
+    void mpf_clear (mpf_t x)
+    unsigned long int mpf_get_prec (mpf_t op)
+    void mpf_set_prec (mpf_t rop, unsigned long int prec)
+    void mpf_set_prec_raw (mpf_t rop, unsigned long int prec)
+
+    # Assignment Functions
+    void mpf_set (mpf_t rop, mpf_t op)
+    void mpf_set_ui (mpf_t rop, unsigned long int op)
+    void mpf_set_si (mpf_t rop, signed long int op)
+    void mpf_set_d (mpf_t rop, double op)
+    void mpf_set_z (mpf_t rop, mpz_t op)
+    void mpf_set_q (mpf_t rop, mpq_t op)
+    int mpf_set_str (mpf_t rop, char *str, int base)
+    void mpf_swap (mpf_t rop1, mpf_t rop2)
+
+    # Combined Initialization and Assignment Functions
+    void mpf_init_set (mpf_t rop, mpf_t op)
+    void mpf_init_set_ui (mpf_t rop, unsigned long int op)
+    void mpf_init_set_si (mpf_t rop, signed long int op)
+    void mpf_init_set_d (mpf_t rop, double op)
+    int mpf_init_set_str (mpf_t rop, char *str, int base)
+
+    # Conversion Functions
+    double mpf_get_d (mpf_t op)
+    double mpf_get_d_2exp (signed long int *exp, mpf_t op)
+    long mpf_get_si (mpf_t op)
+    unsigned long mpf_get_ui (mpf_t op)
+    char * mpf_get_str (char *str, mp_exp_t *expptr, int base, size_t n_digits, mpf_t op)
+
+    # Arithmetic Functions
+    void mpf_add (mpf_t rop, mpf_t op1, mpf_t op2)
+    void mpf_add_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_sub (mpf_t rop, mpf_t op1, mpf_t op2)
+    void mpf_ui_sub (mpf_t rop, unsigned long int op1, mpf_t op2)
+    void mpf_sub_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_mul (mpf_t rop, mpf_t op1, mpf_t op2)
+    void mpf_mul_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_div (mpf_t rop, mpf_t op1, mpf_t op2)
+    void mpf_ui_div (mpf_t rop, unsigned long int op1, mpf_t op2)
+    void mpf_div_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_sqrt (mpf_t rop, mpf_t op)
+    void mpf_sqrt_ui (mpf_t rop, unsigned long int op)
+    void mpf_pow_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_neg (mpf_t rop, mpf_t op)
+    void mpf_abs (mpf_t rop, mpf_t op)
+    void mpf_mul_2exp (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_div_2exp (mpf_t rop, mpf_t op1, unsigned long int op2)
+
+    # Comparison Functions
+    int mpf_cmp (mpf_t op1, mpf_t op2)
+    int mpf_cmp_d (mpf_t op1, double op2)
+    int mpf_cmp_ui (mpf_t op1, unsigned long int op2)
+    int mpf_cmp_si (mpf_t op1, signed long int op2)
+    int mpf_eq (mpf_t op1, mpf_t op2, unsigned long int op3)
+    void mpf_reldiff (mpf_t rop, mpf_t op1, mpf_t op2)
+    int mpf_sgn (mpf_t op)
+
+    # Input and Output Functions
+    # size_t mpf_out_str (file *stream, int base, size_t n_digits, mpf_t op)
+    # size_t mpf_inp_str (mpf_t rop, file *stream, int base)
+
+    # Miscellaneous Functions
+    void mpf_ceil (mpf_t rop, mpf_t op)
+    void mpf_floor (mpf_t rop, mpf_t op)
+    void mpf_trunc (mpf_t rop, mpf_t op)
+    bint mpf_integer_p (mpf_t op)
+    bint mpf_fits_ulong_p (mpf_t op)
+    bint mpf_fits_slong_p (mpf_t op)
+    bint mpf_fits_uint_p (mpf_t op)
+    bint mpf_fits_sint_p (mpf_t op)
+    bint mpf_fits_ushort_p (mpf_t op)
+    bint mpf_fits_sshort_p (mpf_t op)
+    void mpf_urandomb (mpf_t rop, gmp_randstate_t state, unsigned long int nbits)
+    void mpf_random2 (mpf_t rop, mp_size_t max_size, mp_exp_t exp)

sage/libs/gmp/mpn.pxd

@@ -0,0 +1,57 @@
+# sage_setup: distribution = sagemath-objects
+# distutils: libraries = gmp
+
+from sage.libs.gmp.types cimport *
+
+cdef extern from "gmp.h":
+
+    ### Low-level Functions ###
+
+    mp_limb_t mpn_add_n (mp_limb_t *rp, mp_limb_t *s1p, mp_limb_t *s2p, mp_size_t n)
+    mp_limb_t mpn_add_1 (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t n, mp_limb_t s2limb)
+    mp_limb_t mpn_add (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t s1n, mp_limb_t *s2p, mp_size_t s2n)
+    mp_limb_t mpn_sub_n (mp_limb_t *rp, mp_limb_t *s1p, mp_limb_t *s2p, mp_size_t n)
+    mp_limb_t mpn_sub_1 (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t n, mp_limb_t s2limb)
+    mp_limb_t mpn_sub (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t s1n, mp_limb_t *s2p, mp_size_t s2n)
+    void mpn_mul_n (mp_limb_t *rp, mp_limb_t *s1p, mp_limb_t *s2p, mp_size_t n)
+    mp_limb_t mpn_mul_1 (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t n, mp_limb_t s2limb)
+    mp_limb_t mpn_addmul_1 (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t n, mp_limb_t s2limb)
+    mp_limb_t mpn_submul_1 (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t n, mp_limb_t s2limb)
+    mp_limb_t mpn_mul (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t s1n, mp_limb_t *s2p, mp_size_t s2n)
+    void mpn_tdiv_qr (mp_limb_t *qp, mp_limb_t *rp, mp_size_t qxn, mp_limb_t *np, mp_size_t nn, mp_limb_t *dp, mp_size_t dn)
+    mp_limb_t mpn_divrem (mp_limb_t *r1p, mp_size_t qxn, mp_limb_t *rs2p, mp_size_t rs2n, mp_limb_t *s3p, mp_size_t s3n)
+    mp_limb_t mpn_divrem_1 (mp_limb_t *r1p, mp_size_t qxn, mp_limb_t *s2p, mp_size_t s2n, mp_limb_t s3limb)
+    mp_limb_t mpn_divmod_1 (mp_limb_t *r1p, mp_limb_t *s2p, mp_size_t s2n, mp_limb_t s3limb)
+    mp_limb_t mpn_divmod (mp_limb_t *r1p, mp_limb_t *rs2p, mp_size_t rs2n, mp_limb_t *s3p, mp_size_t s3n)
+    mp_limb_t mpn_divexact_by3 (mp_limb_t *rp, mp_limb_t *sp, mp_size_t n)
+    mp_limb_t mpn_divexact_by3c (mp_limb_t *rp, mp_limb_t *sp, mp_size_t n, mp_limb_t carry)
+    mp_limb_t mpn_mod_1 (mp_limb_t *s1p, mp_size_t s1n, mp_limb_t s2limb)
+    mp_limb_t mpn_bdivmod (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t s1n, mp_limb_t *s2p, mp_size_t s2n, unsigned long int d)
+    mp_limb_t mpn_lshift (mp_limb_t *rp, mp_limb_t *sp, mp_size_t n, unsigned int count)
+    mp_limb_t mpn_rshift (mp_limb_t *rp, mp_limb_t *sp, mp_size_t n, unsigned int count)
+    int mpn_cmp (mp_limb_t *s1p, mp_limb_t *s2p, mp_size_t n)
+    mp_size_t mpn_gcd (mp_limb_t *rp, mp_limb_t *s1p, mp_size_t s1n, mp_limb_t *s2p, mp_size_t s2n)
+    mp_limb_t mpn_gcd_1 (mp_limb_t *s1p, mp_size_t s1n, mp_limb_t s2limb)
+    mp_size_t mpn_gcdext (mp_limb_t *r1p, mp_limb_t *r2p, mp_size_t *r2n, mp_limb_t *s1p, mp_size_t s1n, mp_limb_t *s2p, mp_size_t s2n)
+    mp_size_t mpn_sqrtrem (mp_limb_t *r1p, mp_limb_t *r2p, mp_limb_t *sp, mp_size_t n)
+    mp_size_t mpn_get_str (unsigned char *str, int base, mp_limb_t *s1p, mp_size_t s1n)
+    mp_size_t mpn_set_str (mp_limb_t *rp, unsigned char *str, size_t strsize, int base)
+    unsigned long int mpn_scan0 (mp_limb_t *s1p, unsigned long int bit)
+    unsigned long int mpn_scan1 (mp_limb_t *s1p, unsigned long int bit)
+    void mpn_random (mp_limb_t *r1p, mp_size_t r1n)
+    void mpn_random2 (mp_limb_t *r1p, mp_size_t r1n)
+    unsigned long int mpn_popcount (mp_limb_t *s1p, mp_size_t n)
+    unsigned long int mpn_hamdist (mp_limb_t *s1p, mp_limb_t *s2p, mp_size_t n)
+    int mpn_perfect_square_p (mp_limb_t *s1p, mp_size_t n)
+    void mpn_and_n(mp_ptr rp, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n)
+    void mpn_andn_n(mp_ptr rp, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n)
+    void mpn_nand_n(mp_ptr rp, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n)
+    void mpn_ior_n(mp_ptr rp, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n)
+    void mpn_iorn_n(mp_ptr rp, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n)
+    void mpn_nior_n(mp_ptr rp, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n)
+    void mpn_xor_n(mp_ptr rp, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n)
+    void mpn_xnor_n(mp_ptr rp, mp_srcptr s1p, mp_srcptr s2p, mp_size_t n)
+    void mpn_com(mp_ptr rp, mp_srcptr sp, mp_size_t n)
+    void mpn_copyi(mp_ptr rp, mp_srcptr s1p, mp_size_t n)
+    void mpn_copyd(mp_ptr rp, mp_srcptr s1p, mp_size_t n)
+    void mpn_zero(mp_ptr rp, mp_size_t n)

sage/libs/gmp/mpq.pxd

@@ -0,0 +1,57 @@
+# sage_setup: distribution = sagemath-objects
+# distutils: libraries = gmp
+
+from sage.libs.gmp.types cimport *
+
+cdef extern from "gmp.h":
+
+    ### Rational Functions ###
+
+    void mpq_canonicalize (mpq_t op)
+
+    # Initialization and Assignment Functions
+    void mpq_init (mpq_t dest_rational)
+    void mpq_clear (mpq_t rational_number)
+    void mpq_set (mpq_t rop, mpq_t op)
+    void mpq_set_z (mpq_t rop, mpz_t op)
+    void mpq_set_ui (mpq_t rop, unsigned long int op1, unsigned long int op2)
+    void mpq_set_si (mpq_t rop, signed long int op1, unsigned long int op2)
+    int mpq_set_str (mpq_t rop, char *str, int base)
+    void mpq_swap (mpq_t rop1, mpq_t rop2)
+
+    # Conversion Functions
+    double mpq_get_d (mpq_t op)
+    void mpq_set_d (mpq_t rop, double op)
+    void mpq_set_f (mpq_t rop, mpf_t op)
+    char * mpq_get_str (char *str, int base, mpq_t op)
+
+    # Arithmetic Functions
+    void mpq_add (mpq_t sum, mpq_t addend1, mpq_t addend2)
+    void mpq_sub (mpq_t difference, mpq_t minuend, mpq_t subtrahend)
+    void mpq_mul (mpq_t product, mpq_t multiplier, mpq_t multiplicand)
+    void mpq_mul_2exp (mpq_t rop, mpq_t op1, unsigned long int op2)
+    void mpq_div (mpq_t quotient, mpq_t dividend, mpq_t divisor)
+    void mpq_div_2exp (mpq_t rop, mpq_t op1, unsigned long int op2)
+    void mpq_neg (mpq_t negated_operand, mpq_t operand)
+    void mpq_abs (mpq_t rop, mpq_t op)
+    void mpq_inv (mpq_t inverted_number, mpq_t number)
+
+    # Comparison Functions
+    int mpq_cmp (mpq_t op1, mpq_t op2)
+    int mpq_cmp_ui (mpq_t op1, unsigned long int num2, unsigned long int den2)
+    int mpq_cmp_si (mpq_t op1, long int num2, unsigned long int den2)
+    int mpq_cmp_z (const mpq_t op1, const mpz_t op2)
+    int mpq_sgn (mpq_t op)
+    int mpq_equal (mpq_t op1, mpq_t op2)
+
+    # Applying Integer Functions to Rationals
+    mpz_t mpq_numref (mpq_t op)
+    mpz_t mpq_denref (mpq_t op)
+    void mpq_get_num (mpz_t numerator, mpq_t rational)
+    void mpq_get_den (mpz_t denominator, mpq_t rational)
+    void mpq_set_num (mpq_t rational, mpz_t numerator)
+    void mpq_set_den (mpq_t rational, mpz_t denominator)
+
+    # Input and Output Functions
+    # size_t mpq_out_str (file *stream, int base, mpq_t op)
+    # size_t mpq_inp_str (mpq_t rop, file *stream, int base)

sage/libs/gmp/mpz.pxd

@@ -0,0 +1,202 @@
+# sage_setup: distribution = sagemath-objects
+# distutils: libraries = gmp
+
+from sage.libs.gmp.types cimport *
+from libc.stdio cimport FILE
+
+from libc.stdint cimport intmax_t, uintmax_t
+
+cdef extern from "gmp.h":
+
+    ### Integer Functions ###
+
+    # Initialization Functions
+    void mpz_init (mpz_t integer)
+    void mpz_init2 (mpz_t integer, unsigned long n)
+    void mpz_clear (mpz_t integer)
+    void mpz_realloc2 (mpz_t integer, unsigned long n)
+
+    # Assignment Functions
+    void mpz_set (mpz_t rop, mpz_t op)
+    void mpz_set_ui (mpz_t rop, unsigned long int op)
+    void mpz_set_si (mpz_t rop, signed long int op)
+    void mpz_set_ux (mpz_t rop, uintmax_t op)
+    void mpz_set_sx (mpz_t rop, intmax_t op)
+    void mpz_set_d (mpz_t rop, double op)
+    void mpz_set_q (mpz_t rop, mpq_t op)
+    void mpz_set_f (mpz_t rop, mpf_t op)
+    int mpz_set_str (mpz_t rop, char *str, int base)
+    void mpz_swap (mpz_t rop1, mpz_t rop2)
+
+    # Combined Initialization and Assignment Functions
+    void mpz_init_set (mpz_t rop, mpz_t op)
+    void mpz_init_set_ui (mpz_t rop, unsigned long int op)
+    void mpz_init_set_si (mpz_t rop, signed long int op)
+    void mpz_init_set_ux (mpz_t rop, uintmax_t op)
+    void mpz_init_set_sx (mpz_t rop, intmax_t op)
+    void mpz_init_set_d (mpz_t rop, double op)
+    int mpz_init_set_str (mpz_t rop, char *str, int base)
+
+    # Conversion Functions
+    unsigned long int mpz_get_ui (mpz_t op)
+    signed long int mpz_get_si (mpz_t op)
+    uintmax_t mpz_get_ux (mpz_t op)
+    intmax_t mpz_get_sx (mpz_t op)
+    double mpz_get_d (mpz_t op)
+    double mpz_get_d_2exp (long int *exp, mpz_t op)
+    char * mpz_get_str (char *str, int base, mpz_t op)
+
+    # Arithmetic Functions
+    void mpz_add (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_add_ui (mpz_t rop, mpz_t op1, unsigned long int op2)
+    void mpz_sub (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_sub_ui (mpz_t rop, mpz_t op1, unsigned long int op2)
+    void mpz_ui_sub (mpz_t rop, unsigned long int op1, mpz_t op2)
+    void mpz_mul (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_mul_si (mpz_t rop, mpz_t op1, long int op2)
+    void mpz_mul_ui (mpz_t rop, mpz_t op1, unsigned long int op2)
+    void mpz_addmul (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_addmul_ui (mpz_t rop, mpz_t op1, unsigned long int op2)
+    void mpz_submul (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_submul_ui (mpz_t rop, mpz_t op1, unsigned long int op2)
+    void mpz_mul_2exp (mpz_t rop, mpz_t op1, unsigned long int op2)
+    void mpz_neg (mpz_t rop, mpz_t op)
+    void mpz_abs (mpz_t rop, mpz_t op)
+
+    # Division Functions
+    void mpz_cdiv_q (mpz_t q, mpz_t n, mpz_t d)
+    void mpz_cdiv_r (mpz_t r, mpz_t n, mpz_t d)
+    void mpz_cdiv_qr (mpz_t q, mpz_t r, mpz_t n, mpz_t d)
+    unsigned long int mpz_cdiv_q_ui (mpz_t q, mpz_t n, unsigned long int d)
+    unsigned long int mpz_cdiv_r_ui (mpz_t r, mpz_t n, unsigned long int d)
+    unsigned long int mpz_cdiv_qr_ui (mpz_t q, mpz_t r, mpz_t n, unsigned long int d)
+    unsigned long int mpz_cdiv_ui (mpz_t n, unsigned long int d)
+    void mpz_cdiv_q_2exp (mpz_t q, mpz_t n, unsigned long int b)
+    void mpz_cdiv_r_2exp (mpz_t r, mpz_t n, unsigned long int b)
+    void mpz_fdiv_q (mpz_t q, mpz_t n, mpz_t d)
+    void mpz_fdiv_r (mpz_t r, mpz_t n, mpz_t d)
+    void mpz_fdiv_qr (mpz_t q, mpz_t r, mpz_t n, mpz_t d)
+    unsigned long int mpz_fdiv_q_ui (mpz_t q, mpz_t n, unsigned long int d)
+    unsigned long int mpz_fdiv_r_ui (mpz_t r, mpz_t n, unsigned long int d)
+    unsigned long int mpz_fdiv_qr_ui (mpz_t q, mpz_t r, mpz_t n, unsigned long int d)
+    unsigned long int mpz_fdiv_ui (mpz_t n, unsigned long int d)
+    void mpz_fdiv_q_2exp (mpz_t q, mpz_t n, unsigned long int b)
+    void mpz_fdiv_r_2exp (mpz_t r, mpz_t n, unsigned long int b)
+    void mpz_tdiv_q (mpz_t q, mpz_t n, mpz_t d)
+    void mpz_tdiv_r (mpz_t r, mpz_t n, mpz_t d)
+    void mpz_tdiv_qr (mpz_t q, mpz_t r, mpz_t n, mpz_t d)
+    unsigned long int mpz_tdiv_q_ui (mpz_t q, mpz_t n, unsigned long int d)
+    unsigned long int mpz_tdiv_r_ui (mpz_t r, mpz_t n, unsigned long int d)
+    unsigned long int mpz_tdiv_qr_ui (mpz_t q, mpz_t r, mpz_t n, unsigned long int d)
+    unsigned long int mpz_tdiv_ui (mpz_t n, unsigned long int d)
+    void mpz_tdiv_q_2exp (mpz_t q, mpz_t n, unsigned long int b)
+    void mpz_tdiv_r_2exp (mpz_t r, mpz_t n, unsigned long int b)
+    void mpz_mod (mpz_t r, mpz_t n, mpz_t d)
+    unsigned long int mpz_mod_ui (mpz_t r, mpz_t n, unsigned long int d)
+    void mpz_divexact (mpz_t q, mpz_t n, mpz_t d)
+    void mpz_divexact_ui (mpz_t q, mpz_t n, unsigned long d)
+    bint mpz_divisible_p (mpz_t n, mpz_t d)
+    bint mpz_divisible_ui_p (mpz_t n, unsigned long int d)
+    bint mpz_divisible_2exp_p (mpz_t n, unsigned long int b)
+    bint mpz_congruent_p (mpz_t n, mpz_t c, mpz_t d)
+    bint mpz_congruent_ui_p (mpz_t n, unsigned long int c, unsigned long int d)
+    bint mpz_congruent_2exp_p (mpz_t n, mpz_t c, unsigned long int b)
+
+    # Exponentiation Functions
+    void mpz_powm (mpz_t rop, mpz_t base, mpz_t exp, mpz_t mod)
+    void mpz_powm_ui (mpz_t rop, mpz_t base, unsigned long int exp, mpz_t mod)
+    void mpz_pow_ui (mpz_t rop, mpz_t base, unsigned long int exp)
+    void mpz_ui_pow_ui (mpz_t rop, unsigned long int base, unsigned long int exp)
+
+    # Root Extraction Functions
+    int mpz_root (mpz_t rop, mpz_t op, unsigned long int n)
+    void mpz_rootrem (mpz_t root, mpz_t rem, mpz_t u, unsigned long int n)
+    void mpz_sqrt (mpz_t rop, mpz_t op)
+    void mpz_sqrtrem (mpz_t rop1, mpz_t rop2, mpz_t op)
+    bint mpz_perfect_power_p (mpz_t op)
+    bint mpz_perfect_square_p (mpz_t op)
+
+    # Number Theoretic Functions
+    bint mpz_probab_prime_p (mpz_t n, int reps)
+    void mpz_nextprime (mpz_t rop, mpz_t op)
+    void mpz_gcd (mpz_t rop, mpz_t op1, mpz_t op2)
+    unsigned long int mpz_gcd_ui (mpz_t rop, mpz_t op1, unsigned long int op2)
+    void mpz_gcdext (mpz_t g, mpz_t s, mpz_t t, mpz_t a, mpz_t b)
+    void mpz_lcm (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_lcm_ui (mpz_t rop, mpz_t op1, unsigned long op2)
+    int mpz_invert (mpz_t rop, mpz_t op1, mpz_t op2)
+    int mpz_jacobi (mpz_t a, mpz_t b)
+    int mpz_legendre (mpz_t a, mpz_t p)
+    int mpz_kronecker (mpz_t a, mpz_t b)
+    int mpz_kronecker_si (mpz_t a, long b)
+    int mpz_kronecker_ui (mpz_t a, unsigned long b)
+    int mpz_si_kronecker (long a, mpz_t b)
+    int mpz_ui_kronecker (unsigned long a, mpz_t b)
+    unsigned long int mpz_remove (mpz_t rop, mpz_t op, mpz_t f)
+    void mpz_fac_ui (mpz_t rop, unsigned long int op)
+    void mpz_2fac_ui (mpz_t rop, unsigned long int op)
+    void mpz_mfac_uiui (mpz_t rop, unsigned long int n, unsigned long int m)
+    void mpz_bin_ui (mpz_t rop, mpz_t n, unsigned long int k)
+    void mpz_bin_uiui (mpz_t rop, unsigned long int n, unsigned long int k)
+    void mpz_fib_ui (mpz_t fn, unsigned long int n)
+    void mpz_fib2_ui (mpz_t fn, mpz_t fnsub1, unsigned long int n)
+    void mpz_lucnum_ui (mpz_t ln, unsigned long int n)
+    void mpz_lucnum2_ui (mpz_t ln, mpz_t lnsub1, unsigned long int n)
+
+    # Comparison Functions
+    int mpz_cmp (mpz_t op1, mpz_t op2)
+    int mpz_cmp_d (mpz_t op1, double op2)
+    int mpz_cmp_si (mpz_t op1, signed long int op2)
+    int mpz_cmp_ui (mpz_t op1, unsigned long int op2)
+    int mpz_cmpabs (mpz_t op1, mpz_t op2)
+    int mpz_cmpabs_d (mpz_t op1, double op2)
+    int mpz_cmpabs_ui (mpz_t op1, unsigned long int op2)
+    int mpz_sgn (mpz_t op)
+
+    # Logical and Bit Manipulation Functions
+    void mpz_and (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_ior (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_xor (mpz_t rop, mpz_t op1, mpz_t op2)
+    void mpz_com (mpz_t rop, mpz_t op)
+    unsigned long int mpz_popcount (mpz_t op)
+    unsigned long int mpz_hamdist (mpz_t op1, mpz_t op2)
+    unsigned long int mpz_scan0 (mpz_t op, unsigned long int starting_bit)
+    unsigned long int mpz_scan1 (mpz_t op, unsigned long int starting_bit)
+    void mpz_setbit (mpz_t rop, unsigned long int bit_index)
+    void mpz_clrbit (mpz_t rop, unsigned long int bit_index)
+    void mpz_combit (mpz_t rop, unsigned long int bit_index)
+    int mpz_tstbit (mpz_t op, unsigned long int bit_index)
+
+    # Input and Output Functions
+    size_t mpz_out_str (FILE *stream, int base, mpz_t op)
+    size_t mpz_inp_str (mpz_t rop, FILE *stream, int base)
+    size_t mpz_out_raw (FILE *stream, mpz_t op)
+    size_t mpz_inp_raw (mpz_t rop, FILE *stream)
+
+    # Random Number Functions
+    void mpz_urandomb (mpz_t rop, gmp_randstate_t state, unsigned long int n)
+    void mpz_urandomm (mpz_t rop, gmp_randstate_t state, mpz_t n)
+    void mpz_rrandomb (mpz_t rop, gmp_randstate_t state, unsigned long int n)
+    void mpz_random (mpz_t rop, mp_size_t max_size)
+    void mpz_random2 (mpz_t rop, mp_size_t max_size)
+
+    # Integer Import and Export
+    void mpz_import (mpz_t rop, size_t count, int order, int size, int endian, size_t nails, void *op)
+    void * mpz_export (void *rop, size_t *countp, int order, int size, int endian, size_t nails, mpz_t op)
+
+    # Miscellaneous Functions
+    bint mpz_fits_ulong_p (mpz_t op)
+    bint mpz_fits_slong_p (mpz_t op)
+    bint mpz_fits_uint_p (mpz_t op)
+    bint mpz_fits_sint_p (mpz_t op)
+    bint mpz_fits_ushort_p (mpz_t op)
+    bint mpz_fits_sshort_p (mpz_t op)
+    bint mpz_odd_p (mpz_t op)
+    bint mpz_even_p (mpz_t op)
+    size_t mpz_sizeinbase (mpz_t op, int base)
+
+    # Special Functions
+    void * _mpz_realloc (mpz_t integer, mp_size_t new_alloc)
+    mp_limb_t mpz_getlimbn (mpz_t op, mp_size_t n)
+    size_t mpz_size (mpz_t op)
+    mpz_srcptr mpz_roinit_n (mpz_t x, const mp_limb_t *xp, mp_size_t xs)

sage/libs/gmp/pylong.pxd

@@ -0,0 +1,12 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Various functions to deal with conversion mpz <-> Python int/long
+"""
+
+from cpython.longintrepr cimport py_long
+from sage.libs.gmp.types cimport *
+
+cdef mpz_get_pylong(mpz_srcptr z)
+cdef mpz_get_pyintlong(mpz_srcptr z)
+cdef int mpz_set_pylong(mpz_ptr z, py_long L) except -1
+cdef Py_hash_t mpz_pythonhash(mpz_srcptr z) noexcept

sage/libs/gmp/pylong.pyx

@@ -0,0 +1,150 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Various functions to deal with conversion mpz <-> Python int/long
+
+For doctests, see :class:`Integer`.
+
+AUTHORS:
+
+- Gonzalo Tornaria (2006): initial version
+
+- David Harvey (2007-08-18): added ``mpz_get_pyintlong`` function
+  (:issue:`440`)
+
+- Jeroen Demeyer (2015-02-24): moved from c_lib, rewritten using
+  ``mpz_export`` and ``mpz_import`` (:issue:`17853`)
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2015 Jeroen Demeyer <jdemeyer@cage.ugent.be>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+#*****************************************************************************
+
+from cpython.long cimport PyLong_FromLong
+from cpython.longintrepr cimport _PyLong_New, py_long, digit, PyLong_SHIFT
+from sage.cpython.pycore_long cimport (ob_digit, _PyLong_IsNegative,
+    _PyLong_DigitCount, _PyLong_SetSignAndDigitCount)
+from sage.libs.gmp.mpz cimport *
+
+cdef extern from *:
+    void Py_SET_SIZE(object, Py_ssize_t)
+    int hash_bits """
+        #ifdef _PyHASH_BITS
+        _PyHASH_BITS         /* Python 3 */
+        #else
+        (8 * sizeof(void*))  /* Python 2 */
+        #endif
+        """
+    int limb_bits "(8 * sizeof(mp_limb_t))"
+
+
+# Unused bits in every PyLong digit
+cdef size_t PyLong_nails = 8*sizeof(digit) - PyLong_SHIFT
+
+
+cdef mpz_get_pylong_large(mpz_srcptr z):
+    """
+    Convert a nonzero ``mpz`` to a Python ``long``.
+    """
+    cdef size_t nbits = mpz_sizeinbase(z, 2)
+    cdef size_t pylong_size = (nbits + PyLong_SHIFT - 1) // PyLong_SHIFT
+    cdef py_long L = _PyLong_New(pylong_size)
+    mpz_export(ob_digit(L), NULL, -1, sizeof(digit), 0, PyLong_nails, z)
+    _PyLong_SetSignAndDigitCount(L, mpz_sgn(z), pylong_size)
+    return L
+
+
+cdef mpz_get_pylong(mpz_srcptr z):
+    """
+    Convert an ``mpz`` to a Python ``long``.
+    """
+    if mpz_fits_slong_p(z):
+        return PyLong_FromLong(mpz_get_si(z))
+    return mpz_get_pylong_large(z)
+
+
+cdef mpz_get_pyintlong(mpz_srcptr z):
+    """
+    Convert an ``mpz`` to a Python ``int`` if possible, or a ``long``
+    if the value is too large.
+    """
+    if mpz_fits_slong_p(z):
+        return PyLong_FromLong(mpz_get_si(z))
+    return mpz_get_pylong_large(z)
+
+
+cdef int mpz_set_pylong(mpz_ptr z, py_long L) except -1:
+    """
+    Convert a Python ``long`` `L` to an ``mpz``.
+    """
+    cdef Py_ssize_t pylong_size = _PyLong_DigitCount(L)
+    mpz_import(z, pylong_size, -1, sizeof(digit), 0, PyLong_nails, ob_digit(L))
+    if _PyLong_IsNegative(L):
+        mpz_neg(z, z)
+
+
+cdef Py_hash_t mpz_pythonhash(mpz_srcptr z) noexcept:
+    """
+    Hash an ``mpz``, where the hash value is the same as the hash value
+    of the corresponding Python ``int`` or ``long``, except that we do
+    not replace -1 by -2 (the Cython wrapper for ``__hash__`` does that).
+    """
+    if mpz_sgn(z) == 0:
+        return 0
+
+    # The hash value equals z % m where m = 2 ^ hash_bits - 1.
+    #
+    # Safely compute 2 ^ hash_bits - 1 without overflow
+    cdef mp_limb_t modulus = (((<mp_limb_t>(1) << (hash_bits - 1)) - 1) * 2) + 1
+
+    cdef mp_limb_t h = 0
+    cdef mp_limb_t x, y
+    cdef size_t i, n
+    cdef unsigned int r
+    n = mpz_size(z)
+    for i in range(n):
+        x = mpz_getlimbn(z, i)
+
+        # Computing modulo 2 ^ hash_bits - 1 means that the bit at
+        # position j is really moved to position (j % hash_bits).
+        # We need to shift every bit of x left by (limb_bits * i)
+        # and then put it in the right position to account for
+        # the modulo operation. Store the result in y.
+        if limb_bits == hash_bits:
+            y = x
+        else:
+            r = (limb_bits * i) % hash_bits
+            y = (x << r) & modulus
+            y += (x >> (hash_bits - r)) & modulus
+            # Only do this shift if we don't shift more than the size of the
+            # type
+            if r > 2 * hash_bits - limb_bits:
+                y += (x >> (2 * hash_bits - r))
+            # At this point, y <= 2 * modulus, so y did not overflow, but we
+            # need y <= modulus. We use > instead of >= on the line below
+            # because it generates more efficient code.
+            if y > modulus:
+                y -= modulus
+
+        # Safely compute h = (h + y) % modulus knowing that h < modulus
+        # and y <= modulus
+        if h < modulus - y:
+            h = h + y
+        else:
+            h = h - (modulus - y)
+
+    # Special case for Python 2
+    if limb_bits == hash_bits and h == 0:
+        h = -1
+
+    if mpz_sgn(z) < 0:
+        return -h
+    return h
+
+
+assert hash_bits <= limb_bits <= 2 * hash_bits

sage/libs/gmp/random.pxd

@@ -0,0 +1,25 @@
+# sage_setup: distribution = sagemath-objects
+# distutils: libraries = gmp
+
+from sage.libs.gmp.types cimport *
+
+cdef extern from "gmp.h":
+
+    ### Random Number Functions ###
+
+    # Random State Initialization
+    void gmp_randinit_default (gmp_randstate_t state)
+    int gmp_randinit_mt (gmp_randstate_t state)
+    void gmp_randinit_lc_2exp (gmp_randstate_t state, mpz_t a, unsigned long c, unsigned long m2exp)
+    int gmp_randinit_lc_2exp_size (gmp_randstate_t state, unsigned long size)
+    int gmp_randinit_set (gmp_randstate_t rop, gmp_randstate_t op)
+    # void gmp_randinit (gmp_randstate_t state, gmp_randalg_t alg, ...)
+    void gmp_randclear (gmp_randstate_t state)
+
+    # Random State Seeding
+    void gmp_randseed (gmp_randstate_t state, mpz_t seed)
+    void gmp_randseed_ui (gmp_randstate_t state, unsigned long int seed)
+
+    # Random State Miscellaneous
+    unsigned long gmp_urandomb_ui (gmp_randstate_t state, unsigned long n)
+    unsigned long gmp_urandomm_ui (gmp_randstate_t state, unsigned long n)

sage/libs/gmp/randomize.pxd

@@ -0,0 +1,59 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Generate random rationals in Sage
+"""
+
+from sage.libs.gmp.mpz cimport *
+from sage.libs.gmp.mpq cimport *
+from sage.misc.randstate cimport randstate, current_randstate, SAGE_RAND_MAX
+
+###########################
+
+cdef inline void mpq_randomize_entry(mpq_t x, mpz_t num_bound, mpz_t den_bound) noexcept:
+    cdef randstate rstate = current_randstate()
+    mpz_urandomm(mpq_numref(x), rstate.gmp_state, num_bound)
+    mpz_urandomm(mpq_denref(x), rstate.gmp_state, den_bound)
+    if mpz_sgn(mpq_denref(x)) == 0:
+        mpz_set_si(mpq_denref(x),1)
+    if rstate.c_random() % 2:
+        mpz_mul_si(mpq_numref(x), mpq_numref(x), -1)
+    mpq_canonicalize(x)
+
+cdef inline void mpq_randomize_entry_nonzero(mpq_t x, mpz_t num_bound, mpz_t den_bound) noexcept:
+    mpq_randomize_entry(x, num_bound, den_bound)
+    while mpq_sgn(x) == 0:
+        mpq_randomize_entry(x, num_bound, den_bound)
+
+cdef inline void mpq_randomize_entry_as_int(mpq_t x, mpz_t bound) noexcept:
+    cdef randstate rstate = current_randstate()
+    mpz_urandomm(mpq_numref(x), rstate.gmp_state, bound)
+    mpz_set_si(mpq_denref(x), 1)
+    if rstate.c_random() % 2:
+        mpz_mul_si(mpq_numref(x), mpq_numref(x), -1)
+
+cdef inline void mpq_randomize_entry_as_int_nonzero(mpq_t x, mpz_t bound) noexcept:
+    mpq_randomize_entry_as_int(x, bound)
+    while mpq_sgn(x) == 0:
+        mpq_randomize_entry_as_int(x, bound)
+
+cdef inline void mpq_randomize_entry_recip_uniform(mpq_t x) noexcept:
+    cdef randstate rstate = current_randstate()
+    # Numerator is selected the same way as ZZ.random_element();
+    # denominator is selected in a similar way, but
+    # modified to give only positive integers.  (The corresponding
+    # probability distribution is $X = \mbox{trunc}(1/R)$, where R
+    # varies uniformly between 0 and 1.)
+    cdef int den = rstate.c_random() - SAGE_RAND_MAX/2
+    if den == 0:
+        den = 1
+    mpz_set_si(mpq_numref(x), (SAGE_RAND_MAX/5*2) / den)
+    den = rstate.c_random()
+    if den == 0:
+        den = 1
+    mpz_set_si(mpq_denref(x), SAGE_RAND_MAX / den)
+    mpq_canonicalize(x)
+
+cdef inline void mpq_randomize_entry_recip_uniform_nonzero(mpq_t x) noexcept:
+    mpq_randomize_entry_recip_uniform(x)
+    while mpq_sgn(x) == 0:
+        mpq_randomize_entry_recip_uniform(x)