Ticket #12173: trac_12173-fixes-v6.patch

File trac_12173-fixes-v6.patch, 68.9 KB (added by jpflori, 9 years ago)

  • module_list.py 

    # HG changeset patch
# User Jeroen Demeyer <jdemeyer@cage.ugent.be>
# Date 1366201521 -7200
# Node ID 7e5a130a5b6be6fa928cc3adc88567328eb250e7
# Parent  2d7a660149792562f28e8cc0c578aacea4e4f7c7
Manual fixes

diff --git a/module_list.py b/module_list.py
    a b  
    14451445    Extension('sage.rings.fraction_field_FpT',
    14461446              sources = ['sage/rings/fraction_field_FpT.pyx'],
    14471447              libraries = ["csage", "flint", "gmp", "gmpxx", "ntl", "zn_poly"],
    1448               extra_compile_args=["-std=c99", "-D_XPG6"],
     1448              language = 'c++',
    14491449              include_dirs = [SAGE_INC + '/FLINT'],
    14501450              depends = flint_depends),
    14511451   
    … …  
    17251725    Extension('sage.rings.polynomial.polynomial_zmod_flint',
    17261726              sources = ['sage/rings/polynomial/polynomial_zmod_flint.pyx'],
    17271727              libraries = ["csage", "flint", "gmp", "gmpxx", "ntl", "zn_poly"],
    1728               extra_compile_args=["-std=c99", "-D_XPG6"],
     1728              language = 'c++',
    17291729              include_dirs = [SAGE_INC + '/FLINT'],
    17301730              depends = flint_depends),
    17311731
    … …  
    17431743              include_dirs = ['sage/libs/ntl/']),
    17441744
    17451745    Extension('sage.rings.polynomial.polynomial_rational_flint',
    1746               sources = ['sage/rings/polynomial/polynomial_rational_flint.pyx', 'sage/libs/flint/fmpq_poly.c'],
     1746              sources = ['sage/rings/polynomial/polynomial_rational_flint.pyx'],
     1747              libraries = ["csage", "flint", "ntl", "gmpxx", "gmp"],
    17471748              language = 'c++',
    1748               extra_compile_args=["-std=c99"] + uname_specific('SunOS', [], ['-D_XPG6']),
    1749               libraries = ["csage", "flint", "ntl", "gmpxx", "gmp"],
    17501749              include_dirs = [SAGE_INC + '/FLINT', 'sage/libs/flint/'],
    17511750              depends = flint_depends),
    17521751

  • sage/algebras/quatalg/quaternion_algebra_element.pyx 

    diff --git a/sage/algebras/quatalg/quaternion_algebra_element.pyx b/sage/algebras/quatalg/quaternion_algebra_element.pyx
    a b  
    19881988        # Implementation-wise, we compute the GCD's one at a time,
    19891989        # and quit if it ever becomes one
    19901990 
    1991         cdef fmpz_t content = fmpz_init(fmpz_poly_max_limbs(self.x)) # TODO: think about how big this should be (probably the size of d)
    1992                                                                      # Note that we have to allocate this here, and not
    1993                                                                      # as a global variable, because fmpz_t's do not
    1994                                                                      # self allocate memory
     1991        cdef fmpz_t content
     1992        fmpz_init(content)
    19951993        fmpz_poly_content(content, self.x)
    19961994        fmpz_get_mpz(U1, content)
    19971995        mpz_gcd(U1, self.d, U1)
    … …  
    20082006                    fmpz_get_mpz(U2, content)
    20092007                    mpz_gcd(U1, U1, U2)
    20102008                    if mpz_cmp_ui(U1, 1) != 0:
    2011                         fmpz_poly_scalar_fdiv_mpz(self.x, self.x, U1)
    2012                         fmpz_poly_scalar_fdiv_mpz(self.y, self.y, U1)
    2013                         fmpz_poly_scalar_fdiv_mpz(self.z, self.z, U1)
    2014                         fmpz_poly_scalar_fdiv_mpz(self.w, self.w, U1)
     2009                        fmpz_poly_scalar_divexact_mpz(self.x, self.x, U1)
     2010                        fmpz_poly_scalar_divexact_mpz(self.y, self.y, U1)
     2011                        fmpz_poly_scalar_divexact_mpz(self.z, self.z, U1)
     2012                        fmpz_poly_scalar_divexact_mpz(self.w, self.w, U1)
    20152013                        mpz_divexact(self.d, self.d, U1)
    20162014       
    20172015        fmpz_clear(content)

  • sage/ext/gen_interpreters.py 

    diff --git a/sage/ext/gen_interpreters.py b/sage/ext/gen_interpreters.py
    a b  
    193193    that we have to incref/decref at appropriate places.
    194194
    195195    Third is "auto-reference" types.  This is how
    196     GMP/MPIR/MPFR/MPFI/flint types work.  For these types, functions
     196    GMP/MPIR/MPFR/MPFI/FLINT types work.  For these types, functions
    197197    expect arguments to be passed by reference, and the C assignment
    198198    operator does not do what we want.  In addition, they take
    199199    advantage of a quirk in C (where arrays are automatically
    … …  
    793793class StorageTypeAutoReference(StorageType):
    794794    r"""
    795795    StorageTypeAutoReference is a subtype of StorageType that deals with
    796     types in the style of GMP/MPIR/MPFR/MPFI/flint, where copies are
     796    types in the style of GMP/MPIR/MPFR/MPFI/FLINT, where copies are
    797797    not cheap, functions expect arguments to be passed by reference,
    798798    and the API takes advantage of the C quirk where arrays are
    799799    automatically converted to pointers to automatically pass

  • sage/graphs/matchpoly.pyx 

    diff --git a/sage/graphs/matchpoly.pyx b/sage/graphs/matchpoly.pyx
    a b  
    359359    """
    360360    cdef int i, j, k, edge1, edge2, new_edge1, new_edge2, new_nedges
    361361    cdef int *edges1, *edges2, *new_edges1, *new_edges2
    362     cdef fmpz_t coeff
     362    cdef fmpz * coeff
    363363
    364364    if nverts == 3:
    365365        coeff = fmpz_poly_get_coeff_ptr(pol, 3)
    366366        if coeff is NULL:
    367367            fmpz_poly_set_coeff_ui(pol, 3, 1)
    368368        else:
    369             fmpz_add_ui_inplace(coeff, 1)
     369            fmpz_add_ui(coeff, coeff, 1)
    370370        coeff = fmpz_poly_get_coeff_ptr(pol, 1)
    371371        if coeff is NULL:
    372372            fmpz_poly_set_coeff_ui(pol, 1, nedges)
    373373        else:
    374             fmpz_add_ui_inplace(coeff, nedges)
     374            fmpz_add_ui(coeff, coeff, nedges)
    375375        return
    376376
    377377    if nedges == 0:
    … …  
    379379        if coeff is NULL:
    380380            fmpz_poly_set_coeff_ui(pol, nverts, 1)
    381381        else:
    382             fmpz_add_ui_inplace(coeff, 1)
     382            fmpz_add_ui(coeff, coeff, 1)
    383383        return
    384384
    385385    edges1 = edges[2*depth]

  • sage/groups/perm_gps/partn_ref/data_structures_pxd.pxi 

    diff --git a/sage/groups/perm_gps/partn_ref/data_structures_pxd.pxi b/sage/groups/perm_gps/partn_ref/data_structures_pxd.pxi
    a b  
    1 
    21#*****************************************************************************
    32#      Copyright (C) 2006 - 2011 Robert L. Miller <rlmillster@gmail.com>
    43#
    … …  
    6059
    6160    int **generators   # generators for each level,
    6261    int **gen_inverses # and their inverses
    63    
     62
    6463    bitset_s gen_used
    6564    bitset_s gen_is_id
    6665    int *perm_scratch

  • sage/libs/flint/flint.pxd 

    diff --git a/sage/libs/flint/flint.pxd b/sage/libs/flint/flint.pxd
    a b  
    1 cdef extern from "flint.h":
     1cdef extern from "flint/flint.h":
    22
    33    cdef long FLINT_BITS
    44    cdef long FLINT_D_BITS
    55
    66    cdef unsigned long FLINT_BIT_COUNT(unsigned long)
    7     void flint_stack_cleanup()
     7    void _fmpz_cleanup()
     8    void _fmpz_cleanup_mpz_content()

  • sage/libs/flint/flint.pyx 

    diff --git a/sage/libs/flint/flint.pyx b/sage/libs/flint/flint.pyx
    a b  
    1414include "../../ext/cdefs.pxi"
    1515
    1616def free_flint_stack():
    17     flint_stack_cleanup()
     17    _fmpz_cleanup_mpz_content()

  • sage/libs/flint/fmpq_poly.pxd 

    diff --git a/sage/libs/flint/fmpq_poly.pxd b/sage/libs/flint/fmpq_poly.pxd
    a b  
    66#                        http://www.gnu.org/licenses/                         #
    77###############################################################################
    88
    9 #include "fmpz_poly.pxi"
    10 #include "fmpz.pxi"
    11 
    129cdef extern from "gmp.h":
    1310    ctypedef void * mpz_t
    1411    ctypedef void * mpq_t
    1512
     13cdef extern from "fmpq.h":
     14    ctypedef void * fmpq_t
     15    void fmpq_init(fmpq_t)
     16    void fmpq_clear(fmpq_t)
     17    void fmpq_get_mpq(mpq_t, fmpq_t)
     18    void fmpq_set_mpq(fmpq_t, mpq_t)
     19
     20cdef extern from "fmpz_vec.h":
     21    long _fmpz_vec_max_limbs(void * c, long n)
     22
    1623cdef extern from "fmpq_poly.h":
    1724    ctypedef void * fmpz_t
    18     ctypedef void * fmpz_poly_p
    19     struct fmpq_poly:
    20         fmpz_poly_p num
    21         fmpz_t den
    22        
    23     ctypedef fmpq_poly fmpq_poly_struct
    24     ctypedef fmpq_poly_struct fmpq_poly_t[1]
     25    ctypedef void * fmpq_poly_t
    2526
    26     void * fmpq_poly_canonicalize(fmpq_poly_t, fmpz_t)
     27    void fmpq_poly_canonicalise(fmpq_poly_t)
    2728
    2829    void * fmpq_poly_numref(fmpq_poly_t)
    2930    void * fmpq_poly_denref(fmpq_poly_t)
    … …  
    4041    void fmpq_poly_zero(fmpq_poly_t)
    4142    void fmpq_poly_neg(fmpq_poly_t, fmpq_poly_t)
    4243
     44    void fmpq_poly_get_numerator(fmpz_poly_t, fmpq_poly_t)
     45
    4346    void fmpq_poly_get_coeff_mpq(mpq_t, fmpq_poly_t, unsigned long)
    4447    void fmpq_poly_set_coeff_si(fmpq_poly_t, unsigned long, long)
    4548    void fmpq_poly_set_coeff_mpq(fmpq_poly_t, unsigned long, mpq_t)
    4649    void fmpq_poly_set_coeff_mpz(fmpq_poly_t, unsigned long, mpz_t)
    47    
     50
    4851    int fmpq_poly_equal(fmpq_poly_t, fmpq_poly_t)
    4952    int fmpq_poly_cmp(fmpq_poly_t, fmpq_poly_t)
    5053    int fmpq_poly_is_zero(fmpq_poly_t)
    5154
    5255    long fmpq_poly_degree(fmpq_poly_t)
    5356    unsigned long fmpq_poly_length(fmpq_poly_t)
    54    
     57
    5558    void fmpq_poly_add(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
    5659    void fmpq_poly_sub(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
    57    
     60
    5861    void fmpq_poly_scalar_mul_mpq(fmpq_poly_t, fmpq_poly_t, mpq_t)
    5962    void fmpq_poly_scalar_div_mpq(fmpq_poly_t, fmpq_poly_t, mpq_t)
    60    
     63
    6164    void fmpq_poly_mul(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
    6265
    6366    void fmpq_poly_divrem(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
    … …  
    6871
    6972    void fmpq_poly_shift_left(fmpq_poly_t, fmpq_poly_t, unsigned long)
    7073    void fmpq_poly_shift_right(fmpq_poly_t, fmpq_poly_t, unsigned long)
    71    
     74
    7275    void fmpq_poly_gcd(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
    73     void fmpq_poly_xgcd(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
     76    void fmpq_poly_xgcd(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, \
     77            fmpq_poly_t)
    7478    void fmpq_poly_lcm(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
    7579
    7680    void fmpq_poly_derivative(fmpq_poly_t, fmpq_poly_t)
    … …  
    7882    void fmpq_poly_evaluate_mpz(mpq_t, fmpq_poly_t, mpz_t)
    7983    void fmpq_poly_evaluate_mpq(mpq_t, fmpq_poly_t, mpq_t)
    8084
    81     void fmpq_poly_content(mpq_t, fmpq_poly_t)
     85    void fmpq_poly_content(fmpq_t, fmpq_poly_t)
    8286    void fmpq_poly_primitive_part(fmpq_poly_t, fmpq_poly_t)
    8387
    84     void fmpq_poly_resultant(mpq_t, fmpq_poly_t, fmpq_poly_t)
     88    void fmpq_poly_resultant(fmpq_t, fmpq_poly_t, fmpq_poly_t)
    8589
    8690    void fmpq_poly_compose(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
    8791
    88     void fmpq_poly_get_slice(fmpq_poly_t, fmpq_poly_t, unsigned long, unsigned long)
    89     void fmpq_poly_truncate(fmpq_poly_t, fmpq_poly_t, unsigned long)
     92    void fmpq_poly_get_slice(fmpq_poly_t, fmpq_poly_t, long, long)
     93    void fmpq_poly_truncate(fmpq_poly_t, unsigned long)
    9094    void fmpq_poly_reverse(fmpq_poly_t, fmpq_poly_t, unsigned long)
    9195
    9296    void fmpq_poly_set_array_mpq(fmpq_poly_t, mpq_t *, unsigned long)
    9397    void fmpq_poly_from_string(fmpq_poly_t, char *)
    9498    char * fmpq_poly_to_string(fmpq_poly_t, char *)
    9599    char * fmpq_poly_to_string_pretty(fmpq_poly_t, char *)
    96 

  • sage/libs/flint/fmpz.pxi 

    diff --git a/sage/libs/flint/fmpz.pxi b/sage/libs/flint/fmpz.pxi
    a b  
    11include "../ntl/decl.pxi"
    22
    33cdef extern from "flint/fmpz.h":
    4    
    5     ctypedef void * fmpz_t
     4
     5    ctypedef long fmpz
     6    ctypedef long * fmpz_t
    67    ctypedef void * mpz_t
    78
    8     fmpz_t fmpz_init(unsigned long limbs)
     9    void fmpz_init(fmpz_t x)
    910
    1011    void fmpz_set_ui(fmpz_t res, unsigned long x)
    1112    void fmpz_set_si(fmpz_t res, long x)
    12    
     13
    1314    void fmpz_clear(fmpz_t f)
    1415    void fmpz_print(fmpz_t f)
    1516    int fmpz_is_one(fmpz_t f)
    1617
    17     void fmpz_add_ui_inplace(fmpz_t output, unsigned long x)
    18     void fmpz_sub_ui_inplace(fmpz_t output, unsigned long x)
    19    
    2018    void fmpz_get_mpz(mpz_t rop, fmpz_t op)
    2119    void fmpz_set_mpz(fmpz_t rop, mpz_t op)
    2220
     21    void fmpz_add_ui(fmpz_t f, fmpz_t g, unsigned long c)

  • sage/libs/flint/fmpz_poly.pxi 

    diff --git a/sage/libs/flint/fmpz_poly.pxi b/sage/libs/flint/fmpz_poly.pxi
    a b  
    11include "fmpz.pxi"
    22include "../ntl/decl.pxi"
    33
     4from sage.libs.flint.nmod_poly cimport nmod_poly_t
     5
    46cdef extern from "flint/fmpz_poly.h":
    5    
    67    ctypedef void* fmpz_poly_t
    7    
     8
    89    void fmpz_poly_init(fmpz_poly_t poly)
    9     void fmpz_poly_init2(fmpz_poly_t poly, unsigned long alloc, \
    10             unsigned long limbs)
     10    void fmpz_poly_init2(fmpz_poly_t poly, unsigned long alloc)
    1111    void fmpz_poly_realloc(fmpz_poly_t poly, unsigned long alloc)
    12    
     12
    1313    void fmpz_poly_fit_length(fmpz_poly_t poly, unsigned long alloc)
    14     void fmpz_poly_resize_limbs(fmpz_poly_t poly, unsigned long limbs)
    15     void fmpz_poly_fit_limbs(fmpz_poly_t poly, unsigned long limbs)
    16     unsigned long fmpz_poly_limbs(fmpz_poly_t poly)
    1714
    1815    void fmpz_poly_clear(fmpz_poly_t poly)
    19    
     16
    2017    long fmpz_poly_degree(fmpz_poly_t poly)
    2118    unsigned long fmpz_poly_length(fmpz_poly_t poly)
    2219
    23    
    2420    void fmpz_poly_set_length(fmpz_poly_t poly, unsigned long length)
    2521    void fmpz_poly_truncate(fmpz_poly_t poly, unsigned long length)
    2622
    … …  
    3127            unsigned long x)
    3228    void fmpz_poly_set_coeff_mpz(fmpz_poly_t poly, unsigned long n, mpz_t x)
    3329    void fmpz_poly_set_coeff_fmpz(fmpz_poly_t poly, unsigned long n, fmpz_t x)
    34    
     30
    3531    void fmpz_poly_get_coeff_mpz(mpz_t x, fmpz_poly_t poly, unsigned long n)
    36     void fmpz_poly_get_coeff_mpz_read_only(mpz_t x, fmpz_poly_t poly, unsigned long n)
    37     fmpz_t fmpz_poly_get_coeff_ptr(fmpz_poly_t poly, unsigned long n)
     32    void fmpz_poly_get_coeff_mpz_read_only(mpz_t x, fmpz_poly_t poly, \
     33            unsigned long n)
     34    fmpz* fmpz_poly_get_coeff_ptr(fmpz_poly_t poly, unsigned long n)
     35
     36    void fmpz_poly_get_nmod_poly(nmod_poly_t res, fmpz_poly_t poly)
    3837
    3938    void fmpz_poly_add(fmpz_poly_t output, fmpz_poly_t input1, \
    4039            fmpz_poly_t input2)
    … …  
    4948    void fmpz_poly_mul_trunc_left_n(fmpz_poly_t output, fmpz_poly_t input1, \
    5049            fmpz_poly_t input2, unsigned long trunc)
    5150
    52 #    void fmpz_poly_scalar_mul(fmpz_poly_t output, fmpz_poly_t input, fmpz_t x)
    5351    void fmpz_poly_scalar_mul_ui(fmpz_poly_t output, fmpz_poly_t input, \
    5452            unsigned long x)
    5553    void fmpz_poly_scalar_mul_si(fmpz_poly_t output, fmpz_poly_t input, long x)
    5654
    57     void fmpz_poly_scalar_mul_mpz(fmpz_poly_t output, fmpz_poly_t poly,
     55    void fmpz_poly_scalar_mul_mpz(fmpz_poly_t output, fmpz_poly_t poly, \
    5856            mpz_t x)
     57    void fmpz_poly_scalar_mul_fmpz(fmpz_poly_t output, fmpz_poly_t poly, \
     58            fmpz_t x)
    5959
    6060    void fmpz_poly_scalar_divexact_ui(fmpz_poly_t output, fmpz_poly_t poly, \
    6161            unsigned long x)
    6262    void fmpz_poly_scalar_divexact_si(fmpz_poly_t output, fmpz_poly_t poly, \
    6363            long x)
     64    void fmpz_poly_scalar_divexact_mpz(fmpz_poly_t output, fmpz_poly_t poly, \
     65            mpz_t x)
    6466    void fmpz_poly_scalar_divexact_fmpz(fmpz_poly_t output, fmpz_poly_t poly, \
    6567            fmpz_t x)
    66    
    67     void fmpz_poly_scalar_fdiv_mpz( fmpz_poly_t output, fmpz_poly_t poly, mpz_t x)
     68
     69    void fmpz_poly_scalar_fdiv_ui(fmpz_poly_t output, fmpz_poly_t poly, \
     70            unsigned long x)
     71    void fmpz_poly_scalar_fdiv_mpz(fmpz_poly_t output, fmpz_poly_t poly, \
     72            mpz_t x)
    6873
    6974    void fmpz_poly_div(fmpz_poly_t Q, fmpz_poly_t A, fmpz_poly_t B)
    7075    void fmpz_poly_divrem(fmpz_poly_t Q, fmpz_poly_t R, fmpz_poly_t A, \
    71             fmpz_poly_t B)   
    72    
     76            fmpz_poly_t B)
     77
    7378    void fmpz_poly_pseudo_div(fmpz_poly_t Q, unsigned long *d, fmpz_poly_t A, \
    74             fmpz_poly_t B)   
     79            fmpz_poly_t B)
    7580    void fmpz_poly_pseudo_divrem(fmpz_poly_t Q, fmpz_poly_t R, \
    76             unsigned long *d, fmpz_poly_t A, fmpz_poly_t B)   
    77    
    78     int fmpz_poly_equal(fmpz_poly_t poly1, fmpz_poly_t poly2)
     81            unsigned long *d, fmpz_poly_t A, fmpz_poly_t B)
    7982
    80     bint fmpz_poly_set_str(fmpz_poly_t poly, char* s)
     83    int fmpz_poly_equal(fmpz_poly_t poly1, fmpz_poly_t poly2)
     84
     85    int fmpz_poly_set_str(fmpz_poly_t poly, char* s)
    8186    char* fmpz_poly_get_str(fmpz_poly_t poly)
    8287    void fmpz_poly_print(fmpz_poly_t poly)
    8388    bint fmpz_poly_read(fmpz_poly_t poly)
    … …  
    8792    void fmpz_poly_pow_trunc(fmpz_poly_t output, fmpz_poly_t poly, \
    8893            unsigned long exp, unsigned long n)
    8994
    90     void fmpz_poly_shift_left ( fmpz_poly_t output ,
    91                                 fmpz_poly_t poly , unsigned long n )
    92     void fmpz_poly_shift_right ( fmpz_poly_t output ,
    93                                  fmpz_poly_t poly , unsigned long n )
     95    void fmpz_poly_shift_left(fmpz_poly_t output, fmpz_poly_t poly, \
     96            unsigned long n)
     97    void fmpz_poly_shift_right(fmpz_poly_t output, fmpz_poly_t poly, \
     98            unsigned long n)
    9499
    95     void fmpz_poly_derivative ( fmpz_poly_t der , fmpz_poly_t poly )
     100    void fmpz_poly_derivative(fmpz_poly_t der, fmpz_poly_t poly)
    96101
    97102    void fmpz_poly_content(fmpz_t c, fmpz_poly_t poly)
    98103    void fmpz_poly_primitive_part(fmpz_poly_t prim, fmpz_poly_t poly)
    99104
    100     void fmpz_poly_gcd(fmpz_poly_t res, fmpz_poly_t poly1, \
    101             fmpz_poly_t poly2)
     105    void fmpz_poly_gcd(fmpz_poly_t res, fmpz_poly_t poly1, fmpz_poly_t poly2)
    102106
    103     void fmpz_poly_xgcd(fmpz_t r, fmpz_poly_t s, fmpz_poly_t t, fmpz_poly_t a,\
    104             fmpz_poly_t b)
     107    void fmpz_poly_xgcd(fmpz_t r, fmpz_poly_t s, fmpz_poly_t t, \
     108            fmpz_poly_t a, fmpz_poly_t b)
    105109
    106110    unsigned long fmpz_poly_resultant_bound(fmpz_poly_t a, fmpz_poly_t b)
    107111    void fmpz_poly_resultant(fmpz_t r, fmpz_poly_t a, fmpz_poly_t b)
    108112
    109     void fmpz_poly_invmod(fmpz_t d, fmpz_poly_t H, fmpz_poly_t poly1, fmpz_poly_t poly2)
     113    void fmpz_poly_invmod(fmpz_t d, fmpz_poly_t H, fmpz_poly_t poly1, \
     114            fmpz_poly_t poly2)
    110115    void fmpz_poly_derivative(fmpz_poly_t der, fmpz_poly_t poly)
    111116    void fmpz_poly_evaluate_fmpz(fmpz_t output, fmpz_poly_t poly, fmpz_t val)
    112117    void fmpz_poly_compose(fmpz_poly_t output, fmpz_poly_t f, fmpz_poly_t g)
    113     void fmpz_poly_scalar_fdiv_ui(fmpz_poly_t output, fmpz_poly_t poly, unsigned long x)
    114118
    115119    unsigned long fmpz_poly_max_limbs(fmpz_poly_t poly)

  • sage/libs/flint/fmpz_poly.pyx 

    diff --git a/sage/libs/flint/fmpz_poly.pyx b/sage/libs/flint/fmpz_poly.pyx
    a b  
    5353        cdef long c
    5454        cdef Integer w
    5555        if PY_TYPE_CHECK(v, str):
    56             if fmpz_poly_set_str(self.poly, v):
     56            if not fmpz_poly_set_str(self.poly, v):
    5757                return
    5858            else:
    5959                raise ValueError, "Unable to create Fmpz_poly from that string."

  • sage/libs/flint/nmod_poly.pxd 

    diff --git a/sage/libs/flint/nmod_poly.pxd b/sage/libs/flint/nmod_poly.pxd
    a b  
    66from flint import *
    77
    88cdef extern from "flint/nmod_poly.h":
     9    ctypedef unsigned long mp_bitcnt_t
     10    ctypedef void * mp_srcptr
     11
     12    ctypedef struct nmod_t:
     13        mp_limb_t n
     14        mp_limb_t ninv
     15        mp_bitcnt_t norm
     16
    917    ctypedef struct nmod_poly_struct:
    10         unsigned long *coeffs
    11         unsigned long alloc
    12         unsigned long length
    13         unsigned long p
    14         double p_inv
     18        mp_limb_t *coeffs
     19        long alloc
     20        long length
     21        nmod_t mod
    1522
    1623    ctypedef nmod_poly_struct* nmod_poly_t
    1724
    1825    ctypedef struct nmod_poly_factor_struct:
    19         nmod_poly_t *factors
    20         unsigned long *exponents
    21         unsigned long alloc
    22         unsigned long num_factors
     26        nmod_poly_t p
     27        long *exp
     28        long num
     29        long alloc
    2330
    2431    ctypedef nmod_poly_factor_struct* nmod_poly_factor_t
    2532
    26     cdef void nmod_poly_init(nmod_poly_t poly, unsigned long p)
    27     cdef void nmod_poly_init_preinv(nmod_poly_t poly, unsigned long p, double p_inv)
    28     cdef void nmod_poly_init2(nmod_poly_t poly, unsigned long p, unsigned long alloc)
    29     cdef void nmod_poly_init2_preinv(nmod_poly_t poly, unsigned long p, double p_inv, unsigned long alloc)
     33    # Memory management
     34    cdef void nmod_poly_init(nmod_poly_t poly, mp_limb_t n)
     35    cdef void nmod_poly_init_preinv(nmod_poly_t poly, mp_limb_t n, mp_limb_t ninv)
     36    cdef void nmod_poly_init2(nmod_poly_t poly, mp_limb_t n, long alloc)
     37    cdef void nmod_poly_init2_preinv(nmod_poly_t poly, mp_limb_t n, mp_limb_t ninv, long alloc)
     38
    3039    cdef void nmod_poly_clear(nmod_poly_t poly)
    3140
    32     cdef void nmod_poly_realloc(nmod_poly_t poly, unsigned long alloc)
    33     # _bits_ only applies to newly allocated coefficients, not existing ones...
     41    cdef void nmod_poly_realloc(nmod_poly_t poly, long alloc)
    3442
    35     # this non-inlined version REQUIRES that alloc > poly->alloc
    36     void __nmod_poly_fit_length(nmod_poly_t poly, unsigned long alloc)
     43    cdef void nmod_poly_fit_length(nmod_poly_t poly, long alloc)
     44    cdef void _nmod_poly_normalise(nmod_poly_t poly)
    3745
    38     # this is arranged so that the initial comparison (very frequent) is inlined,
    39     # but the actual allocation (infrequent) is not
    40     cdef void nmod_poly_fit_length(nmod_poly_t poly, unsigned long alloc)
     46    # Getting and setting coefficients
     47    cdef unsigned long nmod_poly_get_coeff_ui(nmod_poly_t poly, unsigned long j)
     48    cdef void nmod_poly_set_coeff_ui(nmod_poly_t poly, unsigned long j, unsigned long c)
    4149
    42     # ------------------------------------------------------
    43     # Setting/retrieving coefficients
     50    # Input and output
     51    cdef char * nmod_poly_get_str(nmod_poly_t poly)
     52    cdef int nmod_poly_set_str(char * s, nmod_poly_t poly)
     53    cdef int nmod_poly_print(nmod_poly_t a)
     54    cdef int nmod_poly_fread(FILE * f, nmod_poly_t poly)
     55    cdef int nmod_poly_fprint(FILE * f, nmod_poly_t poly)
     56    cdef int nmod_poly_read(nmod_poly_t poly)
    4457
    45     cdef unsigned long nmod_poly_get_coeff_ui(nmod_poly_t poly, unsigned long n)
     58    # Polynomial parameters
     59    cdef long nmod_poly_length(nmod_poly_t poly)
     60    cdef long nmod_poly_degree(nmod_poly_t poly)
     61    cdef mp_limb_t nmod_poly_modulus(nmod_poly_t poly)
     62    cdef mp_bitcnt_t nmod_poly_max_bits(nmod_poly_t poly)
    4663
    47     cdef unsigned long _nmod_poly_get_coeff_ui(nmod_poly_t poly, unsigned long n)
     64    # Assignment and basic manipulation
     65    cdef void nmod_poly_set(nmod_poly_t a, nmod_poly_t b)
     66    cdef void nmod_poly_swap(nmod_poly_t poly1, nmod_poly_t poly2)
     67    cdef void nmod_poly_zero(nmod_poly_t res)
     68    cdef void nmod_poly_one(nmod_poly_t res)
     69    cdef void nmod_poly_truncate(nmod_poly_t poly, long len)
     70    cdef void nmod_poly_reverse(nmod_poly_t output, nmod_poly_t input, long m)
     71    cdef int nmod_poly_equal(nmod_poly_t a, nmod_poly_t b)
    4872
    49     cdef void nmod_poly_set_coeff_ui(nmod_poly_t poly, unsigned long n, unsigned long c)
     73    # Powering
     74    cdef void nmod_poly_pow(nmod_poly_t res, nmod_poly_t poly, unsigned long e)
     75    cdef void nmod_poly_pow_trunc(nmod_poly_t res, nmod_poly_t poly, unsigned long e, long trunc)
    5076
    51     cdef void _nmod_poly_set_coeff_ui(nmod_poly_t poly, unsigned long n, unsigned long c)
     77    # Inflation and deflation
     78    cdef unsigned long nmod_poly_deflation(nmod_poly_t input)
     79    cdef void nmod_poly_deflate(nmod_poly_t result, nmod_poly_t input, unsigned long deflation)
     80    cdef void nmod_poly_inflate(nmod_poly_t result, nmod_poly_t input, unsigned long inflation)
    5281
    53     # ------------------------------------------------------
    54     # String conversions and I/O
     82    # Comparison
     83    cdef int nmod_poly_is_zero(nmod_poly_t poly)
     84    cdef int nmod_poly_is_one(nmod_poly_t poly)
    5585
    56     cdef int nmod_poly_from_string(nmod_poly_t poly, char* s)
    57     cdef char* nmod_poly_to_string(nmod_poly_t poly)
    58     cdef void nmod_poly_print(nmod_poly_t poly)
    59     cdef void nmod_poly_fprint(nmod_poly_t poly, FILE* f)
    60     cdef int nmod_poly_read(nmod_poly_t poly)
    61     cdef int nmod_poly_fread(nmod_poly_t poly, FILE* f)
     86    # Addition and subtraction
     87    cdef void nmod_poly_add(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
     88    cdef void nmod_poly_sub(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
     89    cdef void nmod_poly_neg(nmod_poly_t res, nmod_poly_t poly1)
    6290
    63     # ------------------------------------------------------
    64     # Length and degree
     91    # Shifting
     92    cdef void nmod_poly_shift_left(nmod_poly_t res, nmod_poly_t poly, long k)
     93    cdef void nmod_poly_shift_right(nmod_poly_t res, nmod_poly_t poly, long k)
    6594
    66     cdef void _nmod_poly_normalise(nmod_poly_t poly)
    67     cdef int _nmod_poly_normalised(nmod_poly_t poly)
    68     cdef void nmod_poly_truncate(nmod_poly_t poly, unsigned long length)
     95    # Multiplication
     96    cdef void nmod_poly_mul(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
     97    cdef void nmod_poly_mullow(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, long trunc)
     98    cdef void nmod_poly_mulhigh(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, long n)
     99    cdef void nmod_poly_mulmod(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, nmod_poly_t f)
    69100
    70     cdef unsigned long nmod_poly_length(nmod_poly_t poly)
     101    # Square roots
     102    cdef void nmod_poly_invsqrt_series(nmod_poly_t g, nmod_poly_t h, long n)
     103    cdef void nmod_poly_sqrt_series(nmod_poly_t g, nmod_poly_t h, long n)
     104    int nmod_poly_sqrt(nmod_poly_t b, nmod_poly_t a)
    71105
    72     cdef long nmod_poly_degree(nmod_poly_t poly)
     106    # Scalar multiplication and division
     107    cdef void nmod_poly_scalar_mul_nmod(nmod_poly_t res, nmod_poly_t poly1, mp_limb_t c)
     108    cdef void nmod_poly_make_monic(nmod_poly_t output, nmod_poly_t input)
    73109
    74     cdef unsigned long nmod_poly_modulus(nmod_poly_t poly)
     110    # Division
     111    cdef void nmod_poly_divrem(nmod_poly_t Q, nmod_poly_t R, nmod_poly_t A, nmod_poly_t B)
     112    cdef void nmod_poly_div(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B)
     113    cdef void nmod_poly_inv_series(nmod_poly_t Qinv, nmod_poly_t Q, long n)
     114    cdef void nmod_poly_div_series(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B, long n)
    75115
    76     cdef double nmod_poly_precomputed_inverse(nmod_poly_t poly)
     116    # GCD
     117    cdef void nmod_poly_gcd(nmod_poly_t G, nmod_poly_t A, nmod_poly_t B)
     118    cdef void nmod_poly_xgcd(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T, nmod_poly_t A, nmod_poly_t B)
     119    mp_limb_t nmod_poly_resultant(nmod_poly_t f, nmod_poly_t g)
    77120
    78     # ------------------------------------------------------
    79     # Assignment
    80121
    81     cdef void _nmod_poly_set(nmod_poly_t res, nmod_poly_t poly)
    82     cdef void nmod_poly_set(nmod_poly_t res, nmod_poly_t poly)
     122    # Evaluation
     123    cdef mp_limb_t nmod_poly_evaluate_nmod(nmod_poly_t poly, mp_limb_t c)
     124    cdef void nmod_poly_evaluate_nmod_vec(mp_ptr ys, nmod_poly_t poly, mp_srcptr xs, long n)
    83125
    84     cdef void nmod_poly_zero(nmod_poly_t poly)
     126    # Interpolation
     127    cdef void nmod_poly_interpolate_nmod_vec(nmod_poly_t poly, mp_srcptr xs, mp_srcptr ys, long n)
    85128
    86     cdef void nmod_poly_swap(nmod_poly_t poly1, nmod_poly_t poly2)
     129    # Composition
     130    cdef void nmod_poly_compose(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    87131
    88     #
    89     # Subpolynomials
    90     #
     132    # Power series composition and reversion
     133    cdef void nmod_poly_compose_series(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, long n)
     134    cdef void nmod_poly_reverse_series(nmod_poly_t Qinv, nmod_poly_t Q, long n)
    91135
    92     cdef void _nmod_poly_attach(nmod_poly_t output, nmod_poly_t input)
     136    # Factoring
     137    cdef void nmod_poly_factor_clear(nmod_poly_factor_t fac)
     138    cdef void nmod_poly_factor_init(nmod_poly_factor_t fac)
     139    cdef void nmod_poly_factor_insert(nmod_poly_factor_t fac, nmod_poly_t poly, unsigned long exp)
     140    cdef void nmod_poly_factor_print(nmod_poly_factor_t fac)
     141    cdef void nmod_poly_factor_concat(nmod_poly_factor_t res, nmod_poly_factor_t fac)
     142    cdef void nmod_poly_factor_pow(nmod_poly_factor_t fac, unsigned long exp)
     143    cdef unsigned long nmod_poly_remove(nmod_poly_t f, nmod_poly_t p)
     144    cdef int nmod_poly_is_irreducible(nmod_poly_t f)
     145    cdef int nmod_poly_is_squarefree(nmod_poly_t f)
     146    cdef void nmod_poly_factor_cantor_zassenhaus(nmod_poly_factor_t res, nmod_poly_t f)
     147    cdef void nmod_poly_factor_berlekamp(nmod_poly_factor_t factors, nmod_poly_t f)
     148    cdef void nmod_poly_factor_squarefree(nmod_poly_factor_t res, nmod_poly_t f)
     149    cdef mp_limb_t nmod_poly_factor_with_berlekamp(nmod_poly_factor_t result, nmod_poly_t input)
     150    cdef mp_limb_t nmod_poly_factor_with_cantor_zassenhaus(nmod_poly_factor_t result, nmod_poly_t input)
     151    cdef mp_limb_t nmod_poly_factor(nmod_poly_factor_t result, nmod_poly_t input)
    93152
    94     cdef void nmod_poly_attach(nmod_poly_t output, nmod_poly_t input)
     153    # Derivative
     154    cdef void nmod_poly_derivative(nmod_poly_t x_prime, nmod_poly_t x)
     155    cdef void nmod_poly_integral(nmod_poly_t x_int, nmod_poly_t x)
    95156
    96     #
    97     # Attach input shifted right by n to output
    98     #
    99 
    100     cdef void _nmod_poly_attach_shift(nmod_poly_t output, nmod_poly_t input, unsigned long n)
    101 
    102     cdef void nmod_poly_attach_shift(nmod_poly_t output, nmod_poly_t input, unsigned long n)
    103 
    104     #
    105     # Attach input to first n coefficients of input
    106     #
    107 
    108     cdef void _nmod_poly_attach_truncate(nmod_poly_t output,  nmod_poly_t input, unsigned long n)
    109 
    110     cdef void nmod_poly_attach_truncate(nmod_poly_t output, nmod_poly_t input, unsigned long n)
    111 
    112     #
    113     # Comparison functions
    114     #
    115 
    116     cdef int nmod_poly_equal(nmod_poly_t poly1, nmod_poly_t poly2)
    117 
    118     cdef int nmod_poly_is_one(nmod_poly_t poly1)
    119 
    120     #
    121     # Reversal
    122     #
    123 
    124     cdef void _nmod_poly_reverse(nmod_poly_t output, nmod_poly_t input, unsigned long length)
    125     cdef void nmod_poly_reverse(nmod_poly_t output, nmod_poly_t input, unsigned long length)
    126 
    127     #
    128     # Monic polys
    129     #
    130 
    131     cdef void nmod_poly_make_monic(nmod_poly_t output, nmod_poly_t pol)
    132 
    133     #
    134     # Addition and subtraction
    135     #
    136 
    137     cdef void nmod_poly_add(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    138     cdef void nmod_poly_add_without_mod(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    139     cdef void nmod_poly_sub(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    140     cdef void _nmod_poly_sub(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    141     cdef void nmod_poly_neg(nmod_poly_t res, nmod_poly_t poly)
    142 
    143     #
    144     # Shifting functions
    145     #
    146 
    147     cdef void nmod_poly_left_shift(nmod_poly_t res, nmod_poly_t poly, unsigned long k)
    148     cdef void nmod_poly_right_shift(nmod_poly_t res, nmod_poly_t poly, unsigned long k)
    149 
    150     #
    151     # Polynomial multiplication
    152     #
    153     # All multiplication functions require that the modulus be no more than FLINT_BITS-1 bits
    154     #
    155 
    156     cdef void nmod_poly_mul(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    157     cdef void nmod_poly_sqr(nmod_poly_t res, nmod_poly_t poly)
    158 
    159     # Requires that poly1 bits + poly2 bits + log_length is not greater than 2*FLINT_BITS
    160 
    161     cdef void nmod_poly_mul_KS(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits_input)
    162     cdef void _nmod_poly_mul_KS(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits_input)
    163 
    164     cdef void nmod_poly_mul_KS_trunc(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits_input, unsigned long trunc)
    165     cdef void _nmod_poly_mul_KS_trunc(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits_input, unsigned long trunc)
    166 
    167     cdef void _nmod_poly_mul_classical(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    168     cdef void __nmod_poly_mul_classical_mod_last(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits)
    169     cdef void __nmod_poly_mul_classical_mod_throughout(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits)
    170     cdef void nmod_poly_mul_classical(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    171     cdef void _nmod_poly_sqr_classical(nmod_poly_t res, nmod_poly_t poly)
    172     cdef void nmod_poly_sqr_classical(nmod_poly_t res, nmod_poly_t poly)
    173 
    174     cdef void _nmod_poly_mul_classical_trunc(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long trunc)
    175     cdef void __nmod_poly_mul_classical_trunc_mod_last(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits, unsigned long trunc)
    176     cdef void __nmod_poly_mul_classical_trunc_mod_throughout(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits, unsigned long trunc)
    177     cdef void nmod_poly_mul_classical_trunc(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long trunc)
    178 
    179     cdef void _nmod_poly_mul_classical_trunc_left(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long trunc)
    180     cdef void __nmod_poly_mul_classical_trunc_left_mod_last(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits, unsigned long trunc)
    181     cdef void __nmod_poly_mul_classical_trunc_left_mod_throughout(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long bits, unsigned long trunc)
    182     cdef void nmod_poly_mul_classical_trunc_left(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long trunc)
    183 
    184     cdef void nmod_poly_mullow(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long trunc)
    185     cdef void nmod_poly_mulhigh(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, unsigned long trunc)
    186 
    187     #
    188     # Bit packing functions
    189     #
    190 
    191     cdef unsigned long nmod_poly_bits(nmod_poly_t poly)
    192     cdef void _nmod_poly_bit_pack_mpn(mp_limb_t * res, nmod_poly_t poly, unsigned long bits, unsigned long length)
    193     cdef void _nmod_poly_bit_unpack_mpn(nmod_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 _nmod_poly_scalar_mul_nmod(nmod_poly_t res, nmod_poly_t poly, unsigned long scalar)
    203     cdef void nmod_poly_scalar_mul_nmod(nmod_poly_t res, nmod_poly_t poly, unsigned long scalar)
    204     cdef void __nmod_poly_scalar_mul_without_mod(nmod_poly_t res, nmod_poly_t poly, unsigned long scalar)
    205 
    206     #
    207     # Division
    208     #
    209 
    210     cdef void nmod_poly_divrem_classical(nmod_poly_t Q, nmod_poly_t R, nmod_poly_t A, nmod_poly_t B)
    211     cdef void __nmod_poly_divrem_classical_mod_last(nmod_poly_t Q, nmod_poly_t R, nmod_poly_t A, nmod_poly_t B)
    212     cdef void nmod_poly_div_classical(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B)
    213     cdef void __nmod_poly_div_classical_mod_last(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B)
    214     cdef void nmod_poly_div_divconquer_recursive(nmod_poly_t Q, nmod_poly_t BQ, nmod_poly_t A, nmod_poly_t B)
    215     cdef void nmod_poly_divrem_divconquer(nmod_poly_t Q, nmod_poly_t R, nmod_poly_t A, nmod_poly_t B)
    216     cdef void nmod_poly_div_divconquer(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B)
    217 
    218     #
    219     # Newton Inversion
    220     #
    221 
    222     cdef void nmod_poly_newton_invert_basecase(nmod_poly_t Q_inv, nmod_poly_t Q, unsigned long n)
    223     cdef void nmod_poly_newton_invert(nmod_poly_t Q_inv, nmod_poly_t Q, unsigned long n)
    224 
    225     #
    226     # Newton Division
    227     #
    228 
    229     cdef void nmod_poly_div_series(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B, unsigned long n)
    230     cdef void nmod_poly_div_newton(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B)
    231     cdef void nmod_poly_divrem_newton(nmod_poly_t Q, nmod_poly_t R, nmod_poly_t A, nmod_poly_t B)
    232 
    233     cdef void nmod_poly_divrem(nmod_poly_t Q, nmod_poly_t R, nmod_poly_t A, nmod_poly_t B)
    234 
    235     cdef void nmod_poly_div(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B)
    236 
    237     #
    238     # Resultant
    239     #
    240 
    241     cdef unsigned long nmod_poly_resultant_euclidean(nmod_poly_t a, nmod_poly_t b)
    242 
    243     cdef unsigned long nmod_poly_resultant(nmod_poly_t a, nmod_poly_t b)
    244 
    245     #
    246     # GCD
    247     #
    248 
    249     cdef void nmod_poly_gcd(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    250     cdef int nmod_poly_gcd_invert(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
    251     cdef void nmod_poly_xgcd(nmod_poly_t res, nmod_poly_t s, nmod_poly_t t, nmod_poly_t poly1, nmod_poly_t poly2)
    252 
    253 
    254 
    255     # Composition / evaluation
    256 
    257     cdef unsigned long nmod_poly_evaluate_nmod(nmod_poly_t, unsigned long)
    258     cdef void nmod_poly_compose(nmod_poly_t, nmod_poly_t, nmod_poly_t)
    259 
    260     # Factorization
    261 
    262     cdef bint nmod_poly_is_irreducible(nmod_poly_t p)
    263 
    264     ctypedef struct nmod_poly_factors_struct:
    265         unsigned long num_factors
    266         unsigned long* exponents
    267         nmod_poly_t* factors
    268 
    269     ctypedef nmod_poly_factors_struct* nmod_poly_factor_t
    270 
    271     cdef void nmod_poly_factor_init(nmod_poly_factor_t)
    272     cdef void nmod_poly_factor_clear(nmod_poly_factor_t)
    273     cdef unsigned long nmod_poly_factor(nmod_poly_factor_t, nmod_poly_t)
    274     cdef void nmod_poly_factor_squarefree(nmod_poly_factor_t, nmod_poly_t)
    275     cdef void nmod_poly_factor_berlekamp(nmod_poly_factor_t factors, nmod_poly_t f)
    276 
    277     cdef void nmod_poly_factor_add(nmod_poly_factor_t fac, nmod_poly_t poly)
    278     cdef void nmod_poly_factor_concat(nmod_poly_factor_t res, nmod_poly_factor_t fac)
    279     cdef void nmod_poly_factor_print(nmod_poly_factor_t fac)
    280     cdef void nmod_poly_factor_pow(nmod_poly_factor_t fac, unsigned long exp)
    281 
    282     #
    283     # Differentiation
    284     #
    285  
    286     cdef void nmod_poly_derivative(nmod_poly_t res, nmod_poly_t poly)
    287    
    288     #
    289     # Arithmetic modulo a polynomial
    290     #
    291    
    292     cdef void nmod_poly_mulmod(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, nmod_poly_t f)
    293     cdef void nmod_poly_powmod(nmod_poly_t res,nmod_poly_t pol, long exp, nmod_poly_t f)
     157    # Transcendental functions
     158    cdef void nmod_poly_atan_series(nmod_poly_t g, nmod_poly_t h, long n)
     159    cdef void nmod_poly_tan_series(nmod_poly_t g, nmod_poly_t h, long n)
     160    cdef void nmod_poly_asin_series(nmod_poly_t g, nmod_poly_t h, long n)
     161    cdef void nmod_poly_sin_series(nmod_poly_t g, nmod_poly_t h, long n)
     162    cdef void nmod_poly_cos_series(nmod_poly_t g, nmod_poly_t h, long n)
     163    cdef void nmod_poly_asinh_series(nmod_poly_t g, nmod_poly_t h, long n)
     164    cdef void nmod_poly_atanh_series(nmod_poly_t g, nmod_poly_t h, long n)
     165    cdef void nmod_poly_sinh_series(nmod_poly_t g, nmod_poly_t h, long n)
     166    cdef void nmod_poly_cosh_series(nmod_poly_t g, nmod_poly_t h, long n)
     167    cdef void nmod_poly_tanh_series(nmod_poly_t g, nmod_poly_t h, long n)
     168    cdef void nmod_poly_log_series(nmod_poly_t res, nmod_poly_t f, long n)
     169    cdef void nmod_poly_exp_series(nmod_poly_t f, nmod_poly_t h, long)

  • sage/libs/flint/nmod_poly_linkage.pxi 

    diff --git a/sage/libs/flint/nmod_poly_linkage.pxi b/sage/libs/flint/nmod_poly_linkage.pxi
    a b  
    8989        6*x
    9090    """
    9191    cdef unsigned long i
    92     if a.p <= n:
     92    if a.mod.n <= n:
    9393        nmod_poly_set(res, a)
    9494    else:
    9595        nmod_poly_zero(res)
    … …  
    139139        sage: Q(0).is_zero()
    140140        True
    141141    """
    142     # is_zero doesn't exist
    143     return nmod_poly_degree(a) == -1
     142    return nmod_poly_is_zero(a)
    144143
    145144cdef inline bint celement_is_one(nmod_poly_t a, unsigned long n) except -2:
    146145    """
    … …  
    496495    elif e == 1:
    497496        nmod_poly_set(res, x)
    498497    elif e == 2:
    499         nmod_poly_sqr(res, x)
     498        nmod_poly_mul(res, x, x)
    500499    else:
    501500        if res == x:
    502501            nmod_poly_set(tmp, x)
    … …  
    510509            nmod_poly_set_coeff_ui(res, 0, 1)
    511510        e = e >> 1
    512511        while(e != 0):
    513             nmod_poly_sqr(pow2, pow2)
     512            nmod_poly_mul(pow2, pow2, pow2)
    514513            if e % 2:
    515514                nmod_poly_mul(res, res, pow2)
    516515            e = e >> 1
    … …  
    634633
    635634    factor_list = []
    636635    cdef Polynomial_zmod_flint t
    637     for i in range(factors_c.num_factors):
     636    for i in range(factors_c.num):
    638637        t = poly._new()
    639         nmod_poly_swap(&t.x, factors_c.factors[i])
    640         factor_list.append((t, factors_c.exponents[i]))
     638        nmod_poly_swap(&t.x, &factors_c.p[i])
     639        factor_list.append((t, factors_c.exp[i]))
    641640
    642641    nmod_poly_factor_clear(factors_c)
    643642

  • sage/libs/flint/ntl_interface.pxd 

    diff --git a/sage/libs/flint/ntl_interface.pxd b/sage/libs/flint/ntl_interface.pxd
    a b  
    66from sage.libs.ntl.ntl_ZZX_decl cimport ZZX_c
    77
    88cdef extern from "flint/NTL-interface.h":
    9     unsigned long ZZ_limbs(ZZ_c z)
    10 
    119    void fmpz_poly_get_ZZX(ZZX_c output, fmpz_poly_t poly)
    1210    void fmpz_poly_set_ZZX(fmpz_poly_t output, ZZX_c poly)
    1311
    14     void fmpz_get_mpz(mpz_t res, fmpz_t f)
     12    void fmpz_get_ZZ(ZZ_c output, fmpz_t f)
    1513    void fmpz_set_ZZ(fmpz_t output, ZZ_c z)
    16    

  • sage/libs/flint/ulong_extras.pxd 

    diff --git a/sage/libs/flint/ulong_extras.pxd b/sage/libs/flint/ulong_extras.pxd
    a b  
     1include "../../ext/stdsage.pxi"
     2include "../../ext/cdefs.pxi"
     3
     4from sage.libs.flint.flint cimport *
     5
     6
     7cdef extern from "flint/ulong_extras.h":
     8
     9    ctypedef struct n_factor_t:
     10        int num
     11        unsigned long exp[15]
     12        unsigned long p[15]
     13
     14    cdef int n_jacobi(long x, unsigned long y)
     15
     16    cdef int n_is_prime(unsigned long n)
     17
     18    cdef unsigned long n_gcd(long x, long y)
     19
     20    cdef void n_factor(n_factor_t * factors, unsigned long n, int proved)
     21    cdef void n_factor_init(n_factor_t * factors)

  • sage/misc/cython.py 

    diff --git a/sage/misc/cython.py b/sage/misc/cython.py
    a b  
    761761#cargs -std=c99 -O3 -ggdb
    762762#cinclude $SAGE_ROOT/devel/sage/sage/libs/flint $SAGE_LOCAL/include/flint
    763763#clib flint
    764 #cfile $SAGE_ROOT/devel/sage/sage/libs/flint/fmpq_poly.c
    765764
    766765from sage.rings.rational cimport Rational
    767766from sage.rings.polynomial.polynomial_rational_flint cimport Polynomial_rational_flint

  • sage/rings/fraction_field_FpT.pyx 

    diff --git a/sage/rings/fraction_field_FpT.pyx b/sage/rings/fraction_field_FpT.pyx
    a b  
    688688        """
    689689        if nmod_poly_degree(self._numer) == -1:
    690690            return self
    691         if not nmod_poly_sqrt_check(self._numer) or not nmod_poly_sqrt_check(self._denom):
    692             return None
    693691        cdef nmod_poly_t numer
    694692        cdef nmod_poly_t denom
     693        cdef long a
    695694        cdef FpTElement res
    696         try:
    697             nmod_poly_init(denom, self.p)
    698             nmod_poly_init(numer, self.p)
    699             if not nmod_poly_sqrt0(numer, self._numer):
    700                 return None
    701             if not nmod_poly_sqrt0(denom, self._denom):
    702                 return None
     695
     696        nmod_poly_init(denom, self.p)
     697        nmod_poly_init(numer, self.p)
     698
     699        if nmod_poly_sqrt(numer, self._numer) and nmod_poly_sqrt(denom, self._denom):
     700            # Make denominator monic
     701            a = nmod_poly_leading(denom)
     702            if a != 1:
     703                a = mod_inverse_int(a, self.p)
     704                nmod_poly_scalar_mul_nmod(numer, numer, a)
     705                nmod_poly_scalar_mul_nmod(denom, denom, a)
     706            # Choose numerator with smaller leading coefficient
     707            a = nmod_poly_leading(numer)
     708            if a > self.p - a:
     709                nmod_poly_neg(numer, numer)
    703710            res = self._new_c()
    704711            nmod_poly_swap(numer, res._numer)
    705712            nmod_poly_swap(denom, res._denom)
    706713            return res
    707         finally:
     714        else:
    708715            nmod_poly_clear(numer)
    709716            nmod_poly_clear(denom)
    710    
     717            return None
     718
    711719    cpdef bint is_square(self):
    712720        """
    713721        Returns True if this element is the square of another element of the fraction field.
    … …  
    741749       
    742750            sage: from sage.rings.fraction_field_FpT import *
    743751            sage: K = GF(7)['t'].fraction_field(); t = K.gen(0)
    744             sage: ((t + 2)^2/(3*t^3 + 1)^4).sqrt()
     752            sage: p = (t + 2)^2/(3*t^3 + 1)^4
     753            sage: p.sqrt()
    745754            (3*t + 6)/(t^6 + 3*t^3 + 4)
     755            sage: p.sqrt()^2 == p
     756            True
     757
    746758        """
    747759        s = self._sqrt_or_None()
    748760        if s is None:
    … …  
    15891601    """
    15901602    cdef long n
    15911603    cdef long a
    1592     cdef long p = poly.p
     1604    cdef long p = poly.mod.n
    15931605    for n from 0 <= n <= nmod_poly_degree(poly) + 1:
    15941606        a = nmod_poly_get_coeff_ui(poly, n) + 1
    15951607        if a == p:
    … …  
    16281640        d -= 1
    16291641    return 0
    16301642
    1631 cdef void nmod_poly_pow(nmod_poly_t res, nmod_poly_t poly, unsigned long e):
    1632     """
    1633     Raises poly to the `e`th power and stores the result in ``res``.
    1634     """
    1635     if nmod_poly_degree(poly) < 2:
    1636         if nmod_poly_degree(poly) == -1:
    1637             nmod_poly_zero(res)
    1638             return
    1639         elif nmod_poly_is_one(poly):
    1640             nmod_poly_set(res, poly)
    1641             return
    1642         elif e > 1 and nmod_poly_degree(poly) == 1 and nmod_poly_get_coeff_ui(poly, 0) == 0 and nmod_poly_get_coeff_ui(poly, 1) == 1:
    1643             nmod_poly_left_shift(res, poly, e-1)
    1644             return
    1645    
    1646     # TODO: Could use the fact that (a+b)^p = a^p + b^p
    1647     # Only seems to be a big gain for large p, large exponents...
    1648     cdef nmod_poly_t pow2
    1649    
    1650     if e < 5:
    1651         if e == 0:
    1652             nmod_poly_zero(res)
    1653             nmod_poly_set_coeff_ui(res, 0, 1)
    1654         elif e == 1:
    1655             nmod_poly_set(res, poly)
    1656         elif e == 2:
    1657             nmod_poly_sqr(res, poly)
    1658         elif e == 3:
    1659             nmod_poly_sqr(res, poly)
    1660             nmod_poly_mul(res, res, poly)
    1661         elif e == 4:
    1662             nmod_poly_sqr(res, poly)
    1663             nmod_poly_sqr(res, res)
    1664     else:
    1665         nmod_poly_init(pow2, poly.p)
    1666         nmod_poly_zero(res)
    1667         nmod_poly_set_coeff_ui(res, 0, 1)
    1668         nmod_poly_set(pow2, poly)
    1669         while True:
    1670             if e & 1:
    1671                 nmod_poly_mul(res, res, pow2)
    1672             e >>= 1
    1673             if e == 0:
    1674                 break
    1675             nmod_poly_sqr(pow2, pow2)
    1676         nmod_poly_clear(pow2)
    1677 
    1678 
    1679 cdef long sqrt_mod_int(long a, long p) except -1:
    1680     """
    1681     Returns the square root of a modulo p, as a long.
    1682     """
    1683     return GF(p)(a).sqrt()
    1684 
    1685 cdef bint nmod_poly_sqrt_check(nmod_poly_t poly):
    1686     """
    1687     Quick check to see if poly could possibly be a square.
    1688     """
    1689     return (nmod_poly_degree(poly) % 2 == 0
    1690         and jacobi_int(nmod_poly_leading(poly), poly.p) == 1
    1691         and jacobi_int(nmod_poly_get_coeff_ui(poly, 0), poly.p) != -1)
    1692  
    1693 cdef bint nmod_poly_sqrt(nmod_poly_t res, nmod_poly_t poly):
    1694     """
    1695     Compute the square root of poly as res if res is a perfect square.
    1696    
    1697     Returns True on success, False on failure.
    1698     """
    1699     if not nmod_poly_sqrt_check(poly):
    1700         return False
    1701     return nmod_poly_sqrt0(res, poly)
    1702 
    1703 cdef bint nmod_poly_sqrt0(nmod_poly_t res, nmod_poly_t poly):
    1704     """
    1705     Compute the square root of poly as res if res is a perfect square, assuming that poly passes nmod_poly_sqrt_check.
    1706    
    1707     Returns True on success, False on failure.
    1708     """
    1709     if nmod_poly_degree(poly) == -1:
    1710         nmod_poly_zero(res)
    1711         return True
    1712     if nmod_poly_degree(poly) == 0:
    1713         nmod_poly_zero(res)
    1714         nmod_poly_set_coeff_ui(res, 0, sqrt_mod_int(nmod_poly_get_coeff_ui(poly, 0), poly.p))
    1715         return True
    1716     cdef nmod_poly_t g
    1717     cdef long p = poly.p
    1718     cdef long n, leading
    1719     cdef nmod_poly_factor_t factors
    1720     try:
    1721         nmod_poly_init(g, p)
    1722         nmod_poly_derivative(res, poly)
    1723         nmod_poly_gcd(g, res, poly)
    1724         if 2*nmod_poly_degree(g) < nmod_poly_degree(poly):
    1725             return False
    1726            
    1727         elif 2*nmod_poly_degree(g) > nmod_poly_degree(poly):
    1728             try:
    1729                 nmod_poly_factor_init(factors)
    1730                 leading = nmod_poly_leading(poly)
    1731                 if leading == 1:
    1732                     nmod_poly_factor_squarefree(factors, poly)
    1733                 else:
    1734                     nmod_poly_scalar_mul_nmod(res, poly, mod_inverse_int(leading, p))
    1735                     nmod_poly_factor_squarefree(factors, res)
    1736                 for n in range(factors.num_factors):
    1737                     if factors.exponents[n] % 2 != 0:
    1738                         return False
    1739                 nmod_poly_pow(res, factors.factors[0], factors.exponents[0]//2)
    1740                 for n in range(1, factors.num_factors):
    1741                     nmod_poly_pow(factors.factors[n], factors.factors[n], factors.exponents[n]//2)
    1742                     nmod_poly_mul(res, res, factors.factors[n])
    1743                 if leading != 1:
    1744                     nmod_poly_scalar_mul_nmod(res, res, sqrt_mod_int(nmod_poly_leading(poly), p))
    1745                 return True
    1746             finally:
    1747                 nmod_poly_factor_clear(factors)
    1748            
    1749         else: # deg(g) == deg(poly)/2
    1750             nmod_poly_sqr(res, g)
    1751             leading = nmod_poly_leading(poly) * mod_inverse_int(nmod_poly_leading(res), p)
    1752             nmod_poly_scalar_mul_nmod(res, res, leading)
    1753             if nmod_poly_equal(res, poly):
    1754                 nmod_poly_scalar_mul_nmod(res, g, sqrt_mod_int(leading, p))
    1755                 return True
    1756             else:
    1757                 return False
    1758     finally:
    1759         nmod_poly_clear(g)
    1760 
    17611643def unpickle_FpT_element(K, numer, denom):
    17621644    """
    17631645    Used for pickling.

  • sage/rings/integer.pyx 

    diff --git a/sage/rings/integer.pyx b/sage/rings/integer.pyx
    a b  
    34693469            if proof is None:
    34703470                from sage.structure.proof.proof import get_flag
    34713471                proof = get_flag(proof, "arithmetic")
     3472            n_factor_init(&f)
    34723473            n_factor(&f, mpz_get_ui(n.value), proof)
    34733474            F = [(Integer(f.p[i]), int(f.exp[i])) for i from 0 <= i < f.num]
    34743475            F.sort()

  • sage/rings/polynomial/polynomial_integer_dense_flint.pyx 

    diff --git a/sage/rings/polynomial/polynomial_integer_dense_flint.pyx b/sage/rings/polynomial/polynomial_integer_dense_flint.pyx
    a b  
    4242from sage.rings.arith import lcm
    4343
    4444from sage.libs.flint.fmpz_poly cimport fmpz_poly_reverse
     45from sage.libs.flint.ntl_interface cimport fmpz_poly_set_ZZX, fmpz_poly_get_ZZX
    4546from sage.libs.ntl.ntl_ZZX_decl cimport *, vec_pair_ZZX_long_c
    4647
    4748cdef extern from "limits.h":
    … …  
    201202                    degree = i
    202203            try:
    203204                sig_on()
    204                 fmpz_poly_realloc(self.__poly, degree)
     205                fmpz_poly_realloc(self.__poly, degree + 1)
    205206                sig_off()
    206207            except RuntimeError:
    207208                raise OverflowError, "Cannot allocate memory!"
    … …  
    310311                if mpz_sgn(a.value) == 0:
    311312                    return self[0]
    312313
    313                 # As of FLINT1.5, memory management for the fmpz_t type
    314                 # has to be done manually.  Without inspection of all
    315                 # coefficients, we can only naively bound the size of
    316                 # the answer by the very large value of "limbs" below. 
    317                 # If this number is too large, we move on to the generic
    318                 # polynomial evaluation code, which might either happen
    319                 # to work (in special cases) or simply run out of memory.
    320                 #
    321                 # It is expected that this workaround is unnecessary
    322                 # with FLINT2.
    323                 if fmpz_poly_length(self.__poly) <= ((1 << 25) / fmpz_poly_length(self.__poly) - fmpz_poly_limbs(self.__poly)) / mpz_size(a.value):
     314                z = PY_NEW(Integer)
    324315
    325                     z = PY_NEW(Integer)
     316                sig_on()
     317                fmpz_init(a_fmpz)
     318                fmpz_init(z_fmpz)
     319                fmpz_set_mpz(a_fmpz, a.value)
     320                fmpz_poly_evaluate_fmpz(z_fmpz, self.__poly, a_fmpz)
     321                fmpz_get_mpz(z.value, z_fmpz)
     322                fmpz_clear(a_fmpz)
     323                fmpz_clear(z_fmpz)
     324                sig_off()
    326325
    327                     _sig_on
    328                     limbs = fmpz_poly_length(self.__poly) * (fmpz_poly_limbs(self.__poly) + fmpz_poly_length(self.__poly) * mpz_size(a.value))
    329                     a_fmpz = fmpz_init(mpz_size(a.value))
    330                     z_fmpz = fmpz_init(limbs)
    331                     fmpz_set_mpz(a_fmpz, a.value)
     326                return z
    332327
    333                     fmpz_poly_evaluate_fmpz(z_fmpz, self.__poly, a_fmpz)
    334 
    335                     fmpz_get_mpz(z.value, z_fmpz)
    336                     fmpz_clear(a_fmpz)
    337                     fmpz_clear(z_fmpz)
    338                     _sig_off
    339 
    340                     return z
    341 
    342         return Polynomial.__call__(self, *x, **kwds)
     328        return Polynomial.__call__(self, *x, **kwds)
    343329
    344330    cpdef Integer content(self):
    345331        r"""
    346332        Return the greatest common divisor of the coefficients of this
    347         polynomial. 
     333        polynomial.
    348334
    349335        EXAMPLES::
    350336
    … …  
    366352            sage: (123456789123456789123456789123456789123456789*t).content()
    367353            123456789123456789123456789123456789123456789
    368354        """
    369         cdef fmpz_t c = fmpz_init(fmpz_poly_limbs(self.__poly))
     355        cdef fmpz_t c
     356        fmpz_init(c)
    370357        fmpz_poly_content(c, self.__poly)
    371358        cdef Integer z = PY_NEW(Integer)
    372359        fmpz_get_mpz(z.value, c)
    … …  
    743730        """
    744731        cdef Polynomial_integer_dense_flint ss = self._new()
    745732        cdef Polynomial_integer_dense_flint tt = self._new()
    746         cdef unsigned long bound = fmpz_poly_resultant_bound(self.__poly,
    747                 (<Polynomial_integer_dense_flint>right).__poly)
    748         cdef fmpz_t r = fmpz_init(bound/flint_BITS+2)
     733        cdef fmpz_t r
     734        fmpz_init(r)
    749735
    750736        sig_on()
    751737        fmpz_poly_xgcd(r, ss.__poly, tt.__poly, self.__poly,
    … …  
    11871173
    11881174        if not ZZ_IsOne(content):
    11891175            fac_py = self._new()
    1190             tcontent = fmpz_init(ZZ_limbs(content))
     1176            fmpz_init(tcontent)
    11911177            fmpz_set_ZZ(tcontent, content)
    11921178            fmpz_poly_set_coeff_fmpz(fac_py.__poly, 0, tcontent)
    11931179            results.append( (fac_py,1) )
    … …  
    13591345        elif self.parent() is not other.parent():
    13601346            raise TypeError
    13611347
    1362         cdef unsigned long bound = fmpz_poly_resultant_bound(self.__poly,
    1363                 (<Polynomial_integer_dense_flint>other).__poly)
    1364         cdef fmpz_t res = fmpz_init(bound/flint_BITS + 2)
     1348        cdef fmpz_t res
     1349        fmpz_init(res)
    13651350        cdef Integer x = PY_NEW(Integer)
    13661351
    13671352        sig_on()

  • sage/rings/polynomial/polynomial_rational_flint.pyx 

    diff --git a/sage/rings/polynomial/polynomial_rational_flint.pyx b/sage/rings/polynomial/polynomial_rational_flint.pyx
    a b  
    6161        sage: g = 2/3 + t^2
    6262        sage: _ = f * g      # indirect doctest
    6363    """
    64     return fmpz_poly_max_limbs(fmpq_poly_numref(op)) > 1 \
    65                                                  or fmpq_poly_degree(op) > 1000
     64    # Trac #12173: check that the degree is greater than 1000 before computing
     65    # the max limb size
     66    return fmpq_poly_length(op) > 0 and \
     67       (fmpq_poly_degree(op) > 1000 or
     68        _fmpz_vec_max_limbs(fmpq_poly_numref(op), fmpq_poly_length(op)) > 1)
    6669
    6770cdef class Polynomial_rational_flint(Polynomial):
    6871    """
    6972    Univariate polynomials over the rationals, implemented via FLINT.
    70    
    71     Internally, we represent rational polynomial as the quotient of an integer 
    72     polynomial and a positive denominator which is coprime to the content of 
     73
     74    Internally, we represent rational polynomial as the quotient of an integer
     75    polynomial and a positive denominator which is coprime to the content of
    7376    the numerator.
    74    
    75     The implementation is based on the C module fmpq_poly written on top of
    76     FLINT 1.
    7777    """
    7878
    7979    ###########################################################################
    8080    # Allocation & initialisation                                             #
    8181    ###########################################################################
    82    
     82
    8383    cdef Polynomial_rational_flint _new(self):
    8484        """
    8585        Quickly creates a new polynomial object in this class.
    … …  
    188188
    189189            sage: f = ZZ['x']([1..10^6])
    190190            sage: g = f.change_ring(QQ)
    191             sage: g[:10]  # long time (5s on sage.math, 2012)
     191            sage: g[:10] # not long anymore thanks to trac #12173
    192192            10*x^9 + 9*x^8 + 8*x^7 + 7*x^6 + 6*x^5 + 5*x^4 + 4*x^3 + 3*x^2 + 2*x + 1           
    193193        """
    194194        cdef long deg
    … …  
    389389        cdef Polynomial_rational_flint res = self._new()
    390390        cdef bint do_sig = _do_sig(self.__poly)
    391391        if isinstance(n, slice):
    392             start, stop, step = n.indices(len(list(self)))
     392            start, stop, step = n.indices(self.degree() + 1)
    393393            if do_sig: sig_on()
    394394            fmpq_poly_get_slice(res.__poly, self.__poly, start, stop)
    395395            if do_sig: sig_off()
    … …  
    517517            if n > 0:
    518518                do_sig = _do_sig(self.__poly)
    519519                if do_sig: sig_on()
    520                 fmpq_poly_truncate(res.__poly, self.__poly, n)
     520                fmpq_poly_get_slice(res.__poly, self.__poly, 0, n)
    521521                if do_sig: sig_off()
    522522            return res
    523523
    … …  
    11701170        sig_on()
    11711171        Polynomial_integer_dense_flint.__init__(num, parent, x=None, \
    11721172                                    check=False, is_gen=False, construct=False)
    1173         fmpz_poly_set(num.__poly, fmpq_poly_numref(self.__poly))
     1173        fmpq_poly_get_numerator(num.__poly, self.__poly)
    11741174        sig_off()
    11751175        return num
    11761176
    … …  
    11891189        if fmpq_poly_denref(self.__poly) is NULL:
    11901190            mpz_set_ui(den.value, 1)
    11911191        else:
    1192             fmpz_get_mpz(den.value, fmpq_poly_denref(self.__poly))
     1192            fmpz_get_mpz(den.value, <fmpz *> fmpq_poly_denref(self.__poly))
    11931193        return den
    11941194   
    11951195    def _derivative(self, var = None):
    … …  
    12871287            0
    12881288        """
    12891289        cdef Rational res = PY_NEW(Rational)
     1290        cdef fmpq_t t
     1291        fmpq_init(t)
    12901292        sig_on()
    1291         fmpq_poly_resultant(res.value, self.__poly, \
     1293        fmpq_poly_resultant(t, self.__poly, \
    12921294                            (<Polynomial_rational_flint>right).__poly)
     1295        fmpq_get_mpq(res.value, t)
    12931296        sig_off()
     1297        fmpq_clear(t)
    12941298        return res
    12951299   
    12961300    def is_irreducible(self):
    … …  
    13401344            sig_on()
    13411345            Polynomial_integer_dense_flint.__init__(primitive, parent, \
    13421346                             x=None, check=True, is_gen=False, construct=False)
    1343             fmpz_poly_primitive_part(primitive.__poly, \
    1344                                      fmpq_poly_numref(self.__poly))
     1347
     1348            fmpq_poly_get_numerator(primitive.__poly, self.__poly)
     1349            fmpz_poly_primitive_part(primitive.__poly, primitive.__poly)
     1350
    13451351            sig_off()
    13461352            return primitive.is_irreducible()
    13471353
    … …  
    17101716    # Alias for discriminant
    17111717    disc = discriminant
    17121718   
    1713    
     1719

  • 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  
    1 cdef extern from "zn_poly/zn_poly.h":
    2      # This header needs to appear before the flint headers.
    3      pass
    4 
    51from sage.libs.flint.nmod_poly cimport nmod_poly_t, nmod_poly_struct
     2from sage.libs.flint.fmpz_poly cimport fmpz_poly_t
    63from sage.structure.parent cimport Parent
     4from sage.rings.polynomial.polynomial_integer_dense_flint cimport Polynomial_integer_dense_flint
    75
    86ctypedef nmod_poly_struct celement
    97ctypedef unsigned long cparent
    … …  
    1412
    1513cdef class Polynomial_zmod_flint(Polynomial_template):
    1614    cdef Polynomial_template _new(self)
    17     cdef _set_list(self, x)
     15    cdef int _set_list(self, x) except -1
     16    cdef int _set_fmpz_poly(self, fmpz_poly_t) except -1
    1817    cpdef _mul_trunc(self, Polynomial_zmod_flint other, length)
    1918    cpdef _mul_trunc_opposite(self, Polynomial_zmod_flint other, length)
    2019    cpdef rational_reconstruct(self, m, n_deg=?, d_deg=?)
    21    

  • 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  
    3636from sage.libs.ntl.ntl_lzz_pX import ntl_zz_pX
    3737from sage.structure.factorization import Factorization
    3838from sage.structure.element import coerce_binop, parent
     39from sage.rings.polynomial.polynomial_integer_dense_flint cimport Polynomial_integer_dense_flint
    3940
    4041# We need to define this stuff before including the templating stuff
    4142# to make sure the function get_cparent is found since it is used in
    … …  
    6061    cdef void zn_mod_clear(zn_mod_struct *mod)
    6162    cdef void zn_array_mul(unsigned long* res, unsigned long* op1, size_t n1, unsigned long* op2, size_t n2, zn_mod_struct *mod)
    6263
     64include "../../libs/flint/fmpz_poly.pxi"
     65
    6366cdef class Polynomial_zmod_flint(Polynomial_template):
    6467    def __init__(self, parent, x=None, check=True, is_gen=False, construct=False):
    6568        """
    … …  
    8487            Polynomial_template.__init__(self, parent, 0, check, is_gen, construct)
    8588            self._set_list(lst)
    8689            return
     90        elif PY_TYPE_CHECK(x, Polynomial_integer_dense_flint):
     91            Polynomial_template.__init__(self, parent, 0, check, is_gen, construct)
     92            self._set_fmpz_poly((<Polynomial_integer_dense_flint>x).__poly)
     93            return
    8794        else:
    8895            if PY_TYPE_CHECK(x, ntl_zz_pX):
    8996                x = x.list()
    … …  
    139146        celement_set_si(&r.x, int(x), (<Polynomial_template>self)._cparent)
    140147        return r
    141148
    142     cdef _set_list(self, x):
     149    cdef int _set_list(self, x) except -1:
    143150        """
     151        Set the coefficients of ``self`` from a list of coefficients.
     152
     153        INPUT:
     154
     155        - ``x`` - a list of coefficients
     156
    144157        EXAMPLES::
    145158
    146159            sage: P.<a>=GF(7)[]
    … …  
    157170        cdef int i
    158171        if length == 0:
    159172            nmod_poly_zero(&self.x)
    160             return
     173            return 0
    161174
    162175        # resize to length of list
    163176        sig_on()
    164177        nmod_poly_realloc(&self.x, length)
    165178        sig_off()
    166179
     180        sig_on()
    167181        for i from 0 <= i < length:
    168             _nmod_poly_set_coeff_ui(&self.x, i, l_in[i])
    169         # we need to set the length manually, we used _nmod_poly_set_coeff_ui
    170         self.x.length = length
     182            nmod_poly_set_coeff_ui(&self.x, i, l_in[i])
     183        sig_off()
     184        return 0
     185
     186    cdef int _set_fmpz_poly(self, fmpz_poly_t x) except -1:
     187        """
     188        Set the coefficients of ``self`` from the coefficients of an ``fmpz_poly_t`` element.
     189
     190        INPUT:
     191
     192        - ``x`` - an ``fmpz_poly_t`` element
     193
     194        EXAMPLES::
     195
     196            sage: a = ZZ['x'](range(17))
     197            sage: R = Integers(7)['x']
     198            sage: R(a)
     199            2*x^16 + x^15 + 6*x^13 + 5*x^12 + 4*x^11 + 3*x^10 + 2*x^9 + x^8 + 6*x^6 + 5*x^5 + 4*x^4 + 3*x^3 + 2*x^2 + x
     200
     201        TESTS:
     202
     203        The following test from :trac:`12173` used to be horribly slow::
     204
     205            sage: a = ZZ['x'](range(100000))
     206            sage: R = Integers(3)['x']
     207            sage: R(a)
     208            2*x^99998 + ... + x
     209        """
     210        sig_on()
     211        fmpz_poly_get_nmod_poly(&self.x, x)
     212        sig_off()
     213        return 0
    171214
    172215    def __getitem__(self, i):
    173216        """
    … …  
    404447        nmod_poly_init2(&r.x, p, n1 + n2 -1 )
    405448
    406449        zn_mod_init(&zn_mod, p)
    407         zn_array_mul(r.x.coeffs, self.x.coeffs, n1, _other.x.coeffs, n2, &zn_mod)
     450        zn_array_mul(<unsigned long *> r.x.coeffs, <unsigned long *> self.x.coeffs, n1, <unsigned long*> _other.x.coeffs, n2, &zn_mod)
    408451        r.x.length = n1 + n2 -1
    409452        _nmod_poly_normalise(&r.x)
    410453        zn_mod_clear(&zn_mod)

  • 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  
    2525include "../../libs/flint/fmpz_poly.pxi"
    2626
    2727from sage.libs.flint.nmod_poly cimport *, nmod_poly_t
    28 from sage.libs.flint.ulong_extras cimport *, factor_t
     28from sage.libs.flint.ulong_extras cimport *, n_factor_t
    2929from sage.libs.ratpoints cimport ratpoints_mpz_exists_only
    3030
    3131cdef int N_RES_CLASSES_BSD = 10
    … …  
    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,
    270270                            nmod_poly_factor_t f_factzn, nmod_poly_t f,
    271                             fmpz_poly_t f1, fmpz_poly_t linear,
    272                             double pp_ui_inv):
     271                            fmpz_poly_t f1, fmpz_poly_t linear):
    273272    """
    274273    Uses the approach of Algorithm 5.3.1 of Siksek's thesis to test for
    275274    solubility of y^2 == ax^4 + bx^3 + cx^2 + dx + e over Zp.
    … …  
    315314        nmod_poly_set_coeff_ui(f, 4, mpz_fdiv_ui(a, pp_ui))
    316315
    317316        result = 0
    318         (<nmod_poly_factor_struct *>f_factzn)[0].num_factors = 0 # reset data struct
     317        (<nmod_poly_factor_struct *>f_factzn)[0].num = 0 # reset data struct
    319318        qq = nmod_poly_factor(f_factzn, f)
    320         for i from 0 <= i < f_factzn.num_factors:
    321             if f_factzn.exponents[i]&1:
     319        for i from 0 <= i < f_factzn.num:
     320            if f_factzn.exp[i]&1:
    322321                result = 1
    323322                break
    324         if result == 0 and z_legendre_precomp(qq, pp_ui, pp_ui_inv) == 1:
     323        if result == 0 and n_jacobi(qq, pp_ui) == 1:
    325324            result = 1
    326325        if result:
    327326            return 1
    328327
    329328        nmod_poly_zero(f)
    330329        nmod_poly_set_coeff_ui(f, 0, ui1)
    331         for i from 0 <= i < f_factzn.num_factors:
    332             for j from 0 <= j < (f_factzn.exponents[i]>>1):
    333                 nmod_poly_mul(f, f, f_factzn.factors[i])
     330        for i from 0 <= i < f_factzn.num:
     331            for j from 0 <= j < (f_factzn.exp[i]>>1):
     332                nmod_poly_mul(f, f, &f_factzn.p[i])
    334333
    335         (<nmod_poly_factor_struct *>f_factzn)[0].num_factors = 0 # reset data struct
     334        (<nmod_poly_factor_struct *>f_factzn)[0].num = 0 # reset data struct
    336335        nmod_poly_factor(f_factzn, f)
    337336        has_roots = 0
    338337        j = 0
    339         for i from 0 <= i < f_factzn.num_factors:
    340             if nmod_poly_degree(f_factzn.factors[i]) == 1 and 0 != nmod_poly_get_coeff_ui(f_factzn.factors[i], 1):
     338        for i from 0 <= i < f_factzn.num:
     339            if nmod_poly_degree(&f_factzn.p[i]) == 1 and 0 != nmod_poly_get_coeff_ui(&f_factzn.p[i], 1):
    341340                has_roots = 1
    342                 roots[j] = pp_ui - nmod_poly_get_coeff_ui(f_factzn.factors[i], 0)
     341                roots[j] = pp_ui - nmod_poly_get_coeff_ui(&f_factzn.p[i], 0)
    343342                j += 1
    344343        if not has_roots:
    345344            return 0
    … …  
    428427                fmpz_poly_get_coeff_mpz(cc, f1, 2)
    429428                fmpz_poly_get_coeff_mpz(dd, f1, 1)
    430429                fmpz_poly_get_coeff_mpz(ee, f1, 0)
    431                 result = Zp_soluble_siksek(aa, bb, cc, dd, ee, pp, pp_ui, f_factzn, f, f1, linear, pp_ui_inv)
     430                result = Zp_soluble_siksek(aa, bb, cc, dd, ee, pp, pp_ui, f_factzn, f, f1, linear)
    432431                mpz_clear(aa)
    433432                mpz_clear(bb)
    434433                mpz_clear(cc)
    … …  
    450449        nmod_poly_set_coeff_ui(f, 2, mpz_fdiv_ui(c, pp_ui))
    451450        nmod_poly_set_coeff_ui(f, 3, mpz_fdiv_ui(b, pp_ui))
    452451        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
     452        (<nmod_poly_factor_struct *>f_factzn)[0].num = 0 # reset data struct
    454453        nmod_poly_factor(f_factzn, f)
    455454        has_roots = 0
    456455        has_single_roots = 0
    457456        j = 0
    458         for i from 0 <= i < f_factzn.num_factors:
    459             if nmod_poly_degree(f_factzn.factors[i]) == 1 and 0 != nmod_poly_get_coeff_ui(f_factzn.factors[i], 1):
     457        for i from 0 <= i < f_factzn.num:
     458            if nmod_poly_degree(&f_factzn.p[i]) == 1 and 0 != nmod_poly_get_coeff_ui(&f_factzn.p[i], 1):
    460459                has_roots = 1
    461                 if f_factzn.exponents[i] == 1:
     460                if f_factzn.exp[i] == 1:
    462461                    has_single_roots = 1
    463462                    break
    464                 roots[j] = pp_ui - nmod_poly_get_coeff_ui(f_factzn.factors[i], 0)
     463                roots[j] = pp_ui - nmod_poly_get_coeff_ui(&f_factzn.p[i], 0)
    465464                j += 1
    466465
    467466        if not has_roots: return 0
    … …  
    491490            fmpz_poly_get_coeff_mpz(cc, f1, 2)
    492491            fmpz_poly_get_coeff_mpz(dd, f1, 1)
    493492            fmpz_poly_get_coeff_mpz(ee, f1, 0)
    494             result = Zp_soluble_siksek(aa, bb, cc, dd, ee, pp, pp_ui, f_factzn, f, f1, linear, pp_ui_inv)
     493            result = Zp_soluble_siksek(aa, bb, cc, dd, ee, pp, pp_ui, f_factzn, f, f1, linear)
    495494            if result == 1:
    496495                break
    497496        if j > 0:
    … …  
    752751    cdef int result = 0
    753752    cdef mpz_t a,b,c,d,e
    754753    cdef nmod_poly_t f
    755     cdef double pp_ui_inv = z_precompute_inverse(P)
    756754    nmod_poly_init(f, P)
    757755
    758756    mpz_init_set(a,A)
    … …  
    761759    mpz_init_set(d,D)
    762760    mpz_init_set(e,E)
    763761
    764     if Zp_soluble_siksek(a,b,c,d,e,p,P,f_factzn, f, f1, linear, pp_ui_inv):
     762    if Zp_soluble_siksek(a,b,c,d,e,p,P,f_factzn, f, f1, linear):
    765763        result = 1
    766764    else:
    767765        mpz_set(a,A)
    … …  
    769767        mpz_set(c,C)
    770768        mpz_set(d,D)
    771769        mpz_set(e,E)
    772         if Zp_soluble_siksek(e,d,c,b,a,p,P,f_factzn, f, f1, linear, pp_ui_inv):
     770        if Zp_soluble_siksek(e,d,c,b,a,p,P,f_factzn, f, f1, linear):
    773771            result = 1
    774772
    775773    mpz_clear(a)
    … …  
    12291227        p_list_mpz = <mpz_t *> sage_malloc(20 * sizeof(mpz_t))
    12301228        mpz_init_set_ui(p_list_mpz[0], ui2)
    12311229        p_list_len = 1
     1230        n_factor_init(&fact)
    12321231        n_factor(&fact, mpz_get_ui(d_mpz), proof)
    12331232        for i from 0 <= i < fact.num:
    12341233            p = fact.p[i]