Ticket #12173: zmod.patch

File zmod.patch, 85.2 KB (added by fredrik.johansson, 10 years ago)
  • sage/libs/flint/zmod_poly.pxd

    # HG changeset patch
    # User Fredrik Johansson <fredrik.johansson@gmail.com>
    # Date 1324222242 0
    # Node ID eff613554034a6ea4aea3fc3d72d612da8fb2253
    # Parent  b72663c760492cc8c360d328a6d370c8f88d2069
    upgrade from flint1 zmod_poly to flint2 nmod_poly
    
    diff --git a/sage/libs/flint/zmod_poly.pxd b/sage/libs/flint/zmod_poly.pxd
    a b  
    55
    66from flint import *
    77
    8 cdef extern from "FLINT/zmod_poly.h":
    9     ctypedef struct zmod_poly_struct:
    10         unsigned long *coeffs
    11         unsigned long alloc
    12         unsigned long length
    13         unsigned long p
    14         double p_inv
     8cdef extern from "FLINT/nmod_poly.h":
    159
    16     ctypedef zmod_poly_struct* zmod_poly_t
     10    ctypedef struct nmod_t:
     11        mp_limb_t n
     12        mp_limb_t ninv
     13        mp_bitcnt_t norm
    1714
    18     ctypedef struct zmod_poly_factor_struct:
    19         zmod_poly_t *factors
     15    ctypedef struct nmod_poly_struct:
     16        mp_limb_t *coeffs
     17        long alloc
     18        long length
     19        nmod_t mod
     20
     21    ctypedef nmod_poly_struct* nmod_poly_t
     22
     23    ctypedef struct nmod_poly_factor_struct:
     24        long alloc
     25        long num_factors
     26        nmod_poly_t *factors
    2027        unsigned long *exponents
    21         unsigned long alloc
    22         unsigned long num_factors
    2328
    24     ctypedef zmod_poly_factor_struct* zmod_poly_factor_t
     29    ctypedef nmod_poly_factor_struct* nmod_poly_factor_t
    2530
    26     cdef void zmod_poly_init(zmod_poly_t poly, unsigned long p)
    27     cdef void zmod_poly_init_precomp(zmod_poly_t poly, unsigned long p, double p_inv)
    28     cdef void zmod_poly_init2(zmod_poly_t poly, unsigned long p, unsigned long alloc)
    29     cdef void zmod_poly_init2_precomp(zmod_poly_t poly, unsigned long p, double p_inv, unsigned long alloc)
    30     cdef void zmod_poly_clear(zmod_poly_t poly)
     31    # Memory management
    3132
    32     cdef void zmod_poly_realloc(zmod_poly_t poly, unsigned long alloc)
    33     # _bits_ only applies to newly allocated coefficients, not existing ones...
     33    cdef void nmod_poly_init(nmod_poly_t poly, mp_limb_t n)
     34    cdef void nmod_poly_init_preinv(nmod_poly_t poly, mp_limb_t n, mp_limb_t ninv)
     35    cdef void nmod_poly_init2(nmod_poly_t poly, mp_limb_t n, long alloc);
     36    cdef void nmod_poly_init2_preinv(nmod_poly_t poly, mp_limb_t n, mp_limb_t ninv, long alloc)
     37    cdef void nmod_poly_realloc(nmod_poly_t poly, long alloc)
     38    cdef void nmod_poly_clear(nmod_poly_t poly)
     39    cdef void nmod_poly_fit_length(nmod_poly_t poly, long alloc)
     40    cdef void _nmod_poly_normalise(nmod_poly_t poly)
    3441
    35     # this non-inlined version REQUIRES that alloc > poly->alloc
    36     void __zmod_poly_fit_length(zmod_poly_t poly, unsigned long alloc)
     42    # Polynomial parameters
    3743
    38     # this is arranged so that the initial comparison (very frequent) is inlined,
    39     # but the actual allocation (infrequent) is not
    40     cdef void zmod_poly_fit_length(zmod_poly_t poly, unsigned long alloc)
     44    cdef long nmod_poly_length(const nmod_poly_t poly)
     45    cdef long nmod_poly_degree(const nmod_poly_t poly)
     46    cdef mp_limb_t nmod_poly_modulus(const nmod_poly_t poly)
     47    cdef mp_bitcnt_t nmod_poly_max_bits(const nmod_poly_t poly)
    4148
    42     # ------------------------------------------------------
    43     # Setting/retrieving coefficients
     49    # Assignment and basic manipulation
    4450
    45     cdef unsigned long zmod_poly_get_coeff_ui(zmod_poly_t poly, unsigned long n)
     51    cdef void nmod_poly_set(nmod_poly_t a, const nmod_poly_t b)
     52    cdef void nmod_poly_swap(nmod_poly_t poly1, nmod_poly_t poly2)
     53    cdef void nmod_poly_zero(nmod_poly_t res)
     54    cdef void nmod_poly_one(nmod_poly_t res)
     55    cdef void nmod_poly_truncate(nmod_poly_t poly, long len)
     56    cdef void _nmod_poly_reverse(mp_ptr output, mp_srcptr input, long len, long m)
     57    cdef void nmod_poly_reverse(nmod_poly_t output, const nmod_poly_t input, long m)
    4658
    47     cdef unsigned long _zmod_poly_get_coeff_ui(zmod_poly_t poly, unsigned long n)
     59    # Comparison
    4860
    49     cdef void zmod_poly_set_coeff_ui(zmod_poly_t poly, unsigned long n, unsigned long c)
     61    cdef int nmod_poly_equal(const nmod_poly_t a, const nmod_poly_t b)
     62    cdef int nmod_poly_is_zero(const nmod_poly_t poly)
     63    cdef int nmod_poly_is_one(const nmod_poly_t poly)
    5064
    51     cdef void _zmod_poly_set_coeff_ui(zmod_poly_t poly, unsigned long n, unsigned long c)
     65    # Randomisation
    5266
    53     # ------------------------------------------------------
    54     # String conversions and I/O
     67    cdef void nmod_poly_randtest(nmod_poly_t poly, flint_rand_t state, long len)
     68    cdef void nmod_poly_randtest_not_zero(nmod_poly_t poly, flint_rand_t state, long len)
    5569
    56     cdef int zmod_poly_from_string(zmod_poly_t poly, char* s)
    57     cdef char* zmod_poly_to_string(zmod_poly_t poly)
    58     cdef void zmod_poly_print(zmod_poly_t poly)
    59     cdef void zmod_poly_fprint(zmod_poly_t poly, FILE* f)
    60     cdef int zmod_poly_read(zmod_poly_t poly)
    61     cdef int zmod_poly_fread(zmod_poly_t poly, FILE* f)
     70    # Getting and setting coefficients
    6271
    63     # ------------------------------------------------------
    64     # Length and degree
     72    cdef unsigned long nmod_poly_get_coeff_ui(const nmod_poly_t poly, unsigned long j)
     73    cdef void nmod_poly_set_coeff_ui(nmod_poly_t poly, unsigned long j, unsigned long c)
    6574
    66     cdef void __zmod_poly_normalise(zmod_poly_t poly)
    67     cdef int __zmod_poly_normalised(zmod_poly_t poly)
    68     cdef void zmod_poly_truncate(zmod_poly_t poly, unsigned long length)
     75    # Input and output
    6976
    70     cdef unsigned long zmod_poly_length(zmod_poly_t poly)
     77    cdef char * nmod_poly_get_str(const nmod_poly_t poly)
     78    cdef int nmod_poly_set_str(const char * s, nmod_poly_t poly)
     79    cdef int nmod_poly_print(const nmod_poly_t a)
     80    cdef int nmod_poly_fread(FILE * f, nmod_poly_t poly)
     81    cdef int nmod_poly_fprint(FILE * f, const nmod_poly_t poly)
     82    cdef int nmod_poly_read(nmod_poly_t poly)
    7183
    72     cdef long zmod_poly_degree(zmod_poly_t poly)
     84    # Shifting
    7385
    74     cdef unsigned long zmod_poly_modulus(zmod_poly_t poly)
     86    cdef void _nmod_poly_shift_left(mp_ptr res, mp_srcptr poly, long len, long k)
     87    cdef void nmod_poly_shift_left(nmod_poly_t res, const nmod_poly_t poly, long k)
     88    cdef void _nmod_poly_shift_right(mp_ptr res, mp_srcptr poly, long len, long k)
     89    cdef void nmod_poly_shift_right(nmod_poly_t res, const nmod_poly_t poly, long k)
    7590
    76     cdef double zmod_poly_precomputed_inverse(zmod_poly_t poly)
     91    # Addition and subtraction
    7792
    78     # ------------------------------------------------------
    79     # Assignment
     93    cdef void _nmod_poly_add(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     94    cdef void nmod_poly_add(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2)
     95    cdef void _nmod_poly_sub(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     96    cdef void nmod_poly_sub(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2)
     97    cdef void nmod_poly_neg(nmod_poly_t res, const nmod_poly_t poly1)
    8098
    81     cdef void _zmod_poly_set(zmod_poly_t res, zmod_poly_t poly)
    82     cdef void zmod_poly_set(zmod_poly_t res, zmod_poly_t poly)
     99    # Scalar multiplication and division
    83100
    84     cdef void zmod_poly_zero(zmod_poly_t poly)
     101    cdef void nmod_poly_scalar_mul_nmod(nmod_poly_t res, const nmod_poly_t poly1, mp_limb_t c)
     102    cdef void _nmod_poly_make_monic(mp_ptr output, mp_srcptr input, long len, nmod_t mod)
     103    cdef void nmod_poly_make_monic(nmod_poly_t output, const nmod_poly_t input)
    85104
    86     cdef void zmod_poly_swap(zmod_poly_t poly1, zmod_poly_t poly2)
     105    # Bit packing and unpacking
    87106
    88     #
    89     # Subpolynomials
    90     #
     107    cdef void _nmod_poly_bit_pack(mp_ptr res, mp_srcptr poly, long len, mp_bitcnt_t bits)
     108    cdef void _nmod_poly_bit_unpack(mp_ptr res, long len, mp_srcptr mpn, mp_bitcnt_t bits, nmod_t mod)
     109    cdef void nmod_poly_bit_pack(fmpz_t f, const nmod_poly_t poly, mp_bitcnt_t bit_size)
     110    cdef void nmod_poly_bit_unpack(nmod_poly_t poly, const fmpz_t f, mp_bitcnt_t bit_size)
    91111
    92     cdef void _zmod_poly_attach(zmod_poly_t output, zmod_poly_t input)
     112    # Multiplication
    93113
    94     cdef void zmod_poly_attach(zmod_poly_t output, zmod_poly_t input)
     114    cdef void _nmod_poly_mul_classical(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     115    cdef void nmod_poly_mul_classical(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2)
     116    cdef void _nmod_poly_mullow_classical(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, long trunc, nmod_t mod)
     117    cdef void nmod_poly_mullow_classical(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, long trunc)
     118    cdef void _nmod_poly_mulhigh_classical(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, long start, nmod_t mod)
     119    cdef void nmod_poly_mulhigh_classical(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, long start)
     120    cdef void _nmod_poly_mul_KS(mp_ptr out, mp_srcptr in1, long len1, mp_srcptr in2, long len2, mp_bitcnt_t bits, nmod_t mod)
    95121
    96     #
    97     # Attach input shifted right by n to output
    98     #
     122    cdef void nmod_poly_mul_KS(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, mp_bitcnt_t bits)
     123    cdef void _nmod_poly_mullow_KS(mp_ptr out, mp_srcptr in1, long len1, mp_srcptr in2, long len2, mp_bitcnt_t bits, long n, nmod_t mod)
     124    cdef void nmod_poly_mullow_KS(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, mp_bitcnt_t bits, long n)
     125    cdef void _nmod_poly_mul(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     126    cdef void nmod_poly_mul(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2)
     127    cdef void _nmod_poly_mullow(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, long trunc, nmod_t mod)
     128    cdef void nmod_poly_mullow(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, long trunc)
     129    cdef void _nmod_poly_mulhigh(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, long n, nmod_t mod)
     130    cdef void nmod_poly_mulhigh(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, long n)
     131    cdef void _nmod_poly_mulmod(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, mp_srcptr f, long lenf, nmod_t mod)
     132    cdef void nmod_poly_mulmod(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, const nmod_poly_t f)
    99133
    100     cdef void _zmod_poly_attach_shift(zmod_poly_t output, zmod_poly_t input, unsigned long n)
     134    # Powering
    101135
    102     cdef void zmod_poly_attach_shift(zmod_poly_t output, zmod_poly_t input, unsigned long n)
     136    cdef void _nmod_poly_pow_binexp(mp_ptr res, mp_srcptr poly, long len, unsigned long e, nmod_t mod)
     137    cdef void nmod_poly_pow_binexp(nmod_poly_t res, const nmod_poly_t poly, unsigned long e)
     138    cdef void _nmod_poly_pow(mp_ptr res, mp_srcptr poly, long len, unsigned long e, nmod_t mod)
     139    cdef void nmod_poly_pow(nmod_poly_t res, const nmod_poly_t poly, unsigned long e)
     140    cdef void _nmod_poly_pow_trunc_binexp(mp_ptr res, mp_srcptr poly, unsigned long e, long trunc, nmod_t mod)
     141    cdef void nmod_poly_pow_trunc_binexp(nmod_poly_t res, const nmod_poly_t poly, unsigned long e, long trunc)
     142    cdef void _nmod_poly_pow_trunc(mp_ptr res, mp_srcptr poly, unsigned long e, long trunc, nmod_t mod)
     143    cdef void nmod_poly_pow_trunc(nmod_poly_t res, const nmod_poly_t poly, unsigned long e, long trunc)
     144    cdef void nmod_poly_powmod_ui_binexp(nmod_poly_t res, const nmod_poly_t poly, unsigned long e, const nmod_poly_t f)
     145    cdef void _nmod_poly_powmod_ui_binexp(mp_ptr res, mp_srcptr poly, unsigned long e, mp_srcptr f, long lenf, nmod_t mod)
     146    cdef void _nmod_poly_powmod_mpz_binexp(mp_ptr res, mp_srcptr poly, mpz_srcptr e, mp_srcptr f, long lenf, nmod_t mod)
     147    cdef void nmod_poly_powmod_mpz_binexp(nmod_poly_t res, const nmod_poly_t poly, mpz_srcptr e, const nmod_poly_t f)
    103148
    104     #
    105     # Attach input to first n coefficients of input
    106     #
     149    # Division
    107150
    108     cdef void _zmod_poly_attach_truncate(zmod_poly_t output,  zmod_poly_t input, unsigned long n)
     151    cdef void _nmod_poly_divrem_basecase(mp_ptr Q, mp_ptr R, mp_ptr W, mp_srcptr A, long A_len, mp_srcptr B, long B_len, nmod_t mod)
     152    cdef void nmod_poly_divrem_basecase(nmod_poly_t Q, nmod_poly_t R, const nmod_poly_t A, const nmod_poly_t B)
     153    cdef void _nmod_poly_divrem_divconquer_recursive(mp_ptr Q, mp_ptr BQ, mp_ptr W, mp_ptr V, mp_srcptr A, mp_srcptr B, long lenB, nmod_t mod)
     154    cdef void _nmod_poly_divrem_divconquer(mp_ptr Q, mp_ptr R, mp_srcptr A, long lenA, mp_srcptr B, long lenB, nmod_t mod)
     155    cdef void nmod_poly_divrem_divconquer(nmod_poly_t Q, nmod_poly_t R, const nmod_poly_t A, const nmod_poly_t B)
     156    cdef void _nmod_poly_divrem(mp_ptr Q, mp_ptr R, mp_srcptr A, long lenA, mp_srcptr B, long lenB, nmod_t mod)
     157    cdef void nmod_poly_divrem(nmod_poly_t Q, nmod_poly_t R, const nmod_poly_t A, const nmod_poly_t B)
     158    cdef void _nmod_poly_div_basecase(mp_ptr Q, mp_ptr W, mp_srcptr A, long A_len, mp_srcptr B, long B_len, nmod_t mod)
     159    cdef void nmod_poly_div_basecase(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B)
     160    cdef void _nmod_poly_div_divconquer_recursive(mp_ptr Q, mp_ptr W, mp_ptr V, mp_srcptr A, mp_srcptr B, long lenB, nmod_t mod)
     161    cdef void _nmod_poly_div_divconquer(mp_ptr Q, mp_srcptr A, long lenA, mp_srcptr B, long lenB, nmod_t mod)
     162    cdef void nmod_poly_div_divconquer(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B)
     163    cdef void _nmod_poly_div(mp_ptr Q, mp_srcptr A, long lenA, mp_srcptr B, long lenB, nmod_t mod)
     164    cdef void nmod_poly_div(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B)
     165    cdef void _nmod_poly_inv_series_basecase(mp_ptr Qinv, mp_srcptr Q, long n, nmod_t mod)
     166    cdef void nmod_poly_inv_series_basecase(nmod_poly_t Qinv, const nmod_poly_t Q, long n)
     167    cdef void _nmod_poly_inv_series_newton(mp_ptr Qinv, mp_srcptr Q, long n, nmod_t mod)
     168    cdef void nmod_poly_inv_series_newton(nmod_poly_t Qinv, const nmod_poly_t Q, long n)
     169    cdef void _nmod_poly_inv_series(mp_ptr Qinv, mp_srcptr Q, long n, nmod_t mod)
     170    cdef void nmod_poly_inv_series(nmod_poly_t Qinv, const nmod_poly_t Q, long n)
     171    cdef void _nmod_poly_div_series(mp_ptr Q, mp_srcptr A, mp_srcptr B, long n, nmod_t mod)
     172    cdef void nmod_poly_div_series(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B, long n)
     173    cdef void _nmod_poly_div_newton(mp_ptr Q, mp_srcptr A, long Alen, mp_srcptr B, long Blen, nmod_t mod)
     174    cdef void nmod_poly_div_newton(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B)
     175    cdef void _nmod_poly_divrem_newton(mp_ptr Q, mp_ptr R, mp_srcptr A, long Alen, mp_srcptr B, long Blen, nmod_t mod)
     176    cdef void nmod_poly_divrem_newton(nmod_poly_t Q, nmod_poly_t R, const nmod_poly_t A, const nmod_poly_t B)
     177    cdef mp_limb_t _nmod_poly_div_root(mp_ptr Q, mp_srcptr A, long len, mp_limb_t c, nmod_t mod)
     178    cdef mp_limb_t nmod_poly_div_root(nmod_poly_t Q, const nmod_poly_t A, mp_limb_t c)
    109179
    110     cdef void zmod_poly_attach_truncate(zmod_poly_t output, zmod_poly_t input, unsigned long n)
     180    # Derivative
    111181
    112     #
    113     # Comparison functions
    114     #
     182    cdef void _nmod_poly_derivative(mp_ptr x_prime, mp_srcptr x, long len, nmod_t mod)
     183    cdef void nmod_poly_derivative(nmod_poly_t x_prime, const nmod_poly_t x)
     184    cdef void _nmod_poly_integral(mp_ptr x_int, mp_srcptr x, long len, nmod_t mod)
     185    cdef void nmod_poly_integral(nmod_poly_t x_int, const nmod_poly_t x)
    115186
    116     cdef int zmod_poly_equal(zmod_poly_t poly1, zmod_poly_t poly2)
     187    # Evaluation
    117188
    118     cdef int zmod_poly_is_one(zmod_poly_t poly1)
     189    cdef mp_limb_t _nmod_poly_evaluate_nmod(mp_srcptr poly, long len, mp_limb_t c, nmod_t mod)
     190    cdef mp_limb_t nmod_poly_evaluate_nmod(const nmod_poly_t poly, mp_limb_t c)
     191    cdef void _nmod_poly_evaluate_nmod_vec(mp_ptr ys, mp_srcptr coeffs, long len, mp_srcptr xs, long n, nmod_t mod)
     192    cdef void nmod_poly_evaluate_nmod_vec(mp_ptr ys, const nmod_poly_t poly, mp_srcptr xs, long n)
    119193
    120     #
    121     # Reversal
    122     #
     194    # Interpolation
    123195
    124     cdef void _zmod_poly_reverse(zmod_poly_t output, zmod_poly_t input, unsigned long length)
    125     cdef void zmod_poly_reverse(zmod_poly_t output, zmod_poly_t input, unsigned long length)
     196    cdef void _nmod_poly_interpolate_nmod_vec_newton(mp_ptr poly, mp_srcptr xs, mp_srcptr ys, long n, nmod_t mod)
     197    cdef void nmod_poly_interpolate_nmod_vec_newton(nmod_poly_t poly, mp_srcptr xs, mp_srcptr ys, long n)
     198    cdef void _nmod_poly_interpolate_nmod_vec_barycentric(mp_ptr poly, mp_srcptr xs, mp_srcptr ys, long n, nmod_t mod)
     199    cdef void nmod_poly_interpolate_nmod_vec_barycentric(nmod_poly_t poly, mp_srcptr xs, mp_srcptr ys, long n)
     200    cdef void _nmod_poly_interpolate_nmod_vec(mp_ptr poly, mp_srcptr xs, mp_srcptr ys, long n, nmod_t mod)
     201    cdef void nmod_poly_interpolate_nmod_vec(nmod_poly_t poly, mp_srcptr xs, mp_srcptr ys, long n)
    126202
    127     #
    128     # Monic polys
    129     #
     203    # Composition
    130204
    131     cdef void zmod_poly_make_monic(zmod_poly_t output, zmod_poly_t pol)
     205    cdef void _nmod_poly_compose_horner(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     206    cdef void nmod_poly_compose_horner(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2)
     207    cdef void _nmod_poly_compose_divconquer(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     208    cdef void nmod_poly_compose_divconquer(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2)
     209    cdef void _nmod_poly_compose(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     210    cdef void nmod_poly_compose(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2)
    132211
    133     #
    134     # Addition and subtraction
    135     #
     212    # Power series composition and reversion
    136213
    137     cdef void zmod_poly_add(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    138     cdef void zmod_poly_add_without_mod(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    139     cdef void zmod_poly_sub(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    140     cdef void _zmod_poly_sub(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    141     cdef void zmod_poly_neg(zmod_poly_t res, zmod_poly_t poly)
     214    cdef void _nmod_poly_compose_series_horner(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, long n, nmod_t mod)
     215    cdef void nmod_poly_compose_series_horner(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, long n)
     216    cdef void _nmod_poly_compose_series_brent_kung(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, long n, nmod_t mod)
     217    cdef void nmod_poly_compose_series_brent_kung(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, long n)
     218    cdef void _nmod_poly_compose_series(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, long n, nmod_t mod)
     219    cdef void nmod_poly_compose_series(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, long n)
     220    cdef void _nmod_poly_reverse_series_lagrange(mp_ptr Qinv, mp_srcptr Q, long n, nmod_t mod)
     221    cdef void nmod_poly_reverse_series_lagrange(nmod_poly_t Qinv, const nmod_poly_t Q, long n)
     222    cdef void _nmod_poly_reverse_series_lagrange_fast(mp_ptr Qinv, mp_srcptr Q, long n, nmod_t mod)
     223    cdef void nmod_poly_reverse_series_lagrange_fast(nmod_poly_t Qinv, const nmod_poly_t Q, long n)
     224    cdef void _nmod_poly_reverse_series_newton(mp_ptr Qinv, mp_srcptr Q, long n, nmod_t mod)
     225    cdef void nmod_poly_reverse_series_newton(nmod_poly_t Qinv, const nmod_poly_t Q, long n)
     226    cdef void _nmod_poly_reverse_series(mp_ptr Qinv, mp_srcptr Q, long n, nmod_t mod)
     227    cdef void nmod_poly_reverse_series(nmod_poly_t Qinv, const nmod_poly_t Q, long n)
     228    cdef void _nmod_poly_compose_series_divconquer(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, long N, nmod_t mod)
     229    cdef void nmod_poly_compose_series_divconquer(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, long N)
    142230
    143     #
    144     # Shifting functions
    145     #
     231    # GCD
    146232
    147     cdef void zmod_poly_left_shift(zmod_poly_t res, zmod_poly_t poly, unsigned long k)
    148     cdef void zmod_poly_right_shift(zmod_poly_t res, zmod_poly_t poly, unsigned long k)
     233    cdef long _nmod_poly_gcd_euclidean(mp_ptr G, mp_srcptr A, long lenA, mp_srcptr B, long lenB, nmod_t mod)
     234    cdef void nmod_poly_gcd_euclidean(nmod_poly_t G, const nmod_poly_t A, const nmod_poly_t B)
     235    cdef long _nmod_poly_gcd(mp_ptr G, mp_srcptr A, long lenA, mp_srcptr B, long lenB, nmod_t mod)
     236    cdef void nmod_poly_gcd(nmod_poly_t G, const nmod_poly_t A, const nmod_poly_t B)
     237    cdef long _nmod_poly_xgcd_euclidean(mp_ptr res, mp_ptr s, mp_ptr t, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     238    cdef void nmod_poly_xgcd_euclidean(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T, const nmod_poly_t A, const nmod_poly_t B)
     239    cdef long _nmod_poly_xgcd(mp_ptr res, mp_ptr s, mp_ptr t, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod)
     240    cdef void nmod_poly_xgcd(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T, const nmod_poly_t A, const nmod_poly_t B)
    149241
    150     #
    151     # Polynomial multiplication
    152     #
    153     # All multiplication functions require that the modulus be no more than FLINT_BITS-1 bits
    154     #
     242    # Square roots
    155243
    156     cdef void zmod_poly_mul(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    157     cdef void zmod_poly_sqr(zmod_poly_t res, zmod_poly_t poly)
     244    cdef void _nmod_poly_invsqrt_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     245    cdef void nmod_poly_invsqrt_series(nmod_poly_t g, const nmod_poly_t h, long n)
     246    cdef void _nmod_poly_sqrt_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     247    cdef void nmod_poly_sqrt_series(nmod_poly_t g, const nmod_poly_t h, long n)
    158248
    159     # Requires that poly1 bits + poly2 bits + log_length is not greater than 2*FLINT_BITS
     249    # Transcendental functions
    160250
    161     cdef void zmod_poly_mul_KS(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits_input)
    162     cdef void _zmod_poly_mul_KS(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits_input)
     251    cdef void _nmod_poly_atan_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     252    cdef void nmod_poly_atan_series(nmod_poly_t g, const nmod_poly_t h, long n)
     253    cdef void _nmod_poly_tan_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     254    cdef void nmod_poly_tan_series(nmod_poly_t g, const nmod_poly_t h, long n)
     255    cdef void _nmod_poly_asin_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     256    cdef void nmod_poly_asin_series(nmod_poly_t g, const nmod_poly_t h, long n)
     257    cdef void _nmod_poly_sin_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     258    cdef void nmod_poly_sin_series(nmod_poly_t g, const nmod_poly_t h, long n)
     259    cdef void _nmod_poly_cos_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     260    cdef void nmod_poly_cos_series(nmod_poly_t g, const nmod_poly_t h, long n)
     261    cdef void _nmod_poly_asinh_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     262    cdef void nmod_poly_asinh_series(nmod_poly_t g, const nmod_poly_t h, long n)
     263    cdef void _nmod_poly_atanh_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     264    cdef void nmod_poly_atanh_series(nmod_poly_t g, const nmod_poly_t h, long n)
     265    cdef void _nmod_poly_sinh_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     266    cdef void nmod_poly_sinh_series(nmod_poly_t g, const nmod_poly_t h, long n)
     267    cdef void _nmod_poly_cosh_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     268    cdef void nmod_poly_cosh_series(nmod_poly_t g, const nmod_poly_t h, long n)
     269    cdef void _nmod_poly_tanh_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
     270    cdef void nmod_poly_tanh_series(nmod_poly_t g, const nmod_poly_t h, long n)
     271    cdef void _nmod_poly_log_series_monomial_ui(mp_ptr res, mp_limb_t coeff, unsigned long power, long n, nmod_t mod)
     272    cdef void nmod_poly_log_series_monomial_ui(nmod_poly_t res, mp_limb_t coeff, unsigned long power, long n)
     273    cdef void _nmod_poly_log_series(mp_ptr res, mp_srcptr f, long n, nmod_t mod)
     274    cdef void nmod_poly_log_series(nmod_poly_t res, const nmod_poly_t f, long n)
     275    cdef void _nmod_poly_exp_series_monomial_ui(mp_ptr res, mp_limb_t coeff, unsigned long power, long n, nmod_t mod)
     276    cdef void nmod_poly_exp_series_monomial_ui(nmod_poly_t res, mp_limb_t coeff, unsigned long power, long n)
     277    cdef void _nmod_poly_exp_series_basecase(mp_ptr f, mp_srcptr h, long hlen, long n, nmod_t mod)
     278    cdef void nmod_poly_exp_series_basecase(nmod_poly_t f, const nmod_poly_t h, long n)
     279    cdef void _nmod_poly_exp_series(mp_ptr f, mp_srcptr h, long n, nmod_t mod)
     280    cdef void nmod_poly_exp_series(nmod_poly_t f, const nmod_poly_t h, long n)
    163281
    164     cdef void zmod_poly_mul_KS_trunc(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits_input, unsigned long trunc)
    165     cdef void _zmod_poly_mul_KS_trunc(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits_input, unsigned long trunc)
     282    # Products
    166283
    167     cdef void _zmod_poly_mul_classical(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    168     cdef void __zmod_poly_mul_classical_mod_last(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits)
    169     cdef void __zmod_poly_mul_classical_mod_throughout(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits)
    170     cdef void zmod_poly_mul_classical(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    171     cdef void _zmod_poly_sqr_classical(zmod_poly_t res, zmod_poly_t poly)
    172     cdef void zmod_poly_sqr_classical(zmod_poly_t res, zmod_poly_t poly)
     284    cdef void nmod_poly_product_roots_nmod_vec(nmod_poly_t poly, mp_srcptr xs, long n)
     285    cdef void _nmod_poly_product_roots_nmod_vec(mp_ptr poly, mp_srcptr xs, long n, nmod_t mod);
    173286
    174     cdef void _zmod_poly_mul_classical_trunc(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
    175     cdef void __zmod_poly_mul_classical_trunc_mod_last(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits, unsigned long trunc)
    176     cdef void __zmod_poly_mul_classical_trunc_mod_throughout(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits, unsigned long trunc)
    177     cdef void zmod_poly_mul_classical_trunc(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
     287    # Inflation and deflation
    178288
    179     cdef void _zmod_poly_mul_classical_trunc_left(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
    180     cdef void __zmod_poly_mul_classical_trunc_left_mod_last(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits, unsigned long trunc)
    181     cdef void __zmod_poly_mul_classical_trunc_left_mod_throughout(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits, unsigned long trunc)
    182     cdef void zmod_poly_mul_classical_trunc_left(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
     289    cdef unsigned long nmod_poly_deflation(const nmod_poly_t input)
     290    cdef void nmod_poly_deflate(nmod_poly_t result, const nmod_poly_t input, unsigned long deflation)
     291    cdef void nmod_poly_inflate(nmod_poly_t result, const nmod_poly_t input, unsigned long inflation)
    183292
    184     cdef void zmod_poly_mul_trunc_n(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
    185     cdef void zmod_poly_mul_trunc_left_n(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
     293    # Factoring
    186294
    187     #
    188     # Bit packing functions
    189     #
    190 
    191     cdef unsigned long zmod_poly_bits(zmod_poly_t poly)
    192     cdef void _zmod_poly_bit_pack_mpn(mp_limb_t * res, zmod_poly_t poly, unsigned long bits, unsigned long length)
    193     cdef void _zmod_poly_bit_unpack_mpn(zmod_poly_t poly, mp_limb_t *mpn, unsigned long length, unsigned long bits)
    194 
    195     cdef void print_binary(unsigned long n, unsigned long len)
    196     cdef void print_binary2(unsigned long n, unsigned long len, unsigned long space_bit)
    197 
    198     #
    199     # Scalar multiplication
    200     #
    201 
    202     cdef void _zmod_poly_scalar_mul(zmod_poly_t res, zmod_poly_t poly, unsigned long scalar)
    203     cdef void zmod_poly_scalar_mul(zmod_poly_t res, zmod_poly_t poly, unsigned long scalar)
    204     cdef void __zmod_poly_scalar_mul_without_mod(zmod_poly_t res, zmod_poly_t poly, unsigned long scalar)
    205 
    206     #
    207     # Division
    208     #
    209 
    210     cdef void zmod_poly_divrem_classical(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
    211     cdef void __zmod_poly_divrem_classical_mod_last(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
    212     cdef void zmod_poly_div_classical(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
    213     cdef void __zmod_poly_div_classical_mod_last(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
    214     cdef void zmod_poly_div_divconquer_recursive(zmod_poly_t Q, zmod_poly_t BQ, zmod_poly_t A, zmod_poly_t B)
    215     cdef void zmod_poly_divrem_divconquer(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
    216     cdef void zmod_poly_div_divconquer(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
    217 
    218     #
    219     # Newton Inversion
    220     #
    221 
    222     cdef void zmod_poly_newton_invert_basecase(zmod_poly_t Q_inv, zmod_poly_t Q, unsigned long n)
    223     cdef void zmod_poly_newton_invert(zmod_poly_t Q_inv, zmod_poly_t Q, unsigned long n)
    224 
    225     #
    226     # Newton Division
    227     #
    228 
    229     cdef void zmod_poly_div_series(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B, unsigned long n)
    230     cdef void zmod_poly_div_newton(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
    231     cdef void zmod_poly_divrem_newton(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
    232 
    233     cdef void zmod_poly_divrem(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
    234 
    235     cdef void zmod_poly_div(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
    236 
    237     #
    238     # Resultant
    239     #
    240 
    241     cdef unsigned long zmod_poly_resultant_euclidean(zmod_poly_t a, zmod_poly_t b)
    242 
    243     cdef unsigned long zmod_poly_resultant(zmod_poly_t a, zmod_poly_t b)
    244 
    245     #
    246     # GCD
    247     #
    248 
    249     cdef void zmod_poly_gcd(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    250     cdef int zmod_poly_gcd_invert(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
    251     cdef void zmod_poly_xgcd(zmod_poly_t res, zmod_poly_t s, zmod_poly_t t, zmod_poly_t poly1, zmod_poly_t poly2)
    252 
    253 
    254 
    255     # Composition / evaluation
    256 
    257     cdef unsigned long zmod_poly_evaluate(zmod_poly_t, unsigned long)
    258     cdef void zmod_poly_compose_horner(zmod_poly_t, zmod_poly_t, zmod_poly_t)
    259 
    260     # Factorization
    261 
    262     cdef bint zmod_poly_isirreducible(zmod_poly_t p)
    263 
    264     ctypedef struct zmod_poly_factors_struct:
    265         unsigned long num_factors
    266         unsigned long* exponents
    267         zmod_poly_t* factors
    268 
    269     ctypedef zmod_poly_factors_struct* zmod_poly_factor_t
    270 
    271     cdef void zmod_poly_factor_init(zmod_poly_factor_t)
    272     cdef void zmod_poly_factor_clear(zmod_poly_factor_t)
    273     cdef unsigned long zmod_poly_factor(zmod_poly_factor_t, zmod_poly_t)
    274     cdef void zmod_poly_factor_square_free(zmod_poly_factor_t, zmod_poly_t)
    275     cdef void zmod_poly_factor_berlekamp(zmod_poly_factor_t factors, zmod_poly_t f)
    276 
    277     cdef void zmod_poly_factor_add(zmod_poly_factor_t fac, zmod_poly_t poly)
    278     cdef void zmod_poly_factor_concat(zmod_poly_factor_t res, zmod_poly_factor_t fac)
    279     cdef void zmod_poly_factor_print(zmod_poly_factor_t fac)
    280     cdef void zmod_poly_factor_pow(zmod_poly_factor_t fac, unsigned long exp)
    281 
    282     #
    283     # Differentiation
    284     #
    285  
    286     cdef void zmod_poly_derivative(zmod_poly_t res, zmod_poly_t poly)
    287    
    288     #
    289     # Arithmetic modulo a polynomial
    290     #
    291    
    292     cdef void zmod_poly_mulmod(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, zmod_poly_t f)
    293     cdef void zmod_poly_powmod(zmod_poly_t res,zmod_poly_t pol, long exp, zmod_poly_t f)
     295    cdef void nmod_poly_factor_clear(nmod_poly_factor_t fac)
     296    cdef void nmod_poly_factor_init(nmod_poly_factor_t fac)
     297    cdef void nmod_poly_factor_insert(nmod_poly_factor_t fac, const nmod_poly_t poly, unsigned long exp)
     298    cdef void nmod_poly_factor_print(const nmod_poly_factor_t fac)
     299    cdef void nmod_poly_factor_concat(nmod_poly_factor_t res, const nmod_poly_factor_t fac)
     300    cdef void nmod_poly_factor_pow(nmod_poly_factor_t fac, unsigned long exp)
     301    cdef void nmod_poly_factor_equal_deg(nmod_poly_factor_t factors, const nmod_poly_t pol, unsigned long d)
     302    cdef int nmod_poly_factor_equal_deg_prob(nmod_poly_t factor, flint_rand_t state, const nmod_poly_t pol, unsigned long d)
     303    cdef unsigned long nmod_poly_remove(nmod_poly_t f, const nmod_poly_t p)
     304    cdef int nmod_poly_is_irreducible(const nmod_poly_t f)
     305    cdef int _nmod_poly_is_squarefree(mp_srcptr f, long len, nmod_t mod)
     306    cdef int nmod_poly_is_squarefree(nmod_poly_t f)
     307    cdef void nmod_poly_factor_cantor_zassenhaus(nmod_poly_factor_t res, const nmod_poly_t f)
     308    cdef void nmod_poly_factor_berlekamp(nmod_poly_factor_t factors, const nmod_poly_t f)
     309    cdef void nmod_poly_factor_squarefree(nmod_poly_factor_t res, const nmod_poly_t f)
     310    cdef mp_limb_t nmod_poly_factor_with_berlekamp(nmod_poly_factor_t result, const nmod_poly_t input)
     311    cdef mp_limb_t nmod_poly_factor_with_cantor_zassenhaus(nmod_poly_factor_t result, const nmod_poly_t input)
     312    cdef mp_limb_t nmod_poly_factor(nmod_poly_factor_t result, const nmod_poly_t input)
  • sage/rings/fraction_field_FpT.pxd

    diff --git a/sage/rings/fraction_field_FpT.pxd b/sage/rings/fraction_field_FpT.pxd
    a b  
    77from sage.categories.map cimport Section
    88
    99cdef class FpTElement(RingElement):
    10     cdef zmod_poly_t _numer, _denom
     10    cdef nmod_poly_t _numer, _denom
    1111    cdef bint initalized
    1212    cdef long p
    1313
     
    2323    cdef parent
    2424    cdef long degree
    2525    cdef FpTElement cur
    26     cdef zmod_poly_t g
     26    cdef nmod_poly_t g
  • sage/rings/fraction_field_FpT.pyx

    diff --git a/sage/rings/fraction_field_FpT.pyx b/sage/rings/fraction_field_FpT.pyx
    a b  
    105105            numer = parent.poly_ring(numer)
    106106            denom = parent.poly_ring(denom)
    107107        self.p = parent.p
    108         zmod_poly_init(self._numer, self.p)
    109         zmod_poly_init(self._denom, self.p)
     108        nmod_poly_init(self._numer, self.p)
     109        nmod_poly_init(self._denom, self.p)
    110110        self.initalized = True
    111111        cdef long n
    112112        for n, a in enumerate(numer):
    113             zmod_poly_set_coeff_ui(self._numer, n, a)
     113            nmod_poly_set_coeff_ui(self._numer, n, a)
    114114        for n, a in enumerate(denom):
    115             zmod_poly_set_coeff_ui(self._denom, n, a)
     115            nmod_poly_set_coeff_ui(self._denom, n, a)
    116116        if reduce:
    117117            normalize(self._numer, self._denom, self.p)
    118118
     
    127127            sage: del t # indirect doctest
    128128        """
    129129        if self.initalized:
    130             zmod_poly_clear(self._numer)
    131             zmod_poly_clear(self._denom)
     130            nmod_poly_clear(self._numer)
     131            nmod_poly_clear(self._denom)
    132132   
    133133    def __reduce__(self):
    134134        """
     
    152152        cdef FpTElement x = <FpTElement>PY_NEW(FpTElement)
    153153        x._parent = self._parent
    154154        x.p = self.p
    155         zmod_poly_init_precomp(x._numer, x.p, self._numer.p_inv)
    156         zmod_poly_init_precomp(x._denom, x.p, self._numer.p_inv)
     155        nmod_poly_init2_preinv(x._numer, x.p, self._numer.mod.ninv)
     156        nmod_poly_init2_preinv(x._denom, x.p, self._numer.mod.ninv)
    157157        x.initalized = True
    158158        return x
    159159   
     
    164164        cdef FpTElement x = <FpTElement>PY_NEW(FpTElement)
    165165        x._parent = self._parent
    166166        x.p = self.p
    167         zmod_poly_init2_precomp(x._numer, x.p, self._numer.p_inv, self._numer.length)
    168         zmod_poly_init2_precomp(x._denom, x.p, self._denom.p_inv, self._denom.length)
    169         zmod_poly_set(x._numer, self._numer)
    170         zmod_poly_set(x._denom, self._denom)
     167        nmod_poly_init2_preinv(x._numer, x.p, self._numer.mod.ninv, self._numer.length)
     168        nmod_poly_init2_preinv(x._denom, x.p, self._denom.mod.ninv, self._denom.length)
     169        nmod_poly_set(x._numer, self._numer)
     170        nmod_poly_set(x._denom, self._denom)
    171171        x.initalized = True
    172172        return x
    173173   
     
    196196            t^6 + 3*t^4 + 10*t^3 + 3*t^2 + 1
    197197        """
    198198        cdef Polynomial_zmod_flint res = <Polynomial_zmod_flint>PY_NEW(Polynomial_zmod_flint)
    199         zmod_poly_init2_precomp(&res.x, self.p, self._numer.p_inv, self._numer.length)
    200         zmod_poly_set(&res.x, self._numer)
     199        nmod_poly_init2_preinv(&res.x, self.p, self._numer.mod.ninv, self._numer.length)
     200        nmod_poly_set(&res.x, self._numer)
    201201        res._parent = self._parent.poly_ring
    202202        return res
    203203
     
    226226            t^3
    227227        """
    228228        cdef Polynomial_zmod_flint res = <Polynomial_zmod_flint>PY_NEW(Polynomial_zmod_flint)
    229         zmod_poly_init2_precomp(&res.x, self.p, self._denom.p_inv, self._denom.length)
    230         zmod_poly_set(&res.x, self._denom)
     229        nmod_poly_init2_preinv(&res.x, self.p, self._denom.mod.ninv, self._denom.length)
     230        nmod_poly_set(&res.x, self._denom)
    231231        res._parent = self._parent.poly_ring
    232232        return res
    233233   
     
    313313            sage: (1-t)/t
    314314            (16*t + 1)/t
    315315        """
    316         if zmod_poly_degree(self._denom) == 0 and zmod_poly_get_coeff_ui(self._denom, 0) == 1:
     316        if nmod_poly_degree(self._denom) == 0 and nmod_poly_get_coeff_ui(self._denom, 0) == 1:
    317317            return repr(self.numer())
    318318        else:
    319319            numer_s = repr(self.numer())
     
    336336            sage: latex((t + 1)/(t-1))
    337337            \frac{t + 1}{t + 6}
    338338        """
    339         if zmod_poly_degree(self._denom) == 0 and zmod_poly_get_coeff_ui(self._denom, 0) == 1:
     339        if nmod_poly_degree(self._denom) == 0 and nmod_poly_get_coeff_ui(self._denom, 0) == 1:
    340340            return self.numer()._latex_()
    341341        else:
    342342            return "\\frac{%s}{%s}" % (self.numer()._latex_(), self.denom()._latex_())
     
    389389            False
    390390        """
    391391        # They are normalized.
    392         cdef int j = sage_cmp_zmod_poly_t(self._numer, (<FpTElement>other)._numer)
     392        cdef int j = sage_cmp_nmod_poly_t(self._numer, (<FpTElement>other)._numer)
    393393        if j: return j
    394         return sage_cmp_zmod_poly_t(self._denom, (<FpTElement>other)._denom)
     394        return sage_cmp_nmod_poly_t(self._denom, (<FpTElement>other)._denom)
    395395   
    396396    def __hash__(self):
    397397        """
     
    426426            (4*t^2 + 3)/(t + 4)
    427427        """
    428428        cdef FpTElement x = self._copy_c()
    429         zmod_poly_neg(x._numer, x._numer)
     429        nmod_poly_neg(x._numer, x._numer)
    430430        return x
    431431       
    432432    def __invert__(self):
     
    440440            sage: ~a # indirect doctest
    441441            (t + 4)/(t^2 + 2)
    442442        """
    443         if zmod_poly_degree(self._numer) == -1:
     443        if nmod_poly_degree(self._numer) == -1:
    444444            raise ZeroDivisionError
    445445        cdef FpTElement x = self._copy_c()
    446         zmod_poly_swap(x._numer, x._denom)
     446        nmod_poly_swap(x._numer, x._denom)
    447447        return x
    448448
    449449    cpdef ModuleElement _add_(self, ModuleElement _other):
     
    467467        """
    468468        cdef FpTElement other = <FpTElement>_other
    469469        cdef FpTElement x = self._new_c()
    470         zmod_poly_mul(x._numer, self._numer, other._denom)
    471         zmod_poly_mul(x._denom, self._denom, other._numer) # use x._denom as a temp
    472         zmod_poly_add(x._numer, x._numer, x._denom)
    473         zmod_poly_mul(x._denom, self._denom, other._denom)
     470        nmod_poly_mul(x._numer, self._numer, other._denom)
     471        nmod_poly_mul(x._denom, self._denom, other._numer) # use x._denom as a temp
     472        nmod_poly_add(x._numer, x._numer, x._denom)
     473        nmod_poly_mul(x._denom, self._denom, other._denom)
    474474        normalize(x._numer, x._denom, self.p)
    475475        return x
    476476
     
    489489        """
    490490        cdef FpTElement other = <FpTElement>_other
    491491        cdef FpTElement x = self._new_c()
    492         zmod_poly_mul(x._numer, self._numer, other._denom)
    493         zmod_poly_mul(x._denom, self._denom, other._numer) # use x._denom as a temp
    494         zmod_poly_sub(x._numer, x._numer, x._denom)
    495         zmod_poly_mul(x._denom, self._denom, other._denom)
     492        nmod_poly_mul(x._numer, self._numer, other._denom)
     493        nmod_poly_mul(x._denom, self._denom, other._numer) # use x._denom as a temp
     494        nmod_poly_sub(x._numer, x._numer, x._denom)
     495        nmod_poly_mul(x._denom, self._denom, other._denom)
    496496        normalize(x._numer, x._denom, self.p)
    497497        return x
    498498
     
    511511        """
    512512        cdef FpTElement other = <FpTElement>_other
    513513        cdef FpTElement x = self._new_c()
    514         zmod_poly_mul(x._numer, self._numer, other._numer)
    515         zmod_poly_mul(x._denom, self._denom, other._denom)
     514        nmod_poly_mul(x._numer, self._numer, other._numer)
     515        nmod_poly_mul(x._denom, self._denom, other._denom)
    516516        normalize(x._numer, x._denom, self.p)
    517517        return x
    518518
     
    532532            t + 1
    533533        """
    534534        cdef FpTElement other = <FpTElement>_other
    535         if zmod_poly_degree(other._numer) == -1:
     535        if nmod_poly_degree(other._numer) == -1:
    536536            raise ZeroDivisionError
    537537        cdef FpTElement x = self._new_c()
    538         zmod_poly_mul(x._numer, self._numer, other._denom)
    539         zmod_poly_mul(x._denom, self._denom, other._numer)
     538        nmod_poly_mul(x._numer, self._numer, other._denom)
     539        nmod_poly_mul(x._denom, self._denom, other._numer)
    540540        normalize(x._numer, x._denom, self.p)
    541541        return x
    542542   
     
    601601        """
    602602        cdef FpTElement next = self._copy_c()
    603603        cdef long a, lead
    604         cdef zmod_poly_t g
    605         if zmod_poly_degree(self._numer) == -1:
     604        cdef nmod_poly_t g
     605        if nmod_poly_degree(self._numer) == -1:
    606606            # self should be normalized, so denom == 1
    607             zmod_poly_set_coeff_ui(next._numer, 0, 1)
     607            nmod_poly_set_coeff_ui(next._numer, 0, 1)
    608608            return next
    609         lead = zmod_poly_leading(next._numer)
     609        lead = nmod_poly_leading(next._numer)
    610610        if lead < self.p - 1:
    611611            a = mod_inverse_int(lead, self.p)
    612612            # no overflow since self.p < 2^16
    613613            a = a * (lead + 1) % self.p
    614             zmod_poly_scalar_mul(next._numer, next._numer, a)
     614            nmod_poly_scalar_mul_nmod(next._numer, next._numer, a)
    615615        else:
    616616            a = mod_inverse_int(lead, self.p)
    617             zmod_poly_scalar_mul(next._numer, next._numer, a)
     617            nmod_poly_scalar_mul_nmod(next._numer, next._numer, a)
    618618            # now both next._numer and next._denom are monic.  We figure out which is lexicographically bigger:
    619             a = zmod_poly_cmp(next._numer, next._denom)
     619            a = nmod_poly_cmp(next._numer, next._denom)
    620620            if a == 0:
    621621                # next._numer and next._denom are relatively prime, so they're both 1.
    622                 zmod_poly_inc(next._denom, True)
     622                nmod_poly_inc(next._denom, True)
    623623                return next
    624             zmod_poly_set(next._denom, next._numer)
    625             zmod_poly_set(next._numer, self._denom)
     624            nmod_poly_set(next._denom, next._numer)
     625            nmod_poly_set(next._numer, self._denom)
    626626            if a < 0:
    627627                # since next._numer is smaller, we flip and return the inverse.
    628628                return next
    629629            elif a > 0:
    630630                # since next._numer is bigger, we're in the flipped phase.  We flip back, and increment the numerator (until we reach the denominator).
    631                 zmod_poly_init(g, self.p)
     631                nmod_poly_init(g, self.p)
    632632                try:
    633633                    while True:
    634                         zmod_poly_inc(next._numer, True)
    635                         if zmod_poly_equal(next._numer, next._denom):
     634                        nmod_poly_inc(next._numer, True)
     635                        if nmod_poly_equal(next._numer, next._denom):
    636636                            # Since we've reached the denominator, we reset the numerator to 1 and increment the denominator.
    637                             zmod_poly_inc(next._denom, True)
    638                             zmod_poly_zero(next._numer)
    639                             zmod_poly_set_coeff_ui(next._numer, 0, 1)
     637                            nmod_poly_inc(next._denom, True)
     638                            nmod_poly_zero(next._numer)
     639                            nmod_poly_set_coeff_ui(next._numer, 0, 1)
    640640                            break
    641641                        else:
    642642                            # otherwise, we keep incrementing until we have a relatively prime numerator.
    643                             zmod_poly_gcd(g, next._numer, next._denom)
    644                             if zmod_poly_is_one(g):
     643                            nmod_poly_gcd(g, next._numer, next._denom)
     644                            if nmod_poly_is_one(g):
    645645                                break
    646646                finally:
    647                     zmod_poly_clear(g)
     647                    nmod_poly_clear(g)
    648648        return next
    649649       
    650650    cpdef _sqrt_or_None(self):
     
    684684            []
    685685
    686686        """
    687         if zmod_poly_degree(self._numer) == -1:
     687        if nmod_poly_degree(self._numer) == -1:
    688688            return self
    689         if not zmod_poly_sqrt_check(self._numer) or not zmod_poly_sqrt_check(self._denom):
     689        if not nmod_poly_sqrt_check(self._numer) or not nmod_poly_sqrt_check(self._denom):
    690690            return None
    691         cdef zmod_poly_t numer
    692         cdef zmod_poly_t denom
     691        cdef nmod_poly_t numer
     692        cdef nmod_poly_t denom
    693693        cdef FpTElement res
    694694        try:
    695             zmod_poly_init(denom, self.p)
    696             zmod_poly_init(numer, self.p)
    697             if not zmod_poly_sqrt0(numer, self._numer):
     695            nmod_poly_init(denom, self.p)
     696            nmod_poly_init(numer, self.p)
     697            if not nmod_poly_sqrt0(numer, self._numer):
    698698                return None
    699             if not zmod_poly_sqrt0(denom, self._denom):
     699            if not nmod_poly_sqrt0(denom, self._denom):
    700700                return None
    701701            res = self._new_c()
    702             zmod_poly_swap(numer, res._numer)
    703             zmod_poly_swap(denom, res._denom)
     702            nmod_poly_swap(numer, res._numer)
     703            nmod_poly_swap(denom, res._denom)
    704704            return res
    705705        finally:
    706             zmod_poly_clear(numer)
    707             zmod_poly_clear(denom)
     706            nmod_poly_clear(numer)
     707            nmod_poly_clear(denom)
    708708   
    709709    cpdef bint is_square(self):
    710710        """
     
    790790        assert dummy is None
    791791        cdef FpTElement x = self._new_c()
    792792        if e >= 0:
    793             zmod_poly_pow(x._numer, self._numer, e)
    794             zmod_poly_pow(x._denom, self._denom, e)
     793            nmod_poly_pow(x._numer, self._numer, e)
     794            nmod_poly_pow(x._denom, self._denom, e)
    795795        else:
    796             zmod_poly_pow(x._denom, self._numer, -e)
    797             zmod_poly_pow(x._numer, self._denom, -e)
    798             if zmod_poly_leading(x._denom) != 1:
    799                 a = mod_inverse_int(zmod_poly_leading(x._denom), self.p)
    800                 zmod_poly_scalar_mul(x._numer, x._numer, a)
    801                 zmod_poly_scalar_mul(x._denom, x._denom, a)
     796            nmod_poly_pow(x._denom, self._numer, -e)
     797            nmod_poly_pow(x._numer, self._denom, -e)
     798            if nmod_poly_leading(x._denom) != 1:
     799                a = mod_inverse_int(nmod_poly_leading(x._denom), self.p)
     800                nmod_poly_scalar_mul_nmod(x._numer, x._numer, a)
     801                nmod_poly_scalar_mul_nmod(x._denom, x._denom, a)
    802802        return x
    803803
    804804       
     
    876876            sage: I
    877877            <sage.rings.fraction_field_FpT.FpT_iter object at ...>
    878878        """
    879         zmod_poly_init(self.g, parent.characteristic())
     879        nmod_poly_init(self.g, parent.characteristic())
    880880   
    881881    def __dealloc__(self):
    882882        """
     
    889889            sage: I = FpT_iter(K, 3)
    890890            sage: del I # indirect doctest
    891891        """
    892         zmod_poly_clear(self.g)
     892        nmod_poly_clear(self.g)
    893893   
    894894    def __iter__(self):
    895895        """
     
    969969            next = self.cur._copy_c()
    970970            sig_on()
    971971            while True:
    972                 zmod_poly_inc(next._numer, False)
    973                 if zmod_poly_degree(next._numer) > self.degree:
    974                     zmod_poly_inc(next._denom, True)
    975                     if zmod_poly_degree(next._denom) > self.degree:
     972                nmod_poly_inc(next._numer, False)
     973                if nmod_poly_degree(next._numer) > self.degree:
     974                    nmod_poly_inc(next._denom, True)
     975                    if nmod_poly_degree(next._denom) > self.degree:
    976976                        sig_off()
    977977                        raise StopIteration
    978                     zmod_poly_zero(next._numer)
    979                     zmod_poly_set_coeff_ui(next._numer, 0, 1)
    980                 zmod_poly_gcd(self.g, next._numer, next._denom)
    981                 if zmod_poly_is_one(self.g):
     978                    nmod_poly_zero(next._numer)
     979                    nmod_poly_set_coeff_ui(next._numer, 0, 1)
     980                nmod_poly_gcd(self.g, next._numer, next._denom)
     981                if nmod_poly_is_one(self.g):
    982982                    break
    983983            sig_off()
    984984            self.cur = next
    985985#            self.cur = self.cur.next()
    986 #            if zmod_poly_degree(self.cur._numer) > self.degree:
     986#            if nmod_poly_degree(self.cur._numer) > self.degree:
    987987#                raise StopIteration
    988988        return self.cur
    989989
     
    10331033        cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
    10341034        ans._parent = self._codomain
    10351035        ans.p = self.p
    1036         zmod_poly_init(ans._numer, ans.p)
    1037         zmod_poly_init(ans._denom, ans.p)
    1038         zmod_poly_set(ans._numer, &x.x)
    1039         zmod_poly_set_coeff_ui(ans._denom, 0, 1)
     1036        nmod_poly_init(ans._numer, ans.p)
     1037        nmod_poly_init(ans._denom, ans.p)
     1038        nmod_poly_set(ans._numer, &x.x)
     1039        nmod_poly_set_coeff_ui(ans._denom, 0, 1)
    10401040        ans.initalized = True
    10411041        return ans
    10421042
     
    10621062        cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
    10631063        ans._parent = self._codomain
    10641064        ans.p = self.p
    1065         zmod_poly_init(ans._numer, ans.p)
    1066         zmod_poly_init(ans._denom, ans.p)
     1065        nmod_poly_init(ans._numer, ans.p)
     1066        nmod_poly_init(ans._denom, ans.p)
    10671067        cdef long r
    1068         zmod_poly_set(ans._numer, &x.x)
     1068        nmod_poly_set(ans._numer, &x.x)
    10691069        if len(args) == 0:
    1070             zmod_poly_set_coeff_ui(ans._denom, 0, 1)
     1070            nmod_poly_set_coeff_ui(ans._denom, 0, 1)
    10711071        elif len(args) == 1:
    10721072            y = args[0]
    10731073            if PY_TYPE_CHECK(y, Integer):
    10741074                r = mpz_fdiv_ui((<Integer>y).value, self.p)
    10751075                if r == 0:
    10761076                    raise ZeroDivisionError
    1077                 zmod_poly_set_coeff_ui(ans._denom, 0, r)
     1077                nmod_poly_set_coeff_ui(ans._denom, 0, r)
    10781078            else:
    10791079                # could use the coerce keyword being set to False to not check this...
    10801080                if not (PY_TYPE_CHECK(y, Element) and y.parent() is self._domain):
    10811081                    # We could special case integers and GF(p) elements here.
    10821082                    y = self._domain(y)
    1083                 zmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
     1083                nmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
    10841084        else:
    10851085            raise ValueError, "FpT only supports two positional arguments"
    10861086        if not (kwds.has_key('reduce') and not kwds['reduce']):
     
    11671167        """
    11681168        cdef FpTElement x = <FpTElement?>_x
    11691169        cdef Polynomial_zmod_flint ans
    1170         if zmod_poly_degree(x._denom) != 0:
     1170        if nmod_poly_degree(x._denom) != 0:
    11711171            normalize(x._numer, x._denom, self.p)
    1172             if zmod_poly_degree(x._denom) != 0:
     1172            if nmod_poly_degree(x._denom) != 0:
    11731173                raise ValueError, "not integral"
    11741174        ans = PY_NEW(Polynomial_zmod_flint)
    1175         if zmod_poly_get_coeff_ui(x._denom, 0) != 1:
     1175        if nmod_poly_get_coeff_ui(x._denom, 0) != 1:
    11761176            normalize(x._numer, x._denom, self.p)
    1177         zmod_poly_init(&ans.x, self.p)
    1178         zmod_poly_set(&ans.x, x._numer)
     1177        nmod_poly_init(&ans.x, self.p)
     1178        nmod_poly_set(&ans.x, x._numer)
    11791179        ans._parent = self._codomain
    11801180        return ans
    11811181
     
    12251225        cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
    12261226        ans._parent = self._codomain
    12271227        ans.p = self.p
    1228         zmod_poly_init(ans._numer, ans.p)
    1229         zmod_poly_init(ans._denom, ans.p)
    1230         zmod_poly_set_coeff_ui(ans._numer, 0, x.ivalue)
    1231         zmod_poly_set_coeff_ui(ans._denom, 0, 1)
     1228        nmod_poly_init(ans._numer, ans.p)
     1229        nmod_poly_init(ans._denom, ans.p)
     1230        nmod_poly_set_coeff_ui(ans._numer, 0, x.ivalue)
     1231        nmod_poly_set_coeff_ui(ans._denom, 0, 1)
    12321232        ans.initalized = True
    12331233        return ans
    12341234
     
    12541254        cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
    12551255        ans._parent = self._codomain
    12561256        ans.p = self.p
    1257         zmod_poly_init(ans._numer, ans.p)
    1258         zmod_poly_init(ans._denom, ans.p)
     1257        nmod_poly_init(ans._numer, ans.p)
     1258        nmod_poly_init(ans._denom, ans.p)
    12591259        cdef long r
    1260         zmod_poly_set_coeff_ui(ans._numer, 0, x.ivalue)
     1260        nmod_poly_set_coeff_ui(ans._numer, 0, x.ivalue)
    12611261        if len(args) == 0:
    1262             zmod_poly_set_coeff_ui(ans._denom, 0, 1)
     1262            nmod_poly_set_coeff_ui(ans._denom, 0, 1)
    12631263        if len(args) == 1:
    12641264            y = args[0]
    12651265            if PY_TYPE_CHECK(y, Integer):
    12661266                r = mpz_fdiv_ui((<Integer>y).value, self.p)
    12671267                if r == 0:
    12681268                    raise ZeroDivisionError
    1269                 zmod_poly_set_coeff_ui(ans._denom, 0, r)
     1269                nmod_poly_set_coeff_ui(ans._denom, 0, r)
    12701270            else:
    12711271                R = self._codomain.ring_of_integers()
    12721272                # could use the coerce keyword being set to False to not check this...
    12731273                if not (PY_TYPE_CHECK(y, Element) and y.parent() is R):
    12741274                    # We could special case integers and GF(p) elements here.
    12751275                    y = R(y)
    1276                 zmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
     1276                nmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
    12771277        else:
    12781278            raise ValueError, "FpT only supports two positional arguments"
    12791279        if not (kwds.has_key('reduce') and not kwds['reduce']):
     
    13701370        """
    13711371        cdef FpTElement x = <FpTElement?>_x
    13721372        cdef IntegerMod_int ans
    1373         if zmod_poly_degree(x._denom) != 0 or zmod_poly_degree(x._numer) > 0:
     1373        if nmod_poly_degree(x._denom) != 0 or nmod_poly_degree(x._numer) > 0:
    13741374            normalize(x._numer, x._denom, self.p)
    1375             if zmod_poly_degree(x._denom) != 0:
     1375            if nmod_poly_degree(x._denom) != 0:
    13761376                raise ValueError, "not integral"
    1377             if zmod_poly_degree(x._numer) > 0:
     1377            if nmod_poly_degree(x._numer) > 0:
    13781378                raise ValueError, "not constant"
    13791379        ans = PY_NEW(IntegerMod_int)
    13801380        ans.__modulus = self._codomain._pyx_order
    1381         if zmod_poly_get_coeff_ui(x._denom, 0) != 1:
     1381        if nmod_poly_get_coeff_ui(x._denom, 0) != 1:
    13821382            normalize(x._numer, x._denom, self.p)
    1383         ans.ivalue = zmod_poly_get_coeff_ui(x._numer, 0)
     1383        ans.ivalue = nmod_poly_get_coeff_ui(x._numer, 0)
    13841384        ans._parent = self._codomain
    13851385        return ans
    13861386
     
    14301430        cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
    14311431        ans._parent = self._codomain
    14321432        ans.p = self.p
    1433         zmod_poly_init(ans._numer, ans.p)
    1434         zmod_poly_init(ans._denom, ans.p)
    1435         zmod_poly_set_coeff_ui(ans._numer, 0, mpz_fdiv_ui(x.value, self.p))
    1436         zmod_poly_set_coeff_ui(ans._denom, 0, 1)
     1433        nmod_poly_init(ans._numer, ans.p)
     1434        nmod_poly_init(ans._denom, ans.p)
     1435        nmod_poly_set_coeff_ui(ans._numer, 0, mpz_fdiv_ui(x.value, self.p))
     1436        nmod_poly_set_coeff_ui(ans._denom, 0, 1)
    14371437        ans.initalized = True
    14381438        return ans
    14391439
     
    14611461        cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
    14621462        ans._parent = self._codomain
    14631463        ans.p = self.p
    1464         zmod_poly_init(ans._numer, ans.p)
    1465         zmod_poly_init(ans._denom, ans.p)
     1464        nmod_poly_init(ans._numer, ans.p)
     1465        nmod_poly_init(ans._denom, ans.p)
    14661466        cdef long r
    1467         zmod_poly_set_coeff_ui(ans._numer, 0, mpz_fdiv_ui(x.value, self.p))
     1467        nmod_poly_set_coeff_ui(ans._numer, 0, mpz_fdiv_ui(x.value, self.p))
    14681468        if len(args) == 0:
    1469             zmod_poly_set_coeff_ui(ans._denom, 0, 1)
     1469            nmod_poly_set_coeff_ui(ans._denom, 0, 1)
    14701470        if len(args) == 1:
    14711471            y = args[0]
    14721472            if PY_TYPE_CHECK(y, Integer):
    14731473                r = mpz_fdiv_ui((<Integer>y).value, self.p)
    14741474                if r == 0:
    14751475                    raise ZeroDivisionError
    1476                 zmod_poly_set_coeff_ui(ans._denom, 0, r)
     1476                nmod_poly_set_coeff_ui(ans._denom, 0, r)
    14771477            else:
    14781478                R = self._codomain.ring_of_integers()
    14791479                # could use the coerce keyword being set to False to not check this...
    14801480                if not (PY_TYPE_CHECK(y, Element) and y.parent() is R):
    14811481                    # We could special case integers and GF(p) elements here.
    14821482                    y = R(y)
    1483                 zmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
     1483                nmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
    14841484        else:
    14851485            raise ValueError, "FpT only supports two positional arguments"
    14861486        if not (kwds.has_key('reduce') and not kwds['reduce']):
     
    15231523        """
    15241524        return ZZ.convert_map_from(self._codomain.base_ring()) * Fp_FpT_coerce(self._codomain).section()
    15251525
    1526 cdef inline bint normalize(zmod_poly_t numer, zmod_poly_t denom, long p):
     1526cdef inline bint normalize(nmod_poly_t numer, nmod_poly_t denom, long p):
    15271527    """
    15281528    Puts numer/denom into a normal form: denominator monic and sharing no common factor with the numerator.
    15291529
     
    15331533    """
    15341534    cdef long a
    15351535    cdef bint changed
    1536     if zmod_poly_degree(numer) == -1:
    1537         if zmod_poly_degree(denom) > 0 or zmod_poly_leading(denom) != 1:
     1536    if nmod_poly_degree(numer) == -1:
     1537        if nmod_poly_degree(denom) > 0 or nmod_poly_leading(denom) != 1:
    15381538            changed = True
    15391539        else:
    15401540            changed = False
    1541         zmod_poly_truncate(denom, 0)
    1542         zmod_poly_set_coeff_ui(denom, 0, 1)
     1541        nmod_poly_truncate(denom, 0)
     1542        nmod_poly_set_coeff_ui(denom, 0, 1)
    15431543        return changed
    1544     elif zmod_poly_degree(numer) == 0 or zmod_poly_degree(denom) == 0:
    1545         if zmod_poly_leading(denom) != 1:
    1546             a = mod_inverse_int(zmod_poly_leading(denom), p)
    1547             zmod_poly_scalar_mul(numer, numer, a)
    1548             zmod_poly_scalar_mul(denom, denom, a)
     1544    elif nmod_poly_degree(numer) == 0 or nmod_poly_degree(denom) == 0:
     1545        if nmod_poly_leading(denom) != 1:
     1546            a = mod_inverse_int(nmod_poly_leading(denom), p)
     1547            nmod_poly_scalar_mul(numer, numer, a)
     1548            nmod_poly_scalar_mul(denom, denom, a)
    15491549            return True
    15501550        return False
    1551     cdef zmod_poly_t g
     1551    cdef nmod_poly_t g
    15521552    changed = False
    15531553    try:
    1554         zmod_poly_init_precomp(g, p, numer.p_inv)
    1555         zmod_poly_gcd(g, numer, denom)
    1556         if zmod_poly_degree(g) != 0:
     1554        nmod_poly_init_precomp(g, p, numer.p_inv)
     1555        nmod_poly_gcd(g, numer, denom)
     1556        if nmod_poly_degree(g) != 0:
    15571557            # Divide knowing divisible by? Can we get these quotients as a byproduct of the gcd?
    1558             zmod_poly_div(numer, numer, g)
    1559             zmod_poly_div(denom, denom, g)
     1558            nmod_poly_div(numer, numer, g)
     1559            nmod_poly_div(denom, denom, g)
    15601560            changed = True
    1561         if zmod_poly_leading(denom) != 1:
    1562             a = mod_inverse_int(zmod_poly_leading(denom), p)
    1563             zmod_poly_scalar_mul(numer, numer, a)
    1564             zmod_poly_scalar_mul(denom, denom, a)
     1561        if nmod_poly_leading(denom) != 1:
     1562            a = mod_inverse_int(nmod_poly_leading(denom), p)
     1563            nmod_poly_scalar_mul(numer, numer, a)
     1564            nmod_poly_scalar_mul(denom, denom, a)
    15651565            changed = True
    15661566        return changed
    15671567    finally:
    1568         zmod_poly_clear(g)
     1568        nmod_poly_clear(g)
    15691569
    1570 cdef inline unsigned long zmod_poly_leading(zmod_poly_t poly):
     1570cdef inline unsigned long nmod_poly_leading(nmod_poly_t poly):
    15711571    """
    15721572    Returns the leading coefficient of ``poly``.
    15731573    """
    1574     return zmod_poly_get_coeff_ui(poly, zmod_poly_degree(poly))
     1574    return nmod_poly_get_coeff_ui(poly, nmod_poly_degree(poly))
    15751575
    1576 cdef inline void zmod_poly_inc(zmod_poly_t poly, bint monic):
     1576cdef inline void nmod_poly_inc(nmod_poly_t poly, bint monic):
    15771577    """
    15781578    Sets poly to the "next" polynomial: this is just counting in base p.
    15791579
     
    15821582    cdef long n
    15831583    cdef long a
    15841584    cdef long p = poly.p
    1585     for n from 0 <= n <= zmod_poly_degree(poly) + 1:
    1586         a = zmod_poly_get_coeff_ui(poly, n) + 1
     1585    for n from 0 <= n <= nmod_poly_degree(poly) + 1:
     1586        a = nmod_poly_get_coeff_ui(poly, n) + 1
    15871587        if a == p:
    1588             zmod_poly_set_coeff_ui(poly, n, 0)
     1588            nmod_poly_set_coeff_ui(poly, n, 0)
    15891589        else:
    1590             zmod_poly_set_coeff_ui(poly, n, a)
     1590            nmod_poly_set_coeff_ui(poly, n, a)
    15911591            break
    1592     if monic and a == 2 and n == zmod_poly_degree(poly):
    1593         zmod_poly_set_coeff_ui(poly, n, 0)
    1594         zmod_poly_set_coeff_ui(poly, n+1, 1)
     1592    if monic and a == 2 and n == nmod_poly_degree(poly):
     1593        nmod_poly_set_coeff_ui(poly, n, 0)
     1594        nmod_poly_set_coeff_ui(poly, n+1, 1)
    15951595
    1596 cdef inline long zmod_poly_cmp(zmod_poly_t a, zmod_poly_t b):
     1596cdef inline long nmod_poly_cmp(nmod_poly_t a, nmod_poly_t b):
    15971597    """
    15981598    Compares `a` and `b`, returning 0 if they are equal.
    15991599
     
    16031603
    16041604    - Otherwise, compares `a` and `b` lexicographically, starting at the leading terms.
    16051605    """
    1606     cdef long ad = zmod_poly_degree(a)
    1607     cdef long bd = zmod_poly_degree(b)
     1606    cdef long ad = nmod_poly_degree(a)
     1607    cdef long bd = nmod_poly_degree(b)
    16081608    if ad < bd:
    16091609        return -1
    16101610    elif ad > bd:
    16111611        return 1
    1612     cdef long d = zmod_poly_degree(a)
     1612    cdef long d = nmod_poly_degree(a)
    16131613    while d >= 0:
    1614         ad = zmod_poly_get_coeff_ui(a, d)
    1615         bd = zmod_poly_get_coeff_ui(b, d)
     1614        ad = nmod_poly_get_coeff_ui(a, d)
     1615        bd = nmod_poly_get_coeff_ui(b, d)
    16161616        if ad < bd:
    16171617            return -1
    16181618        elif ad > bd:
     
    16201620        d -= 1
    16211621    return 0
    16221622
    1623 cdef void zmod_poly_pow(zmod_poly_t res, zmod_poly_t poly, unsigned long e):
    1624     """
    1625     Raises poly to the `e`th power and stores the result in ``res``.
    1626     """
    1627     if zmod_poly_degree(poly) < 2:
    1628         if zmod_poly_degree(poly) == -1:
    1629             zmod_poly_zero(res)
    1630             return
    1631         elif zmod_poly_is_one(poly):
    1632             zmod_poly_set(res, poly)
    1633             return
    1634         elif e > 1 and zmod_poly_degree(poly) == 1 and zmod_poly_get_coeff_ui(poly, 0) == 0 and zmod_poly_get_coeff_ui(poly, 1) == 1:
    1635             zmod_poly_left_shift(res, poly, e-1)
    1636             return
    1637    
    1638     # TODO: Could use the fact that (a+b)^p = a^p + b^p
    1639     # Only seems to be a big gain for large p, large exponents...
    1640     cdef zmod_poly_t pow2
    1641    
    1642     if e < 5:
    1643         if e == 0:
    1644             zmod_poly_zero(res)
    1645             zmod_poly_set_coeff_ui(res, 0, 1)
    1646         elif e == 1:
    1647             zmod_poly_set(res, poly)
    1648         elif e == 2:
    1649             zmod_poly_sqr(res, poly)
    1650         elif e == 3:
    1651             zmod_poly_sqr(res, poly)
    1652             zmod_poly_mul(res, res, poly)
    1653         elif e == 4:
    1654             zmod_poly_sqr(res, poly)
    1655             zmod_poly_sqr(res, res)
    1656     else:
    1657         zmod_poly_init(pow2, poly.p)
    1658         zmod_poly_zero(res)
    1659         zmod_poly_set_coeff_ui(res, 0, 1)
    1660         zmod_poly_set(pow2, poly)
    1661         while True:
    1662             if e & 1:
    1663                 zmod_poly_mul(res, res, pow2)
    1664             e >>= 1
    1665             if e == 0:
    1666                 break
    1667             zmod_poly_sqr(pow2, pow2)
    1668         zmod_poly_clear(pow2)
    1669 
    1670 
    16711623cdef long sqrt_mod_int(long a, long p) except -1:
    16721624    """
    16731625    Returns the square root of a modulo p, as a long.
    16741626    """
    16751627    return GF(p)(a).sqrt()
    16761628
    1677 cdef bint zmod_poly_sqrt_check(zmod_poly_t poly):
     1629cdef bint nmod_poly_sqrt_check(nmod_poly_t poly):
    16781630    """
    16791631    Quick check to see if poly could possibly be a square.
    16801632    """
    1681     return (zmod_poly_degree(poly) % 2 == 0
    1682         and jacobi_int(zmod_poly_leading(poly), poly.p) == 1
    1683         and jacobi_int(zmod_poly_get_coeff_ui(poly, 0), poly.p) != -1)
     1633    return (nmod_poly_degree(poly) % 2 == 0
     1634        and jacobi_int(nmod_poly_leading(poly), poly.p) == 1
     1635        and jacobi_int(nmod_poly_get_coeff_ui(poly, 0), poly.p) != -1)
    16841636 
    1685 cdef bint zmod_poly_sqrt(zmod_poly_t res, zmod_poly_t poly):
     1637cdef bint nmod_poly_sqrt(nmod_poly_t res, nmod_poly_t poly):
    16861638    """
    16871639    Compute the square root of poly as res if res is a perfect square.
    16881640   
    16891641    Returns True on success, False on failure.
    16901642    """
    1691     if not zmod_poly_sqrt_check(poly):
     1643    if not nmod_poly_sqrt_check(poly):
    16921644        return False
    1693     return zmod_poly_sqrt0(res, poly)
     1645    return nmod_poly_sqrt0(res, poly)
    16941646
    1695 cdef bint zmod_poly_sqrt0(zmod_poly_t res, zmod_poly_t poly):
     1647cdef bint nmod_poly_sqrt0(nmod_poly_t res, nmod_poly_t poly):
    16961648    """
    1697     Compute the square root of poly as res if res is a perfect square, assuming that poly passes zmod_poly_sqrt_check.
     1649    Compute the square root of poly as res if res is a perfect square, assuming that poly passes nmod_poly_sqrt_check.
    16981650   
    16991651    Returns True on success, False on failure.
    17001652    """
    1701     if zmod_poly_degree(poly) == -1:
    1702         zmod_poly_zero(res)
     1653    if nmod_poly_degree(poly) == -1:
     1654        nmod_poly_zero(res)
    17031655        return True
    1704     if zmod_poly_degree(poly) == 0:
    1705         zmod_poly_zero(res)
    1706         zmod_poly_set_coeff_ui(res, 0, sqrt_mod_int(zmod_poly_get_coeff_ui(poly, 0), poly.p))
     1656    if nmod_poly_degree(poly) == 0:
     1657        nmod_poly_zero(res)
     1658        nmod_poly_set_coeff_ui(res, 0, sqrt_mod_int(nmod_poly_get_coeff_ui(poly, 0), poly.p))
    17071659        return True
    1708     cdef zmod_poly_t g
     1660    cdef nmod_poly_t g
    17091661    cdef long p = poly.p
    17101662    cdef long n, leading
    1711     cdef zmod_poly_factor_t factors
     1663    cdef nmod_poly_factor_t factors
    17121664    try:
    1713         zmod_poly_init(g, p)
    1714         zmod_poly_derivative(res, poly)
    1715         zmod_poly_gcd(g, res, poly)
    1716         if 2*zmod_poly_degree(g) < zmod_poly_degree(poly):
     1665        nmod_poly_init(g, p)
     1666        nmod_poly_derivative(res, poly)
     1667        nmod_poly_gcd(g, res, poly)
     1668        if 2*nmod_poly_degree(g) < nmod_poly_degree(poly):
    17171669            return False
    17181670           
    1719         elif 2*zmod_poly_degree(g) > zmod_poly_degree(poly):
     1671        elif 2*nmod_poly_degree(g) > nmod_poly_degree(poly):
    17201672            try:
    1721                 zmod_poly_factor_init(factors)
    1722                 leading = zmod_poly_leading(poly)
     1673                nmod_poly_factor_init(factors)
     1674                leading = nmod_poly_leading(poly)
    17231675                if leading == 1:
    1724                     zmod_poly_factor_square_free(factors, poly)
     1676                    nmod_poly_factor_square_free(factors, poly)
    17251677                else:
    1726                     zmod_poly_scalar_mul(res, poly, mod_inverse_int(leading, p))
    1727                     zmod_poly_factor_square_free(factors, res)
     1678                    nmod_poly_scalar_mul(res, poly, mod_inverse_int(leading, p))
     1679                    nmod_poly_factor_square_free(factors, res)
    17281680                for n in range(factors.num_factors):
    17291681                    if factors.exponents[n] % 2 != 0:
    17301682                        return False
    1731                 zmod_poly_pow(res, factors.factors[0], factors.exponents[0]//2)
     1683                nmod_poly_pow(res, factors.factors[0], factors.exponents[0]//2)
    17321684                for n in range(1, factors.num_factors):
    1733                     zmod_poly_pow(factors.factors[n], factors.factors[n], factors.exponents[n]//2)
    1734                     zmod_poly_mul(res, res, factors.factors[n])
     1685                    nmod_poly_pow(factors.factors[n], factors.factors[n], factors.exponents[n]//2)
     1686                    nmod_poly_mul(res, res, factors.factors[n])
    17351687                if leading != 1:
    1736                     zmod_poly_scalar_mul(res, res, sqrt_mod_int(zmod_poly_leading(poly), p))
     1688                    nmod_poly_scalar_mul(res, res, sqrt_mod_int(nmod_poly_leading(poly), p))
    17371689                return True
    17381690            finally:
    1739                 zmod_poly_factor_clear(factors)
     1691                nmod_poly_factor_clear(factors)
    17401692           
    17411693        else: # deg(g) == deg(poly)/2
    1742             zmod_poly_sqr(res, g)
    1743             leading = zmod_poly_leading(poly) * mod_inverse_int(zmod_poly_leading(res), p)
    1744             zmod_poly_scalar_mul(res, res, leading)
    1745             if zmod_poly_equal(res, poly):
    1746                 zmod_poly_scalar_mul(res, g, sqrt_mod_int(leading, p))
     1694            nmod_poly_sqr(res, g)
     1695            leading = nmod_poly_leading(poly) * mod_inverse_int(nmod_poly_leading(res), p)
     1696            nmod_poly_scalar_mul(res, res, leading)
     1697            if nmod_poly_equal(res, poly):
     1698                nmod_poly_scalar_mul(res, g, sqrt_mod_int(leading, p))
    17471699                return True
    17481700            else:
    17491701                return False
    17501702    finally:
    1751         zmod_poly_clear(g)
     1703        nmod_poly_clear(g)
    17521704
    17531705def unpickle_FpT_element(K, numer, denom):
    17541706    """
     
    17661718
    17671719#  Somehow this isn't in FLINT, evidently.  It could be moved
    17681720#  elsewhere at some point.
    1769 cdef int sage_cmp_zmod_poly_t(zmod_poly_t L, zmod_poly_t R):
     1721cdef int sage_cmp_nmod_poly_t(nmod_poly_t L, nmod_poly_t R):
    17701722    """
    1771     Compare two zmod_poly_t in a Pythonic way, so this returns -1, 0,
     1723    Compare two nmod_poly_t in a Pythonic way, so this returns -1, 0,
    17721724    or 1, and is consistent.
    17731725    """
    17741726    cdef int j
    17751727    cdef Py_ssize_t i
    17761728
    17771729    # First compare the degrees
    1778     j = zmod_poly_degree(L) - zmod_poly_degree(R)
     1730    j = nmod_poly_degree(L) - nmod_poly_degree(R)
    17791731    if j<0: return -1
    17801732    elif j>0: return 1
    17811733   
    17821734    # Same degree, so compare coefficients, term by term
    1783     for i in range(zmod_poly_degree(L)+1):
    1784         j = zmod_poly_get_coeff_ui(L,i) - zmod_poly_get_coeff_ui(R,i)
     1735    for i in range(nmod_poly_degree(L)+1):
     1736        j = nmod_poly_get_coeff_ui(L,i) - nmod_poly_get_coeff_ui(R,i)
    17851737        if j<0: return -1
    17861738        elif j>0: return 1
    17871739
  • sage/rings/polynomial/polynomial_zmod_flint.pxd

    diff --git a/sage/rings/polynomial/polynomial_zmod_flint.pxd b/sage/rings/polynomial/polynomial_zmod_flint.pxd
    a b  
    22     # This header needs to appear before the flint headers.
    33     pass
    44
    5 from sage.libs.flint.zmod_poly cimport zmod_poly_t, zmod_poly_struct
     5from sage.libs.flint.zmod_poly cimport nmod_poly_t, nmod_poly_struct
    66from sage.structure.parent cimport Parent
    77
    8 ctypedef zmod_poly_struct celement
     8ctypedef nmod_poly_struct celement
    99
    1010include "polynomial_template_header.pxi"
    1111
  • sage/rings/polynomial/polynomial_zmod_flint.pyx

    diff --git a/sage/rings/polynomial/polynomial_zmod_flint.pyx b/sage/rings/polynomial/polynomial_zmod_flint.pyx
    a b  
    105105            x + 3
    106106        """
    107107        cdef Polynomial_template e = <Polynomial_template>PY_NEW(self.__class__)
    108         zmod_poly_init(&e.x, self._parent.modulus())
     108        nmod_poly_init(&e.x, self._parent.modulus())
    109109        e._parent = self._parent
    110110        return e
    111111
     
    135135        """
    136136        cdef Polynomial_template r = <Polynomial_template>PY_NEW(self.__class__)
    137137        r._parent = P
    138         zmod_poly_init(&r.x, zmod_poly_modulus(&self.x))
     138        nmod_poly_init(&r.x, nmod_poly_modulus(&self.x))
    139139        celement_set_si(&r.x, int(x), get_cparent(P))
    140140        return r
    141141
     
    153153        """
    154154        cdef list l_in = x
    155155        cdef unsigned long length = len(l_in)
    156         cdef unsigned long modulus = zmod_poly_modulus(&self.x)
     156        cdef unsigned long modulus = nmod_poly_modulus(&self.x)
    157157        cdef int i
    158158        if length == 0:
    159             zmod_poly_zero(&self.x)
     159            nmod_poly_zero(&self.x)
    160160            return
    161161
    162162        # resize to length of list
    163163        sig_on()
    164         zmod_poly_realloc(&self.x, length)
     164        nmod_poly_realloc(&self.x, length)
    165165        sig_off()
    166166
    167167        for i from 0 <= i < length:
    168             _zmod_poly_set_coeff_ui(&self.x, i, l_in[i])
    169         # we need to set the length manually, we used _zmod_poly_set_coeff_ui
    170         self.x.length = length
     168            nmod_poly_set_coeff_ui(&self.x, i, l_in[i])
    171169
    172170    def __getitem__(self, i):
    173171        """
     
    185183            0
    186184        """
    187185        cdef unsigned long c = 0
    188         if 0 <= i < zmod_poly_length(&self.x):
    189             c = zmod_poly_get_coeff_ui(&self.x, i)
     186        if 0 <= i < nmod_poly_length(&self.x):
     187            c = nmod_poly_get_coeff_ui(&self.x, i)
    190188        return self._parent.base_ring()(c)
    191189
    192190    def __call__(self, *x, **kwds):
     
    231229            P = parent(x[0])
    232230            if K.has_coerce_map_from(P):
    233231                x = K(x[0])
    234                 return K(zmod_poly_evaluate(&self.x, x))
     232                return K(nmod_poly_evaluate_nmod(&self.x, x))
    235233            elif self._parent.has_coerce_map_from(P):
    236234                y = <Polynomial_zmod_flint>self._parent(x[0])
    237235                t = self._new()
    238                 if zmod_poly_degree(&y.x) == 0:
    239                     c = zmod_poly_evaluate(&self.x, zmod_poly_get_coeff_ui(&y.x, 0))
    240                     zmod_poly_set_coeff_ui(&t.x, 0, c)
    241                 elif zmod_poly_degree(&y.x) == 1 and zmod_poly_get_coeff_ui(&y.x, 0) == 0:
    242                     c = zmod_poly_get_coeff_ui(&y.x, 1)
     236                if nmod_poly_degree(&y.x) == 0:
     237                    c = nmod_poly_evaluate(&self.x, nmod_poly_get_coeff_ui(&y.x, 0))
     238                    nmod_poly_set_coeff_ui(&t.x, 0, c)
     239                elif nmod_poly_degree(&y.x) == 1 and nmod_poly_get_coeff_ui(&y.x, 0) == 0:
     240                    c = nmod_poly_get_coeff_ui(&y.x, 1)
    243241                    if c == 1:
    244242                        return self
    245                 zmod_poly_compose_horner(&t.x, &self.x, &y.x)
     243                nmod_poly_compose_horner(&t.x, &self.x, &y.x)
    246244                return t
    247245        return Polynomial.__call__(self, *x, **kwds)
    248246   
     
    279277        # If it is not a field we fall back to direct computation through the
    280278        # Sylvester matrix.
    281279        if self.base_ring().is_field():
    282             res = zmod_poly_resultant(&(<Polynomial_template>self).x,
     280            res = nmod_poly_resultant(&(<Polynomial_template>self).x,
    283281                                      &(<Polynomial_template>other).x)
    284282            return self.parent().base_ring()(res)
    285283        else:
     
    331329        n = int(n)
    332330        value = self.base_ring()(value)
    333331        if n >= 0:
    334             zmod_poly_set_coeff_ui(&self.x, n, int(value)%zmod_poly_modulus(&self.x))
     332            nmod_poly_set_coeff_ui(&self.x, n, int(value)%nmod_poly_modulus(&self.x))
    335333        else:
    336334            raise IndexError, "Polynomial coefficient index must be nonnegative."
    337335       
     
    384382
    385383        cdef zn_mod_struct zn_mod
    386384
    387         zmod_poly_init2(&r.x, p, n1 + n2 -1 )
     385        nmod_poly_init2(&r.x, p, n1 + n2 -1 )
    388386
    389387        zn_mod_init(&zn_mod, p)
    390388        zn_array_mul(r.x.coeffs, self.x.coeffs, n1, _other.x.coeffs, n2, &zn_mod)
    391389        r.x.length = n1 + n2 -1
    392         __zmod_poly_normalise(&r.x)
     390        _nmod_poly_normalise(&r.x)
    393391        zn_mod_clear(&zn_mod)
    394392        return r
    395393
     
    420418        cdef Polynomial_zmod_flint res = self._new()
    421419        if n <= 0:
    422420            raise ValueError, "length must be > 0"
    423         zmod_poly_mul_trunc_n(&res.x, &self.x, &other.x, n)
     421        nmod_poly_mullow(&res.x, &self.x, &other.x, n)
    424422        return res
    425423
    426424    _mul_short = _mul_trunc
     
    453451        cdef Polynomial_zmod_flint res = self._new()
    454452        if n < 0:
    455453            raise ValueError, "length must be >= 0"
    456         zmod_poly_mul_trunc_left_n(&res.x, &self.x, &other.x, n)
     454        nmod_poly_mulhigh(&res.x, &self.x, &other.x, n)
    457455        return res
    458456
    459457    _mul_short_opposite = _mul_trunc_opposite
     
    490488        cdef Polynomial_zmod_flint r0
    491489        cdef Polynomial_zmod_flint r1
    492490
    493         while zmod_poly_length(&t1.x) != 0 and n_deg < zmod_poly_degree(&t1.x):
     491        while nmod_poly_length(&t1.x) != 0 and n_deg < nmod_poly_degree(&t1.x):
    494492            q = self._new()
    495493            r1 = self._new()
    496             zmod_poly_divrem(&q.x, &r1.x, &s1.x, &t1.x)
     494            nmod_poly_divrem(&q.x, &r1.x, &s1.x, &t1.x)
    497495            r0 = s0 - q*t0
    498496            s0 = t0
    499497            s1 = t1
     
    501499            t1 = r1
    502500
    503501        assert(t0 != 0)
    504         if d_deg < zmod_poly_degree(&t0.x):
     502        if d_deg < nmod_poly_degree(&t0.x):
    505503            raise ValueError, "could not complete rational reconstruction"
    506504
    507505        # make the denominator monic
     
    554552        if not self.base_ring().is_field():
    555553            raise NotImplementedError, "checking irreducibility of polynomials over rings with composite characteristic is not implemented"
    556554
    557         if 1 == zmod_poly_isirreducible(&self.x):
     555        if 1 == nmod_poly_is_irreducible(&self.x):
    558556            return True
    559557        else:
    560558            return False
     
    636634                self.leading_coefficient().lift()) != 1:
    637635            raise ValueError, "leading coefficient must be invertible"
    638636        cdef Polynomial_zmod_flint res = self._new()
    639         zmod_poly_make_monic(&res.x, &self.x)
     637        nmod_poly_make_monic(&res.x, &self.x)
    640638        return res
    641639
    642640    def reverse(self, degree=None):
     
    701699            d = degree
    702700            if d != degree:
    703701                raise ValueError, "degree argument must be a non-negative integer, got %s"%(degree)
    704             zmod_poly_reverse(&res.x, &self.x, d+1) # FLINT expects length
     702            nmod_poly_reverse(&res.x, &self.x, d+1) # FLINT expects length
    705703        else:
    706             zmod_poly_reverse(&res.x, &self.x, zmod_poly_length(&self.x))
     704            nmod_poly_reverse(&res.x, &self.x, nmod_poly_length(&self.x))
    707705        return res
  • sage/schemes/elliptic_curves/descent_two_isogeny.pyx

    diff --git a/sage/schemes/elliptic_curves/descent_two_isogeny.pyx b/sage/schemes/elliptic_curves/descent_two_isogeny.pyx
    a b  
    2424include "../../ext/interrupt.pxi"
    2525include "../../libs/flint/fmpz_poly.pxi"
    2626
    27 from sage.libs.flint.zmod_poly cimport *, zmod_poly_t
     27from sage.libs.flint.zmod_poly cimport *, nmod_poly_t
    2828from sage.libs.flint.long_extras cimport *, factor_t
    2929from sage.libs.ratpoints cimport ratpoints_mpz_exists_only
    3030
     
    267267
    268268cdef bint Zp_soluble_siksek(mpz_t a, mpz_t b, mpz_t c, mpz_t d, mpz_t e,
    269269                            mpz_t pp, unsigned long pp_ui,
    270                             zmod_poly_factor_t f_factzn, zmod_poly_t f,
     270                            nmod_poly_factor_t f_factzn, nmod_poly_t f,
    271271                            fmpz_poly_t f1, fmpz_poly_t linear,
    272272                            double pp_ui_inv):
    273273    """
     
    308308
    309309    if not v_min%2:
    310310        # Step I in Alg. 5.3.1 of Siksek's thesis
    311         zmod_poly_set_coeff_ui(f, 0, mpz_fdiv_ui(e, pp_ui))
    312         zmod_poly_set_coeff_ui(f, 1, mpz_fdiv_ui(d, pp_ui))
    313         zmod_poly_set_coeff_ui(f, 2, mpz_fdiv_ui(c, pp_ui))
    314         zmod_poly_set_coeff_ui(f, 3, mpz_fdiv_ui(b, pp_ui))
    315         zmod_poly_set_coeff_ui(f, 4, mpz_fdiv_ui(a, pp_ui))
     311        nmod_poly_set_coeff_ui(f, 0, mpz_fdiv_ui(e, pp_ui))
     312        nmod_poly_set_coeff_ui(f, 1, mpz_fdiv_ui(d, pp_ui))
     313        nmod_poly_set_coeff_ui(f, 2, mpz_fdiv_ui(c, pp_ui))
     314        nmod_poly_set_coeff_ui(f, 3, mpz_fdiv_ui(b, pp_ui))
     315        nmod_poly_set_coeff_ui(f, 4, mpz_fdiv_ui(a, pp_ui))
    316316
    317317        result = 0
    318         (<zmod_poly_factor_struct *>f_factzn)[0].num_factors = 0 # reset data struct
    319         qq = zmod_poly_factor(f_factzn, f)
     318        (<nmod_poly_factor_struct *>f_factzn)[0].num_factors = 0 # reset data struct
     319        qq = nmod_poly_factor(f_factzn, f)
    320320        for i from 0 <= i < f_factzn.num_factors:
    321321            if f_factzn.exponents[i]&1:
    322322                result = 1
     
    326326        if result:
    327327            return 1
    328328
    329         zmod_poly_zero(f)
    330         zmod_poly_set_coeff_ui(f, 0, ui1)
     329        nmod_poly_zero(f)
     330        nmod_poly_set_coeff_ui(f, 0, ui1)
    331331        for i from 0 <= i < f_factzn.num_factors:
    332332            for j from 0 <= j < (f_factzn.exponents[i]>>1):
    333                 zmod_poly_mul(f, f, f_factzn.factors[i])
     333                nmod_poly_mul(f, f, f_factzn.factors[i])
    334334
    335         (<zmod_poly_factor_struct *>f_factzn)[0].num_factors = 0 # reset data struct
    336         zmod_poly_factor(f_factzn, f)
     335        (<nmod_poly_factor_struct *>f_factzn)[0].num_factors = 0 # reset data struct
     336        nmod_poly_factor(f_factzn, f)
    337337        has_roots = 0
    338338        j = 0
    339339        for i from 0 <= i < f_factzn.num_factors:
    340             if zmod_poly_degree(f_factzn.factors[i]) == 1 and 0 != zmod_poly_get_coeff_ui(f_factzn.factors[i], 1):
     340            if nmod_poly_degree(f_factzn.factors[i]) == 1 and 0 != nmod_poly_get_coeff_ui(f_factzn.factors[i], 1):
    341341                has_roots = 1
    342                 roots[j] = pp_ui - zmod_poly_get_coeff_ui(f_factzn.factors[i], 0)
     342                roots[j] = pp_ui - nmod_poly_get_coeff_ui(f_factzn.factors[i], 0)
    343343                j += 1
    344344        if not has_roots:
    345345            return 0
    346346       
    347         i = zmod_poly_degree(f)
     347        i = nmod_poly_degree(f)
    348348        mpz_init(aaa)
    349349        mpz_init(bbb)
    350350        mpz_init(ccc)
     
    361361            mpz_set(aaa, a)
    362362            mpz_set(bbb, b)
    363363            mpz_sub_ui(ccc, c, qq)
    364             rr = zmod_poly_get_coeff_ui(f, 0)
     364            rr = nmod_poly_get_coeff_ui(f, 0)
    365365            ss = rr*qq
    366366            mpz_set(ddd,d)
    367367            mpz_sub_ui(ddd, ddd, ss*ui2)
     
    369369            mpz_sub_ui(eee, eee, ss*rr)
    370370        elif i == 2: # g == x^2 + rr*x + ss
    371371            mpz_sub_ui(aaa, a, qq)
    372             rr = zmod_poly_get_coeff_ui(f, 1)
     372            rr = nmod_poly_get_coeff_ui(f, 1)
    373373            mpz_init(tt)
    374374            mpz_set_ui(tt, rr*qq)
    375375            mpz_set(bbb,b)
    376376            mpz_submul_ui(bbb, tt, ui2)
    377377            mpz_set(ccc,c)
    378378            mpz_submul_ui(ccc, tt, rr)
    379             ss = zmod_poly_get_coeff_ui(f, 0)
     379            ss = nmod_poly_get_coeff_ui(f, 0)
    380380            mpz_set_ui(tt, ss*qq)
    381381            mpz_set(eee,e)
    382382            mpz_submul_ui(eee, tt, ss)
     
    445445        return result
    446446    else:
    447447        # Step II in Alg. 5.3.1 of Siksek's thesis
    448         zmod_poly_set_coeff_ui(f, 0, mpz_fdiv_ui(e, pp_ui))
    449         zmod_poly_set_coeff_ui(f, 1, mpz_fdiv_ui(d, pp_ui))
    450         zmod_poly_set_coeff_ui(f, 2, mpz_fdiv_ui(c, pp_ui))
    451         zmod_poly_set_coeff_ui(f, 3, mpz_fdiv_ui(b, pp_ui))
    452         zmod_poly_set_coeff_ui(f, 4, mpz_fdiv_ui(a, pp_ui))
    453         (<zmod_poly_factor_struct *>f_factzn)[0].num_factors = 0 # reset data struct
    454         zmod_poly_factor(f_factzn, f)
     448        nmod_poly_set_coeff_ui(f, 0, mpz_fdiv_ui(e, pp_ui))
     449        nmod_poly_set_coeff_ui(f, 1, mpz_fdiv_ui(d, pp_ui))
     450        nmod_poly_set_coeff_ui(f, 2, mpz_fdiv_ui(c, pp_ui))
     451        nmod_poly_set_coeff_ui(f, 3, mpz_fdiv_ui(b, pp_ui))
     452        nmod_poly_set_coeff_ui(f, 4, mpz_fdiv_ui(a, pp_ui))
     453        (<nmod_poly_factor_struct *>f_factzn)[0].num_factors = 0 # reset data struct
     454        nmod_poly_factor(f_factzn, f)
    455455        has_roots = 0
    456456        has_single_roots = 0
    457457        j = 0
    458458        for i from 0 <= i < f_factzn.num_factors:
    459             if zmod_poly_degree(f_factzn.factors[i]) == 1 and 0 != zmod_poly_get_coeff_ui(f_factzn.factors[i], 1):
     459            if nmod_poly_degree(f_factzn.factors[i]) == 1 and 0 != nmod_poly_get_coeff_ui(f_factzn.factors[i], 1):
    460460                has_roots = 1
    461461                if f_factzn.exponents[i] == 1:
    462462                    has_single_roots = 1
    463463                    break
    464                 roots[j] = pp_ui - zmod_poly_get_coeff_ui(f_factzn.factors[i], 0)
     464                roots[j] = pp_ui - nmod_poly_get_coeff_ui(f_factzn.factors[i], 0)
    465465                j += 1
    466466
    467467        if not has_roots: return 0
     
    743743
    744744cdef bint Qp_soluble_siksek(mpz_t A, mpz_t B, mpz_t C, mpz_t D, mpz_t E,
    745745                            mpz_t p, unsigned long P,
    746                             zmod_poly_factor_t f_factzn, fmpz_poly_t f1,
     746                            nmod_poly_factor_t f_factzn, fmpz_poly_t f1,
    747747                            fmpz_poly_t linear):
    748748    """
    749749    Uses Samir Siksek's thesis results to determine whether the quartic is
     
    751751    """
    752752    cdef int result = 0
    753753    cdef mpz_t a,b,c,d,e
    754     cdef zmod_poly_t f
     754    cdef nmod_poly_t f
    755755    cdef double pp_ui_inv = z_precompute_inverse(P)
    756     zmod_poly_init(f, P)
     756    nmod_poly_init(f, P)
    757757
    758758    mpz_init_set(a,A)
    759759    mpz_init_set(b,B)
     
    777777    mpz_clear(c)
    778778    mpz_clear(d)
    779779    mpz_clear(e)
    780     zmod_poly_clear(f)
     780    nmod_poly_clear(f)
    781781    return result
    782782
    783783cdef bint Qp_soluble_siksek_large_p(mpz_t A, mpz_t B, mpz_t C, mpz_t D, mpz_t E,
     
    837837    cdef int bsd_sol, sik_sol
    838838    cdef unsigned long pp
    839839    cdef fmpz_poly_t f1, linear
    840     cdef zmod_poly_factor_t f_factzn
     840    cdef nmod_poly_factor_t f_factzn
    841841    bsd_sol = Qp_soluble_BSD(a, b, c, d, e, p)
    842842    if mpz_cmp_ui(p,N_RES_CLASSES_BSD)>0 and not bsd_sol:
    843843        fmpz_poly_init(f1)
    844844        fmpz_poly_init(linear)
    845845        if mpz_fits_ulong_p(p):
    846             zmod_poly_factor_init(f_factzn)
     846            nmod_poly_factor_init(f_factzn)
    847847            pp = mpz_get_ui(p)
    848848            sik_sol = Qp_soluble_siksek(a,b,c,d,e,p,pp,f_factzn,f1,linear)
    849             zmod_poly_factor_clear(f_factzn)
     849            nmod_poly_factor_clear(f_factzn)
    850850        else:
    851851            sik_sol = Qp_soluble_siksek_large_p(a,b,c,d,e,p,f1,linear)
    852852        fmpz_poly_clear(f1)