Context Navigation

Back to Ticket #12173

Ticket #12173: flint-2.3-sage-5.1.beta0.patch

File flint-2.3-sage-5.1.beta0.patch, 248.6 KB (added by jpflori, 10 years ago)
Rebased patch for 5.1.beta0.

module_list.py

# HG changeset patch
# User Jean-Pierre Flori <jean-pierre.flor@ssi.gouv.fr>
# Date 1338366709 -7200
# Node ID 4f6a3b00730d86706f1f3fd75cab27d751eab8d6
# Parent  369df2b2966bb9053dddcf461c269f8da6b711b1
[mq]: flint-2.3-sage-5.0.diff

diff --git a/module_list.py b/module_list.py

-                      a
               include_dirs = ['sage/libs/ntl/']),
     Extension('sage.rings.polynomial.polynomial_rational_flint',
               sources = ['sage/rings/polynomial/polynomial_rational_flint.pyx', 'sage/libs/flint/fmpq_poly.c'],
+              sources = ['sage/rings/polynomial/polynomial_rational_flint.pyx'],
               language = 'c++',
               extra_compile_args=["-std=c99"] + uname_specific('SunOS', [], ['-D_XPG6']),
               libraries = ["csage", "flint", "ntl", "gmpxx", "gmp"],

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
         x, y, z, w = to_quaternion(parent._base, v)
         cdef NumberFieldElement a = <NumberFieldElement>(parent._base(parent._a))
         cdef NumberFieldElement b = <NumberFieldElement>(parent._base(parent._b))
         ZZX_to_fmpz_poly(self.x, (<NumberFieldElement>x).__numerator)
         ZZX_to_fmpz_poly(self.y, (<NumberFieldElement>y).__numerator)
         ZZX_to_fmpz_poly(self.z, (<NumberFieldElement>z).__numerator)
         ZZX_to_fmpz_poly(self.w, (<NumberFieldElement>w).__numerator)
+        fmpz_poly_set_ZZX(self.x, (<NumberFieldElement>x).__numerator)
+        fmpz_poly_set_ZZX(self.y, (<NumberFieldElement>y).__numerator)
+        fmpz_poly_set_ZZX(self.z, (<NumberFieldElement>z).__numerator)
+        fmpz_poly_set_ZZX(self.w, (<NumberFieldElement>w).__numerator)
         ZZ_to_mpz(&T1, &(<NumberFieldElement>x).__denominator)
         ZZ_to_mpz(&T2, &(<NumberFieldElement>y).__denominator)
 …
         fmpz_poly_scalar_mul_mpz(self.z, self.z, t3)
         fmpz_poly_scalar_mul_mpz(self.w, self.w, t4)
         ZZX_to_fmpz_poly(self.a, a.__numerator)     # we will assume that the denominator of a and b are 1
         ZZX_to_fmpz_poly(self.b, b.__numerator)
+        fmpz_poly_set_ZZX(self.a, a.__numerator)     # we will assume that the denominator of a and b are 1
+        fmpz_poly_set_ZZX(self.b, b.__numerator)
         ZZX_to_fmpz_poly(self.modulus, (<NumberFieldElement>x).__fld_numerator.x) # and same for the modulus
+        fmpz_poly_set_ZZX(self.modulus, (<NumberFieldElement>x).__fld_numerator.x) # and same for the modulus
     def __getitem__(self, int i):
         """
 …
         cdef NumberFieldElement item = el._new()
         if i == 0:
             fmpz_poly_to_ZZX(item.__numerator, self.x)
+            fmpz_poly_get_ZZX(item.__numerator, self.x)
         elif i == 1:
             fmpz_poly_to_ZZX(item.__numerator, self.y)
+            fmpz_poly_get_ZZX(item.__numerator, self.y)
         elif i == 2:
             fmpz_poly_to_ZZX(item.__numerator, self.z)
+            fmpz_poly_get_ZZX(item.__numerator, self.z)
         elif i == 3:
             fmpz_poly_to_ZZX(item.__numerator, self.w)
+            fmpz_poly_get_ZZX(item.__numerator, self.w)
         else:
             raise IndexError, "quaternion element index out of range"
 …
         # Implementation-wise, we compute the GCD's one at a time,
         # and quit if it ever becomes one
+        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)
+                                                                     # Note that we have to allocate this here, and not
+                                                                     # as a global variable, because fmpz_t's do not
+                                                                     # self allocate memory
+        cdef fmpz_t content
+        fmpz_init(content)
         fmpz_poly_content(content, self.x)
         fmpz_to_mpz(U1, content)
+        fmpz_get_mpz(U1, content)
         mpz_gcd(U1, self.d, U1)
         if mpz_cmp_ui(U1, 1) != 0:
             fmpz_poly_content(content, self.y)
             fmpz_to_mpz(U2, content)
+            fmpz_get_mpz(U2, content)
             mpz_gcd(U1, U1, U2)
             if mpz_cmp_ui(U1, 1) != 0:
                 fmpz_poly_content(content, self.z)
                 fmpz_to_mpz(U2, content)
+                fmpz_get_mpz(U2, content)
                 mpz_gcd(U1, U1, U2)
                 if mpz_cmp_ui(U1, 1) != 0:
                     fmpz_poly_content(content, self.w)
                     fmpz_to_mpz(U2, content)
+                    fmpz_get_mpz(U2, content)
                     mpz_gcd(U1, U1, U2)
                     if mpz_cmp_ui(U1, 1) != 0:
                         fmpz_poly_scalar_div_mpz(self.x, self.x, U1)
                         fmpz_poly_scalar_div_mpz(self.y, self.y, U1)
                         fmpz_poly_scalar_div_mpz(self.z, self.z, U1)
                         fmpz_poly_scalar_div_mpz(self.w, self.w, U1)
+                        fmpz_poly_scalar_divexact_mpz(self.x, self.x, U1)
+                        fmpz_poly_scalar_divexact_mpz(self.y, self.y, U1)
+                        fmpz_poly_scalar_divexact_mpz(self.z, self.z, U1)
+                        fmpz_poly_scalar_divexact_mpz(self.w, self.w, U1)
                         mpz_divexact(self.d, self.d, U1)
         fmpz_clear(content)

sage/graphs/matchpoly.pyx

diff --git a/sage/graphs/matchpoly.pyx b/sage/graphs/matchpoly.pyx

-                      a
     """
     cdef int i, j, k, edge1, edge2, new_edge1, new_edge2, new_nedges
     cdef int *edges1, *edges2, *new_edges1, *new_edges2
     cdef fmpz_t coeff
+    cdef fmpz * coeff
     if nverts == 3:
         coeff = fmpz_poly_get_coeff_ptr(pol, 3)
         if coeff is NULL:
             fmpz_poly_set_coeff_ui(pol, 3, 1)
         else:
             fmpz_add_ui_inplace(coeff, 1)
+            fmpz_add_ui(coeff, coeff, 1)
         coeff = fmpz_poly_get_coeff_ptr(pol, 1)
         if coeff is NULL:
             fmpz_poly_set_coeff_ui(pol, 1, nedges)
         else:
             fmpz_add_ui_inplace(coeff, nedges)
+            fmpz_add_ui(coeff, coeff, nedges)
         return
     if nedges == 0:
 …
         if coeff is NULL:
             fmpz_poly_set_coeff_ui(pol, nverts, 1)
         else:
             fmpz_add_ui_inplace(coeff, 1)
+            fmpz_add_ui(coeff, coeff, 1)
         return
     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
 cdef extern from "stdlib.h":
     int rand()
 cdef extern from "FLINT/long_extras.h":
     int z_isprime(unsigned long n)
+cdef extern from "FLINT/ulong_extras.h":
+    int n_is_prime(unsigned long n)
 cdef struct OrbitPartition:
     # Disjoint set data structure for representing the orbits of the generators

sage/groups/perm_gps/partn_ref/data_structures_pyx.pxi

diff --git a/sage/groups/perm_gps/partn_ref/data_structures_pyx.pxi b/sage/groups/perm_gps/partn_ref/data_structures_pyx.pxi

-                      a
             if OP.parent[i] == i:
                 q = OP.size[i]
                 if m < 2*q and q < m-2:
                     if z_isprime(q):
+                    if n_is_prime(q):
                         sage_free(perm)
                         OP_dealloc(OP)
                         return True

deleted file sage/libs/flint/fmpq_poly.c

diff --git a/sage/libs/flint/fmpq_poly.c b/sage/libs/flint/fmpq_poly.c
deleted file mode 100644

-                      +
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2010 Sebastian Pancratz                                     //
-//                                                                           //
-// Distributed under the terms of the GNU General Public License as          //
-// published by the Free Software Foundation; either version 2 of the        //
-// License, or (at your option) any later version.                           //
-//                                                                           //
-// http://www.gnu.org/licenses/                                              //
-///////////////////////////////////////////////////////////////////////////////
-#ifdef __cplusplus
-    extern "C" {
-#endif
-#include "fmpq_poly.h"
-/**
- * \file     fmpq_poly.c
- * \brief    Fast implementation of the rational function field
- * \author   Sebastian Pancratz
- * \date     Mar 2010 -- July 2010
- * \version  0.1.8
+ *
- * \mainpage
+ *
- * <center>
- * A FLINT-based implementation of the rational polynomial ring.
- * </center>
+ *
- * \section Overview
+ *
- * The module <tt>fmpq_poly</tt> provides functions for performing
- * arithmetic on rational polynomials in \f$\mathbf{Q}[t]\f$, represented as
- * quotients of integer polynomials of type <tt>fmpz_poly_t</tt> and
- * denominators of type <tt>fmpz_t</tt>.  These functions start with the
- * prefix <tt>fmpq_poly_</tt>.
+ *
- * Rational polynomials are stored in objects of type #fmpq_poly_t,
- * which is an array of #fmpq_poly_struct's of length one.  This
- * permits passing parameters of type #fmpq_poly_t by reference.
- * We also define the type #fmpq_poly_ptr to be a pointer to
- * #fmpq_poly_struct's.
+ *
- * The representation of a rational polynomial as the quotient of an integer
- * polynomial and an integer denominator can be made canonical by demanding
- * the numerator and denominator to be coprime and the denominator to be
- * positive.  As the only special case, we represent the zero function as
- * \f$0/1\f$.  All arithmetic functions assume that the operands are in this
- * canonical form, and canonicalize their result.  If the numerator or
- * denominator is modified individually, for example using the methods in the
- * group \ref NumDen, it is the user's responsibility to canonicalize the
- * rational function using the function #fmpq_poly_canonicalize() if necessary.
+ *
- * All methods support aliasing of their inputs and outputs \e unless
- * explicitly stated otherwise, subject to the following caveat.  If
- * different rational polynomials (as objects in memory, not necessarily in
- * the mathematical sense) share some of the underlying integer polynomials
- * or integers, the behaviour is undefined.
+ *
- * \section Changelog  Version history
- * - 0.1.8
- *   - Extra checks for <tt>NULL</tt> returns of <tt>malloc</tt> calls
- * - 0.1.7
- *   - Explicit casts for return values of <tt>malloc</tt>
- *   - Changed a few calls to GMP and FLINT methods from <tt>_si</tt>
- *     to <tt>_ui</tt>
- * - 0.1.6
- *   - Added tons of testing code in the subdirectory <tt>test</tt>
- *   - Made a few changes throughout the code base indicated by the tests
- * - 0.1.5
- *   - Re-wrote the entire code to always initialise the denominator
- * - 0.1.4
- *   - Fixed a bug in #fmpq_poly_divrem()
- *   - Swapped calls to #fmpq_poly_degree to calls to #fmpq_poly_length in
- *     many places
- * - 0.1.3
- *   - Changed #fmpq_poly_inv()
- *   - Another sign check to <tt>fmpz_abs</tt> in #fmpq_poly_content()
- * - 0.1.2
- *   - Introduce a function #fmpq_poly_monic() and use this to simplify the
- *     code for the gcd and xgcd functions
- *   - Make further use of #fmpq_poly_is_zero()
- * - 0.1.1
- *   - Replaced a few sign checks and negations by <tt>fmpz_abs</tt>
- *   - Small changes to comments and the documentation
- *   - Moved some function bodies from #fmpq_poly.h to #fmpq_poly.c
- * - 0.1.0
- *   - First draft, based on the author's Sage code
- */
-/**
- * \defgroup Definitions        Type definitions
- * \defgroup MemoryManagement   Memory management
- * \defgroup NumDen             Accessing numerator and denominator
- * \defgroup Assignment         Assignment and basic manipulation
- * \defgroup Coefficients       Setting and retrieving individual coefficients
- * \defgroup PolyParameters     Polynomial parameters
- * \defgroup Comparison         Comparison
- * \defgroup Addition           Addition and subtraction
- * \defgroup ScalarMul          Scalar multiplication and division
- * \defgroup Multiplication     Multiplication
- * \defgroup Division           Euclidean division
- * \defgroup Powering           Powering
- * \defgroup GCD                Greatest common divisor
- * \defgroup Derivative         Derivative
- * \defgroup Evaluation         Evaluation
- * \defgroup Content            Gaussian content
- * \defgroup Resultant          Resultant
- * \defgroup Composition        Composition
- * \defgroup Squarefree         Square-free test
- * \defgroup Subpolynomials     Subpolynomials
- * \defgroup StringConversions  String conversions and I/O
- */
-///////////////////////////////////////////////////////////////////////////////
-// Auxiliary functions                                                       //
-///////////////////////////////////////////////////////////////////////////////
-/**
- * Returns the number of digits in the decimal representation of \c n.
- */
-unsigned int fmpq_poly_places(ulong n)
+{
-    unsigned int count;
-    if (n == 0)
-        return 1u;
-    count = 0;
-    while (n > 0)
+    {
-        n /= 10ul;
-        count++;
+    }
-    return count;
+}
-///////////////////////////////////////////////////////////////////////////////
-// Implementation                                                            //
-///////////////////////////////////////////////////////////////////////////////
-/**
- * \brief    Puts <tt>f</tt> into canonical form.
- * \ingroup  Definitions
+ *
- * This method ensures that the denominator is coprime to the content
- * of the numerator polynomial, and that the denominator is positive.
+ *
- * The optional parameter <tt>temp</tt> is the temporary variable that this
- * method would otherwise need to allocate.  If <tt>temp</tt> is provided as
- * an initialized <tt>fmpz_t</tt>, it is assumed \e without further checks
- * that it is large enough.  For example,
- * <tt>max(f-\>num-\>limbs, fmpz_size(f-\>den))</tt> limbs will certainly
- * suffice.
- */
-void fmpq_poly_canonicalize(fmpq_poly_ptr f, fmpz_t temp)
+{
-    if (fmpz_is_one(f->den))
-        return;
-    if (fmpq_poly_is_zero(f))
-        fmpz_set_ui(f->den, 1ul);
-    else if (fmpz_is_m1(f->den))
+    {
-        fmpz_poly_neg(f->num, f->num);
-        fmpz_set_ui(f->den, 1ul);
+    }
-    else
+    {
-        int tcheck;  /* Whether temp == NULL */
-        //if (temp == NULL)
-        //{
-            tcheck = 1;
-            temp = fmpz_init(FLINT_MAX(f->num->limbs, fmpz_size(f->den)));
-        //}
-        //else
-        //    tcheck = 0;
-        fmpz_poly_content(temp, f->num);
-        fmpz_abs(temp, temp);
-        if (fmpz_is_one(temp))
+        {
-            if (fmpz_sgn(f->den) < 0)
+            {
-                fmpz_poly_neg(f->num, f->num);
-                fmpz_neg(f->den, f->den);
+            }
+        }
-        else
+        {
-            fmpz_t tempgcd;
-            tempgcd = fmpz_init(FLINT_MAX(f->num->limbs, fmpz_size(f->den)));
-            fmpz_gcd(tempgcd, temp, f->den);
-            fmpz_abs(tempgcd, tempgcd);
-            if (fmpz_is_one(tempgcd))
+            {
-                if (fmpz_sgn(f->den) < 0)
+                {
-                    fmpz_poly_neg(f->num, f->num);
-                    fmpz_neg(f->den, f->den);
+                }
+            }
-            else
+            {
-                if (fmpz_sgn(f->den) < 0)
-                    fmpz_neg(tempgcd, tempgcd);
-                fmpz_poly_scalar_div_fmpz(f->num, f->num, tempgcd);
-                fmpz_tdiv(temp, f->den, tempgcd);
-                fmpz_set(f->den, temp);
+            }
-            fmpz_clear(tempgcd);
+        }
-        if (tcheck)
-            fmpz_clear(temp);
+    }
+}
-///////////////////////////////////////////////////////////////////////////////
-// Assignment and basic manipulation
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to the additive inverse of \c op.
- */
-void fmpq_poly_neg(fmpq_poly_ptr rop, const fmpq_poly_ptr op)
+{
-    if (rop == op)
+    {
-        fmpz_poly_neg(rop->num, op->num);
+    }
-    else
+    {
-        fmpz_poly_neg(rop->num, op->num);
-        rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-        fmpz_set(rop->den, op->den);
+    }
+}
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to the multiplicative inverse of \c op.
+ *
- * Assumes that the element \c op is a unit.  Otherwise, an exception
- * is raised in the form of an <tt>abort</tt> statement.
- */
-void fmpq_poly_inv(fmpq_poly_ptr rop, const fmpq_poly_ptr op)
+{
-    /* Assertion! */
-    if (fmpq_poly_length(op) != 1ul)
+    {
-        printf("ERROR (fmpq_poly_inv).  Element is not a unit.\n");
-        abort();
+    }
-    if (rop == op)
+    {
-        fmpz_t t;
-        t = fmpz_init(rop->num->limbs);
-        fmpz_set(t, rop->num->coeffs);
-        fmpz_poly_zero(rop->num);
-        if (fmpz_sgn(t) > 0)
+        {
-            fmpz_poly_set_coeff_fmpz(rop->num, 0, rop->den);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(t));
-            fmpz_set(rop->den, t);
+        }
-        else
+        {
-            fmpz_neg(rop->den, rop->den);
-            fmpz_poly_set_coeff_fmpz(rop->num, 0, rop->den);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(t));
-            fmpz_neg(rop->den, t);
+        }
-        fmpz_clear(t);
+    }
-    else
+    {
-        fmpz_poly_zero(rop->num);
-        fmpz_poly_set_coeff_fmpz(rop->num, 0, op->den);
-        rop->den = fmpz_realloc(rop->den, fmpz_size(op->num->coeffs));
-        fmpz_set(rop->den, op->num->coeffs);
-        if (fmpz_sgn(rop->den) < 0)
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            fmpz_neg(rop->den, rop->den);
+        }
+    }
+}
-///////////////////////////////////////////////////////////////////////////////
-// Setting/ retrieving individual coefficients
-/**
- * \ingroup  Coefficients
+ *
- * Obtains the <tt>i</tt>th coefficient from the polynomial <tt>op</tt>.
- */
-void fmpq_poly_get_coeff_mpq(mpq_t rop, const fmpq_poly_ptr op, ulong i)
+{
-    fmpz_poly_get_coeff_mpz(mpq_numref(rop), op->num, i);
-    fmpz_to_mpz(mpq_denref(rop), op->den);
-    mpq_canonicalize(rop);
+}
-/**
- * \ingroup  Coefficients
+ *
- * Sets the <tt>i</tt>th coefficient of the polynomial <tt>op</tt> to \c x.
- */
-void fmpq_poly_set_coeff_fmpz(fmpq_poly_ptr rop, ulong i, const fmpz_t x)
+{
-    fmpz_t t;
-    int canonicalize;
-    /* Is the denominator 1?  This includes the case when rop == 0. */
-    if (fmpz_is_one(rop->den))
+    {
-        fmpz_poly_set_coeff_fmpz(rop->num, i, x);
-        return;
+    }
-    t = fmpz_poly_get_coeff_ptr(rop->num, i);
-    canonicalize = !(t == NULL || fmpz_is_zero(t));
-    t = fmpz_init(fmpz_size(x) + fmpz_size(rop->den));
-    fmpz_mul(t, x, rop->den);
-    fmpz_poly_set_coeff_fmpz(rop->num, i, t);
-    fmpz_clear(t);
-    if (canonicalize)
-        fmpq_poly_canonicalize(rop, NULL);
+}
-/**
- * \ingroup  Coefficients
+ *
- * Sets the <tt>i</tt>th coefficient of the polynomial <tt>op</tt> to \c x.
- */
-void fmpq_poly_set_coeff_mpz(fmpq_poly_ptr rop, ulong i, const mpz_t x)
+{
-    mpz_t z;
-    fmpz_t t;
-    int canonicalize;
-    /* Is the denominator 1?  This includes the case when rop == 0. */
-    if (fmpz_is_one(rop->den))
+    {
-        fmpz_poly_set_coeff_mpz(rop->num, i, x);
-        return;
+    }
-    t = fmpz_poly_get_coeff_ptr(rop->num, i);
-    canonicalize = !(t == NULL || fmpz_is_zero(t));
-    mpz_init(z);
-    fmpz_to_mpz(z, rop->den);
-    mpz_mul(z, z, x);
-    fmpz_poly_set_coeff_mpz(rop->num, i, z);
-    if (canonicalize)
-        fmpq_poly_canonicalize(rop, NULL);
-    mpz_clear(z);
+}
-/**
- * \ingroup  Coefficients
+ *
- * Sets the <tt>i</tt>th coefficient of the polynomial <tt>op</tt> to \c x.
- */
-void fmpq_poly_set_coeff_mpq(fmpq_poly_ptr rop, ulong i, const mpq_t x)
+{
-    fmpz_t oldc;
-    mpz_t den, gcd;
-    int canonicalize;
-    mpz_init(den);
-    mpz_init(gcd);
-    fmpz_to_mpz(den, rop->den);
-    mpz_gcd(gcd, den, mpq_denref(x));
-    oldc = fmpz_poly_get_coeff_ptr(rop->num, i);
-    canonicalize = !(oldc == NULL || fmpz_is_zero(oldc));
-    if (mpz_cmp(mpq_denref(x), gcd) == 0)
+    {
-        mpz_divexact(den, den, gcd);
-        mpz_mul(gcd, den, mpq_numref(x));
-        fmpz_poly_set_coeff_mpz(rop->num, i, gcd);
+    }
-    else
+    {
-        mpz_t t;
-        mpz_init(t);
-        mpz_divexact(t, mpq_denref(x), gcd);
-        fmpz_poly_scalar_mul_mpz(rop->num, rop->num, t);
-        mpz_divexact(gcd, den, gcd);
-        mpz_mul(gcd, gcd, mpq_numref(x));
-        fmpz_poly_set_coeff_mpz(rop->num, i, gcd);
-        mpz_mul(den, den, t);
-        rop->den = fmpz_realloc(rop->den, mpz_size(den));
-        mpz_to_fmpz(rop->den, den);
-        mpz_clear(t);
+    }
-    if (canonicalize)
-        fmpq_poly_canonicalize(rop, NULL);
-    mpz_clear(den);
-    mpz_clear(gcd);
+}
-/**
- * \ingroup  Coefficients
+ *
- * Sets the <tt>i</tt>th coefficient of the polynomial <tt>op</tt> to \c x.
- */
-void fmpq_poly_set_coeff_si(fmpq_poly_ptr rop, ulong i, long x)
+{
-    mpz_t z;
-    fmpz_t t;
-    int canonicalize;
-    /* Is the denominator 1?  This includes the case when rop == 0. */
-    if (fmpz_is_one(rop->den))
+    {
-        fmpz_poly_set_coeff_si(rop->num, i, x);
-        return;
+    }
-    t = fmpz_poly_get_coeff_ptr(rop->num, i);
-    canonicalize = !(t == NULL || fmpz_is_zero(t));
-    mpz_init(z);
-    fmpz_to_mpz(z, rop->den);
-    mpz_mul_si(z, z, x);
-    fmpz_poly_set_coeff_mpz(rop->num, i, z);
-    if (canonicalize)
-        fmpq_poly_canonicalize(rop, NULL);
-    mpz_clear(z);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Comparison
-/**
- * \brief    Returns whether \c op1 and \c op2 are equal.
- * \ingroup  Comparison
+ *
- * Returns whether the two elements \c op1 and \c op2 are equal.
- */
-int fmpq_poly_equal(const fmpq_poly_ptr op1, const fmpq_poly_ptr op2)
+{
-    return (op1->num->length == op2->num->length)
-        && (fmpz_equal(op1->den, op2->den))
-        && (fmpz_poly_equal(op1->num, op2->num));
+}
-/**
- * \brief   Compares the two polynomials <tt>left</tt> and <tt>right</tt>.
- * \ingroup Comparison
+ *
- * Compares the two polnomials <tt>left</tt> and <tt>right</tt>, returning
- * <tt>-1</tt>, <tt>0</tt>, or <tt>1</tt> as <tt>left</tt> is less than,
- * equal to, or greater than <tt>right</tt>.
+ *
- * The comparison is first done by degree and then, in case of a tie, by
- * the individual coefficients, beginning with the highest.
- */
-int fmpq_poly_cmp(const fmpq_poly_ptr left, const fmpq_poly_ptr right)
+{
-    long degdiff, i;
-    /* Quick check whether left and right are the same object. */
-    if (left == right)
-        return 0;
-    i = fmpz_poly_degree(left->num);
-    degdiff = i - fmpz_poly_degree(right->num);
-    if (degdiff < 0)
-        return -1;
-    else if (degdiff > 0)
-        return 1;
-    else
+    {
-        int ans;
-        ulong limbs;
-        fmpz_t lcoeff, rcoeff;
-        if (fmpz_equal(left->den, right->den))
+        {
-            if (i == -1)  /* left and right are both zero */
-                return 0;
-            limbs = FLINT_MAX(left->num->limbs, right->num->limbs) + 1;
-            lcoeff = fmpz_init(limbs);
-            while (fmpz_equal(fmpz_poly_get_coeff_ptr(left->num, i),
-                fmpz_poly_get_coeff_ptr(right->num, i)) && i > 0)
-                i--;
-            fmpz_sub(lcoeff, fmpz_poly_get_coeff_ptr(left->num, i),
-                fmpz_poly_get_coeff_ptr(right->num, i));
-            ans = fmpz_sgn(lcoeff);
-            fmpz_clear(lcoeff);
-            return ans;
+        }
-        else if (fmpz_is_one(left->den))
+        {
-            limbs = FLINT_MAX(left->num->limbs + fmpz_size(right->den),
-                right->num->limbs) + 1;
-            lcoeff = fmpz_init(limbs);
-            fmpz_mul(lcoeff, fmpz_poly_get_coeff_ptr(left->num, i), right->den);
-            while (fmpz_equal(lcoeff, fmpz_poly_get_coeff_ptr(right->num, i))
-                && i > 0)
+            {
-                i--;
-                fmpz_mul(lcoeff, fmpz_poly_get_coeff_ptr(left->num, i),
-                    right->den);
+            }
-            fmpz_sub(lcoeff, lcoeff, fmpz_poly_get_coeff_ptr(right->num, i));
-            ans = fmpz_sgn(lcoeff);
-            fmpz_clear(lcoeff);
-            return ans;
+        }
-        else if (fmpz_is_one(right->den))
+        {
-            limbs = FLINT_MAX(left->num->limbs,
-                right->num->limbs + fmpz_size(left->den)) + 1;
-            rcoeff = fmpz_init(limbs);
-            fmpz_mul(rcoeff, fmpz_poly_get_coeff_ptr(right->num, i), left->den);
-            while (fmpz_equal(fmpz_poly_get_coeff_ptr(left->num, i), rcoeff)
-                && i > 0)
+            {
-                i--;
-                fmpz_mul(rcoeff, fmpz_poly_get_coeff_ptr(right->num, i),
-                    left->den);
+            }
-            fmpz_sub(rcoeff, fmpz_poly_get_coeff_ptr(left->num, i), rcoeff);
-            ans = fmpz_sgn(rcoeff);
-            fmpz_clear(rcoeff);
-            return ans;
+        }
-        else
+        {
-            limbs = FLINT_MAX(left->num->limbs + fmpz_size(right->den),
-                right->num->limbs + fmpz_size(left->den)) + 1;
-            lcoeff = fmpz_init(limbs);
-            rcoeff = fmpz_init(right->num->limbs + fmpz_size(left->den));
-            fmpz_mul(lcoeff, fmpz_poly_get_coeff_ptr(left->num, i), right->den);
-            fmpz_mul(rcoeff, fmpz_poly_get_coeff_ptr(right->num, i), left->den);
-            while (fmpz_equal(lcoeff, rcoeff) && i > 0)
+            {
-                i--;
-                fmpz_mul(lcoeff, fmpz_poly_get_coeff_ptr(left->num, i),
-                    right->den);
-                fmpz_mul(rcoeff, fmpz_poly_get_coeff_ptr(right->num, i),
-                    left->den);
+            }
-            fmpz_sub(lcoeff, lcoeff, rcoeff);
-            ans = fmpz_sgn(lcoeff);
-            fmpz_clear(lcoeff);
-            fmpz_clear(rcoeff);
-            return ans;
+        }
+    }
+}
-///////////////////////////////////////////////////////////////////////////////
-// Addition/ subtraction
-/**
- * \ingroup  Addition
+ *
- * Sets \c rop to the sum of \c rop and \c op.
+ *
- * \todo  This is currently implemented by creating a copy!
- */
-void _fmpq_poly_add_in_place(fmpq_poly_ptr rop, const fmpq_poly_ptr op)
+{
-    if (rop == op)
+    {
-        fmpq_poly_scalar_mul_si(rop, rop, 2l);
-        return;
+    }
-    if (fmpq_poly_is_zero(rop))
+    {
-        fmpq_poly_set(rop, op);
-        return;
+    }
-    if (fmpq_poly_is_zero(op))
+    {
-        return;
+    }
-    /* Now we may assume that rop and op refer to distinct objects in        */
-    /* memory and that both polynomials are non-zero.                        */
-    fmpq_poly_t t;
-    fmpq_poly_init(t);
-    fmpq_poly_add(t, rop, op);
-    fmpq_poly_swap(rop, t);
-    fmpq_poly_clear(t);
+}
-/**
- * \ingroup  Addition
+ *
- * Sets \c rop to the sum of \c op1 and \c op2.
- */
-void fmpq_poly_add(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2)
+{
-    if (op1 == op2)
+    {
-        fmpq_poly_scalar_mul_si(rop, op1, 2l);
-        return;
+    }
-    if (rop == op1)
+    {
-        _fmpq_poly_add_in_place(rop, op2);
-        return;
+    }
-    if (rop == op2)
+    {
-        _fmpq_poly_add_in_place(rop, op1);
-        return;
+    }
-    /* From here on, we may assume that rop, op1 and op2 all refer to        */
-    /* distinct objects in memory, although they may still be equal.         */
-    if (fmpz_is_one(op1->den))
+    {
-        if (fmpz_is_one(op2->den))
+        {
-            fmpz_poly_add(rop->num, op1->num, op2->num);
-            fmpz_set_ui(rop->den, 1ul);
+        }
-        else
+        {
-            fmpz_poly_scalar_mul_fmpz(rop->num, op1->num, op2->den);
-            fmpz_poly_add(rop->num, rop->num, op2->num);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op2->den));
-            fmpz_set(rop->den, op2->den);
+        }
+    }
-    else
+    {
-        if (fmpz_is_one(op2->den))
+        {
-            fmpz_poly_scalar_mul_fmpz(rop->num, op2->num, op1->den);
-            fmpz_poly_add(rop->num, op1->num, rop->num);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op1->den));
-            fmpz_set(rop->den, op1->den);
+        }
-        else
+        {
-            fmpz_poly_t tpoly;
-            fmpz_t tfmpz;
-            ulong limbs;
-            fmpz_poly_init(tpoly);
-            limbs = fmpz_size(op1->den) + fmpz_size(op2->den);
-            rop->den = fmpz_realloc(rop->den, limbs);
-            limbs = FLINT_MAX(limbs, fmpz_size(op2->den) + op1->num->limbs);
-            limbs = FLINT_MAX(limbs, fmpz_size(op1->den) + op2->num->limbs);
-            tfmpz = fmpz_init(limbs);
-            fmpz_gcd(rop->den, op1->den, op2->den);
-            fmpz_tdiv(tfmpz, op2->den, rop->den);
-            fmpz_poly_scalar_mul_fmpz(rop->num, op1->num, tfmpz);
-            fmpz_tdiv(tfmpz, op1->den, rop->den);
-            fmpz_poly_scalar_mul_fmpz(tpoly, op2->num, tfmpz);
-            fmpz_poly_add(rop->num, rop->num, tpoly);
-            fmpz_mul(rop->den, tfmpz, op2->den);
-            fmpq_poly_canonicalize(rop, tfmpz);
-            fmpz_poly_clear(tpoly);
-            fmpz_clear(tfmpz);
+        }
+    }
+}
-/**
- * \ingroup  Addition
+ *
- * Sets \c rop to the difference of \c rop and \c op.
+ *
- * \note  This is implemented using the methods #fmpq_poly_neg() and
- *        #_fmpq_poly_add_in_place().
- */
-void _fmpq_poly_sub_in_place(fmpq_poly_ptr rop, const fmpq_poly_ptr op)
+{
-    if (rop == op)
+    {
-        fmpq_poly_zero(rop);
-        return;
+    }
-    fmpq_poly_neg(rop, rop);
-    _fmpq_poly_add_in_place(rop, op);
-    fmpq_poly_neg(rop, rop);
+}
-/**
- * \ingroup  Addition
+ *
- * Sets \c rop to the difference of \c op1 and \c op2.
- */
-void fmpq_poly_sub(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2)
+{
-    if (op1 == op2)
+    {
-        fmpq_poly_zero(rop);
-        return;
+    }
-    if (rop == op1)
+    {
-        _fmpq_poly_sub_in_place(rop, op2);
-        return;
+    }
-    if (rop == op2)
+    {
-        _fmpq_poly_sub_in_place(rop, op1);
-        fmpq_poly_neg(rop, rop);
-        return;
+    }
-    /* From here on, we know that rop, op1 and op2 refer to distinct objects */
-    /* in memory, although as rational functions they may still be equal     */
-    if (fmpz_is_one(op1->den))
+    {
-        if (fmpz_is_one(op2->den))
+        {
-            fmpz_poly_sub(rop->num, op1->num, op2->num);
-            fmpz_set_ui(rop->den, 1ul);
+        }
-        else
+        {
-            fmpz_poly_scalar_mul_fmpz(rop->num, op1->num, op2->den);
-            fmpz_poly_sub(rop->num, rop->num, op2->num);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op2->den));
-            fmpz_set(rop->den, op2->den);
+        }
+    }
-    else
+    {
-        if (fmpz_is_one(op2->den))
+        {
-            fmpz_poly_scalar_mul_fmpz(rop->num, op2->num, op1->den);
-            fmpz_poly_sub(rop->num, op1->num, rop->num);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op1->den));
-            fmpz_set(rop->den, op1->den);
+        }
-        else
+        {
-            fmpz_poly_t tpoly;
-            fmpz_t tfmpz;
-            ulong limbs;
-            fmpz_poly_init(tpoly);
-            limbs = fmpz_size(op1->den) + fmpz_size(op2->den);
-            rop->den = fmpz_realloc(rop->den, limbs);
-            limbs = FLINT_MAX(limbs, fmpz_size(op2->den) + op1->num->limbs);
-            limbs = FLINT_MAX(limbs, fmpz_size(op1->den) + op2->num->limbs);
-            tfmpz = fmpz_init(limbs);
-            fmpz_gcd(rop->den, op1->den, op2->den);
-            fmpz_tdiv(tfmpz, op2->den, rop->den);
-            fmpz_poly_scalar_mul_fmpz(rop->num, op1->num, tfmpz);
-            fmpz_tdiv(tfmpz, op1->den, rop->den);
-            fmpz_poly_scalar_mul_fmpz(tpoly, op2->num, tfmpz);
-            fmpz_poly_sub(rop->num, rop->num, tpoly);
-            fmpz_mul(rop->den, tfmpz, op2->den);
-            fmpq_poly_canonicalize(rop, tfmpz);
-            fmpz_poly_clear(tpoly);
-            fmpz_clear(tfmpz);
+        }
+    }
+}
-/**
- * \ingroup  Addition
+ *
- * Sets \c rop to <tt>rop + op1 * op2</tt>.
+ *
- * Currently, this method refers to the methods #fmpq_poly_mul() and
- * #fmpq_poly_add() to form the result in the naive way.
+ *
- * \todo  Implement this method more efficiently.
- */
-void fmpq_poly_addmul(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2)
+{
-    fmpq_poly_t t;
-    fmpq_poly_init(t);
-    fmpq_poly_mul(t, op1, op2);
-    fmpq_poly_add(rop, rop, t);
-    fmpq_poly_clear(t);
+}
-/**
- * \ingroup  Addition
+ *
- * Sets \c rop to <tt>rop - op1 * op2</tt>.
+ *
- * Currently, this method refers to the methods #fmpq_poly_mul() and
- * #fmpq_poly_sub() to form the result in the naive way.
+ *
- * \todo  Implement this method more efficiently.
- */
-void fmpq_poly_submul(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2)
+{
-    fmpq_poly_t t;
-    fmpq_poly_init(t);
-    fmpq_poly_mul(t, op1, op2);
-    fmpq_poly_sub(rop, rop, t);
-    fmpq_poly_clear(t);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Scalar multiplication and division
-/**
- * \ingroup  ScalarMul
+ *
- * Sets \c rop to the scalar product of \c op and the integer \c x.
- */
-void fmpq_poly_scalar_mul_si(fmpq_poly_ptr rop, const fmpq_poly_ptr op, long x)
+{
-    if (fmpz_is_one(op->den))
+    {
-        fmpz_poly_scalar_mul_si(rop->num, op->num, x);
-        fmpz_set_ui(rop->den, 1ul);
+    }
-    else
+    {
-        fmpz_t fx, g;
-        g  = fmpz_init(fmpz_size(op->den));
-        fx = fmpz_init(1);
-        fmpz_set_si(fx, x);
-        fmpz_gcd(g, op->den, fx);
-        fmpz_abs(g, g);
-        if (fmpz_is_one(g))
+        {
-            fmpz_poly_scalar_mul_si(rop->num, op->num, x);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-            fmpz_set(rop->den, op->den);
+        }
-        else
+        {
-            if (rop == op)
+            {
-                fmpz_t t;
-                t = fmpz_init(fmpz_size(op->den));
-                fmpz_tdiv(t, fx, g);
-                fmpz_poly_scalar_mul_fmpz(rop->num, op->num, t);
-                fmpz_tdiv(t, op->den, g);
-                fmpz_clear(rop->den);  // FIXME  Fixed
-                rop->den = t;
+            }
-            else
+            {
-                rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-                fmpz_tdiv(rop->den, fx, g);
-                fmpz_poly_scalar_mul_fmpz(rop->num, op->num, rop->den);
-                fmpz_tdiv(rop->den, op->den, g);
+            }
+        }
-        fmpz_clear(g);
-        fmpz_clear(fx);
+    }
+}
-/**
- * \ingroup  ScalarMul
+ *
- * Sets \c rop to the scalar multiple of \c op with the \c mpz_t \c x.
- */
-void fmpq_poly_scalar_mul_mpz(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpz_t x)
+{
-    fmpz_t g, y;
-    if (fmpz_is_one(op->den))
+    {
-        fmpz_poly_scalar_mul_mpz(rop->num, op->num, x);
-        fmpz_set_ui(rop->den, 1UL);
-        return;
+    }
-    if (mpz_cmpabs_ui(x, 1) == 0)
+    {
-        if (mpz_sgn(x) > 0)
-            fmpq_poly_set(rop, op);
-        else
-            fmpq_poly_neg(rop, op);
-        return;
+    }
-    if (mpz_sgn(x) == 0)
+    {
-        fmpq_poly_zero(rop);
-        return;
+    }
-    g = fmpz_init(FLINT_MAX(fmpz_size(op->den), mpz_size(x)));
-    y = fmpz_init(mpz_size(x));
-    mpz_to_fmpz(y, x);
-    fmpz_gcd(g, op->den, y);
-    if (fmpz_is_one(g))
+    {
-        fmpz_poly_scalar_mul_fmpz(rop->num, op->num, y);
-        if (rop != op)
+        {
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-            fmpz_set(rop->den, op->den);
+        }
+    }
-    else
+    {
-        fmpz_t t;
-        t = fmpz_init(FLINT_MAX(fmpz_size(y), fmpz_size(op->den)));
-        fmpz_divides(t, y, g);
-        fmpz_poly_scalar_mul_fmpz(rop->num, op->num, t);
-        fmpz_divides(t, op->den, g);
-        fmpz_clear(rop->den);
-        rop->den = t;
+    }
-    fmpz_clear(g);
-    fmpz_clear(y);
+}
-/**
- * \ingroup  ScalarMul
+ *
- * Sets \c rop to the scalar multiple of \c op with the \c mpq_t \c x.
- */
-void fmpq_poly_scalar_mul_mpq(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpq_t x)
+{
-    fmpz_poly_scalar_mul_mpz(rop->num, op->num, mpq_numref(x));
-    if (fmpz_is_one(op->den))
+    {
-        rop->den = fmpz_realloc(rop->den, mpz_size(mpq_denref(x)));
-        mpz_to_fmpz(rop->den, mpq_denref(x));
+    }
-    else
+    {
-        fmpz_t s, t;
-        s = fmpz_init(mpz_size(mpq_denref(x)));
-        t = fmpz_init(fmpz_size(op->den));
-        mpz_to_fmpz(s, mpq_denref(x));
-        fmpz_set(t, op->den);
-        rop->den = fmpz_realloc(rop->den, fmpz_size(s) + fmpz_size(t));
-        fmpz_mul(rop->den, s, t);
-        fmpz_clear(s);
-        fmpz_clear(t);
+    }
-    fmpq_poly_canonicalize(rop, NULL);
+}
-/**
- * /ingroup  ScalarMul
+ *
- * Divides \c rop by the integer \c x.
+ *
- * Assumes that \c x is non-zero.  Otherwise, an exception is raised in the
- * form of an <tt>abort</tt> statement.
- */
-void _fmpq_poly_scalar_div_si_in_place(fmpq_poly_ptr rop, long x)
+{
-    fmpz_t cont, fx, gcd;
-    /* Assertion! */
-    if (x == 0l)
+    {
-        printf("ERROR (_fmpq_poly_scalar_div_si_in_place).  Division by zero.\n");
-        abort();
+    }
-    if (x == 1l)
+    {
-        return;
+    }
-    cont = fmpz_init(rop->num->limbs);
-    fmpz_poly_content(cont, rop->num);
-    fmpz_abs(cont, cont);
-    if (fmpz_is_one(cont))
+    {
-        if (x > 0l)
+        {
-            if (fmpz_is_one(rop->den))
+            {
-                fmpz_set_si(rop->den, x);
+            }
-            else
+            {
-                fmpz_t t;
-                t = fmpz_init(fmpz_size(rop->den) + 1);
-                fmpz_mul_ui(t, rop->den, (ulong) x);
-                fmpz_clear(rop->den);  // FIXME  Fixed
-                rop->den = t;
+            }
+        }
-        else
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            if (fmpz_is_one(rop->den))
+            {
-                fmpz_set_si(rop->den, -x);
+            }
-            else
+            {
-                fmpz_t t;
-                t = fmpz_init(fmpz_size(rop->den) + 1);
-                fmpz_mul_ui(t, rop->den, (ulong) -x);
-                fmpz_clear(rop->den);  // FIXME  Fixed
-                rop->den = t;
+            }
+        }
-        fmpz_clear(cont);
-        return;
+    }
-    fx = fmpz_init(1);
-    fmpz_set_si(fx, x);
-    gcd = fmpz_init(FLINT_MAX(rop->num->limbs, fmpz_size(fx)));
-    fmpz_gcd(gcd, cont, fx);
-    fmpz_abs(gcd, gcd);
-    if (fmpz_is_one(gcd))
+    {
-        if (x > 0l)
+        {
-            if (fmpz_is_one(rop->den))
+            {
-                fmpz_set_si(rop->den, x);
+            }
-            else
+            {
-                fmpz_t t;
-                t = fmpz_init(fmpz_size(rop->den) + 1);
-                fmpz_mul_ui(t, rop->den, (ulong) x);
-                fmpz_clear(rop->den);  // FIXME  Fixed
-                rop->den = t;
+            }
+        }
-        else
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            if (fmpz_is_one(rop->den))
+            {
-                fmpz_set_si(rop->den, -x);
+            }
-            else
+            {
-                fmpz_t t;
-                t = fmpz_init(fmpz_size(rop->den) + 1);
-                fmpz_mul_ui(t, rop->den, (ulong) -x);
-                fmpz_clear(rop->den);  // FIXME  Fixed
-                rop->den = t;
+            }
+        }
+    }
-    else
+    {
-        fmpz_poly_scalar_div_fmpz(rop->num, rop->num, gcd);
-        if (fmpz_is_one(rop->den))
+        {
-            fmpz_tdiv(rop->den, fx, gcd);
+        }
-        else
+        {
-            fmpz_tdiv(cont, fx, gcd);
-            fx = fmpz_realloc(fx, fmpz_size(rop->den));
-            fmpz_set(fx, rop->den);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(rop->den) + 1);
-            fmpz_mul(rop->den, fx, cont);
+        }
-        if (x < 0l)
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            fmpz_neg(rop->den, rop->den);
+        }
+    }
-    fmpz_clear(cont);
-    fmpz_clear(fx);
-    fmpz_clear(gcd);
+}
-/**
- * \ingroup  ScalarMul
+ *
- * Sets \c rop to the scalar multiple of \c op with the multiplicative inverse
- * of the integer \c x.
+ *
- * Assumes that \c x is non-zero.  Otherwise, an exception is raised in the
- * form of an <tt>abort</tt> statement.
- */
-void fmpq_poly_scalar_div_si(fmpq_poly_ptr rop, const fmpq_poly_ptr op, long x)
+{
-    fmpz_t cont, fx, gcd;
-    /* Assertion! */
-    if (x == 0l)
+    {
-        printf("ERROR (fmpq_poly_scalar_div_si).  Division by zero.\n");
-        abort();
+    }
-    if (rop == op)
+    {
-        _fmpq_poly_scalar_div_si_in_place(rop, x);
-        return;
+    }
-    /* From here on, we may assume that rop and op denote two different      */
-    /* rational polynomials (as objects in memory).                          */
-    if (x == 1l)
+    {
-        fmpq_poly_set(rop, op);
-        return;
+    }
-    cont = fmpz_init(op->num->limbs);
-    fmpz_poly_content(cont, op->num);
-    fmpz_abs(cont, cont);
-    if (fmpz_is_one(cont))
+    {
-        if (x > 0l)
+        {
-            fmpz_poly_set(rop->num, op->num);
-            if (fmpz_is_one(op->den))
+            {
-                fmpz_set_si(rop->den, x);
+            }
-            else
+            {
-                rop->den = fmpz_realloc(rop->den, fmpz_size(op->den) + 1);
-                fmpz_mul_ui(rop->den, op->den, (ulong) x);
+            }
+        }
-        else
+        {
-            fmpz_poly_neg(rop->num, op->num);
-            if (fmpz_is_one(op->den))
+            {
-                fmpz_set_si(rop->den, -x);
+            }
-            else
+            {
-                rop->den = fmpz_realloc(rop->den, fmpz_size(op->den) + 1);
-                fmpz_mul_ui(rop->den, op->den, (ulong) -x);
+            }
+        }
-        fmpz_clear(cont);
-        return;
+    }
-    fx = fmpz_init(1);
-    fmpz_set_si(fx, x);
-    gcd = fmpz_init(FLINT_MAX(op->num->limbs, fmpz_size(fx)));
-    fmpz_gcd(gcd, cont, fx);
-    fmpz_abs(gcd, gcd);
-    if (fmpz_is_one(gcd))
+    {
-        if (x > 0l)
+        {
-            fmpz_poly_set(rop->num, op->num);
-            if (fmpz_is_one(op->den))
+            {
-                fmpz_set_si(rop->den, x);
+            }
-            else
+            {
-                rop->den = fmpz_realloc(rop->den, fmpz_size(op->den) + 1);
-                fmpz_mul_ui(rop->den, op->den, (ulong) x);
+            }
+        }
-        else
+        {
-            fmpz_poly_neg(rop->num, op->num);
-            if (fmpz_is_one(op->den))
+            {
-                fmpz_set_si(rop->den, -x);
+            }
-            else
+            {
-                rop->den = fmpz_realloc(rop->den, fmpz_size(op->den) + 1);
-                fmpz_mul_ui(rop->den, op->den, (ulong) -x);
+            }
+        }
+    }
-    else
+    {
-        fmpz_poly_scalar_div_fmpz(rop->num, op->num, gcd);
-        if (fmpz_is_one(op->den))
+        {
-            fmpz_tdiv(rop->den, fx, gcd);
+        }
-        else
+        {
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op->den) + 1);
-            fmpz_tdiv(cont, fx, gcd);  /* fx and gcd are word-sized */
-            fmpz_mul(rop->den, op->den, cont);
+        }
-        if (x < 0l)
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            fmpz_neg(rop->den, rop->den);
+        }
+    }
-    fmpz_clear(cont);
-    fmpz_clear(fx);
-    fmpz_clear(gcd);
+}
-/**
- * \ingroup  ScalarMul
+ *
- * Sets \c rop to the scalar multiple of \c op with the multiplicative inverse
- * of the integer \c x.
+ *
- * Assumes that \c x is non-zero.  Otherwise, an exception is raised in the
- * form of an <tt>abort</tt> statement.
- */
-void _fmpq_poly_scalar_div_mpz_in_place(fmpq_poly_ptr rop, const mpz_t x)
+{
-    fmpz_t cont, fx, gcd;
-    /* Assertion! */
-    if (mpz_sgn(x) == 0)
+    {
-        printf("ERROR (_fmpq_poly_scalar_div_mpz_in_place).  Division by zero.\n");
-        abort();
+    }
-    if (mpz_cmp_ui(x, 1) == 0)
-        return;
-    cont = fmpz_init(rop->num->limbs);
-    fmpz_poly_content(cont, rop->num);
-    fmpz_abs(cont, cont);
-    if (fmpz_is_one(cont))
+    {
-        if (fmpz_is_one(rop->den))
+        {
-            rop->den = fmpz_realloc(rop->den, mpz_size(x));
-            mpz_to_fmpz(rop->den, x);
+        }
-        else
+        {
-            fmpz_t t;
-            fx = fmpz_init(mpz_size(x));
-            mpz_to_fmpz(fx, x);
-            t = fmpz_init(fmpz_size(rop->den) + mpz_size(x));
-            fmpz_mul(t, rop->den, fx);
-            fmpz_clear(rop->den);  // FIXME  Fixed
-            rop->den = t;
-            fmpz_clear(fx);
+        }
-        if (mpz_sgn(x) < 0)
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            fmpz_neg(rop->den, rop->den);
+        }
-        fmpz_clear(cont);
-        return;
+    }
-    fx = fmpz_init(mpz_size(x));
-    mpz_to_fmpz(fx, x);
-    gcd = fmpz_init(FLINT_MAX(rop->num->limbs, fmpz_size(fx)));
-    fmpz_gcd(gcd, cont, fx);
-    fmpz_abs(gcd, gcd);
-    if (fmpz_is_one(gcd))
+    {
-        if (fmpz_is_one(rop->den))
+        {
-            rop->den = fmpz_realloc(rop->den, mpz_size(x));
-            mpz_to_fmpz(rop->den, x);
+        }
-        else
+        {
-            fmpz_t t;
-            t = fmpz_init(fmpz_size(rop->den) + mpz_size(x));
-            fmpz_mul(t, rop->den, fx);
-            fmpz_clear(rop->den);  // FIXME  Fixed
-            rop->den = t;
+        }
-        if (mpz_sgn(x) < 0)
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            fmpz_neg(rop->den, rop->den);
+        }
+    }
-    else
+    {
-        fmpz_poly_scalar_div_fmpz(rop->num, rop->num, gcd);
-        if (fmpz_is_one(rop->den))
+        {
-            rop->den = fmpz_realloc(rop->den, fmpz_size(fx));
-            fmpz_tdiv(rop->den, fx, gcd);
+        }
-        else
+        {
-            cont = fmpz_realloc(cont, fmpz_size(fx));
-            fmpz_tdiv(cont, fx, gcd);
-            fx = fmpz_realloc(fx, fmpz_size(rop->den));
-            fmpz_set(fx, rop->den);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(fx) + fmpz_size(cont));
-            fmpz_mul(rop->den, fx, cont);
+        }
-        if (mpz_sgn(x) < 0)
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            fmpz_neg(rop->den, rop->den);
+        }
+    }
-    fmpz_clear(cont);
-    fmpz_clear(fx);
-    fmpz_clear(gcd);
+}
-/**
- * \ingroup  ScalarMul
+ *
- * Sets \c rop to the scalar multiple of \c op with the multiplicative inverse
- * of the integer \c x.
+ *
- * Assumes that \c x is non-zero.  Otherwise, an exception is raised in the
- * form of an <tt>abort</tt> statement.
- */
-void fmpq_poly_scalar_div_mpz(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpz_t x)
+{
-    fmpz_t cont, fx, gcd;
-    /* Assertion! */
-    if (mpz_sgn(x) == 0)
+    {
-        printf("ERROR (fmpq_poly_scalar_div_mpz).  Division by zero.\n");
-        abort();
+    }
-    if (rop == op)
+    {
-        _fmpq_poly_scalar_div_mpz_in_place(rop, x);
-        return;
+    }
-    /* From here on, we may assume that rop and op denote two different      */
-    /* rational polynomials (as objects in memory).                          */
-    if (mpz_cmp_ui(x, 1) == 0)
+    {
-        fmpq_poly_set(rop, op);
-        return;
+    }
-    cont = fmpz_init(op->num->limbs);
-    fmpz_poly_content(cont, op->num);
-    fmpz_abs(cont, cont);
-    if (fmpz_is_one(cont))
+    {
-        if (fmpz_is_one(op->den))
+        {
-            rop->den = fmpz_realloc(rop->den, mpz_size(x));
-            mpz_to_fmpz(rop->den, x);
+        }
-        else
+        {
-            fmpz_t t;
-            t = fmpz_init(mpz_size(x));
-            mpz_to_fmpz(t, x);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op->den) + fmpz_size(t));
-            fmpz_mul(rop->den, op->den, t);
-            fmpz_clear(t);
+        }
-        if (mpz_sgn(x) > 0)
+        {
-            fmpz_poly_set(rop->num, op->num);
+        }
-        else
+        {
-            fmpz_poly_neg(rop->num, op->num);
-            fmpz_neg(rop->den, rop->den);
+        }
-        fmpz_clear(cont);
-        return;
+    }
-    fx = fmpz_init(mpz_size(x));
-    mpz_to_fmpz(fx, x);
-    gcd = fmpz_init(FLINT_MAX(op->num->limbs, fmpz_size(fx)));
-    fmpz_gcd(gcd, cont, fx);
-    fmpz_abs(gcd, gcd);
-    if (fmpz_is_one(gcd))
+    {
-        if (fmpz_is_one(op->den))
+        {
-            rop->den = fmpz_realloc(rop->den, mpz_size(x));
-            mpz_to_fmpz(rop->den, x);
+        }
-        else
+        {
-            fmpz_t t;
-            t = fmpz_init(mpz_size(x));
-            mpz_to_fmpz(t, x);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op->den) + fmpz_size(t));
-            fmpz_mul(rop->den, op->den, t);
-            fmpz_clear(t);
+        }
-        if (mpz_sgn(x) > 0)
+        {
-            fmpz_poly_set(rop->num, op->num);
+        }
-        else
+        {
-            fmpz_poly_neg(rop->num, op->num);
-            fmpz_neg(rop->den, rop->den);
+        }
+    }
-    else
+    {
-        fmpz_poly_scalar_div_fmpz(rop->num, op->num, gcd);
-        if (fmpz_is_one(op->den))
+        {
-            rop->den = fmpz_realloc(rop->den, fmpz_size(fx));
-            fmpz_tdiv(rop->den, fx, gcd);
+        }
-        else
+        {
-            cont = fmpz_realloc(cont, fmpz_size(fx));
-            fmpz_tdiv(cont, fx, gcd);
-            rop->den = fmpz_realloc(rop->den, fmpz_size(op->den) + fmpz_size(cont));
-            fmpz_mul(rop->den, op->den, cont);
+        }
-        if (mpz_sgn(x) < 0)
+        {
-            fmpz_poly_neg(rop->num, rop->num);
-            fmpz_neg(rop->den, rop->den);
+        }
+    }
-    fmpz_clear(cont);
-    fmpz_clear(fx);
-    fmpz_clear(gcd);
+}
-/**
- * \ingroup  ScalarMul
+ *
- * Sets \c rop to the scalar multiple of \c op with the multiplicative inverse
- * of the rational \c x.
+ *
- * Assumes that the rational \c x is in lowest terms and non-zero.  If the
- * rational is not in lowest terms, the resulting value of <tt>rop</tt> is
- * undefined.  If <tt>x</tt> is zero, an exception is raised in the form
- * of an <tt>abort</tt> statement.
- */
-void fmpq_poly_scalar_div_mpq(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpq_t x)
+{
-    /* Assertion! */
-    if (mpz_sgn(mpq_numref(x)) == 0)
+    {
-        printf("ERROR (fmpq_poly_scalar_div_mpq).  Division by zero.\n");
-        abort();
+    }
-    fmpz_poly_scalar_mul_mpz(rop->num, op->num, mpq_denref(x));
-    if (fmpz_is_one(op->den))
+    {
-        rop->den = fmpz_realloc(rop->den, mpz_size(mpq_numref(x)));
-        mpz_to_fmpz(rop->den, mpq_numref(x));
+    }
-    else
+    {
-        fmpz_t s, t;
-        s = fmpz_init(mpz_size(mpq_numref(x)));
-        t = fmpz_init(fmpz_size(op->den));
-        mpz_to_fmpz(s, mpq_numref(x));
-        fmpz_set(t, op->den);
-        rop->den = fmpz_realloc(rop->den, fmpz_size(s) + fmpz_size(t));
-        fmpz_mul(rop->den, s, t);
-        fmpz_clear(s);
-        fmpz_clear(t);
+    }
-    fmpq_poly_canonicalize(rop, NULL);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Multiplication
-/**
- * \ingroup  Multiplication
+ *
- * Multiplies <tt>rop</tt> by <tt>op</tt>.
- */
-void _fmpq_poly_mul_in_place(fmpq_poly_ptr rop, const fmpq_poly_ptr op)
+{
-    fmpq_poly_t t;
-    if (rop == op)
+    {
-        fmpz_poly_power(rop->num, op->num, 2ul);
-        if (!fmpz_is_one(rop->den))
+        {
-            rop->den = fmpz_realloc(rop->den, 2 * fmpz_size(rop->den));
-            fmpz_pow_ui(rop->den, op->den, 2ul);
+        }
-        return;
+    }
-    if (fmpq_poly_is_zero(rop) || fmpq_poly_is_zero(op))
+    {
-        fmpq_poly_zero(rop);
-        return;
+    }
-    /* From here on, rop and op point to two different objects in memory,    */
-    /* and these are both non-zero rational polynomials.                     */
-    fmpq_poly_init(t);
-    fmpq_poly_mul(t, rop, op);
-    fmpq_poly_swap(rop, t);
-    fmpq_poly_clear(t);
+}
-/**
- * \ingroup  Multiplication
+ *
- * Sets \c rop to the product of \c op1 and \c op2.
- */
-void fmpq_poly_mul(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2)
+{
-    fmpz_t gcd1, gcd2;
-    if (op1 == op2)
+    {
-        fmpz_poly_power(rop->num, op1->num, 2ul);
-        if (fmpz_is_one(op1->den))
+        {
-            fmpz_set_ui(rop->den, 1);
+        }
-        else
+        {
-            if (rop == op1)
+            {
-                fmpz_t t;
-                t = fmpz_init(2 * fmpz_size(op1->den));
-                fmpz_pow_ui(t, op1->den, 2ul);
-                fmpz_clear(rop->den);  // FIXME  Fixed
-                rop->den = t;
+            }
-            else
+            {
-                rop->den = fmpz_realloc(rop->den, 2 * fmpz_size(op1->den));
-                fmpz_pow_ui(rop->den, op1->den, 2ul);
+            }
+        }
-        return;
+    }
-    if (rop == op1)
+    {
-        _fmpq_poly_mul_in_place(rop, op2);
-        return;
+    }
-    if (rop == op2)
+    {
-        _fmpq_poly_mul_in_place(rop, op1);
-        return;
+    }
-    /* From here on, we may assume that rop, op1 and op2 all refer to        */
-    /* distinct objects in memory, although they may still be equal.         */
-    gcd1 = NULL;
-    gcd2 = NULL;
-    if (!fmpz_is_one(op2->den))
+    {
-        gcd1 = fmpz_init(FLINT_MAX(op1->num->limbs, fmpz_size(op2->den)));
-        fmpz_poly_content(gcd1, op1->num);
-        if (!fmpz_is_one(gcd1))
+        {
-            fmpz_t t;
-            t = fmpz_init(FLINT_MAX(fmpz_size(gcd1), fmpz_size(op2->den)));
-            fmpz_gcd(t, gcd1, op2->den);
-            fmpz_clear(gcd1);
-            gcd1 = t;
+        }
+    }
-    if (!fmpz_is_one(op1->den))
+    {
-        gcd2 = fmpz_init(FLINT_MAX(op2->num->limbs, fmpz_size(op1->den)));
-        fmpz_poly_content(gcd2, op2->num);
-        if (!fmpz_is_one(gcd2))
+        {
-            fmpz_t t;
-            t = fmpz_init(FLINT_MAX(fmpz_size(gcd2), fmpz_size(op1->den)));
-            fmpz_gcd(t, gcd2, op1->den);
-            fmpz_clear(gcd2);
-            gcd2 = t;
+        }
+    }
-    /* TODO:  If gcd1 and gcd2 are very large compared to the degrees of  */
-    /* poly1 and poly2, we might want to create copies of the polynomials */
-    /* and divide out the common factors *before* the multiplication.     */
-    fmpz_poly_mul(rop->num, op1->num, op2->num);
-    rop->den = fmpz_realloc(rop->den, fmpz_size(op1->den)
-             + fmpz_size(op2->den));
-    fmpz_mul(rop->den, op1->den, op2->den);
-    if (gcd1 == NULL || fmpz_is_one(gcd1))
+    {
-        if (gcd2 != NULL && !fmpz_is_one(gcd2))
+        {
-            fmpz_t h;
-            h = fmpz_init(fmpz_size(rop->den));
-            fmpz_poly_scalar_div_fmpz(rop->num, rop->num, gcd2);
-            fmpz_divides(h, rop->den, gcd2);
-            fmpz_clear(rop->den);
-            rop->den = h;
+        }
+    }
-    else
+    {
-        if (gcd2 == NULL || fmpz_is_one(gcd2))
+        {
-            fmpz_t h;
-            h = fmpz_init(fmpz_size(rop->den));
-            fmpz_poly_scalar_div_fmpz(rop->num, rop->num, gcd1);
-            fmpz_divides(h, rop->den, gcd1);
-            fmpz_clear(rop->den);
-            rop->den = h;
+        }
-        else
+        {
-            fmpz_t g, h;
-            g = fmpz_init(fmpz_size(gcd1) + fmpz_size(gcd2));
-            h = fmpz_init(fmpz_size(rop->den));
-            fmpz_mul(g, gcd1, gcd2);
-            fmpz_poly_scalar_div_fmpz(rop->num, rop->num, g);
-            fmpz_divides(h, rop->den, g);
-            fmpz_clear(rop->den);
-            rop->den = h;
-            fmpz_clear(g);
+        }
+    }
-    if (gcd1 != NULL) fmpz_clear(gcd1);
-    if (gcd2 != NULL) fmpz_clear(gcd2);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Division
-/**
- * \ingroup  Division
+ *
- * Returns the quotient of the Euclidean division of \c a by \c b.
+ *
- * Assumes that \c b is non-zero.  Otherwise, an exception is raised in the
- * form of an <tt>abort</tt> statement.
- */
-void fmpq_poly_floordiv(fmpq_poly_ptr q, const fmpq_poly_ptr a, const fmpq_poly_ptr b)
+{
-    ulong m;
-    fmpz_t lead;
-    /* Assertion! */
-    if (fmpq_poly_is_zero(b))
+    {
-        printf("ERROR (fmpq_poly_floordiv).  Division by zero.\n");
-        abort();
+    }
-    /* Catch the case when a and b are the same objects in memory. */
-    /* As of FLINT version 1.5.1, there is a bug in this case.     */
-    if (a == b)
+    {
-        fmpq_poly_set_si(q, 1);
-        return;
+    }
-    /* Deal with the various other cases of aliasing. */
-    if (q == a | q == b)
+    {
-        fmpq_poly_t tpoly;
-        fmpq_poly_init(tpoly);
-        fmpq_poly_floordiv(tpoly, a, b);
-        fmpq_poly_swap(q, tpoly);
-        fmpq_poly_clear(tpoly);
-        return;
+    }
-    /* Deal separately with the case deg(b) = 0. */
-    if (fmpq_poly_length(b) == 1ul)
+    {
-        lead = fmpz_poly_get_coeff_ptr(b->num, 0);
-        if (fmpz_is_one(a->den))
+        {
-            if (fmpz_is_one(b->den))  /* a->den == b->den == 1 */
-                fmpz_poly_set(q->num, a->num);
-            else  /* a->den == 1, b->den > 1 */
-                fmpz_poly_scalar_mul_fmpz(q->num, a->num, b->den);
-            q->den = fmpz_realloc(q->den, fmpz_size(lead));
-            fmpz_set(q->den, lead);
-            fmpq_poly_canonicalize(q, NULL);
+        }
-        else
+        {
-            if (fmpz_is_one(b->den))  /* a->den > 1, b->den == 1 */
-                fmpz_poly_set(q->num, a->num);
-            else  /* a->den, b->den > 1 */
-                fmpz_poly_scalar_mul_fmpz(q->num, a->num, b->den);
-            q->den = fmpz_realloc(q->den, fmpz_size(a->den) + fmpz_size(lead));
-            fmpz_mul(q->den, a->den, lead);
-            fmpq_poly_canonicalize(q, NULL);
+        }
-        return;
+    }
-    /* General case..                            */
-    /* Set q to b->den q->num / (a->den lead^m). */
-    /* Since the fmpz_poly_pseudo_div method is broken as of FLINT 1.5.0, we */
-    /* use the fmpz_poly_pseudo_divrem method instead.                       */
-    /* fmpz_poly_pseudo_div(q->num, &m, a->num, b->num);                     */
+    {
-        fmpz_poly_t r;
-        fmpz_poly_init(r);
-        fmpz_poly_pseudo_divrem(q->num, r, &m, a->num, b->num);
-        fmpz_poly_clear(r);
+    }
-    lead = fmpz_poly_lead(b->num);
-    if (!fmpz_is_one(b->den))
-        fmpz_poly_scalar_mul_fmpz(q->num, q->num, b->den);
-    /* Case 1:  lead^m is 1 */
-    if (fmpz_is_one(lead) || m == 0ul || (fmpz_is_m1(lead) & m % 2 == 0))
+    {
-        q->den = fmpz_realloc(q->den, fmpz_size(a->den));
-        fmpz_set(q->den, a->den);
-        fmpq_poly_canonicalize(q, NULL);
+    }
-    /* Case 2:  lead^m is -1 */
-    else if (fmpz_is_m1(lead) & m % 2)
+    {
-        fmpz_poly_neg(q->num, q->num);
-        q->den = fmpz_realloc(q->den, fmpz_size(a->den));
-        fmpz_set(q->den, a->den);
-        fmpq_poly_canonicalize(q, NULL);
+    }
-    /* Case 3:  lead^m is not +-1 */
-    else
+    {
-        ulong limbs;
-        limbs = m * fmpz_size(lead);
-        if (fmpz_is_one(a->den))
+        {
-            q->den = fmpz_realloc(q->den, limbs);
-            fmpz_pow_ui(q->den, lead, m);
+        }
-        else
+        {
-            fmpz_t t;
-            t = fmpz_init(limbs);
-            q->den = fmpz_realloc(q->den, limbs + fmpz_size(a->den));
-            fmpz_pow_ui(t, lead, m);
-            fmpz_mul(q->den, t, a->den);
-            fmpz_clear(t);
+        }
-        fmpq_poly_canonicalize(q, NULL);
+    }
+}
-/**
- * \ingroup  Division
+ *
- * Sets \c r to the remainder of the Euclidean division of \c a by \c b.
+ *
- * Assumes that \c b is non-zero.  Otherwise, an exception is raised in the
- * form of an <tt>abort</tt> statement.
- */
-void fmpq_poly_mod(fmpq_poly_ptr r, const fmpq_poly_ptr a, const fmpq_poly_ptr b)
+{
-    ulong m;
-    fmpz_t lead;
-    /* Assertion! */
-    if (fmpq_poly_is_zero(b))
+    {
-        printf("ERROR (fmpq_poly_mod).  Division by zero.\n");
-        abort();
+    }
-    /* Catch the case when a and b are the same objects in memory. */
-    /* As of FLINT version 1.5.1, there is a bug in this case.     */
-    if (a == b)
+    {
-        fmpq_poly_set_si(r, 0);
-        return;
+    }
-    /* Deal with the various other cases of aliasing. */
-    if (r == a | r == b)
+    {
-        fmpq_poly_t tpoly;
-        fmpq_poly_init(tpoly);
-        fmpq_poly_mod(tpoly, a, b);
-        fmpq_poly_swap(r, tpoly);
-        fmpq_poly_clear(tpoly);
-        return;
+    }
-    /* Deal separately with the case deg(b) = 0. */
-    if (fmpq_poly_length(b) == 1ul)
+    {
-        fmpz_poly_zero(r->num);
-        fmpz_set_ui(r->den, 1);
-        return;
+    }
-    /* General case..                     */
-    /* Set r to r->num / (a->den lead^m). */
-    /* As of FLINT 1.5.0, the fmpz_poly_pseudo_mod method is not             */
-    /* asymptotically fast and hence we swap to the fmpz_poly_pseudo_divrem  */
-    /* method if one of the operands' lengths is at least 32.                */
-    if (fmpq_poly_length(a) < 32 && fmpq_poly_length(b) < 32)
-        fmpz_poly_pseudo_rem(r->num, &m, a->num, b->num);
-    else
+    {
-        fmpz_poly_t q;
-        fmpz_poly_init(q);
-        fmpz_poly_pseudo_divrem(q, r->num, &m, a->num, b->num);
-        fmpz_poly_clear(q);
+    }
-    lead = fmpz_poly_lead(b->num);
-    /* Case 1:  lead^m is 1 */
-    if (fmpz_is_one(lead) || m == 0ul || (fmpz_is_m1(lead) & m % 2 == 0))
+    {
-        r->den = fmpz_realloc(r->den, fmpz_size(a->den));
-        fmpz_set(r->den, a->den);
+    }
-    /* Case 2:  lead^m is -1 */
-    else if (fmpz_is_m1(lead) & m % 2)
+    {
-        r->den = fmpz_realloc(r->den, fmpz_size(a->den));
-        fmpz_neg(r->den, a->den);
+    }
-    /* Case 3:  lead^m is not +-1 */
-    else
+    {
-        ulong limbs;
-        limbs = m * fmpz_size(lead);
-        if (fmpz_is_one(a->den))
+        {
-            r->den = fmpz_realloc(r->den, limbs);
-            fmpz_pow_ui(r->den, lead, m);
+        }
-        else
+        {
-            fmpz_t t;
-            t = fmpz_init(limbs);
-            r->den = fmpz_realloc(r->den, limbs + fmpz_size(a->den));
-            fmpz_pow_ui(t, lead, m);
-            fmpz_mul(r->den, t, a->den);
-            fmpz_clear(t);
+        }
+    }
-    fmpq_poly_canonicalize(r, NULL);
+}
-/**
- * \ingroup  Division
+ *
- * Sets \c q and \c r to the quotient and remainder of the Euclidean
- * division of \c a by \c b.
+ *
- * Assumes that \c b is non-zero, and that \c q and \c r refer to distinct
- * objects in memory.
- */
-void fmpq_poly_divrem(fmpq_poly_ptr q, fmpq_poly_ptr r, const fmpq_poly_ptr a, const fmpq_poly_ptr b)
+{
-    ulong m;
-    fmpz_t lead;
-    /* Assertion! */
-    if (fmpq_poly_is_zero(b))
+    {
-        printf("ERROR (fmpq_poly_divrem).  Division by zero.\n");
-        abort();
+    }
-    if (q == r)
+    {
-        printf("ERROR (fmpq_poly_divrem).  Output arguments aliased.\n");
-        abort();
+    }
-    /* Catch the case when a and b are the same objects in memory.           */
-    /* As of FLINT version 1.5.1, there is a bug in this case.               */
-    if (a == b)
+    {
-        fmpq_poly_set_si(q, 1);
-        fmpq_poly_set_si(r, 0);
-        return;
+    }
-    /* Deal with the various other cases of aliasing.                        */
-    if (r == a | r == b)
+    {
-        if (q == a | q == b)
+        {
-            fmpq_poly_t tempq, tempr;
-            fmpq_poly_init(tempq);
-            fmpq_poly_init(tempr);
-            fmpq_poly_divrem(tempq, tempr, a, b);
-            fmpq_poly_swap(q, tempq);
-            fmpq_poly_swap(r, tempr);
-            fmpq_poly_clear(tempq);
-            fmpq_poly_clear(tempr);
-            return;
+        }
-        else
+        {
-            fmpq_poly_t tempr;
-            fmpq_poly_init(tempr);
-            fmpq_poly_divrem(q, tempr, a, b);
-            fmpq_poly_swap(r, tempr);
-            fmpq_poly_clear(tempr);
-            return;
+        }
+    }
-    else
+    {
-        if (q == a | q == b)
+        {
-            fmpq_poly_t tempq;
-            fmpq_poly_init(tempq);
-            fmpq_poly_divrem(tempq, r, a, b);
-            fmpq_poly_swap(q, tempq);
-            fmpq_poly_clear(tempq);
-            return;
+        }
+    }
-    // TODO: Implement the case `\deg(b) = 0` more efficiently!
-    /* General case..                                                        */
-    /* Set q to b->den q->num / (a->den lead^m)                              */
-    /* and r to r->num / (a->den lead^m).                                    */
-    fmpz_poly_pseudo_divrem(q->num, r->num, &m, a->num, b->num);
-    lead = fmpz_poly_lead(b->num);
-    if (!fmpz_is_one(b->den))
-        fmpz_poly_scalar_mul_fmpz(q->num, q->num, b->den);
-    /* Case 1.  lead^m is 1 */
-    if (fmpz_is_one(lead) || m == 0ul || (fmpz_is_m1(lead) & m % 2 == 0))
+    {
-        q->den = fmpz_realloc(q->den, fmpz_size(a->den));
-        fmpz_set(q->den, a->den);
+    }
-    /* Case 2.  lead^m is -1 */
-    else if (fmpz_is_m1(lead) & m % 2)
+    {
-        fmpz_poly_neg(q->num, q->num);
-        q->den = fmpz_realloc(q->den, fmpz_size(a->den));
-        fmpz_set(q->den, a->den);
-        fmpz_poly_neg(r->num, r->num);
+    }
-    /* Case 3.  lead^m is not +-1 */
-    else
+    {
-        ulong limbs;
-        limbs = m * fmpz_size(lead);
-        if (fmpz_is_one(a->den))
+        {
-            q->den = fmpz_realloc(q->den, limbs);
-            fmpz_pow_ui(q->den, lead, m);
+        }
-        else
+        {
-            fmpz_t t;
-            t = fmpz_init(limbs);
-            q->den = fmpz_realloc(q->den, limbs + fmpz_size(a->den));
-            fmpz_pow_ui(t, lead, m);
-            fmpz_mul(q->den, t, a->den);
-            fmpz_clear(t);
+        }
+    }
-    r->den = fmpz_realloc(r->den, fmpz_size(q->den));
-    fmpz_set(r->den, q->den);
-    fmpq_poly_canonicalize(q, NULL);
-    fmpq_poly_canonicalize(r, NULL);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Powering
-/**
- * \ingroup  Powering
+ *
- * Sets \c rop to the <tt>exp</tt>th power of \c op.
+ *
- * The corner case of <tt>exp == 0</tt> is handled by setting \c rop to the
- * constant function \f$1\f$.  Note that this includes the case \f$0^0 = 1\f$.
- */
-void fmpq_poly_power(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong exp)
+{
-    if (exp == 0ul)
+    {
-        fmpq_poly_one(rop);
+    }
-    else
+    {
-        fmpz_poly_power(rop->num, op->num, exp);
-        if (fmpz_is_one(op->den))
+        {
-            fmpz_set_ui(rop->den, 1);
+        }
-        else
+        {
-            if (rop == op)
+            {
-                fmpz_t t;
-                t = fmpz_init(exp * fmpz_size(op->den));
-                fmpz_pow_ui(t, op->den, exp);
-                fmpz_clear(rop->den);  // FIXME  Fixed
-                rop->den = t;
+            }
-            else
+            {
-                rop->den = fmpz_realloc(rop->den, exp * fmpz_size(op->den));
-                fmpz_pow_ui(rop->den, op->den, exp);
+            }
+        }
+    }
+}
-///////////////////////////////////////////////////////////////////////////////
-// Greatest common divisor
-/**
- * \ingroup  GCD
+ *
- * Returns the (monic) greatest common divisor \c res of \c a and \c b.
+ *
- * Corner cases:  If \c a and \c b are both zero, returns zero.  If only
- * one of them is zero, returns the other polynomial, up to normalisation.
- */
-void fmpq_poly_gcd(fmpq_poly_ptr rop, const fmpq_poly_ptr a, const fmpq_poly_ptr b)
+{
-    fmpz_t lead;
-    fmpz_poly_t num;
-    /* Deal with aliasing */
-    if (rop == a | rop == b)
+    {
-        fmpq_poly_t tpoly;
-        fmpq_poly_init(tpoly);
-        fmpq_poly_gcd(tpoly, a, b);
-        fmpq_poly_swap(rop, tpoly);
-        fmpq_poly_clear(tpoly);
-        return;
+    }
-    /* Deal with corner cases */
-    if (fmpq_poly_is_zero(a))
+    {
-        if (fmpq_poly_is_zero(b))  /* a == b == 0 */
-            fmpq_poly_zero(rop);
-        else                       /* a == 0, b != 0 */
-            fmpq_poly_monic(rop, b);
-        return;
+    }
-    else
+    {
-        if (fmpq_poly_is_zero(b))  /* a != 0, b == 0 */
+        {
-            fmpq_poly_monic(rop, a);
-            return;
+        }
+    }
-    /* General case.. */
-    fmpz_poly_init(num);
-    fmpz_poly_primitive_part(rop->num, a->num);
-    fmpz_poly_primitive_part(num, b->num);
-    /* Since rop.num is the greatest common divisor of the primitive parts   */
-    /* of a.num and b.num, it is also primitive.  But as of FLINT 1.4.0, the */
-    /* leading term *might* be negative.                                     */
-    fmpz_poly_gcd(rop->num, rop->num, num);
-    lead = fmpz_poly_lead(rop->num);
-    rop->den = fmpz_realloc(rop->den, fmpz_size(lead));
-    if (fmpz_sgn(lead) < 0)
+    {
-        fmpz_poly_neg(rop->num, rop->num);
-        fmpz_neg(rop->den, lead);
+    }
-    else
-        fmpz_set(rop->den, lead);
-    fmpz_poly_clear(num);
+}
-/**
- * \ingroup  GCD
+ *
- * Returns polynomials \c s, \c t and \c rop such that \c rop is
- * (monic) greatest common divisor of \c a and \c b, and such that
- * <tt>rop = s a + t b</tt>.
+ *
- * Corner cases:  If \c a and \c b are zero, returns zero polynomials.
- * Otherwise, if only \c a is zero, returns <tt>(res, s, t) = (b, 0, 1)</tt>
- * up to normalisation, and similarly if only \c b is zero.
+ *
- * Assumes that the output parameters \c rop, \c s, and \c t refer to
- * distinct objects in memory.  Otherwise, an exception is raised in the
- * form of an <tt>abort</tt> statement.
- */
-void fmpq_poly_xgcd(fmpq_poly_ptr rop, fmpq_poly_ptr s, fmpq_poly_ptr t, const fmpq_poly_ptr a, const fmpq_poly_ptr b)
+{
-    fmpz_t lead, temp;
-    ulong bound, limbs;
-    /* Assertion! */
-    if (rop == s | rop == t | s == t)
+    {
-        printf("ERROR (fmpq_poly_xgcd).  Output arguments aliased.\n");
-        abort();
+    }
-    /* Deal with aliasing */
-    if (rop == a | rop == b)
+    {
-        if (s == a | s == b)
+        {
-            /* We know that t does not coincide with a or b, since otherwise */
-            /* two of rop, s, and t coincide, too.                           */
-            fmpq_poly_t tempg, temps;
-            fmpq_poly_init(tempg);
-            fmpq_poly_init(temps);
-            fmpq_poly_xgcd(tempg, temps, t, a, b);
-            fmpq_poly_swap(rop, tempg);
-            fmpq_poly_swap(s, temps);
-            fmpq_poly_clear(tempg);
-            fmpq_poly_clear(temps);
-            return;
+        }
-        else
+        {
-            if (t == a | t == b)
+            {
-                fmpq_poly_t tempg, tempt;
-                fmpq_poly_init(tempg);
-                fmpq_poly_init(tempt);
-                fmpq_poly_xgcd(tempg, s, tempt, a, b);
-                fmpq_poly_swap(rop, tempg);
-                fmpq_poly_swap(t, tempt);
-                fmpq_poly_clear(tempg);
-                fmpq_poly_clear(tempt);
-                return;
+            }
-            else
+            {
-                fmpq_poly_t tempg;
-                fmpq_poly_init(tempg);
-                fmpq_poly_xgcd(tempg, s, t, a, b);
-                fmpq_poly_swap(rop, tempg);
-                fmpq_poly_clear(tempg);
-                return;
+            }
+        }
+    }
-    else
+    {
-        if (s == a | s == b)
+        {
-            if (t == a | t == b)
+            {
-                fmpq_poly_t temps, tempt;
-                fmpq_poly_init(temps);
-                fmpq_poly_init(tempt);
-                fmpq_poly_xgcd(rop, temps, tempt, a, b);
-                fmpq_poly_swap(s, temps);
-                fmpq_poly_swap(t, tempt);
-                fmpq_poly_clear(temps);
-                fmpq_poly_clear(tempt);
-                return;
+            }
-            else
+            {
-                fmpq_poly_t temps;
-                fmpq_poly_init(temps);
-                fmpq_poly_xgcd(rop, temps, t, a, b);
-                fmpq_poly_swap(s, temps);
-                fmpq_poly_clear(temps);
-                return;
+            }
+        }
-        else
+        {
-            if (t == a | t == b)
+            {
-                fmpq_poly_t tempt;
-                fmpq_poly_init(tempt);
-                fmpq_poly_xgcd(rop, s, tempt, a, b);
-                fmpq_poly_swap(t, tempt);
-                fmpq_poly_clear(tempt);
-                return;
+            }
+        }
+    }
-    /* From here on, we may assume that none of the output variables are */
-    /* aliases for the input variables.                                  */
-    /* Deal with the following three corner cases: */
-    /*   a == 0, b == 0                            */
-    /*   a == 0, b =! 0                            */
-    /*   a != 0, b == 0                            */
-    if (fmpq_poly_is_zero(a))
+    {
-        if (fmpq_poly_is_zero(b))  /* Case 1.  a == b == 0 */
+        {
-            fmpq_poly_zero(rop);
-            fmpq_poly_zero(s);
-            fmpq_poly_zero(t);
-            return;
+        }
-        else  /* Case 2.  a == 0, b != 0 */
+        {
-            fmpz_t blead = fmpz_poly_lead(b->num);
-            fmpq_poly_monic(rop, b);
-            fmpq_poly_zero(s);
-            fmpz_poly_zero(t->num);
-            fmpz_poly_set_coeff_fmpz(t->num, 0, b->den);
-            if (fmpz_is_one(blead))
-                fmpz_set_ui(t->den, 1);
-            else
+            {
-                fmpz_t g;
-                g = fmpz_init(FLINT_MAX(b->num->limbs, fmpz_size(b->den)));
-                fmpz_gcd(g, blead, b->den);
-                if (fmpz_sgn(g) != fmpz_sgn(blead))
-                    fmpz_neg(g, g);
-                fmpz_poly_scalar_div_fmpz(t->num, t->num, g);
-                t->den = fmpz_realloc(t->den, fmpz_size(blead));
-                fmpz_divides(t->den, blead, g);
-                fmpz_clear(g);
+            }
-            return;
+        }
+    }
-    else
+    {
-        if (fmpq_poly_is_zero(b))  /* Case 3.  a != 0, b == 0 */
+        {
-            fmpq_poly_xgcd(rop, t, s, b, a);
-            return;
+        }
+    }
-    /* We are now in the general case where a and b are non-zero. */
-    s->den = fmpz_realloc(s->den, a->num->limbs);
-    t->den = fmpz_realloc(t->den, b->num->limbs);
-    fmpz_poly_content(s->den, a->num);
-    fmpz_poly_content(t->den, b->num);
-    fmpz_poly_scalar_div_fmpz(s->num, a->num, s->den);
-    fmpz_poly_scalar_div_fmpz(t->num, b->num, t->den);
-    /* Note that, since s->num and t->num are primitive, rop->num is         */
-    /* primitive, too.  In fact, it is the rational greatest common divisor  */
-    /* of a and b.  As of FLINT 1.4.0, the leading coefficient of res.num    */
-    /* *might* be negative.                                                  */
-    fmpz_poly_gcd(rop->num, s->num, t->num);
-    if (fmpz_sgn(fmpz_poly_lead(rop->num)) < 0)
-        fmpz_poly_neg(rop->num, rop->num);
-    lead = fmpz_poly_lead(rop->num);
-    /* Now rop->num is a (primitive) rational greatest common divisor of */
-    /* a and b.                                                          */
-    if (fmpz_poly_degree(rop->num) > 0)
+    {
-        fmpz_poly_div(s->num, s->num, rop->num);
-        fmpz_poly_div(t->num, t->num, rop->num);
+    }
-    bound = fmpz_poly_resultant_bound(s->num, t->num);
-    if (fmpz_is_one(lead))
-        bound = bound / FLINT_BITS + 2;
-    else
-        bound = FLINT_MAX(bound / FLINT_BITS + 2, fmpz_size(lead));
-    rop->den = fmpz_realloc(rop->den, bound);
-    fmpz_poly_xgcd(rop->den, s->num, t->num, s->num, t->num);
-    /* Now the following equation holds:                                     */
-    /*   rop->den rop->num ==                                                */
-    /*             (s->num a->den / s->den) a +  (t->num b->den / t->den) b. */
-    limbs = FLINT_MAX(s->num->limbs, t->num->limbs);
-    limbs = FLINT_MAX(limbs, fmpz_size(s->den));
-    limbs = FLINT_MAX(limbs, fmpz_size(t->den) + fmpz_size(rop->den) + fmpz_size(lead));
-    temp = fmpz_init(limbs);
-    s->den = fmpz_realloc(s->den, fmpz_size(s->den) + fmpz_size(rop->den)
-                                                    + fmpz_size(lead));
-    if (!fmpz_is_one(a->den))
-        fmpz_poly_scalar_mul_fmpz(s->num, s->num, a->den);
-    fmpz_mul(temp, s->den, rop->den);
-    fmpz_mul(s->den, temp, lead);
-    t->den = fmpz_realloc(t->den, fmpz_size(t->den) + fmpz_size(rop->den)
-                                                    + fmpz_size(lead));
-    if (!fmpz_is_one(b->den))
-        fmpz_poly_scalar_mul_fmpz(t->num, t->num, b->den);
-    fmpz_mul(temp, t->den, rop->den);
-    fmpz_mul(t->den, temp, lead);
-    fmpq_poly_canonicalize(s, temp);
-    fmpq_poly_canonicalize(t, temp);
-    fmpz_set(rop->den, lead);
-    fmpz_clear(temp);
+}
-/**
- * \ingroup  GCD
+ *
- * Computes the monic (or zero) least common multiple of \c a and \c b.
+ *
- * If either of \c a and \c b is zero, returns zero.  This behaviour ensures
- * that the relation
- * \f[
- * \text{lcm}(a,b) \gcd(a,b) \sim a b
- * \f]
- * holds, where \f$\sim\f$ denotes equality up to units.
- */
-void fmpq_poly_lcm(fmpq_poly_ptr rop, const fmpq_poly_ptr a, const fmpq_poly_ptr b)
+{
-    /* Handle aliasing */
-    if (rop == a | rop == b)
+    {
-        fmpq_poly_t tpoly;
-        fmpq_poly_init(tpoly);
-        fmpq_poly_lcm(tpoly, a, b);
-        fmpq_poly_swap(rop, tpoly);
-        fmpq_poly_clear(tpoly);
-        return;
+    }
-    if (fmpq_poly_is_zero(a))
-        fmpq_poly_zero(rop);
-    else if (fmpq_poly_is_zero(b))
-        fmpq_poly_zero(rop);
-    else
+    {
-        fmpz_poly_t prod;
-        fmpz_t lead;
-        fmpz_poly_init(prod);
-        fmpq_poly_gcd(rop, a, b);
-        fmpz_poly_mul(prod, a->num, b->num);
-        fmpz_poly_primitive_part(prod, prod);
-        fmpz_poly_div(rop->num, prod, rop->num);
-        /* Note that GCD returns a monic rop and so a primitive rop.num.   */
-        /* Dividing the primitive prod by this yields a primitive quotient */
-        /* rop->num.                                                       */
-        lead = fmpz_poly_lead(rop->num);
-        rop->den = fmpz_realloc(rop->den, fmpz_size(lead));
-        if (fmpz_sgn(lead) < 0)
-            fmpz_poly_neg(rop->num, rop->num);
-        fmpz_set(rop->den, fmpz_poly_lead(rop->num));
-        fmpz_poly_clear(prod);
+    }
+}
-///////////////////////////////////////////////////////////////////////////////
-// Derivative
-/**
- * \ingroup  Derivative
+ *
- * Sets \c rop to the derivative of \c op.
+ *
- * \todo  The second argument should be declared \c const, but as of
- *        FLINT 1.5.0 this generates a compile-time warning.
- */
-void fmpq_poly_derivative(fmpq_poly_ptr rop, fmpq_poly_ptr op)
+{
-    if (fmpq_poly_length(op) < 2ul)
-        fmpq_poly_zero(rop);
-    else
+    {
-        fmpz_poly_derivative(rop->num, op->num);
-        rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-        fmpz_set(rop->den, op->den);
-        fmpq_poly_canonicalize(rop, NULL);
+    }
+}
-///////////////////////////////////////////////////////////////////////////////
-// Evaluation
-/**
- * \ingroup  Evaluation
+ *
- * Evaluates the integer polynomial \c f at the rational \c a using Horner's
- * method.
- */
-void _fmpz_poly_evaluate_mpq_horner(mpq_t rop, const fmpz_poly_t f, const mpq_t a)
+{
-    mpq_t temp;
-    ulong n;
-    /* Handle aliasing */
-    if (rop == a)
+    {
-        mpq_t tempr;
-        mpq_init(tempr);
-        _fmpz_poly_evaluate_mpq_horner(tempr, f, a);
-        mpq_swap(rop, tempr);
-        mpq_clear(tempr);
-        return;
+    }
-    n = fmpz_poly_length(f);
-    if (n == 0ul)
+    {
-        mpq_set_ui(rop, 0, 1);
+    }
-    else if (n == 1ul)
+    {
-        fmpz_poly_get_coeff_mpz(mpq_numref(rop), f, 0);
-        mpz_set_ui(mpq_denref(rop), 1);
+    }
-    else
+    {
-        n--;
-        fmpz_poly_get_coeff_mpz(mpq_numref(rop), f, n);
-        mpz_set_ui(mpq_denref(rop), 1);
-        mpq_init(temp);
-        do {
-            n--;
-            mpq_mul(temp, rop, a);
-            fmpz_poly_get_coeff_mpz(mpq_numref(rop), f, n);
-            mpz_set_ui(mpq_denref(rop), 1);
-            mpq_add(rop, rop, temp);
-        } while (n);
-        mpq_clear(temp);
+    }
+}
-/**
- * \ingroup  Evaluation
+ *
- * Evaluates the rational polynomial \c f at the integer \c a.
+ *
- * Assumes that the numerator and denominator of the <tt>mpq_t</tt>
- * \c rop are distinct (as objects in memory) from the <tt>mpz_t</tt>
- * \c a.
- */
-void fmpq_poly_evaluate_mpz(mpq_t rop, fmpq_poly_ptr f, const mpz_t a)
+{
-    fmpz_t num, t;
-    ulong limbs, max;
-    if (fmpq_poly_is_zero(f))
+    {
-        mpq_set_ui(rop, 0, 1);
-        return;
+    }
-    /* Establish a bound on the size of f->num evaluated at a */
-    max = (f->num->length) * (f->num->limbs + f->num->length * mpz_size(a));
-    /* Compute the result */
-    num = fmpz_init(max);
-    t   = fmpz_init(mpz_size(a));
-    mpz_to_fmpz(t, a);
-    fmpz_poly_evaluate(num, f->num, t);
-    fmpz_to_mpz(mpq_numref(rop), num);
-    if (fmpz_is_one(f->den))
+    {
-        mpz_set_ui(mpq_denref(rop), 1);
+    }
-    else
+    {
-        fmpz_to_mpz(mpq_denref(rop), f->den);
-        mpq_canonicalize(rop);
+    }
-    fmpz_clear(num);
-    fmpz_clear(t);
+}
-/**
- * \ingroup  Evaluation
+ *
- * Evaluates the rational polynomial \c f at the rational \c a.
- */
-void fmpq_poly_evaluate_mpq(mpq_t rop, fmpq_poly_ptr f, const mpq_t a)
+{
-    if (rop == a)
+    {
-        mpq_t tempr;
-        mpq_init(tempr);
-        fmpq_poly_evaluate_mpq(tempr, f, a);
-        mpq_swap(rop, tempr);
-        mpq_clear(tempr);
-        return;
+    }
-    _fmpz_poly_evaluate_mpq_horner(rop, f->num, a);
-    if (!fmpz_is_one(f->den))
+    {
-        mpz_t den;
-        mpz_init(den);
-        fmpz_to_mpz(den, f->den);
-        mpz_mul(mpq_denref(rop), mpq_denref(rop), den);
-        mpq_canonicalize(rop);
-        mpz_clear(den);
+    }
+}
-///////////////////////////////////////////////////////////////////////////////
-// Gaussian content
-/**
- * \ingroup  Content
+ *
- * Returns the non-negative content of \c op.
+ *
- * The content of \f$0\f$ is defined to be \f$0\f$.
- */
-void fmpq_poly_content(mpq_t rop, const fmpq_poly_ptr op)
+{
-    fmpz_t numc;
-    numc = fmpz_init(op->num->limbs);
-    fmpz_poly_content(numc, op->num);
-    fmpz_abs(numc, numc);
-    fmpz_to_mpz(mpq_numref(rop), numc);
-    if (fmpz_is_one(op->den))
-        mpz_set_ui(mpq_denref(rop), 1);
-    else
-        fmpz_to_mpz(mpq_denref(rop), op->den);
-    fmpz_clear(numc);
+}
-/**
- * \ingroup  Content
+ *
- * Returns the primitive part (with non-negative leading coefficient) of
- * \c op as an element of type #fmpq_poly_t.
- */
-void fmpq_poly_primitive_part(fmpq_poly_ptr rop, const fmpq_poly_ptr op)
+{
-    if (fmpq_poly_is_zero(op))
-        fmpq_poly_zero(rop);
-    else
+    {
-        fmpz_poly_primitive_part(rop->num, op->num);
-        if (fmpz_sgn(fmpz_poly_lead(rop->num)) < 0)
-            fmpz_poly_neg(rop->num, rop->num);
-        fmpz_set_ui(rop->den, 1);
+    }
+}
-/**
- * \brief    Returns whether \c op is monic.
- * \ingroup  Content
+ *
- * Returns whether \c op is monic.
+ *
- * By definition, the zero polynomial is \e not monic.
- */
-int fmpq_poly_is_monic(const fmpq_poly_ptr op)
+{
-    fmpz_t lead;
-    if (fmpq_poly_is_zero(op))
-        return 0;
-    else
+    {
-        lead = fmpz_poly_lead(op->num);
-        if (fmpz_is_one(op->den))
-            return fmpz_is_one(lead);
-        else
-            return (fmpz_sgn(lead) > 0) && (fmpz_cmpabs(lead, op->den) == 0);
+    }
+}
-/**
- * Sets \c rop to the unique monic scalar multiple of \c op.
+ *
- * As the only special case, if \c op is the zero polynomial, \c rop is set
- * to zero, too.
- */
-void fmpq_poly_monic(fmpq_poly_ptr rop, const fmpq_poly_ptr op)
+{
-    fmpz_t lead;
-    if (fmpq_poly_is_zero(op))
+    {
-        fmpq_poly_zero(rop);
-        return;
+    }
-    fmpz_poly_primitive_part(rop->num, op->num);
-    lead = fmpz_poly_lead(rop->num);
-    rop->den = fmpz_realloc(rop->den, fmpz_size(lead));
-    if (fmpz_sgn(lead) < 0)
-        fmpz_poly_neg(rop->num, rop->num);
-    fmpz_set(rop->den, fmpz_poly_lead(rop->num));
+}
-///////////////////////////////////////////////////////////////////////////////
-// Resultant
-/**
- * \brief    Returns the resultant of \c a and \c b.
- * \ingroup  Resultant
+ *
- * Returns the resultant of \c a and \c b.
+ *
- * Enumerating the roots of \c a and \c b over \f$\bar{\mathbf{Q}}\f$ as
- * \f$r_1, \dotsc, r_m\f$ and \f$s_1, \dotsc, s_n\f$, respectively, and
- * letting \f$x\f$ and \f$y\f$ denote the leading coefficients, the resultant
- * is defined as
- * \f[
- * x^{\deg(b)} y^{\deg(a)} \prod_{1 \leq i, j \leq n} (r_i - s_j).
- * \f]
+ *
- * We handle special cases as follows:  if one of the polynomials is zero,
- * the resultant is zero.  Note that otherwise if one of the polynomials is
- * constant, the last term in the above expression is the empty product.
- */
-void fmpq_poly_resultant(mpq_t rop, const fmpq_poly_ptr a, const fmpq_poly_ptr b)
+{
-    fmpz_t rest, t1, t2;
-    fmpz_poly_t anum, bnum;
-    fmpz_t acont, bcont;
-    long d1, d2;
-    ulong bound, denbound, numbound;
-    fmpz_poly_t g;
-    d1 = fmpq_poly_degree(a);
-    d2 = fmpq_poly_degree(b);
-    /* We first handle special cases. */
-    if (d1 < 0l | d2 < 0l)
+    {
-        mpq_set_ui(rop, 0, 1);
-        return;
+    }
-    if (d1 == 0l)
+    {
-        if (d2 == 0l)
-            mpq_set_ui(rop, 1, 1);
-        else if (d2 == 1l)
+        {
-            fmpz_to_mpz(mpq_numref(rop), fmpz_poly_lead(a->num));
-            fmpz_to_mpz(mpq_denref(rop), a->den);
+        }
-        else
+        {
-            if (fmpz_is_one(a->den))
-                bound = a->num->limbs;
-            else
-                bound = FLINT_MAX(a->num->limbs, fmpz_size(a->den));
-            t1 = fmpz_init(d2 * bound);
-            fmpz_pow_ui(t1, fmpz_poly_lead(a->num), d2);
-            fmpz_to_mpz(mpq_numref(rop), t1);
-            if (fmpz_is_one(a->den))
-                mpz_set_ui(mpq_denref(rop), 1);
-            else
+            {
-                fmpz_pow_ui(t1, a->den, d2);
-                fmpz_to_mpz(mpq_denref(rop), t1);
+            }
-            fmpz_clear(t1);
+        }
-        return;
+    }
-    if (d2 == 0l)
+    {
-        fmpq_poly_resultant(rop, b, a);
-        return;
+    }
-    /* We are now in the general case, with both polynomials of degree at */
-    /* least 1.                                                           */
-    /* We set a->num =: acont anum with acont > 0 and anum primitive. */
-    acont = fmpz_init(a->num->limbs);
-    fmpz_poly_content(acont, a->num);
-    fmpz_abs(acont, acont);
-    fmpz_poly_init(anum);
-    fmpz_poly_scalar_div_fmpz(anum, a->num, acont);
-    /* We set b->num =: bcont bnum with bcont > 0 and bnum primitive. */
-    bcont = fmpz_init(b->num->limbs);
-    fmpz_poly_content(bcont, b->num);
-    fmpz_abs(bcont, bcont);
-    fmpz_poly_init(bnum);
-    fmpz_poly_scalar_div_fmpz(bnum, b->num, bcont);
-    fmpz_poly_init(g);
-    fmpz_poly_gcd(g, anum, bnum);
-    /* If the gcd has positive degree, the resultant is zero. */
-    if (fmpz_poly_degree(g) > 0)
+    {
-        mpq_set_ui(rop, 0, 1);
-        /* Clean up */
-        fmpz_clear(acont);
-        fmpz_clear(bcont);
-        fmpz_poly_clear(anum);
-        fmpz_poly_clear(bnum);
-        fmpz_poly_clear(g);
-        return;
+    }
-    /* Set some bounds */
-    if (fmpz_is_one(a->den))
+    {
-        if (fmpz_is_one(b->den))
+        {
-            numbound = FLINT_MAX(d2 * fmpz_size(acont), d1 * fmpz_size(bcont));
-            denbound = 1;
+        }
-        else
+        {
-            numbound = FLINT_MAX(d2 * fmpz_size(acont), d1 * fmpz_size(bcont));
-            denbound = d1 * fmpz_size(b->den);
+        }
+    }
-    else
+    {
-        if (fmpz_is_one(b->den))
+        {
-            numbound = FLINT_MAX(d2 * fmpz_size(acont), d1 * fmpz_size(bcont));
-            denbound = d2 * fmpz_size(a->den);
+        }
-        else
+        {
-            numbound = FLINT_MAX(d2 * fmpz_size(acont), d1 * fmpz_size(bcont));
-            denbound = FLINT_MAX(d2 * fmpz_size(a->den), d1 * fmpz_size(b->den));
+        }
+    }
-    /* Now anum and bnum are coprime and we compute their resultant using */
-    /* the method from the fmpz_poly module.                              */
-    bound = fmpz_poly_resultant_bound(anum, bnum);
-    bound = bound/FLINT_BITS + 2 + d2 * fmpz_size(acont)
-        + d1 * fmpz_size(bcont);
-    rest = fmpz_init(FLINT_MAX(bound, denbound));
-    fmpz_poly_resultant(rest, anum, bnum);
-    /* Finally, w take into account the factors acont/a.den and bcont/b.den. */
-    t1 = fmpz_init(FLINT_MAX(bound, denbound));
-    t2 = fmpz_init(FLINT_MAX(numbound, denbound));
-    if (!fmpz_is_one(acont))
+    {
-        fmpz_pow_ui(t2, acont, d2);
-        fmpz_set(t1, rest);
-        fmpz_mul(rest, t1, t2);
+    }
-    if (!fmpz_is_one(bcont))
+    {
-        fmpz_pow_ui(t2, bcont, d1);
-        fmpz_set(t1, rest);
-        fmpz_mul(rest, t1, t2);
+    }
-    fmpz_to_mpz(mpq_numref(rop), rest);
-    if (fmpz_is_one(a->den))
+    {
-        if (fmpz_is_one(b->den))
-            fmpz_set_ui(rest, 1);
-        else
-            fmpz_pow_ui(rest, b->den, d1);
+    }
-    else
+    {
-        if (fmpz_is_one(b->den))
-            fmpz_pow_ui(rest, a->den, d2);
-        else
+        {
-            fmpz_pow_ui(t1, a->den, d2);
-            fmpz_pow_ui(t2, b->den, d1);
-            fmpz_mul(rest, t1, t2);
+        }
+    }
-    fmpz_to_mpz(mpq_denref(rop), rest);
-    mpq_canonicalize(rop);
-    /* Clean up */
-    fmpz_clear(rest);
-    fmpz_clear(t1);
-    fmpz_clear(t2);
-    fmpz_poly_clear(anum);
-    fmpz_poly_clear(bnum);
-    fmpz_clear(acont);
-    fmpz_clear(bcont);
-    fmpz_poly_clear(g);
+}
-/**
- * \brief    Computes the discriminant of \c a.
- * \ingroup  Discriminant
+ *
- * Computes the discriminant of the polynomial \f$a\f$.
+ *
- * The discriminant \f$R_n\f$ is defined as
- * \f[
- * R_n = a_n^{2 n-2} \prod_{1 \le i < j \le n} (r_i - r_j)^2,
- * \f]
- * where \f$n\f$ is the degree of this polynomial, \f$a_n\f$ is the leading
- * coefficient and \f$r_1, \ldots, r_n\f$ are the roots over
- * \f$\bar{\mathbf{Q}}\f$ are.
+ *
- * The discriminant of constant polynomials is defined to be \f$0\f$.
+ *
- * This implementation uses the identity
- * \f[
- * R_n(f) := (-1)^(n (n-1)/2) R(f,f') / a_n,
- * \f]
- * where \f$n\f$ is the degree of this polynomial, \f$a_n\f$ is the leading
- * coefficient and \f$f'\f$ is the derivative of \f$f\f$.
+ *
- * \see  #fmpq_poly_resultant()
- */
-void fmpq_poly_discriminant(mpq_t disc, fmpq_poly_t a)
+{
-    fmpq_poly_t der;
-    mpq_t t;
-    long n;
-    n = fmpq_poly_degree(a);
-    if (n < 1L)
+    {
-        mpq_set_ui(disc, 0, 1);
-        return;
+    }
-    fmpq_poly_init(der);
-    fmpq_poly_derivative(der, a);
-    fmpq_poly_resultant(disc, a, der);
-    mpq_init(t);
-    fmpz_to_mpz(mpq_numref(t), a->den);
-    fmpz_to_mpz(mpq_denref(t), fmpz_poly_lead(a->num));
-    mpq_canonicalize(t);
-    mpq_mul(disc, disc, t);
-    if (n % 4 > 1)
-        mpz_neg(mpq_numref(disc), mpq_numref(disc));
-    fmpq_poly_clear(der);
-    mpq_clear(t);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Composition
-/**
- * \brief    Returns the composition of \c a and \c b.
- * \ingroup  Composition
+ *
- * Returns the composition of \c a and \c b.
+ *
- * To be clear about the order of the composition, denoting the polynomials
- * \f$a(T)\f$ and \f$b(T)\f$, returns the polynomial \f$a(b(T))\f$.
- */
-void fmpq_poly_compose(fmpq_poly_ptr rop, const fmpq_poly_ptr a, const fmpq_poly_ptr b)
+{
-    mpq_t x;            /* Rational to hold the inverse of b->den */
-    if (fmpz_is_one(b->den))
+    {
-        fmpz_poly_compose(rop->num, a->num, b->num);
-        rop->den = fmpz_realloc(rop->den, fmpz_size(a->den));
-        fmpz_set(rop->den, a->den);
-        fmpq_poly_canonicalize(rop, NULL);
-        return;
+    }
-    /* Aliasing.                                                            */
-    /*                                                                      */
-    /* Note that rop and a, as well as a and b may be aliased, but rop and  */
-    /* b may not be aliased.                                                */
-    if (rop == b)
+    {
-        fmpq_poly_t tempr;
-        fmpq_poly_init(tempr);
-        fmpq_poly_compose(tempr, a, b);
-        fmpq_poly_swap(rop, tempr);
-        fmpq_poly_clear(tempr);
-        return;
+    }
-    /* Set x = 1/b.den, and note this is already in canonical form. */
-    mpq_init(x);
-    mpz_set_ui(mpq_numref(x), 1);
-    fmpz_to_mpz(mpq_denref(x), b->den);
-    /* First set rop = a(T / b.den) and then use FLINT's composition to */
-    /* set rop->num = rop->num(b->num).                                 */
-    fmpq_poly_rescale(rop, a, x);
-    fmpz_poly_compose(rop->num, rop->num, b->num);
-    fmpq_poly_canonicalize(rop, NULL);
-    mpq_clear(x);
+}
-/**
- * \brief    Rescales the co-ordinate.
- * \ingroup  Composition
+ *
- * Denoting this polynomial \f$a(T)\f$, computes the polynomial \f$a(x T)\f$.
- */
-void fmpq_poly_rescale(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpq_t x)
+{
-    ulong numsize, densize;
-    ulong limbs;
-    fmpz_t num, den;
-    fmpz_t coeff, power, t;
-    long i, n;
-    fmpq_poly_set(rop, op);
-    if (fmpq_poly_length(rop) < 2ul)
-        return;
-    num = fmpz_init(mpz_size(mpq_numref(x)));
-    den = fmpz_init(mpz_size(mpq_denref(x)));
-    mpz_to_fmpz(num, mpq_numref(x));
-    mpz_to_fmpz(den, mpq_denref(x));
-    numsize = fmpz_size(num);
-    densize = fmpz_size(den);
-    n = fmpz_poly_degree(rop->num);
-    if (fmpz_is_one(den))
+    {
-        coeff = fmpz_init(rop->num->limbs + n * numsize);
-        power = fmpz_init(n * numsize);
-        t = fmpz_init(rop->num->limbs + n * numsize);
-        fmpz_set(power, num);
-        fmpz_poly_get_coeff_fmpz(t, rop->num, 1);
-        fmpz_mul(coeff, t, power);
-        fmpz_poly_set_coeff_fmpz(rop->num, 1, coeff);
-        for (i = 2; i <= n; i++)
+        {
-            fmpz_set(t, power);
-            fmpz_mul(power, t, num);
-            fmpz_poly_get_coeff_fmpz(t, rop->num, i);
-            fmpz_mul(coeff, t, power);
-            fmpz_poly_set_coeff_fmpz(rop->num, i, coeff);
+        }
+    }
-    else
+    {
-        coeff = fmpz_init(rop->num->limbs + n * (numsize + densize));
-        power = fmpz_init(n * (numsize + densize));
-        limbs = rop->num->limbs + n * (numsize + densize);
-        limbs = FLINT_MAX(limbs, fmpz_size(rop->den));
-        t = fmpz_init(limbs);
-        fmpz_pow_ui(power, den, n);
-        if (fmpz_is_one(rop->den))
+        {
-            rop->den = fmpz_realloc(rop->den, n * densize);
-            fmpz_set(rop->den, power);
+        }
-        else
+        {
-            fmpz_set(t, rop->den);
-            limbs = n * densize + fmpz_size(rop->den);
-            rop->den = fmpz_realloc(rop->den, limbs);
-            fmpz_mul(rop->den, power, t);
+        }
-        fmpz_set_ui(power, 1);
-        for (i = n - 1; i >= 0; i--)
+        {
-            fmpz_set(t, power);
-            fmpz_mul(power, t, den);
-            fmpz_poly_get_coeff_fmpz(t, rop->num, i);
-            fmpz_mul(coeff, t, power);
-            fmpz_poly_set_coeff_fmpz(rop->num, i, coeff);
+        }
-        fmpz_set_ui(power, 1);
-        for (i = 1; i <= n; i++)
+        {
-            fmpz_set(t, power);
-            fmpz_mul(power, t, num);
-            fmpz_poly_get_coeff_fmpz(t, rop->num, i);
-            fmpz_mul(coeff, t, power);
-            fmpz_poly_set_coeff_fmpz(rop->num, i, coeff);
+        }
+    }
-    fmpq_poly_canonicalize(rop, NULL);
-    fmpz_clear(num);
-    fmpz_clear(den);
-    fmpz_clear(coeff);
-    fmpz_clear(power);
-    fmpz_clear(t);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Square-free
-/**
- * \brief    Returns whether \c op is squarefree.
- * \ingroup  Squarefree
+ *
- * Returns whether \c op is squarefree.
+ *
- * By definition, a polynomial is square-free if it is not a multiple of a
- * non-unit factor.  In particular, polynomials up to degree 1 (including)
- * are square-free.
- */
-int fmpq_poly_is_squarefree(const fmpq_poly_ptr op)
+{
-    if (fmpq_poly_length(op) < 3ul)
-        return 1;
-    else
+    {
-        int ans;
-        fmpz_poly_t prim;
-        fmpz_poly_init(prim);
-        fmpz_poly_primitive_part(prim, op->num);
-        ans = fmpz_poly_is_squarefree(prim);
-        fmpz_poly_clear(prim);
-        return ans;
+    }
+}
-///////////////////////////////////////////////////////////////////////////////
-// Subpolynomials
-/**
- * \brief    Returns a contiguous subpolynomial.
- * \ingroup  Subpolynomials
+ *
- * Returns the slice with coefficients from \f$x^i\f$ (including) to
- * \f$x^j\f$ (excluding).
- */
-void fmpq_poly_getslice(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong i, ulong j)
+{
-    ulong k;
-    j = FLINT_MIN(fmpq_poly_length(op), j);
-    /* Aliasing */
-    if (rop == op)
+    {
-        for (k = 0; k < i; k++)
-            fmpz_poly_set_coeff_ui(rop->num, k, 0);
-        for (k = j; k < fmpz_poly_length(rop->num); k++)
-            fmpz_poly_set_coeff_ui(rop->num, k, 0);
-        fmpq_poly_canonicalize(rop, NULL);
-        return;
+    }
-    fmpz_poly_zero(rop->num);
-    if (i < j)
+    {
-        for (k = j; k != i; )
+        {
-            k--;
-            fmpz_poly_set_coeff_fmpz(rop->num, k,
-                                     fmpz_poly_get_coeff_ptr(op->num, k));
+        }
-        rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-        fmpz_set(rop->den, op->den);
-        fmpq_poly_canonicalize(rop, NULL);
+    }
-    else
+    {
-        fmpz_set_ui(rop->den, 1);
+    }
+}
-/**
- * \brief    Shifts this polynomial to the left by \f$n\f$ coefficients.
- * \ingroup  Subpolynomials
+ *
- * Notionally multiplies \c op by \f$t^n\f$ and stores the result in \c rop.
- */
-void fmpq_poly_left_shift(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong n)
+{
-    /* XXX:  As a workaround for a bug in FLINT 1.5.1, we need to handle */
-    /* the zero polynomial separately.                                   */
-    if (fmpq_poly_is_zero(op))
+    {
-        fmpq_poly_zero(rop);
-        return;
+    }
-    if (n == 0ul)
+    {
-        fmpq_poly_set(rop, op);
-        return;
+    }
-    fmpz_poly_left_shift(rop->num, op->num, n);
-    if (rop != op)
+    {
-        rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-        fmpz_set(rop->den, op->den);
+    }
+}
-/**
- * \brief    Shifts this polynomial to the right by \f$n\f$ coefficients.
- * \ingroup  Subpolynomials
+ *
- * Notationally returns the quotient of floor division of \c rop by \c op.
- */
-void fmpq_poly_right_shift(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong n)
+{
-    /* XXX:  As a workaround for a bug in FLINT 1.5.1, we need to handle */
-    /* the zero polynomial separately.                                   */
-    if (fmpq_poly_is_zero(op))
+    {
-        fmpq_poly_zero(rop);
-        return;
+    }
-    if (n == 0ul)
+    {
-        fmpq_poly_set(rop, op);
-        return;
+    }
-    fmpz_poly_right_shift(rop->num, op->num, n);
-    if (rop != op)
+    {
-        rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-        fmpz_set(rop->den, op->den);
+    }
-    fmpq_poly_canonicalize(rop, NULL);
+}
-/**
- * \brief    Truncates this polynomials.
- * \ingroup  Subpolynomials
+ *
- * Truncates <tt>op</tt>  modulo \f$x^n\f$ whenever \f$n\f$ is positive.
- * Returns zero otherwise.
- */
-void fmpq_poly_truncate(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong n)
+{
-    fmpq_poly_set(rop, op);
-    if (fmpq_poly_length(rop) > n)
+    {
-        fmpz_poly_truncate(rop->num, n);
-        fmpq_poly_canonicalize(rop, NULL);
+    }
+}
-/**
- * \brief    Reverses this polynomial.
- * \ingroup  Subpolynomials
+ *
- * Reverses the coefficients of \c op - thought of as a polynomial of
- * length \c n - and places the result in <tt>rop</tt>.
- */
-void fmpq_poly_reverse(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong n)
+{
-    ulong len;
-    len = fmpq_poly_length(op);
-    if (n == 0ul || len == 0ul)
+    {
-        fmpq_poly_zero(rop);
-        return;
+    }
-    fmpz_poly_reverse(rop->num, op->num, n);
-    if (rop != op)
+    {
-        rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-        fmpz_set(rop->den, op->den);
+    }
-    if (n < len)
-        fmpq_poly_canonicalize(rop, NULL);
+}
-///////////////////////////////////////////////////////////////////////////////
-// String conversion
-/**
- * \addtogroup StringConversions
+ *
- * The following three methods enable users to construct elements of type
- * \c fmpq_poly_ptr from strings or to obtain string representations of such
- * elements.
+ *
- * The format used is based on the FLINT format for integer polynomials of
- * type <tt>fmpz_poly_t</tt>, which we recall first:
+ *
- * A non-zero polynomial \f$a_0 + a_1 X + \dotsb + a_n X^n\f$ of length
- * \f$n + 1\f$ is represented by the string <tt>n+1  a_0 a_1 ... a_n</tt>,
- * where there are two space characters following the length and single space
- * characters separating the individual coefficients.  There is no leading or
- * trailing white-space.  In contrast, the zero polynomial is represented by
- * <tt>0</tt>.
+ *
- * We adapt this notation for rational polynomials by using the <tt>mpq_t</tt>
- * notation for the coefficients without any additional white-space.
+ *
- * There is also a <tt>_pretty</tt> variant available.
+ *
- * Note that currently these functions are not optimized for performance and
- * are intended to be used only for debugging purposes or one-off input and
- * output, rather than as a low-level parser.
- */
-/**
- * \ingroup StringConversions
- * \brief Constructs a polynomial from a list of rationals.
+ *
- * Given a list of length <tt>n</tt> containing rationals of type
- * <tt>mpq_t</tt>, this method constructs a polynomial with these
- * coefficients, beginning with the constant term.
- */
-void _fmpq_poly_from_list(fmpq_poly_ptr rop, mpq_t * a, ulong n)
+{
-    mpz_t den, t;
-    ulong i;
-    mpz_init(t);
-    mpz_init_set_ui(den, 1);
-    for (i = 0; i < n; i++)
-        mpz_lcm(den, den, mpq_denref(a[i]));
-    for (i = 0; i < n; i++)
+    {
-        mpz_divexact(t, den, mpq_denref(a[i]));
-        mpz_mul(mpq_numref(a[i]), mpq_numref(a[i]), t);
+    }
-    fmpz_poly_realloc(rop->num, n);
-    for (i = n - 1ul; i != -1ul; i--)
-        fmpz_poly_set_coeff_mpz(rop->num, i, mpq_numref(a[i]));
-    if (mpz_cmp_ui(den, 1) == 0)
-        fmpz_set_ui(rop->den, 1);
-    else
+    {
-        rop->den = fmpz_realloc(rop->den, mpz_size(den));
-        mpz_to_fmpz(rop->den, den);
+    }
-    mpz_clear(den);
-    mpz_clear(t);
+}
-/**
- * \ingroup  StringConversions
+ *
- * Sets the rational polynomial \c rop to the value specified by the
- * null-terminated string \c str.
+ *
- * The behaviour is undefined if the format of the string \c str does not
- * conform to the specification.
+ *
- * \todo  In a future version, it would be nice to have this function return
- *        <tt>0</tt> or <tt>1</tt> depending on whether the input format
- *        was correct.  Currently, the method always returns <tt>1</tt>.
- */
-int fmpq_poly_from_string(fmpq_poly_ptr rop, const char * str)
+{
-    mpq_t * a;
-    char * strcopy;
-    ulong strcopy_len;
-    ulong i, j, k, n;
-    n = atoi(str);
-    /* Handle the case of the zero polynomial */
-    if (n == 0ul)
+    {
-        fmpq_poly_zero(rop);
-        return 1;
+    }
-    /* Compute the maximum length that the copy buffer has to be */
-    strcopy_len = 0;
-    for (j = 0; str[j] != ' '; j++);
-    j += 2;
-    for (i = 0; i < n; i++)
+    {
-        for (k = j; !(str[k] == ' ' || str[k] == '\0'); k++);
-        strcopy_len = FLINT_MAX(strcopy_len, k - j + 1);
-        j = k + 1;
+    }
-    strcopy = (char *) malloc(strcopy_len * sizeof(char));
-    if (!strcopy)
+    {
-        printf("ERROR (fmpq_poly_from_string).  Memory allocation failed.\n");
-        abort();
+    }
-    /* Read the data into the array a of mpq_t's */
-    a = (mpq_t *) malloc(n * sizeof(mpq_t));
-    for (j = 0; str[j] != ' '; j++);
-    j += 2;
-    for (i = 0; i < n; i++)
+    {
-        for (k = j; !(str[k] == ' ' || str[k] == '\0'); k++);
-        memcpy(strcopy, str + j, k - j + 1);
-        strcopy[k - j] = '\0';
-        mpq_init(a[i]);
-        mpq_set_str(a[i], strcopy, 10);
-        mpq_canonicalize(a[i]);
-        j = k + 1;
+    }
-    _fmpq_poly_from_list(rop, a, n);
-    /* Clean-up */
-    free(strcopy);
-    for (i = 0; i < n; i++)
-        mpq_clear(a[i]);
-    free(a);
-    return 1;
+}
-/**
- * \ingroup  StringConversions
+ *
- * Returns the string representation of the rational polynomial \c op.
- */
-char * fmpq_poly_to_string(const fmpq_poly_ptr op)
+{
-    ulong i, j;
-    ulong len;     /* Upper bound on the length          */
-    ulong denlen;  /* Size of the denominator in base 10 */
-    mpz_t z;
-    mpq_t q;
-    char * str;
-    if (fmpq_poly_is_zero(op))
+    {
-        str = (char *) malloc(2 * sizeof(char));
-        if (!str)
+        {
-            printf("ERROR (fmpq_poly_to_string).  Memory allocation failed.\n");
-            abort();
+        }
-        str[0] = '0';
-        str[1] = '\0';
-        return str;
+    }
-    mpz_init(z);
-    if (fmpz_is_one(op->den))
+    {
-        denlen = 0;
+    }
-    else
+    {
-        fmpz_to_mpz(z, op->den);
-        denlen = mpz_sizeinbase(z, 10);
+    }
-    len = fmpq_poly_places(fmpq_poly_length(op)) + 2;
-    for (i = 0; i < fmpq_poly_length(op); i++)
+    {
-        fmpz_poly_get_coeff_mpz(z, op->num, i);
-        len += mpz_sizeinbase(z, 10) + 1;
-        if (mpz_sgn(z) != 0)
-            len += 2 + denlen;
+    }
-    mpq_init(q);
-    str = (char *) malloc(len * sizeof(char));
-    if (!str)
+    {
-        printf("ERROR (fmpq_poly_to_string).  Memory allocation failed.\n");
-        abort();
+    }
-    sprintf(str, "%lu", fmpq_poly_length(op));
-    for (j = 0; str[j] != '\0'; j++);
-    str[j++] = ' ';
-    for (i = 0; i < fmpq_poly_length(op); i++)
+    {
-        str[j++] = ' ';
-        fmpz_poly_get_coeff_mpz(mpq_numref(q), op->num, i);
-        if (op->den == NULL)
-            mpz_set_ui(mpq_denref(q), 1);
-        else
-            fmpz_to_mpz(mpq_denref(q), op->den);
-        mpq_canonicalize(q);
-        mpq_get_str(str + j, 10, q);
-        for ( ; str[j] != '\0'; j++);
+    }
-    mpq_clear(q);
-    mpz_clear(z);
-    return str;
+}
-/**
- * \ingroup  StringConversions
+ *
- * Returns the pretty string representation of \c op.
+ *
- * Returns the pretty string representation of the rational polynomial \c op,
- * using the string \c var as the variable name.
- */
-char * fmpq_poly_to_string_pretty(const fmpq_poly_ptr op, const char * var)
+{
-    long i;
-    ulong j;
-    ulong len;     /* Upper bound on the length          */
-    ulong denlen;  /* Size of the denominator in base 10 */
-    ulong varlen;  /* Length of the variable name        */
-    mpz_t z;       /* op->den (if this is not 1)         */
-    mpq_t q;
-    char * str;
-    if (fmpq_poly_is_zero(op))
+    {
-        str = (char *) malloc(2 * sizeof(char));
-        if (!str)
+        {
-            printf("ERROR (fmpq_poly_to_string_pretty).  Memory allocation failed.\n");
-            abort();
+        }
-        str[0] = '0';
-        str[1] = '\0';
-        return str;
+    }
-    if (fmpq_poly_length(op) == 1ul)
+    {
-        mpq_init(q);
-        fmpz_to_mpz(mpq_numref(q), fmpz_poly_lead(op->num));
-        if (fmpz_is_one(op->den))
-            mpz_set_ui(mpq_denref(q), 1);
-        else
+        {
-            fmpz_to_mpz(mpq_denref(q), op->den);
-            mpq_canonicalize(q);
+        }
-        str = mpq_get_str(NULL, 10, q);
-        mpq_clear(q);
-        return str;
+    }
-    varlen = strlen(var);
-    /* Copy the denominator into an mpz_t */
-    mpz_init(z);
-    if (fmpz_is_one(op->den))
+    {
-        denlen = 0;
+    }
-    else
+    {
-        fmpz_to_mpz(z, op->den);
-        denlen = mpz_sizeinbase(z, 10);
+    }
-    /* Estimate the length */
-    len = 0;
-    for (i = 0; i < fmpq_poly_length(op); i++)
+    {
-        fmpz_poly_get_coeff_mpz(z, op->num, i);
-        len += mpz_sizeinbase(z, 10);            /* Numerator                */
-        if (mpz_sgn(z) != 0)
-            len += 1 + denlen;                   /* Denominator and /        */
-        len += 3;                                /* Operator and whitespace  */
-        len += 1 + varlen + 1;                   /* *, x and ^               */
-        len += fmpq_poly_places(i);              /* Exponent                 */
+    }
-    mpq_init(q);
-    str = (char *) malloc(len * sizeof(char));
-    if (!str)
+    {
-        printf("ERROR (fmpq_poly_to_string_pretty).  Memory allocation failed.\n");
-        abort();
+    }
-    j = 0;
-    /* Print the leading term */
-    fmpz_to_mpz(mpq_numref(q), fmpz_poly_lead(op->num));
-    fmpz_to_mpz(mpq_denref(q), op->den);
-    mpq_canonicalize(q);
-    if (mpq_cmp_ui(q, 1, 1) != 0)
+    {
-        if (mpq_cmp_si(q, -1, 1) == 0)
-            str[j++] = '-';
-        else
+        {
-            mpq_get_str(str, 10, q);
-            for ( ; str[j] != '\0'; j++);
-            str[j++] = '*';
+        }
+    }
-    sprintf(str + j, "%s", var);
-    j += varlen;
-    if (fmpz_poly_degree(op->num) > 1)
+    {
-        str[j++] = '^';
-        sprintf(str + j, "%li", fmpz_poly_degree(op->num));
-        for ( ; str[j] != '\0'; j++);
+    }
-    for (i = fmpq_poly_degree(op) - 1; i >= 0; i--)
+    {
-        if (fmpz_is_zero(fmpz_poly_get_coeff_ptr(op->num, i)))
-            continue;
-        fmpz_poly_get_coeff_mpz(mpq_numref(q), op->num, i);
-        fmpz_to_mpz(mpq_denref(q), op->den);
-        mpq_canonicalize(q);
-        str[j++] = ' ';
-        if (mpq_sgn(q) < 0)
+        {
-            mpq_abs(q, q);
-            str[j++] = '-';
+        }
-        else
-            str[j++] = '+';
-        str[j++] = ' ';
-        mpq_get_str(str + j, 10, q);
-        for ( ; str[j] != '\0'; j++);
-        if (i > 0)
+        {
-            str[j++] = '*';
-            sprintf(str + j, "%s", var);
-            j += varlen;
-            if (i > 1)
+            {
-                str[j++] = '^';
-                sprintf(str + j, "%li", i);
-                for ( ; str[j] != '\0'; j++);
+            }
+        }
+    }
-    mpq_clear(q);
-    mpz_clear(z);
-    return str;
+}
-#ifdef __cplusplus
+    }
-#endif

deleted file sage/libs/flint/fmpq_poly.h

diff --git a/sage/libs/flint/fmpq_poly.h b/sage/libs/flint/fmpq_poly.h
deleted file mode 100644

-                      +
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2010 Sebastian Pancratz                                     //
-//                                                                           //
-// Distributed under the terms of the GNU General Public License as          //
-// published by the Free Software Foundation; either version 2 of the        //
-// License, or (at your option) any later version.                           //
-//                                                                           //
-// http://www.gnu.org/licenses/                                              //
-///////////////////////////////////////////////////////////////////////////////
-#ifndef _FMPQ_POLY_H_
-#define _FMPQ_POLY_H_
-#ifdef __cplusplus
-    extern "C" {
-#endif
-#include <stdio.h>
-#include <gmp.h>
-#include "fmpz.h"
-#include "fmpz_poly.h"
-/**
- * \file     fmpq_poly.h
- * \brief    Fast implementation of the rational polynomial ring
- * \author   Sebastian Pancratz
- * \date     Mar 2010 -- July 2010
- * \version  0.1.8
- */
-/**
- * \ingroup  Definitions
- * \brief    Data type for a rational polynomial.
- * \details  We represent a rational polynomial as the quotient of an integer
- *           polynomial of type <tt>fmpz_poly_t</tt> and a denominator of type
- *           <tt>fmpz_t</tt>, enforcing coprimality and that the denominator
- *           is positive.  The zero polynomial is represented as \f$0/1\f$.
- */
-typedef struct
+{
-    fmpz_poly_t num;  //!< Numerator
-    fmpz_t den;       //!< Denominator
-} fmpq_poly_struct;
-/**
- * \ingroup  Definitions
- * \brief    Array of #fmpq_poly_struct of length one.
- * \details  This allows passing <em>by reference</em> without having to
- *           explicitly allocate memory for the structure, as one would have
- *           to when using pointers.
- */
-typedef fmpq_poly_struct fmpq_poly_t[1];
-/**
- * \ingroup  Definitions
- * \brief    Pointer to #fmpq_poly_struct.
- */
-typedef fmpq_poly_struct * fmpq_poly_ptr;
-void fmpq_poly_canonicalize(fmpq_poly_ptr f, fmpz_t temp);
-///////////////////////////////////////////////////////////////////////////////
-// fmpq_poly_*                                                               //
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// Accessing numerator and denominator
-/**
- * \def      fmpq_poly_numref(op)
- * \brief    Returns a reference to the numerator of \c op.
- * \ingroup  NumDen
- * \details  The <tt>fmpz_poly</tt> functions can be used on the result of
- *           this macro.
- */
-#define fmpq_poly_numref(op)  ((op)->num)
-/**
- * \def      fmpq_poly_denref(op)
- * \brief    Returns a reference to the denominator of \c op.
- * \ingroup  NumDen
- * \details  The <tt>fmpz</tt> functions can be used on the result of
- *           this macro.
- */
-#define fmpq_poly_denref(op)  ((op)->den)
-///////////////////////////////////////////////////////////////////////////////
-// Memory management
-/**
- * \ingroup  MemoryManagement
+ *
- * Initializes the element \c rop to zero.
+ *
- * This function should be called once for the #fmpq_poly_ptr \c rop, before
- * using it with other <tt>fmpq_poly</tt> functions, or following a
- * preceeding call to #fmpq_poly_clear().
- */
-static inline
-void fmpq_poly_init(fmpq_poly_ptr rop)
+{
-    fmpz_poly_init(rop->num);
-    rop->den = fmpz_init(1ul);
-    fmpz_set_ui(rop->den, 1ul);
+}
-/**
- * \ingroup  MemoryManagement
+ *
- * Clears the element \c rop.
+ *
- * This function should only be called on an element which has been
- * initialised.
- */
-static inline
-void fmpq_poly_clear(fmpq_poly_ptr rop)
+{
-    fmpz_poly_clear(rop->num);
-    fmpz_clear(rop->den);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Assignment and basic manipulation
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to the same value as the element \c op.
- */
-static inline
-void fmpq_poly_set(fmpq_poly_ptr rop, const fmpq_poly_ptr op)
+{
-    if (rop != op)
+    {
-        fmpz_poly_set(rop->num, op->num);
-        rop->den = fmpz_realloc(rop->den, fmpz_size(op->den));
-        fmpz_set(rop->den, op->den);
+    }
+}
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to the same value as the element \c op.
- */
-static inline
-void fmpq_poly_set_fmpz_poly(fmpq_poly_ptr rop, const fmpz_poly_t op)
+{
-    fmpz_poly_set(rop->num, op);
-    fmpz_set_ui(rop->den, 1);
+}
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to the value given by the \c int \c op.
- */
-static inline
-void fmpq_poly_set_si(fmpq_poly_ptr rop, long op)
+{
-    fmpz_poly_zero(rop->num);
-    fmpz_poly_set_coeff_si(rop->num, 0, op);
-    fmpz_set_ui(rop->den, 1ul);
+}
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to the integer \c x.
- */
-static inline
-void fmpq_poly_set_fmpz(fmpq_poly_ptr rop, const fmpz_t x)
+{
-    fmpz_poly_zero(rop->num);
-    fmpz_poly_set_coeff_fmpz(rop->num, 0, x);
-    fmpz_set_ui(rop->den, 1ul);
+}
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to the integer \c x.
- */
-static inline
-void fmpq_poly_set_mpz(fmpq_poly_ptr rop, const mpz_t x)
+{
-    fmpz_poly_zero(rop->num);
-    fmpz_poly_set_coeff_mpz(rop->num, 0, x);
-    fmpz_set_ui(rop->den, 1ul);
+}
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to the rational \c x, assumed to be given
- * in lowest terms.
- */
-static inline
-void fmpq_poly_set_mpq(fmpq_poly_ptr rop, const mpq_t x)
+{
-    fmpz_poly_zero(rop->num);
-    fmpz_poly_set_coeff_mpz(rop->num, 0, mpq_numref(x));
-    rop->den = fmpz_realloc(rop->den, mpz_size(mpq_denref(x)));
-    mpz_to_fmpz(rop->den, mpq_denref(x));
+}
-/**
- * \ingroup  Assignment
+ *
- * Swaps the elements \c op1 and \c op2.
+ *
- * This is done efficiently by swapping pointers.
- */
-static inline
-void fmpq_poly_swap(fmpq_poly_ptr op1, fmpq_poly_ptr op2)
+{
-    if (op1 != op2)
+    {
-        fmpz_t t;
-        fmpz_poly_swap(op1->num, op2->num);
-        t        = op1->den;
-        op1->den = op2->den;
-        op2->den = t;
+    }
+}
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to zero.
- */
-static inline
-void fmpq_poly_zero(fmpq_poly_ptr rop)
+{
-    fmpz_poly_zero(rop->num);
-    fmpz_set_ui(rop->den, 1ul);
+}
-/**
- * \ingroup  Assignment
+ *
- * Sets the element \c rop to one.
- */
-static inline
-void fmpq_poly_one(fmpq_poly_ptr rop)
+{
-    fmpz_poly_zero(rop->num);
-    fmpz_poly_set_coeff_si(rop->num, 0, 1);
-    fmpz_set_ui(rop->den, 1ul);
+}
-void fmpq_poly_neg(fmpq_poly_ptr rop, const fmpq_poly_ptr op);
-void fmpq_poly_inv(fmpq_poly_ptr rop, const fmpq_poly_ptr op);
-///////////////////////////////////////////////////////////////////////////////
-// Setting/ retrieving individual coefficients
-void fmpq_poly_get_coeff_mpq(mpq_t rop, const fmpq_poly_ptr op, ulong i);
-void fmpq_poly_set_coeff_fmpz(fmpq_poly_ptr rop, ulong i, const fmpz_t x);
-void fmpq_poly_set_coeff_mpz(fmpq_poly_ptr rop, ulong i, const mpz_t x);
-void fmpq_poly_set_coeff_mpq(fmpq_poly_ptr rop, ulong i, const mpq_t x);
-void fmpq_poly_set_coeff_si(fmpq_poly_ptr rop, ulong i, long x);
-///////////////////////////////////////////////////////////////////////////////
-// Comparison
-/**
- * \brief    Returns whether \c op is zero.
- * \ingroup  Comparison
+ *
- * Returns whether the element \c op is zero.
- */
-static inline
-int fmpq_poly_is_zero(const fmpq_poly_ptr op)
+{
-    return op->num->length == 0ul;
+}
-/**
- * \brief    Returns whether \c op is equal to \f$1\f$.
- * \ingroup  Comparison
+ *
- * Returns whether the element \c op is equal to the constant polynomial
- * \f$1\f$.
- */
-static inline
-int fmpq_poly_is_one(const fmpq_poly_ptr op)
+{
-    return (op->num->length == 1ul) && fmpz_is_one(op->num->coeffs)
-                                    && fmpz_is_one(op->den);
+}
-int fmpq_poly_equal(const fmpq_poly_ptr op1, const fmpq_poly_ptr op2);
-int fmpq_poly_cmp(const fmpq_poly_ptr left, const fmpq_poly_ptr right);
-///////////////////////////////////////////////////////////////////////////////
-// Polynomial parameters
-/**
- * \brief    Returns the length of \c op.
- * \ingroup  PolyParameters
- * \details  Returns the length of the polynomial \c op, which is one greater
- *           than its degree.
- */
-static inline
-ulong fmpq_poly_length(const fmpq_poly_ptr op)
+{
-    return op->num->length;
+}
-/**
- * \brief    Returns the degree of \c op.
- * \ingroup  Parameters
- * \details  Returns the degree of the polynomial \c op.
- */
-static inline
-long fmpq_poly_degree(const fmpq_poly_ptr op)
+{
-    return (long) (op->num->length - 1ul);
+}
-///////////////////////////////////////////////////////////////////////////////
-// Addition/ subtraction
-void fmpq_poly_add(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2);
-void fmpq_poly_sub(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2);
-void fmpq_poly_addmul(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2);
-void fmpq_poly_submul(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2);
-///////////////////////////////////////////////////////////////////////////////
-// Scalar multiplication and division
-void fmpq_poly_scalar_mul_si(fmpq_poly_ptr rop, const fmpq_poly_ptr op, long x);
-void fmpq_poly_scalar_mul_mpz(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpz_t x);
-void fmpq_poly_scalar_mul_mpq(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpq_t x);
-void fmpq_poly_scalar_div_si(fmpq_poly_ptr rop, const fmpq_poly_ptr op, long x);
-void fmpq_poly_scalar_div_mpz(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpz_t x);
-void fmpq_poly_scalar_div_mpq(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpq_t x);
-///////////////////////////////////////////////////////////////////////////////
-// Multiplication
-void fmpq_poly_mul(fmpq_poly_ptr rop, const fmpq_poly_ptr op1, const fmpq_poly_ptr op2);
-///////////////////////////////////////////////////////////////////////////////
-// Division
-void fmpq_poly_floordiv(fmpq_poly_ptr q, const fmpq_poly_ptr a, const fmpq_poly_ptr b);
-void fmpq_poly_mod(fmpq_poly_ptr r, const fmpq_poly_ptr a, const fmpq_poly_ptr b);
-void fmpq_poly_divrem(fmpq_poly_ptr q, fmpq_poly_ptr r, const fmpq_poly_ptr a, const fmpq_poly_ptr b);
-///////////////////////////////////////////////////////////////////////////////
-// Powering
-void fmpq_poly_power(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong exp);
-///////////////////////////////////////////////////////////////////////////////
-// Greatest common divisor
-void fmpq_poly_gcd(fmpq_poly_ptr rop, const fmpq_poly_ptr a, const fmpq_poly_ptr b);
-void fmpq_poly_xgcd(fmpq_poly_ptr rop, fmpq_poly_ptr s, fmpq_poly_ptr t, const fmpq_poly_ptr a, const fmpq_poly_ptr b);
-void fmpq_poly_lcm(fmpq_poly_ptr rop, const fmpq_poly_ptr a, const fmpq_poly_ptr b);
-///////////////////////////////////////////////////////////////////////////////
-// Derivative
-void fmpq_poly_derivative(fmpq_poly_ptr rop, fmpq_poly_ptr op);
-///////////////////////////////////////////////////////////////////////////////
-// Evaluation
-void fmpq_poly_evaluate_mpz(mpq_t rop, fmpq_poly_ptr f, const mpz_t a);
-void fmpq_poly_evaluate_mpq(mpq_t rop, fmpq_poly_ptr f, const mpq_t a);
-///////////////////////////////////////////////////////////////////////////////
-// Gaussian content
-void fmpq_poly_content(mpq_t rop, const fmpq_poly_ptr op);
-void fmpq_poly_primitive_part(fmpq_poly_ptr rop, const fmpq_poly_ptr op);
-int fmpq_poly_is_monic(const fmpq_poly_ptr op);
-void fmpq_poly_monic(fmpq_poly_ptr rop, const fmpq_poly_ptr op);
-///////////////////////////////////////////////////////////////////////////////
-// Resultant
-void fmpq_poly_resultant(mpq_t rop, const fmpq_poly_ptr a, const fmpq_poly_ptr b);
-void fmpq_poly_discriminant(mpq_t disc, fmpq_poly_t a);
-///////////////////////////////////////////////////////////////////////////////
-// Composition
-void fmpq_poly_compose(fmpq_poly_ptr rop, const fmpq_poly_ptr a, const fmpq_poly_ptr b);
-void fmpq_poly_rescale(fmpq_poly_ptr rop, const fmpq_poly_ptr op, const mpq_t x);
-///////////////////////////////////////////////////////////////////////////////
-// Square-free
-int fmpq_poly_is_squarefree(const fmpq_poly_ptr op);
-///////////////////////////////////////////////////////////////////////////////
-// Subpolynomials
-void fmpq_poly_getslice(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong i, ulong j);
-void fmpq_poly_left_shift(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong n);
-void fmpq_poly_right_shift(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong n);
-void fmpq_poly_truncate(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong n);
-void fmpq_poly_reverse(fmpq_poly_ptr rop, const fmpq_poly_ptr op, ulong n);
-///////////////////////////////////////////////////////////////////////////////
-// String conversion
-void _fmpq_poly_from_list(fmpq_poly_ptr rop, mpq_t * a, ulong n);
-int fmpq_poly_from_string(fmpq_poly_ptr rop, const char * s);
-char * fmpq_poly_to_string(const fmpq_poly_ptr op);
-char * fmpq_poly_to_string_pretty(const fmpq_poly_ptr op, const char * x);
-#ifdef __cplusplus
+    }
-#endif
-#endif

sage/libs/flint/fmpq_poly.pxd

diff --git a/sage/libs/flint/fmpq_poly.pxd b/sage/libs/flint/fmpq_poly.pxd

-                      a
+###############################################################################
+#          Copyright (C) 2010 Sebastian Pancratz <sfp@pancratz.org>           #
+#                                                                             #
+#     Distributed under the terms of the GNU General Public License (GPL)     #
+#                                                                             #
+#                        http://www.gnu.org/licenses/                         #
+###############################################################################
+#include "fmpz_poly.pxi"
+#include "fmpz.pxi"
+cdef extern from "gmp.h":
+    ctypedef void * mpz_t
+    ctypedef void * mpq_t
+cdef extern from "fmpq_poly.h":
+    ctypedef void * fmpz_t
+    ctypedef void * fmpz_poly_p
+    struct fmpq_poly:
+        fmpz_poly_p num
+        fmpz_t den
+    ctypedef fmpq_poly fmpq_poly_struct
+    ctypedef fmpq_poly_struct fmpq_poly_t[1]
+    void * fmpq_poly_canonicalize(fmpq_poly_t, fmpz_t)
+    void * fmpq_poly_numref(fmpq_poly_t)
+    void * fmpq_poly_denref(fmpq_poly_t)
+    void fmpq_poly_init(fmpq_poly_t)
+    void fmpq_poly_clear(fmpq_poly_t)
+    void fmpq_poly_set(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_set_fmpz_poly(fmpq_poly_t, fmpz_poly_t)
+    void fmpq_poly_set_si(fmpq_poly_t, long)
+    void fmpq_poly_set_mpz(fmpq_poly_t, mpz_t)
+    void fmpq_poly_set_mpq(fmpq_poly_t, mpq_t)
+    void fmpq_poly_swap(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_zero(fmpq_poly_t)
+    void fmpq_poly_neg(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_get_coeff_mpq(mpq_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_set_coeff_si(fmpq_poly_t, unsigned long, long)
+    void fmpq_poly_set_coeff_mpq(fmpq_poly_t, unsigned long, mpq_t)
+    void fmpq_poly_set_coeff_mpz(fmpq_poly_t, unsigned long, mpz_t)
+    int fmpq_poly_equal(fmpq_poly_t, fmpq_poly_t)
+    int fmpq_poly_cmp(fmpq_poly_t, fmpq_poly_t)
+    int fmpq_poly_is_zero(fmpq_poly_t)
+    long fmpq_poly_degree(fmpq_poly_t)
+    unsigned long fmpq_poly_length(fmpq_poly_t)
+    void fmpq_poly_add(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_sub(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_scalar_mul_mpq(fmpq_poly_t, fmpq_poly_t, mpq_t)
+    void fmpq_poly_scalar_div_mpq(fmpq_poly_t, fmpq_poly_t, mpq_t)
+    void fmpq_poly_mul(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_divrem(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_floordiv(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_mod(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_power(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_left_shift(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_right_shift(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_gcd(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_xgcd(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_lcm(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_derivative(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_evaluate_mpz(mpq_t, fmpq_poly_t, mpz_t)
+    void fmpq_poly_evaluate_mpq(mpq_t, fmpq_poly_t, mpq_t)
+    void fmpq_poly_content(mpq_t, fmpq_poly_t)
+    void fmpq_poly_primitive_part(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_resultant(mpq_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_compose(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_getslice(fmpq_poly_t, fmpq_poly_t, unsigned long, unsigned long)
+    void fmpq_poly_truncate(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_reverse(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void _fmpq_poly_from_list(fmpq_poly_t, mpq_t *, unsigned long)
+    void fmpq_poly_from_string(fmpq_poly_t, char *)
+    char * fmpq_poly_to_string(fmpq_poly_t, char *)
+    char * fmpq_poly_to_string_pretty(fmpq_poly_t, char *)
+###############################################################################
+#          Copyright (C) 2010 Sebastian Pancratz <sfp@pancratz.org>           #
+#                                                                             #
+#     Distributed under the terms of the GNU General Public License (GPL)     #
+#                                                                             #
+#                        http://www.gnu.org/licenses/                         #
+###############################################################################
+#include "fmpz_poly.pxi"
+#include "fmpz.pxi"
+cdef extern from "gmp.h":
+    ctypedef void * mpz_t
+    ctypedef void * mpq_t
+cdef extern from "fmpq.h":
+    ctypedef void * fmpq_t
+    void fmpq_init(fmpq_t)
+    void fmpq_clear(fmpq_t)
+    void fmpq_get_mpq(mpq_t, fmpq_t)
+    void fmpq_set_mpq(fmpq_t, mpq_t)
+cdef extern from "fmpz_vec.h":
+    long _fmpz_vec_max_limbs(void * c, long n)
+cdef extern from "fmpq_poly.h":
+    ctypedef void * fmpz_t
+    ctypedef void * fmpq_poly_t
+    void fmpq_poly_canonicalise(fmpq_poly_t)
+    void * fmpq_poly_numref(fmpq_poly_t)
+    void * fmpq_poly_denref(fmpq_poly_t)
+    void fmpq_poly_init(fmpq_poly_t)
+    void fmpq_poly_clear(fmpq_poly_t)
+    void fmpq_poly_set(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_set_fmpz_poly(fmpq_poly_t, fmpz_poly_t)
+    void fmpq_poly_set_si(fmpq_poly_t, long)
+    void fmpq_poly_set_mpz(fmpq_poly_t, mpz_t)
+    void fmpq_poly_set_mpq(fmpq_poly_t, mpq_t)
+    void fmpq_poly_swap(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_zero(fmpq_poly_t)
+    void fmpq_poly_neg(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_get_numerator(fmpz_poly_t, fmpq_poly_t)
+    void fmpq_poly_get_coeff_mpq(mpq_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_set_coeff_si(fmpq_poly_t, unsigned long, long)
+    void fmpq_poly_set_coeff_mpq(fmpq_poly_t, unsigned long, mpq_t)
+    void fmpq_poly_set_coeff_mpz(fmpq_poly_t, unsigned long, mpz_t)
+    int fmpq_poly_equal(fmpq_poly_t, fmpq_poly_t)
+    int fmpq_poly_cmp(fmpq_poly_t, fmpq_poly_t)
+    int fmpq_poly_is_zero(fmpq_poly_t)
+    long fmpq_poly_degree(fmpq_poly_t)
+    unsigned long fmpq_poly_length(fmpq_poly_t)
+    void fmpq_poly_add(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_sub(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_scalar_mul_mpq(fmpq_poly_t, fmpq_poly_t, mpq_t)
+    void fmpq_poly_scalar_div_mpq(fmpq_poly_t, fmpq_poly_t, mpq_t)
+    void fmpq_poly_mul(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_divrem(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_div(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_rem(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_pow(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_shift_left(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_shift_right(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_gcd(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_xgcd(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_lcm(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_derivative(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_evaluate_mpz(mpq_t, fmpq_poly_t, mpz_t)
+    void fmpq_poly_evaluate_mpq(mpq_t, fmpq_poly_t, mpq_t)
+    void fmpq_poly_content(fmpq_t, fmpq_poly_t)
+    void fmpq_poly_primitive_part(fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_resultant(fmpq_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_compose(fmpq_poly_t, fmpq_poly_t, fmpq_poly_t)
+    void fmpq_poly_get_slice(fmpq_poly_t, fmpq_poly_t, long, long)
+    void fmpq_poly_truncate(fmpq_poly_t, unsigned long)
+    void fmpq_poly_reverse(fmpq_poly_t, fmpq_poly_t, unsigned long)
+    void fmpq_poly_set_array_mpq(fmpq_poly_t, mpq_t *, unsigned long)
+    void fmpq_poly_from_string(fmpq_poly_t, char *)
+    char * fmpq_poly_to_string(fmpq_poly_t, char *)
+    char * fmpq_poly_to_string_pretty(fmpq_poly_t, char *)

sage/libs/flint/fmpz.pxi

diff --git a/sage/libs/flint/fmpz.pxi b/sage/libs/flint/fmpz.pxi

-                      a
 include "../ntl/decl.pxi"
 cdef extern from "FLINT/fmpz.h":
+    ctypedef void * fmpz_t
+    ctypedef long fmpz
+    ctypedef long * fmpz_t
     ctypedef void * mpz_t
     fmpz_t fmpz_init(unsigned long limbs)
+    void fmpz_init(fmpz_t x)
     void fmpz_set_ui(fmpz_t res, unsigned long x)
     void fmpz_set_si(fmpz_t res, long x)
 …
     void fmpz_clear(fmpz_t f)
     void fmpz_print(fmpz_t f)
     int fmpz_is_one(fmpz_t f)
+    void fmpz_get_mpz(mpz_t rop, fmpz_t op)
+    void fmpz_set_mpz(fmpz_t rop, mpz_t op)
+    void fmpz_add_ui_inplace(fmpz_t output, unsigned long x)
+    void fmpz_sub_ui_inplace(fmpz_t output, unsigned long x)
+    void fmpz_to_mpz(mpz_t rop, fmpz_t op)
+    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
     ctypedef void* fmpz_poly_t
     void fmpz_poly_init(fmpz_poly_t poly)
+    void fmpz_poly_init2(fmpz_poly_t poly, unsigned long alloc, \
+            unsigned long limbs)
+    void fmpz_poly_init2(fmpz_poly_t poly, unsigned long alloc)
     void fmpz_poly_realloc(fmpz_poly_t poly, unsigned long alloc)
     void fmpz_poly_fit_length(fmpz_poly_t poly, unsigned long alloc)
-    void fmpz_poly_resize_limbs(fmpz_poly_t poly, unsigned long limbs)
-    void fmpz_poly_fit_limbs(fmpz_poly_t poly, unsigned long limbs)
-    unsigned long fmpz_poly_limbs(fmpz_poly_t poly)
     void fmpz_poly_clear(fmpz_poly_t poly)
 …
             unsigned long x)
     void fmpz_poly_scalar_mul_si(fmpz_poly_t output, fmpz_poly_t input, long x)
+    void fmpz_poly_scalar_mul_mpz(fmpz_poly_t output, fmpz_poly_t poly,
+            mpz_t x)
+    void fmpz_poly_scalar_mul_fmpz(fmpz_poly_t output, fmpz_poly_t poly,
+            fmpz_t x)
+    void fmpz_poly_scalar_mul_mpz(fmpz_poly_t output, fmpz_poly_t poly, mpz_t x)
     void fmpz_poly_scalar_div_exact_ui(fmpz_poly_t output, fmpz_poly_t poly, \
+    void fmpz_poly_scalar_divexact_ui(fmpz_poly_t output, fmpz_poly_t poly, \
             unsigned long x)
     void fmpz_poly_scalar_div_exact_si(fmpz_poly_t output, fmpz_poly_t poly, \
+    void fmpz_poly_scalar_divexact_si(fmpz_poly_t output, fmpz_poly_t poly, \
             long x)
     void fmpz_poly_scalar_div_exact_fmpz(fmpz_poly_t output, fmpz_poly_t poly, \
+    void fmpz_poly_scalar_divexact_fmpz(fmpz_poly_t output, fmpz_poly_t poly, \
             fmpz_t x)
+    void fmpz_poly_scalar_div_mpz( fmpz_poly_t output, fmpz_poly_t poly, mpz_t x)
+    void fmpz_poly_scalar_divexact_mpz( fmpz_poly_t output, fmpz_poly_t poly, mpz_t x)
+    void fmpz_poly_scalar_fdiv_ui(fmpz_poly_t output, fmpz_poly_t poly, unsigned long x)
+    void fmpz_poly_scalar_fdiv_mpz(fmpz_poly_t output, fmpz_poly_t poly, mpz_t x)
     void fmpz_poly_div(fmpz_poly_t Q, fmpz_poly_t A, fmpz_poly_t B)
     void fmpz_poly_divrem(fmpz_poly_t Q, fmpz_poly_t R, fmpz_poly_t A, \
 …
     int fmpz_poly_equal(fmpz_poly_t poly1, fmpz_poly_t poly2)
     bint fmpz_poly_from_string(fmpz_poly_t poly, char* s)
     char* fmpz_poly_to_string(fmpz_poly_t poly)
+    int fmpz_poly_set_str(fmpz_poly_t poly, char* s)
+    char* fmpz_poly_get_str(fmpz_poly_t poly)
     void fmpz_poly_print(fmpz_poly_t poly)
     bint fmpz_poly_read(fmpz_poly_t poly)
     void fmpz_poly_power(fmpz_poly_t output, fmpz_poly_t poly, \
+    void fmpz_poly_pow(fmpz_poly_t output, fmpz_poly_t poly, \
             unsigned long exp)
     void fmpz_poly_power_trunc_n(fmpz_poly_t output, fmpz_poly_t poly, \
+    void fmpz_poly_pow_trunc(fmpz_poly_t output, fmpz_poly_t poly, \
             unsigned long exp, unsigned long n)
     void fmpz_poly_left_shift ( fmpz_poly_t output ,
+    void fmpz_poly_shift_left ( fmpz_poly_t output ,
                                 fmpz_poly_t poly , unsigned long n )
     void fmpz_poly_right_shift ( fmpz_poly_t output ,
+    void fmpz_poly_shift_right ( fmpz_poly_t output ,
                                  fmpz_poly_t poly , unsigned long n )
     void fmpz_poly_derivative ( fmpz_poly_t der , 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
         cdef long c
         cdef Integer w
         if PY_TYPE_CHECK(v, str):
             if fmpz_poly_from_string(self.poly, v):
+            if not fmpz_poly_set_str(self.poly, v):
                 return
             else:
                 raise ValueError, "Unable to create Fmpz_poly from that string."
 …
             sage: f = Fmpz_poly([0,1]); f^7
   0 0 0 0 0 0 0 1
         """
         cdef char* ss = fmpz_poly_to_string(self.poly)
+        cdef char* ss = fmpz_poly_get_str(self.poly)
         cdef object s = ss
         sage_free(ss)
         return s
 …
         if not PY_TYPE_CHECK(self, Fmpz_poly):
             raise TypeError
         cdef Fmpz_poly res = <Fmpz_poly>PY_NEW(Fmpz_poly)
         fmpz_poly_power(res.poly, (<Fmpz_poly>self).poly, nn)
+        fmpz_poly_pow(res.poly, (<Fmpz_poly>self).poly, nn)
         return res
     def pow_truncate(self, exp, n):
 …
             raise ValueError, "Exponent must be at least 0"
         cdef long exp_c = exp, nn = n
         cdef Fmpz_poly res = <Fmpz_poly>PY_NEW(Fmpz_poly)
         fmpz_poly_power_trunc_n(res.poly, (<Fmpz_poly>self).poly, exp_c, nn)
+        fmpz_poly_pow_trunc(res.poly, (<Fmpz_poly>self).poly, exp_c, nn)
         return res
     def __floordiv__(left, right):
 …
         """
         cdef Fmpz_poly res = <Fmpz_poly>PY_NEW(Fmpz_poly)
         fmpz_poly_left_shift(res.poly, self.poly, n)
+        fmpz_poly_shift_left(res.poly, self.poly, n)
         return res
 …
         """
         cdef Fmpz_poly res = <Fmpz_poly>PY_NEW(Fmpz_poly)
         fmpz_poly_right_shift(res.poly, self.poly, n)
+        fmpz_poly_shift_right(res.poly, self.poly, n)
         return res

deleted file sage/libs/flint/long_extras.pxd

diff --git a/sage/libs/flint/long_extras.pxd b/sage/libs/flint/long_extras.pxd
deleted file mode 100644

-                      +
-include "../../ext/stdsage.pxi"
-include "../../ext/cdefs.pxi"
-from sage.libs.flint.flint cimport *
-cdef extern from "FLINT/long_extras.h":
-    ctypedef struct factor_t:
-        int num
-        unsigned long p[15]
-        unsigned long exp[15]
-    cdef unsigned long z_randint(unsigned long limit)
-    cdef unsigned long z_randbits(unsigned long bits)
-    cdef unsigned long z_randprime(unsigned long bits, int proved)
-    cdef double z_precompute_inverse(unsigned long n)
-    cdef double z_precompute_inverse2(unsigned long n)
-    cdef double z_ll_precompute_inverse(unsigned long n)
-    cdef unsigned long z_addmod(unsigned long a, unsigned long b, unsigned long p)
-    cdef unsigned long z_submod(unsigned long a, unsigned long b, unsigned long p)
-    cdef unsigned long z_negmod(unsigned long a, unsigned long p)
-    cdef unsigned long z_mod_precomp(unsigned long a, unsigned long n, double ninv)
-    cdef unsigned long z_div2_precomp(unsigned long a, unsigned long n, double ninv)
-    cdef unsigned long z_mod2_precomp(unsigned long a, unsigned long n, double ninv)
-    cdef unsigned long z_ll_mod_precomp(unsigned long a_hi, unsigned long a_lo, unsigned long n, double ninv)
-    cdef unsigned long z_mulmod_precomp(unsigned long a, unsigned long b, unsigned long n, double ninv)
-    cdef unsigned long z_mulmod2_precomp(unsigned long a, unsigned long b, unsigned long n, double ninv)
-    cdef unsigned long z_powmod(unsigned long a, long exp, unsigned long n)
-    cdef unsigned long z_powmod2(unsigned long a, long exp, unsigned long n)
-    cdef unsigned long z_powmod_precomp(unsigned long a, long exp, unsigned long n, double ninv)
-    cdef unsigned long z_powmod2_precomp(unsigned long a, long exp, unsigned long n, double ninv)
-    cdef int z_legendre_precomp(unsigned long a, unsigned long p, double pinv)
-    cdef int z_jacobi(long x, unsigned long y)
-    cdef int z_ispseudoprime_fermat(unsigned long n, unsigned long i)
-    cdef int z_isprime(unsigned long n)
-    cdef int z_isprime_precomp(unsigned long n, double ninv)
-    cdef unsigned long z_nextprime(unsigned long n, int proved)
-    cdef int z_isprime_pocklington(unsigned long n, unsigned long iterations)
-    cdef int z_ispseudoprime_lucas_ab(unsigned long n, int a, int b)
-    cdef int z_ispseudoprime_lucas(unsigned long n)
-    cdef unsigned long z_pow(unsigned long a, unsigned long exp)
-    cdef unsigned long z_sqrtmod(unsigned long a, unsigned long p)
-    cdef unsigned long z_cuberootmod(unsigned long * cuberoot1, unsigned long a, unsigned long p)
-    cdef unsigned long z_invert(unsigned long a, unsigned long p)
-    cdef long z_gcd_invert(long* a, long x, long y)
-    cdef long z_extgcd(long* a, long* b, long x, long y)
-    cdef unsigned long z_gcd(long x, long y)
-    cdef unsigned long z_intsqrt(unsigned long r)
-    cdef int z_issquare(unsigned long x)
-    cdef unsigned long z_CRT(unsigned long x1, unsigned long n1, unsigned long x2, unsigned long n2)
-    cdef int z_issquarefree(unsigned long n, int proved)
-    cdef int z_remove_precomp(unsigned long * n, unsigned long p, double pinv)
-    cdef int z_remove(unsigned long * n, unsigned long p)
-    cdef unsigned long z_factor_SQUFOF(unsigned long n)
-    cdef unsigned long z_primitive_root(unsigned long p)
-    cdef unsigned long z_primitive_root_precomp(unsigned long p, double p_inv)
-    cdef void z_factor(factor_t * factors, unsigned long n, int proved)

sage/libs/flint/ntl_interface.pxd

diff --git a/sage/libs/flint/ntl_interface.pxd b/sage/libs/flint/ntl_interface.pxd

-                      a
 from sage.libs.ntl.ntl_ZZX_decl cimport ZZX_c
 cdef extern from "FLINT/NTL-interface.h":
-    unsigned long ZZ_limbs(ZZ_c z)
     void fmpz_poly_to_ZZX(ZZX_c output, fmpz_poly_t poly)
     void ZZX_to_fmpz_poly(fmpz_poly_t output, ZZX_c poly)
+    void fmpz_poly_get_ZZX(ZZX_c output, fmpz_poly_t poly)
+    void fmpz_poly_set_ZZX(fmpz_poly_t output, ZZX_c poly)
     void fmpz_to_mpz(mpz_t res, fmpz_t f)
     void ZZ_to_fmpz(fmpz_t output, ZZ_c z)
+    void fmpz_get_ZZ(ZZ_c output, fmpz_t f)
+    void fmpz_set_ZZ(fmpz_t output, ZZ_c z)

new file sage/libs/flint/ulong_extras.pxd

diff --git a/sage/libs/flint/ulong_extras.pxd b/sage/libs/flint/ulong_extras.pxd
new file mode 100644

-                      -
+include "../../ext/stdsage.pxi"
+include "../../ext/cdefs.pxi"
+from sage.libs.flint.flint cimport *
+cdef extern from "FLINT/ulong_extras.h":
+    ctypedef struct n_factor_t:
+        int num
+        unsigned long p[15]
+        unsigned long exp[15]
+    cdef int n_jacobi(long x, unsigned long y)
+    cdef int n_is_prime(unsigned long n)
+    cdef unsigned long n_gcd(long x, long y)
+    cdef void n_factor(n_factor_t * factors, unsigned long n, int proved)

sage/libs/flint/zmod_poly.pxd

diff --git a/sage/libs/flint/zmod_poly.pxd b/sage/libs/flint/zmod_poly.pxd

-                      a
 from flint import *
+cdef extern from "FLINT/zmod_poly.h":
+    ctypedef struct zmod_poly_struct:
+        unsigned long *coeffs
+        unsigned long alloc
+        unsigned long length
+        unsigned long p
+        double p_inv
+cdef extern from "FLINT/nmod_poly.h":
+    ctypedef zmod_poly_struct* zmod_poly_t
+    ctypedef unsigned long mp_bitcnt_t
+    ctypedef void * mp_srcptr
+    ctypedef struct zmod_poly_factor_struct:
+        zmod_poly_t *factors
+        unsigned long *exponents
+        unsigned long alloc
+        unsigned long num_factors
+    ctypedef struct nmod_t:
+        mp_limb_t n
+        mp_limb_t ninv
+        mp_bitcnt_t norm
+    ctypedef zmod_poly_factor_struct* zmod_poly_factor_t
+    ctypedef struct nmod_poly_struct:
+        mp_limb_t *coeffs
+        long alloc
+        long length
+        nmod_t mod
+    cdef void zmod_poly_init(zmod_poly_t poly, unsigned long p)
+    cdef void zmod_poly_init_precomp(zmod_poly_t poly, unsigned long p, double p_inv)
+    cdef void zmod_poly_init2(zmod_poly_t poly, unsigned long p, unsigned long alloc)
+    cdef void zmod_poly_init2_precomp(zmod_poly_t poly, unsigned long p, double p_inv, unsigned long alloc)
+    cdef void zmod_poly_clear(zmod_poly_t poly)
+    ctypedef nmod_poly_struct* nmod_poly_t
+    cdef void zmod_poly_realloc(zmod_poly_t poly, unsigned long alloc)
+    # _bits_ only applies to newly allocated coefficients, not existing ones...
+    ctypedef struct nmod_poly_factor_struct:
+        nmod_poly_struct *p
+        long *exp
+        long num
+        long alloc
+    # this non-inlined version REQUIRES that alloc > poly->alloc
+    void __zmod_poly_fit_length(zmod_poly_t poly, unsigned long alloc)
+    ctypedef nmod_poly_factor_struct* nmod_poly_factor_t
+    # this is arranged so that the initial comparison (very frequent) is inlined,
+    # but the actual allocation (infrequent) is not
+    cdef void zmod_poly_fit_length(zmod_poly_t poly, unsigned long alloc)
+    # Memory management
+    # ------------------------------------------------------
+    # Setting/retrieving coefficients
+    cdef void nmod_poly_init(nmod_poly_t poly, mp_limb_t n)
+    cdef void nmod_poly_init_preinv(nmod_poly_t poly, mp_limb_t n, mp_limb_t ninv)
+    cdef void nmod_poly_init2(nmod_poly_t poly, mp_limb_t n, long alloc)
+    cdef void nmod_poly_init2_preinv(nmod_poly_t poly, mp_limb_t n, mp_limb_t ninv, long alloc)
+    cdef void nmod_poly_realloc(nmod_poly_t poly, long alloc)
+    cdef void nmod_poly_clear(nmod_poly_t poly)
+    cdef void nmod_poly_fit_length(nmod_poly_t poly, long alloc)
+    cdef void _nmod_poly_normalise(nmod_poly_t poly)
     cdef unsigned long zmod_poly_get_coeff_ui(zmod_poly_t poly, unsigned long n)
+    # Polynomial parameters
+    cdef unsigned long _zmod_poly_get_coeff_ui(zmod_poly_t poly, unsigned long n)
+    cdef long nmod_poly_length(nmod_poly_t poly)
+    cdef long nmod_poly_degree(nmod_poly_t poly)
+    cdef mp_limb_t nmod_poly_modulus(nmod_poly_t poly)
+    cdef mp_bitcnt_t nmod_poly_max_bits(nmod_poly_t poly)
     cdef void zmod_poly_set_coeff_ui(zmod_poly_t poly, unsigned long n, unsigned long c)
+    # Assignment and basic manipulation
+    cdef void _zmod_poly_set_coeff_ui(zmod_poly_t poly, unsigned long n, unsigned long c)
+    cdef void nmod_poly_set(nmod_poly_t a, nmod_poly_t b)
+    cdef void nmod_poly_swap(nmod_poly_t poly1, nmod_poly_t poly2)
+    cdef void nmod_poly_zero(nmod_poly_t res)
+    cdef void nmod_poly_one(nmod_poly_t res)
+    cdef void nmod_poly_truncate(nmod_poly_t poly, long len)
+    cdef void nmod_poly_reverse(nmod_poly_t output, nmod_poly_t input, long m)
+    # ------------------------------------------------------
+    # String conversions and I/O
+    # Comparison
+    cdef int zmod_poly_from_string(zmod_poly_t poly, char* s)
+    cdef char* zmod_poly_to_string(zmod_poly_t poly)
+    cdef void zmod_poly_print(zmod_poly_t poly)
+    cdef void zmod_poly_fprint(zmod_poly_t poly, FILE* f)
+    cdef int zmod_poly_read(zmod_poly_t poly)
+    cdef int zmod_poly_fread(zmod_poly_t poly, FILE* f)
+    cdef int nmod_poly_equal(nmod_poly_t a, nmod_poly_t b)
+    cdef int nmod_poly_is_zero(nmod_poly_t poly)
+    cdef int nmod_poly_is_one(nmod_poly_t poly)
+    # ------------------------------------------------------
+    # Length and degree
+    # Getting and setting coefficients
+    cdef void __zmod_poly_normalise(zmod_poly_t poly)
+    cdef int __zmod_poly_normalised(zmod_poly_t poly)
+    cdef void zmod_poly_truncate(zmod_poly_t poly, unsigned long length)
+    cdef unsigned long nmod_poly_get_coeff_ui(nmod_poly_t poly, unsigned long j)
+    cdef void nmod_poly_set_coeff_ui(nmod_poly_t poly, unsigned long j, unsigned long c)
     cdef unsigned long zmod_poly_length(zmod_poly_t poly)
+    # Input and output
+    cdef long zmod_poly_degree(zmod_poly_t poly)
+    cdef char * nmod_poly_get_str(nmod_poly_t poly)
+    cdef int nmod_poly_set_str(char * s, nmod_poly_t poly)
+    cdef int nmod_poly_print(nmod_poly_t a)
+    cdef int nmod_poly_fread(FILE * f, nmod_poly_t poly)
+    cdef int nmod_poly_fprint(FILE * f, nmod_poly_t poly)
+    cdef int nmod_poly_read(nmod_poly_t poly)
     cdef unsigned long zmod_poly_modulus(zmod_poly_t poly)
+    # Shifting
+    cdef double zmod_poly_precomputed_inverse(zmod_poly_t poly)
+    cdef void nmod_poly_shift_left(nmod_poly_t res, nmod_poly_t poly, long k)
+    cdef void nmod_poly_shift_right(nmod_poly_t res, nmod_poly_t poly, long k)
+    # ------------------------------------------------------
+    # Assignment
+    # Addition and subtraction
+    cdef void _zmod_poly_set(zmod_poly_t res, zmod_poly_t poly)
+    cdef void zmod_poly_set(zmod_poly_t res, zmod_poly_t poly)
+    cdef void nmod_poly_add(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
+    cdef void nmod_poly_sub(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
+    cdef void nmod_poly_neg(nmod_poly_t res, nmod_poly_t poly1)
     cdef void zmod_poly_zero(zmod_poly_t poly)
+    # Scalar multiplication and division
+    cdef void zmod_poly_swap(zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef void nmod_poly_scalar_mul_nmod(nmod_poly_t res, nmod_poly_t poly1, mp_limb_t c)
+    cdef void nmod_poly_make_monic(nmod_poly_t output, nmod_poly_t input)
+    #
+    # Subpolynomials
+    #
+    # Multiplication
+    cdef void _zmod_poly_attach(zmod_poly_t output, zmod_poly_t input)
+    cdef void nmod_poly_mul(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
+    cdef void nmod_poly_mullow(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, long trunc)
+    cdef void nmod_poly_mulhigh(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, long n)
+    cdef void nmod_poly_mulmod(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, nmod_poly_t f)
     cdef void zmod_poly_attach(zmod_poly_t output, zmod_poly_t input)
+    # Powering
+    #
+    # Attach input shifted right by n to output
+    #
+    cdef void nmod_poly_pow(nmod_poly_t res, nmod_poly_t poly, unsigned long e)
+    cdef void nmod_poly_pow_trunc(nmod_poly_t res, nmod_poly_t poly, unsigned long e, long trunc)
     cdef void _zmod_poly_attach_shift(zmod_poly_t output, zmod_poly_t input, unsigned long n)
+    # Division
+    cdef void zmod_poly_attach_shift(zmod_poly_t output, zmod_poly_t input, unsigned long n)
+    cdef void nmod_poly_divrem(nmod_poly_t Q, nmod_poly_t R, nmod_poly_t A, nmod_poly_t B)
+    cdef void nmod_poly_div(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B)
+    cdef void nmod_poly_inv_series(nmod_poly_t Qinv, nmod_poly_t Q, long n)
+    cdef void nmod_poly_div_series(nmod_poly_t Q, nmod_poly_t A, nmod_poly_t B, long n)
+    #
+    # Attach input to first n coefficients of input
+    #
+    # Derivative
+    cdef void _zmod_poly_attach_truncate(zmod_poly_t output,  zmod_poly_t input, unsigned long n)
+    cdef void nmod_poly_derivative(nmod_poly_t x_prime, nmod_poly_t x)
+    cdef void nmod_poly_integral(nmod_poly_t x_int, nmod_poly_t x)
     cdef void zmod_poly_attach_truncate(zmod_poly_t output, zmod_poly_t input, unsigned long n)
+    # Evaluation
+    #
+    # Comparison functions
+    #
+    cdef mp_limb_t nmod_poly_evaluate_nmod(nmod_poly_t poly, mp_limb_t c)
+    cdef void nmod_poly_evaluate_nmod_vec(mp_ptr ys, nmod_poly_t poly, mp_srcptr xs, long n)
     cdef int zmod_poly_equal(zmod_poly_t poly1, zmod_poly_t poly2)
+    # Interpolation
     cdef int zmod_poly_is_one(zmod_poly_t poly1)
+    cdef void nmod_poly_interpolate_nmod_vec(nmod_poly_t poly, mp_srcptr xs, mp_srcptr ys, long n)
+    #
+    # Reversal
+    #
+    # Composition
+    cdef void _zmod_poly_reverse(zmod_poly_t output, zmod_poly_t input, unsigned long length)
+    cdef void zmod_poly_reverse(zmod_poly_t output, zmod_poly_t input, unsigned long length)
+    cdef void nmod_poly_compose(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2)
+    #
+    # Monic polys
+    #
+    # Power series composition and reversion
+    cdef void zmod_poly_make_monic(zmod_poly_t output, zmod_poly_t pol)
+    cdef void nmod_poly_compose_series(nmod_poly_t res, nmod_poly_t poly1, nmod_poly_t poly2, long n)
+    cdef void nmod_poly_reverse_series(nmod_poly_t Qinv, nmod_poly_t Q, long n)
+    #
+    # Addition and subtraction
+    #
+    # GCD
+    cdef void zmod_poly_add(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef void zmod_poly_add_without_mod(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef void zmod_poly_sub(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef void _zmod_poly_sub(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef void zmod_poly_neg(zmod_poly_t res, zmod_poly_t poly)
+    cdef void nmod_poly_gcd(nmod_poly_t G, nmod_poly_t A, nmod_poly_t B)
+    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)
+    mp_limb_t nmod_poly_resultant(nmod_poly_t f, nmod_poly_t g)
+    #
+    # Shifting functions
+    #
+    # Square roots
+    cdef void zmod_poly_left_shift(zmod_poly_t res, zmod_poly_t poly, unsigned long k)
+    cdef void zmod_poly_right_shift(zmod_poly_t res, zmod_poly_t poly, unsigned long k)
+    cdef void nmod_poly_invsqrt_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_sqrt_series(nmod_poly_t g, nmod_poly_t h, long n)
+    int nmod_poly_sqrt(nmod_poly_t b, nmod_poly_t a)
+    #
+    # Polynomial multiplication
+    #
+    # All multiplication functions require that the modulus be no more than FLINT_BITS-1 bits
+    #
+    # Transcendental functions
+    cdef void zmod_poly_mul(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef void zmod_poly_sqr(zmod_poly_t res, zmod_poly_t poly)
+    cdef void nmod_poly_atan_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_tan_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_asin_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_sin_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_cos_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_asinh_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_atanh_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_sinh_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_cosh_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_tanh_series(nmod_poly_t g, nmod_poly_t h, long n)
+    cdef void nmod_poly_log_series(nmod_poly_t res, nmod_poly_t f, long n)
+    cdef void nmod_poly_exp_series(nmod_poly_t f, nmod_poly_t h, long)
     # Requires that poly1 bits + poly2 bits + log_length is not greater than 2*FLINT_BITS
+    # Inflation and deflation
+    cdef void zmod_poly_mul_KS(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits_input)
+    cdef void _zmod_poly_mul_KS(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits_input)
+    cdef unsigned long nmod_poly_deflation(nmod_poly_t input)
+    cdef void nmod_poly_deflate(nmod_poly_t result, nmod_poly_t input, unsigned long deflation)
+    cdef void nmod_poly_inflate(nmod_poly_t result, nmod_poly_t input, unsigned long inflation)
+    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)
+    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)
+    # Factoring
+    cdef void _zmod_poly_mul_classical(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef void __zmod_poly_mul_classical_mod_last(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits)
+    cdef void __zmod_poly_mul_classical_mod_throughout(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long bits)
+    cdef void zmod_poly_mul_classical(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef void _zmod_poly_sqr_classical(zmod_poly_t res, zmod_poly_t poly)
+    cdef void zmod_poly_sqr_classical(zmod_poly_t res, zmod_poly_t poly)
+    cdef void _zmod_poly_mul_classical_trunc(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
+    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)
+    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)
+    cdef void zmod_poly_mul_classical_trunc(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
+    cdef void _zmod_poly_mul_classical_trunc_left(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
+    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)
+    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)
+    cdef void zmod_poly_mul_classical_trunc_left(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
+    cdef void zmod_poly_mul_trunc_n(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
+    cdef void zmod_poly_mul_trunc_left_n(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, unsigned long trunc)
+    #
+    # Bit packing functions
+    #
+    cdef unsigned long zmod_poly_bits(zmod_poly_t poly)
+    cdef void _zmod_poly_bit_pack_mpn(mp_limb_t * res, zmod_poly_t poly, unsigned long bits, unsigned long length)
+    cdef void _zmod_poly_bit_unpack_mpn(zmod_poly_t poly, mp_limb_t *mpn, unsigned long length, unsigned long bits)
+    cdef void print_binary(unsigned long n, unsigned long len)
+    cdef void print_binary2(unsigned long n, unsigned long len, unsigned long space_bit)
+    #
+    # Scalar multiplication
+    #
+    cdef void _zmod_poly_scalar_mul(zmod_poly_t res, zmod_poly_t poly, unsigned long scalar)
+    cdef void zmod_poly_scalar_mul(zmod_poly_t res, zmod_poly_t poly, unsigned long scalar)
+    cdef void __zmod_poly_scalar_mul_without_mod(zmod_poly_t res, zmod_poly_t poly, unsigned long scalar)
+    #
+    # Division
+    #
+    cdef void zmod_poly_divrem_classical(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
+    cdef void __zmod_poly_divrem_classical_mod_last(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
+    cdef void zmod_poly_div_classical(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
+    cdef void __zmod_poly_div_classical_mod_last(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
+    cdef void zmod_poly_div_divconquer_recursive(zmod_poly_t Q, zmod_poly_t BQ, zmod_poly_t A, zmod_poly_t B)
+    cdef void zmod_poly_divrem_divconquer(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
+    cdef void zmod_poly_div_divconquer(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
+    #
+    # Newton Inversion
+    #
+    cdef void zmod_poly_newton_invert_basecase(zmod_poly_t Q_inv, zmod_poly_t Q, unsigned long n)
+    cdef void zmod_poly_newton_invert(zmod_poly_t Q_inv, zmod_poly_t Q, unsigned long n)
+    #
+    # Newton Division
+    #
+    cdef void zmod_poly_div_series(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B, unsigned long n)
+    cdef void zmod_poly_div_newton(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
+    cdef void zmod_poly_divrem_newton(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
+    cdef void zmod_poly_divrem(zmod_poly_t Q, zmod_poly_t R, zmod_poly_t A, zmod_poly_t B)
+    cdef void zmod_poly_div(zmod_poly_t Q, zmod_poly_t A, zmod_poly_t B)
+    #
+    # Resultant
+    #
+    cdef unsigned long zmod_poly_resultant_euclidean(zmod_poly_t a, zmod_poly_t b)
+    cdef unsigned long zmod_poly_resultant(zmod_poly_t a, zmod_poly_t b)
+    #
+    # GCD
+    #
+    cdef void zmod_poly_gcd(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    cdef int zmod_poly_gcd_invert(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2)
+    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)
+    # Composition / evaluation
+    cdef unsigned long zmod_poly_evaluate(zmod_poly_t, unsigned long)
+    cdef void zmod_poly_compose_horner(zmod_poly_t, zmod_poly_t, zmod_poly_t)
+    # Factorization
+    cdef bint zmod_poly_isirreducible(zmod_poly_t p)
+    ctypedef struct zmod_poly_factors_struct:
+        unsigned long num_factors
+        unsigned long* exponents
+        zmod_poly_t* factors
+    ctypedef zmod_poly_factors_struct* zmod_poly_factor_t
+    cdef void zmod_poly_factor_init(zmod_poly_factor_t)
+    cdef void zmod_poly_factor_clear(zmod_poly_factor_t)
+    cdef unsigned long zmod_poly_factor(zmod_poly_factor_t, zmod_poly_t)
+    cdef void zmod_poly_factor_square_free(zmod_poly_factor_t, zmod_poly_t)
+    cdef void zmod_poly_factor_berlekamp(zmod_poly_factor_t factors, zmod_poly_t f)
+    cdef void zmod_poly_factor_add(zmod_poly_factor_t fac, zmod_poly_t poly)
+    cdef void zmod_poly_factor_concat(zmod_poly_factor_t res, zmod_poly_factor_t fac)
+    cdef void zmod_poly_factor_print(zmod_poly_factor_t fac)
+    cdef void zmod_poly_factor_pow(zmod_poly_factor_t fac, unsigned long exp)
+    #
+    # Differentiation
+    #
+    cdef void zmod_poly_derivative(zmod_poly_t res, zmod_poly_t poly)
+    #
+    # Arithmetic modulo a polynomial
+    #
+    cdef void zmod_poly_mulmod(zmod_poly_t res, zmod_poly_t poly1, zmod_poly_t poly2, zmod_poly_t f)
+    cdef void zmod_poly_powmod(zmod_poly_t res,zmod_poly_t pol, long exp, zmod_poly_t f)
+    cdef void nmod_poly_factor_clear(nmod_poly_factor_t fac)
+    cdef void nmod_poly_factor_init(nmod_poly_factor_t fac)
+    cdef void nmod_poly_factor_insert(nmod_poly_factor_t fac, nmod_poly_t poly, unsigned long exp)
+    cdef void nmod_poly_factor_print(nmod_poly_factor_t fac)
+    cdef void nmod_poly_factor_concat(nmod_poly_factor_t res, nmod_poly_factor_t fac)
+    cdef void nmod_poly_factor_pow(nmod_poly_factor_t fac, unsigned long exp)
+    cdef unsigned long nmod_poly_remove(nmod_poly_t f, nmod_poly_t p)
+    cdef int nmod_poly_is_irreducible(nmod_poly_t f)
+    cdef int nmod_poly_is_squarefree(nmod_poly_t f)
+    cdef void nmod_poly_factor_cantor_zassenhaus(nmod_poly_factor_t res, nmod_poly_t f)
+    cdef void nmod_poly_factor_berlekamp(nmod_poly_factor_t factors, nmod_poly_t f)
+    cdef void nmod_poly_factor_squarefree(nmod_poly_factor_t res, nmod_poly_t f)
+    cdef mp_limb_t nmod_poly_factor_with_berlekamp(nmod_poly_factor_t result, nmod_poly_t input)
+    cdef mp_limb_t nmod_poly_factor_with_cantor_zassenhaus(nmod_poly_factor_t result, nmod_poly_t input)
+    cdef mp_limb_t nmod_poly_factor(nmod_poly_factor_t result, nmod_poly_t input)

sage/libs/flint/zmod_poly_linkage.pxi

diff --git a/sage/libs/flint/zmod_poly_linkage.pxi b/sage/libs/flint/zmod_poly_linkage.pxi

-                      a
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 from sage.libs.flint.zmod_poly cimport *, zmod_poly_t
 from sage.libs.flint.long_extras cimport *
+from sage.libs.flint.zmod_poly cimport *, nmod_poly_t
+from sage.libs.flint.ulong_extras cimport *
 include "../../ext/stdsage.pxi"
 cdef inline celement *celement_new(unsigned long n):
     cdef celement *g = <celement *>sage_malloc(sizeof(zmod_poly_t))
     zmod_poly_init(g, n)
+    cdef celement *g = <celement *>sage_malloc(sizeof(nmod_poly_t))
+    nmod_poly_init(g, n)
     return g
 cdef inline int celement_delete(zmod_poly_t e, unsigned long n):
     zmod_poly_clear(e)
+cdef inline int celement_delete(nmod_poly_t e, unsigned long n):
+    nmod_poly_clear(e)
     sage_free(e)
 cdef inline int celement_construct(zmod_poly_t e, unsigned long n):
+cdef inline int celement_construct(nmod_poly_t e, unsigned long n):
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
         sage: Q.<x> = GF(7)[]
     """
     zmod_poly_init(e, n)
+    nmod_poly_init(e, n)
 cdef inline int celement_destruct(zmod_poly_t e, unsigned long n):
+cdef inline int celement_destruct(nmod_poly_t e, unsigned long n):
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: Q.<x> = GF(7)[]
         sage: del x
     """
     zmod_poly_clear(e)
+    nmod_poly_clear(e)
 cdef inline int celement_gen(zmod_poly_t e, long i, unsigned long n) except -2:
+cdef inline int celement_gen(nmod_poly_t e, long i, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
         sage: Q.<x> = GF(7)[]
     """
     zmod_poly_zero(e)
     zmod_poly_set_coeff_ui(e, 1, 1)
+    nmod_poly_zero(e)
+    nmod_poly_set_coeff_ui(e, 1, 1)
 cdef object celement_repr(zmod_poly_t e, unsigned long n):
+cdef object celement_repr(nmod_poly_t e, unsigned long n):
     raise NotImplementedError
 cdef inline int celement_set(zmod_poly_t res, zmod_poly_t a, unsigned long n) except -2:
+cdef inline int celement_set(nmod_poly_t res, nmod_poly_t a, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
 *x
     """
     cdef unsigned long i
     if a.p <= n:
         zmod_poly_set(res, a)
+    if a.mod.n <= n:
+        nmod_poly_set(res, a)
     else:
         zmod_poly_zero(res)
+        nmod_poly_zero(res)
         for i from 0 <= i < a.length:
             zmod_poly_set_coeff_ui(res, i, zmod_poly_get_coeff_ui(a, i) % n)
+            nmod_poly_set_coeff_ui(res, i, nmod_poly_get_coeff_ui(a, i) % n)
 cdef inline int celement_set_si(zmod_poly_t res, long i, unsigned long n) except -2:
+cdef inline int celement_set_si(nmod_poly_t res, long i, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
     """
     while i < 0:
         i += n
     zmod_poly_zero(res)
+    nmod_poly_zero(res)
     if i:
         zmod_poly_set_coeff_ui(res, 0, <unsigned long>i)
+        nmod_poly_set_coeff_ui(res, 0, <unsigned long>i)
 cdef inline long celement_get_si(zmod_poly_t res, unsigned long n) except -2:
+cdef inline long celement_get_si(nmod_poly_t res, unsigned long n) except -2:
     raise NotImplementedError
 cdef inline bint celement_is_zero(zmod_poly_t a, unsigned long n) except -2:
+cdef inline bint celement_is_zero(nmod_poly_t a, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: Q(0).is_zero()
         True
     """
+    # is_zero doesn't exist
+    return zmod_poly_degree(a) == -1
+    return nmod_poly_is_zero(a)
 cdef inline bint celement_is_one(zmod_poly_t a, unsigned long n) except -2:
+cdef inline bint celement_is_one(nmod_poly_t a, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         False
     """
     return zmod_poly_is_one(a)
+    return nmod_poly_is_one(a)
 cdef inline bint celement_equal(zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline bint celement_equal(nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: (3*2)*x + 7 == 3*(2*x) + 1 + 1
         False
     """
     return zmod_poly_equal(a, b)
+    return nmod_poly_equal(a, b)
 cdef inline int celement_cmp(zmod_poly_t l, zmod_poly_t r, unsigned long n) except -2:
+cdef inline int celement_cmp(nmod_poly_t l, nmod_poly_t r, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: f < g
         True
     """
     cdef int deg_right = zmod_poly_degree(r)
     cdef int degdiff = deg_right - zmod_poly_degree(l)
+    cdef int deg_right = nmod_poly_degree(r)
+    cdef int degdiff = deg_right - nmod_poly_degree(l)
     cdef int i
     cdef unsigned long rcoeff, lcoeff
     if degdiff > 0:
 …
     elif degdiff < 0:
         return 1
     else:
         if zmod_poly_equal(l, r):
+        if nmod_poly_equal(l, r):
             return 0
         i = deg_right
         rcoeff = zmod_poly_get_coeff_ui(r, i)
         lcoeff = zmod_poly_get_coeff_ui(l, i)
+        rcoeff = nmod_poly_get_coeff_ui(r, i)
+        lcoeff = nmod_poly_get_coeff_ui(l, i)
         while rcoeff == lcoeff and i > 0:
             i -= 1
             rcoeff = zmod_poly_get_coeff_ui(r, i)
             lcoeff = zmod_poly_get_coeff_ui(l, i)
+            rcoeff = nmod_poly_get_coeff_ui(r, i)
+            lcoeff = nmod_poly_get_coeff_ui(l, i)
         return cmp(lcoeff, rcoeff)
 cdef long celement_len(zmod_poly_t a, unsigned long n) except -2:
+cdef long celement_len(nmod_poly_t a, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: P(0).degree()
         -1
     """
     return <long>zmod_poly_length(a)
+    return <long>nmod_poly_length(a)
 cdef inline int celement_add(zmod_poly_t res, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_add(nmod_poly_t res, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: x + 1
         x + 1
     """
     zmod_poly_add(res, a, b)
+    nmod_poly_add(res, a, b)
 cdef inline int celement_sub(zmod_poly_t res, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_sub(nmod_poly_t res, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: x - 1
         x + 6
     """
     zmod_poly_sub(res, a, b)
+    nmod_poly_sub(res, a, b)
 cdef inline int celement_neg(zmod_poly_t res, zmod_poly_t a, unsigned long n) except -2:
+cdef inline int celement_neg(nmod_poly_t res, nmod_poly_t a, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: -(x + 2)
 *x + 5
     """
     zmod_poly_neg(res, a)
+    nmod_poly_neg(res, a)
 cdef inline int celement_mul_scalar(zmod_poly_t res, zmod_poly_t p,
+cdef inline int celement_mul_scalar(nmod_poly_t res, nmod_poly_t p,
         object c, unsigned long n) except -2:
     """
     TESTS::
 …
         sage: p*983
 *x^2 + 18665*x + 17051
     """
     zmod_poly_scalar_mul(res, p, (<unsigned long>c)%n)
+    nmod_poly_scalar_mul_nmod(res, p, (<unsigned long>c)%n)
 cdef inline int celement_mul(zmod_poly_t res, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_mul(nmod_poly_t res, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: (x + 1) * (x + 2)
         x^2 + 3*x + 2
     """
     zmod_poly_mul(res, a, b)
+    nmod_poly_mul(res, a, b)
 cdef inline int celement_div(zmod_poly_t res, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_div(nmod_poly_t res, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     raise NotImplementedError
 cdef inline int celement_floordiv(zmod_poly_t res, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_floordiv(nmod_poly_t res, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: (x^2 + 3*x + 2)//(x + 2)
         x + 1
     """
     zmod_poly_div(res, a, b)
+    nmod_poly_div(res, a, b)
 cdef inline int celement_mod(zmod_poly_t res, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_mod(nmod_poly_t res, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         ...
         ZeroDivisionError
     """
     cdef zmod_poly_t q
+    cdef nmod_poly_t q
     cdef unsigned long leadcoeff, modulus
     zmod_poly_init(q, n)
     leadcoeff = zmod_poly_get_coeff_ui(b, zmod_poly_degree(b))
     modulus = zmod_poly_modulus(b)
     if (leadcoeff > 1 and z_gcd(modulus,leadcoeff) != 1):
+    nmod_poly_init(q, n)
+    leadcoeff = nmod_poly_get_coeff_ui(b, nmod_poly_degree(b))
+    modulus = nmod_poly_modulus(b)
+    if (leadcoeff > 1 and n_gcd(modulus,leadcoeff) != 1):
         raise ValueError("Leading coefficient of a must be invertible.")
     zmod_poly_divrem(q, res, a, b)
     zmod_poly_clear(q)
+    nmod_poly_divrem(q, res, a, b)
+    nmod_poly_clear(q)
 cdef inline int celement_quorem(zmod_poly_t q, zmod_poly_t r, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_quorem(nmod_poly_t q, nmod_poly_t r, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLES:
         sage: R.<x> = Integers(125)[]
 …
     """
     cdef unsigned long leadcoeff, modulus
     leadcoeff = zmod_poly_get_coeff_ui(b, zmod_poly_degree(b))
     modulus = zmod_poly_modulus(b)
     if (leadcoeff > 1 and z_gcd(modulus,leadcoeff) != 1):
+    leadcoeff = nmod_poly_get_coeff_ui(b, nmod_poly_degree(b))
+    modulus = nmod_poly_modulus(b)
+    if (leadcoeff > 1 and n_gcd(modulus,leadcoeff) != 1):
         raise ValueError("Leading coefficient of a must be invertible.")
     zmod_poly_divrem(q, r, a, b)
+    nmod_poly_divrem(q, r, a, b)
 cdef inline int celement_inv(zmod_poly_t res, zmod_poly_t a, unsigned long n) except -2:
+cdef inline int celement_inv(nmod_poly_t res, nmod_poly_t a, unsigned long n) except -2:
     raise NotImplementedError
 cdef inline int celement_pow(zmod_poly_t res, zmod_poly_t x, long e, zmod_poly_t modulus, unsigned long n) except -2:
+cdef inline int celement_pow(nmod_poly_t res, nmod_poly_t x, long e, nmod_poly_t modulus, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: f^5 % g
 *x + 17274
     """
     cdef zmod_poly_t pow2
     cdef zmod_poly_t q
     cdef zmod_poly_t tmp
+    cdef nmod_poly_t pow2
+    cdef nmod_poly_t q
+    cdef nmod_poly_t tmp
     zmod_poly_init(q, n)
     zmod_poly_init(tmp, n)
+    nmod_poly_init(q, n)
+    nmod_poly_init(tmp, n)
     if zmod_poly_degree(x) == 1 and zmod_poly_get_coeff_ui(x,0) == 0 and zmod_poly_get_coeff_ui(x,1) == 1:
         zmod_poly_zero(res)
         zmod_poly_set_coeff_ui(res,e,1)
+    if nmod_poly_degree(x) == 1 and nmod_poly_get_coeff_ui(x,0) == 0 and nmod_poly_get_coeff_ui(x,1) == 1:
+        nmod_poly_zero(res)
+        nmod_poly_set_coeff_ui(res,e,1)
     elif e == 0:
         zmod_poly_zero(res)
         zmod_poly_set_coeff_ui(res,0,1)
+        nmod_poly_zero(res)
+        nmod_poly_set_coeff_ui(res,0,1)
     elif e == 1:
         zmod_poly_set(res, x)
+        nmod_poly_set(res, x)
     elif e == 2:
         zmod_poly_sqr(res, x)
+        nmod_poly_mul(res, x, x)
     else:
         if res == x:
             zmod_poly_set(tmp, x)
+            nmod_poly_set(tmp, x)
             x = tmp
         zmod_poly_init(pow2, n)
         zmod_poly_set(pow2, x)
+        nmod_poly_init(pow2, n)
+        nmod_poly_set(pow2, x)
         if e % 2:
             zmod_poly_set(res, x)
+            nmod_poly_set(res, x)
         else:
             zmod_poly_zero(res)
             zmod_poly_set_coeff_ui(res, 0, 1)
+            nmod_poly_zero(res)
+            nmod_poly_set_coeff_ui(res, 0, 1)
         e = e >> 1
         while(e != 0):
             zmod_poly_sqr(pow2, pow2)
+            nmod_poly_mul(pow2, pow2, pow2)
             if e % 2:
                 zmod_poly_mul(res, res, pow2)
+                nmod_poly_mul(res, res, pow2)
             e = e >> 1
             if modulus != NULL:
                 zmod_poly_divrem(q, res, res, modulus)
         zmod_poly_clear(pow2)
+                nmod_poly_divrem(q, res, res, modulus)
+        nmod_poly_clear(pow2)
     if modulus != NULL:
         zmod_poly_divrem(q, res, res, modulus)
     zmod_poly_clear(q)
     zmod_poly_clear(tmp)
+        nmod_poly_divrem(q, res, res, modulus)
+    nmod_poly_clear(q)
+    nmod_poly_clear(tmp)
 cdef inline int celement_gcd(zmod_poly_t res, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_gcd(nmod_poly_t res, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         True
     """
     if celement_is_zero(b, n):
         zmod_poly_set(res, a)
+        nmod_poly_set(res, a)
         return 0
     zmod_poly_gcd(res, a, b)
     cdef unsigned long leadcoeff = zmod_poly_get_coeff_ui(res, zmod_poly_degree(res))
     cdef unsigned long modulus = zmod_poly_modulus(res)
     if z_gcd(modulus,leadcoeff) == 1:
         zmod_poly_make_monic(res, res)
+    nmod_poly_gcd(res, a, b)
+    cdef unsigned long leadcoeff = nmod_poly_get_coeff_ui(res, nmod_poly_degree(res))
+    cdef unsigned long modulus = nmod_poly_modulus(res)
+    if n_gcd(modulus,leadcoeff) == 1:
+        nmod_poly_make_monic(res, res)
 cdef inline int celement_xgcd(zmod_poly_t res, zmod_poly_t s, zmod_poly_t t, zmod_poly_t a, zmod_poly_t b, unsigned long n) except -2:
+cdef inline int celement_xgcd(nmod_poly_t res, nmod_poly_t s, nmod_poly_t t, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """
     EXAMPLE:
         sage: P.<x> = GF(32003)[]
 …
         sage: (G//d)*d == G
         True
     """
     zmod_poly_xgcd(res, s, t, a, b)
+    nmod_poly_xgcd(res, s, t, a, b)
 cdef factor_helper(Polynomial_zmod_flint poly, bint squarefree=False):
 …
         sage: (prod(P.random_element()^i for i in range(5))).squarefree_decomposition()
         (54) * (x^2 + 55*x + 839) * (x^2 + 48*x + 496)^2 * (x^2 + 435*x + 104)^3 * (x^2 + 176*x + 156)^4
     """
     cdef zmod_poly_factor_t factors_c
     zmod_poly_factor_init(factors_c)
+    cdef nmod_poly_factor_t factors_c
+    nmod_poly_factor_init(factors_c)
     if squarefree:
         zmod_poly_factor_square_free(factors_c, &poly.x)
+        nmod_poly_factor_squarefree(factors_c, &poly.x)
     else:
         zmod_poly_factor(factors_c, &poly.x)
+        nmod_poly_factor(factors_c, &poly.x)
     factor_list = []
     cdef Polynomial_zmod_flint t
     for i in range(factors_c.num_factors):
+    for i in range(factors_c.num):
         t = poly._new()
         zmod_poly_swap(&t.x, factors_c.factors[i])
         factor_list.append((t, factors_c.exponents[i]))
+        nmod_poly_swap(&t.x, &factors_c.p[i])
+        factor_list.append((t, factors_c.exp[i]))
     zmod_poly_factor_clear(factors_c)
+    nmod_poly_factor_clear(factors_c)
     return Factorization(factor_list, unit=poly.leading_coefficient(),
             sort=(not squarefree))

sage/modular/modsym/apply.pyx

diff --git a/sage/modular/modsym/apply.pyx b/sage/modular/modsym/apply.pyx

-                      a
         fmpz_poly_set_coeff_si(self.g, 1, c)
         # h = (f**i)*(g**(j-i))
         fmpz_poly_power(self.ff, self.f, i)
         fmpz_poly_power(self.gg, self.g, j-i)
+        fmpz_poly_pow(self.ff, self.f, i)
+        fmpz_poly_pow(self.gg, self.g, j-i)
         fmpz_poly_mul(ans, self.ff, self.gg)
         return 0

sage/rings/fraction_field_FpT.pxd

diff --git a/sage/rings/fraction_field_FpT.pxd b/sage/rings/fraction_field_FpT.pxd

-                      a
 from sage.categories.map cimport Section
 cdef class FpTElement(RingElement):
     cdef zmod_poly_t _numer, _denom
+    cdef nmod_poly_t _numer, _denom
     cdef bint initalized
     cdef long p
 …
     cdef parent
     cdef long degree
     cdef FpTElement cur
     cdef zmod_poly_t g
+    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
             numer = parent.poly_ring(numer)
             denom = parent.poly_ring(denom)
         self.p = parent.p
         zmod_poly_init(self._numer, self.p)
         zmod_poly_init(self._denom, self.p)
+        nmod_poly_init(self._numer, self.p)
+        nmod_poly_init(self._denom, self.p)
         self.initalized = True
         cdef long n
         for n, a in enumerate(numer):
             zmod_poly_set_coeff_ui(self._numer, n, a)
+            nmod_poly_set_coeff_ui(self._numer, n, a)
         for n, a in enumerate(denom):
             zmod_poly_set_coeff_ui(self._denom, n, a)
+            nmod_poly_set_coeff_ui(self._denom, n, a)
         if reduce:
             normalize(self._numer, self._denom, self.p)
 …
             sage: del t # indirect doctest
         """
         if self.initalized:
             zmod_poly_clear(self._numer)
             zmod_poly_clear(self._denom)
+            nmod_poly_clear(self._numer)
+            nmod_poly_clear(self._denom)
     def __reduce__(self):
         """
 …
         cdef FpTElement x = <FpTElement>PY_NEW(FpTElement)
         x._parent = self._parent
         x.p = self.p
         zmod_poly_init_precomp(x._numer, x.p, self._numer.p_inv)
         zmod_poly_init_precomp(x._denom, x.p, self._numer.p_inv)
+        nmod_poly_init_preinv(x._numer, x.p, self._numer.mod.ninv)
+        nmod_poly_init_preinv(x._denom, x.p, self._numer.mod.ninv)
         x.initalized = True
         return x
 …
         cdef FpTElement x = <FpTElement>PY_NEW(FpTElement)
         x._parent = self._parent
         x.p = self.p
         zmod_poly_init2_precomp(x._numer, x.p, self._numer.p_inv, self._numer.length)
         zmod_poly_init2_precomp(x._denom, x.p, self._denom.p_inv, self._denom.length)
         zmod_poly_set(x._numer, self._numer)
         zmod_poly_set(x._denom, self._denom)
+        nmod_poly_init2_preinv(x._numer, x.p, self._numer.mod.ninv, self._numer.length)
+        nmod_poly_init2_preinv(x._denom, x.p, self._denom.mod.ninv, self._denom.length)
+        nmod_poly_set(x._numer, self._numer)
+        nmod_poly_set(x._denom, self._denom)
         x.initalized = True
         return x
 …
             t^6 + 3*t^4 + 10*t^3 + 3*t^2 + 1
         """
         cdef Polynomial_zmod_flint res = <Polynomial_zmod_flint>PY_NEW(Polynomial_zmod_flint)
         zmod_poly_init2_precomp(&res.x, self.p, self._numer.p_inv, self._numer.length)
         zmod_poly_set(&res.x, self._numer)
+        nmod_poly_init2_preinv(&res.x, self.p, self._numer.mod.ninv, self._numer.length)
+        nmod_poly_set(&res.x, self._numer)
         res._parent = self._parent.poly_ring
         res._cparent = get_cparent(self._parent.poly_ring)
         return res
 …
             t^3
         """
         cdef Polynomial_zmod_flint res = <Polynomial_zmod_flint>PY_NEW(Polynomial_zmod_flint)
         zmod_poly_init2_precomp(&res.x, self.p, self._denom.p_inv, self._denom.length)
         zmod_poly_set(&res.x, self._denom)
+        nmod_poly_init2_preinv(&res.x, self.p, self._denom.mod.ninv, self._denom.length)
+        nmod_poly_set(&res.x, self._denom)
         res._parent = self._parent.poly_ring
         res._cparent = get_cparent(self._parent.poly_ring)
         return res
 …
             sage: (1-t)/t
             (16*t + 1)/t
         """
         if zmod_poly_degree(self._denom) == 0 and zmod_poly_get_coeff_ui(self._denom, 0) == 1:
+        if nmod_poly_degree(self._denom) == 0 and nmod_poly_get_coeff_ui(self._denom, 0) == 1:
             return repr(self.numer())
         else:
             numer_s = repr(self.numer())
 …
             sage: latex((t + 1)/(t-1))
             \frac{t + 1}{t + 6}
         """
         if zmod_poly_degree(self._denom) == 0 and zmod_poly_get_coeff_ui(self._denom, 0) == 1:
+        if nmod_poly_degree(self._denom) == 0 and nmod_poly_get_coeff_ui(self._denom, 0) == 1:
             return self.numer()._latex_()
         else:
             return "\\frac{%s}{%s}" % (self.numer()._latex_(), self.denom()._latex_())
 …
             False
         """
         # They are normalized.
         cdef int j = sage_cmp_zmod_poly_t(self._numer, (<FpTElement>other)._numer)
+        cdef int j = sage_cmp_nmod_poly_t(self._numer, (<FpTElement>other)._numer)
         if j: return j
         return sage_cmp_zmod_poly_t(self._denom, (<FpTElement>other)._denom)
+        return sage_cmp_nmod_poly_t(self._denom, (<FpTElement>other)._denom)
     def __hash__(self):
         """
 …
             (4*t^2 + 3)/(t + 4)
         """
         cdef FpTElement x = self._copy_c()
         zmod_poly_neg(x._numer, x._numer)
+        nmod_poly_neg(x._numer, x._numer)
         return x
     def __invert__(self):
 …
             sage: ~a # indirect doctest
             (t + 4)/(t^2 + 2)
         """
         if zmod_poly_degree(self._numer) == -1:
+        if nmod_poly_degree(self._numer) == -1:
             raise ZeroDivisionError
         cdef FpTElement x = self._copy_c()
         zmod_poly_swap(x._numer, x._denom)
+        nmod_poly_swap(x._numer, x._denom)
         return x
     cpdef ModuleElement _add_(self, ModuleElement _other):
 …
         """
         cdef FpTElement other = <FpTElement>_other
         cdef FpTElement x = self._new_c()
         zmod_poly_mul(x._numer, self._numer, other._denom)
         zmod_poly_mul(x._denom, self._denom, other._numer) # use x._denom as a temp
         zmod_poly_add(x._numer, x._numer, x._denom)
         zmod_poly_mul(x._denom, self._denom, other._denom)
+        nmod_poly_mul(x._numer, self._numer, other._denom)
+        nmod_poly_mul(x._denom, self._denom, other._numer) # use x._denom as a temp
+        nmod_poly_add(x._numer, x._numer, x._denom)
+        nmod_poly_mul(x._denom, self._denom, other._denom)
         normalize(x._numer, x._denom, self.p)
         return x
 …
         """
         cdef FpTElement other = <FpTElement>_other
         cdef FpTElement x = self._new_c()
         zmod_poly_mul(x._numer, self._numer, other._denom)
         zmod_poly_mul(x._denom, self._denom, other._numer) # use x._denom as a temp
         zmod_poly_sub(x._numer, x._numer, x._denom)
         zmod_poly_mul(x._denom, self._denom, other._denom)
+        nmod_poly_mul(x._numer, self._numer, other._denom)
+        nmod_poly_mul(x._denom, self._denom, other._numer) # use x._denom as a temp
+        nmod_poly_sub(x._numer, x._numer, x._denom)
+        nmod_poly_mul(x._denom, self._denom, other._denom)
         normalize(x._numer, x._denom, self.p)
         return x
 …
         """
         cdef FpTElement other = <FpTElement>_other
         cdef FpTElement x = self._new_c()
         zmod_poly_mul(x._numer, self._numer, other._numer)
         zmod_poly_mul(x._denom, self._denom, other._denom)
+        nmod_poly_mul(x._numer, self._numer, other._numer)
+        nmod_poly_mul(x._denom, self._denom, other._denom)
         normalize(x._numer, x._denom, self.p)
         return x
 …
             t + 1
         """
         cdef FpTElement other = <FpTElement>_other
         if zmod_poly_degree(other._numer) == -1:
+        if nmod_poly_degree(other._numer) == -1:
             raise ZeroDivisionError
         cdef FpTElement x = self._new_c()
         zmod_poly_mul(x._numer, self._numer, other._denom)
         zmod_poly_mul(x._denom, self._denom, other._numer)
+        nmod_poly_mul(x._numer, self._numer, other._denom)
+        nmod_poly_mul(x._denom, self._denom, other._numer)
         normalize(x._numer, x._denom, self.p)
         return x
 …
         """
         cdef FpTElement next = self._copy_c()
         cdef long a, lead
         cdef zmod_poly_t g
         if zmod_poly_degree(self._numer) == -1:
+        cdef nmod_poly_t g
+        if nmod_poly_degree(self._numer) == -1:
             # self should be normalized, so denom == 1
             zmod_poly_set_coeff_ui(next._numer, 0, 1)
+            nmod_poly_set_coeff_ui(next._numer, 0, 1)
             return next
         lead = zmod_poly_leading(next._numer)
+        lead = nmod_poly_leading(next._numer)
         if lead < self.p - 1:
             a = mod_inverse_int(lead, self.p)
             # no overflow since self.p < 2^16
             a = a * (lead + 1) % self.p
             zmod_poly_scalar_mul(next._numer, next._numer, a)
+            nmod_poly_scalar_mul_nmod(next._numer, next._numer, a)
         else:
             a = mod_inverse_int(lead, self.p)
             zmod_poly_scalar_mul(next._numer, next._numer, a)
+            nmod_poly_scalar_mul_nmod(next._numer, next._numer, a)
             # now both next._numer and next._denom are monic.  We figure out which is lexicographically bigger:
             a = zmod_poly_cmp(next._numer, next._denom)
+            a = nmod_poly_cmp(next._numer, next._denom)
             if a == 0:
                 # next._numer and next._denom are relatively prime, so they're both 1.
                 zmod_poly_inc(next._denom, True)
+                nmod_poly_inc(next._denom, True)
                 return next
             zmod_poly_set(next._denom, next._numer)
             zmod_poly_set(next._numer, self._denom)
+            nmod_poly_set(next._denom, next._numer)
+            nmod_poly_set(next._numer, self._denom)
             if a < 0:
                 # since next._numer is smaller, we flip and return the inverse.
                 return next
             elif a > 0:
                 # since next._numer is bigger, we're in the flipped phase.  We flip back, and increment the numerator (until we reach the denominator).
                 zmod_poly_init(g, self.p)
+                nmod_poly_init(g, self.p)
                 try:
                     while True:
                         zmod_poly_inc(next._numer, True)
                         if zmod_poly_equal(next._numer, next._denom):
+                        nmod_poly_inc(next._numer, True)
+                        if nmod_poly_equal(next._numer, next._denom):
                             # Since we've reached the denominator, we reset the numerator to 1 and increment the denominator.
                             zmod_poly_inc(next._denom, True)
                             zmod_poly_zero(next._numer)
                             zmod_poly_set_coeff_ui(next._numer, 0, 1)
+                            nmod_poly_inc(next._denom, True)
+                            nmod_poly_zero(next._numer)
+                            nmod_poly_set_coeff_ui(next._numer, 0, 1)
                             break
                         else:
                             # otherwise, we keep incrementing until we have a relatively prime numerator.
                             zmod_poly_gcd(g, next._numer, next._denom)
                             if zmod_poly_is_one(g):
+                            nmod_poly_gcd(g, next._numer, next._denom)
+                            if nmod_poly_is_one(g):
                                 break
                 finally:
                     zmod_poly_clear(g)
+                    nmod_poly_clear(g)
         return next
     cpdef _sqrt_or_None(self):
 …
             []
         """
         if zmod_poly_degree(self._numer) == -1:
+        if nmod_poly_degree(self._numer) == -1:
             return self
+        if not zmod_poly_sqrt_check(self._numer) or not zmod_poly_sqrt_check(self._denom):
+            return None
+        cdef zmod_poly_t numer
+        cdef zmod_poly_t denom
+        cdef nmod_poly_t numer
+        cdef nmod_poly_t denom
         cdef FpTElement res
+        try:
+            zmod_poly_init(denom, self.p)
+            zmod_poly_init(numer, self.p)
+            if not zmod_poly_sqrt0(numer, self._numer):
+                return None
+            if not zmod_poly_sqrt0(denom, self._denom):
+                return None
+        nmod_poly_init(denom, self.p)
+        nmod_poly_init(numer, self.p)
+        if nmod_poly_sqrt(numer, self._numer) and nmod_poly_sqrt(denom, self._denom):
             res = self._new_c()
             zmod_poly_swap(numer, res._numer)
             zmod_poly_swap(denom, res._denom)
+            nmod_poly_swap(numer, res._numer)
+            nmod_poly_swap(denom, res._denom)
             return res
+        finally:
+            zmod_poly_clear(numer)
+            zmod_poly_clear(denom)
+        else:
+            nmod_poly_clear(numer)
+            nmod_poly_clear(denom)
+            return None
     cpdef bint is_square(self):
         """
         Returns True if this element is the square of another element of the fraction field.
 …
         assert dummy is None
         cdef FpTElement x = self._new_c()
         if e >= 0:
             zmod_poly_pow(x._numer, self._numer, e)
             zmod_poly_pow(x._denom, self._denom, e)
+            nmod_poly_pow(x._numer, self._numer, e)
+            nmod_poly_pow(x._denom, self._denom, e)
         else:
             zmod_poly_pow(x._denom, self._numer, -e)
             zmod_poly_pow(x._numer, self._denom, -e)
             if zmod_poly_leading(x._denom) != 1:
                 a = mod_inverse_int(zmod_poly_leading(x._denom), self.p)
                 zmod_poly_scalar_mul(x._numer, x._numer, a)
                 zmod_poly_scalar_mul(x._denom, x._denom, a)
+            nmod_poly_pow(x._denom, self._numer, -e)
+            nmod_poly_pow(x._numer, self._denom, -e)
+            if nmod_poly_leading(x._denom) != 1:
+                a = mod_inverse_int(nmod_poly_leading(x._denom), self.p)
+                nmod_poly_scalar_mul_nmod(x._numer, x._numer, a)
+                nmod_poly_scalar_mul_nmod(x._denom, x._denom, a)
         return x
 …
             sage: I
             <sage.rings.fraction_field_FpT.FpT_iter object at ...>
         """
         zmod_poly_init(self.g, parent.characteristic())
+        nmod_poly_init(self.g, parent.characteristic())
     def __dealloc__(self):
         """
 …
             sage: I = FpT_iter(K, 3)
             sage: del I # indirect doctest
         """
         zmod_poly_clear(self.g)
+        nmod_poly_clear(self.g)
     def __iter__(self):
         """
 …
             next = self.cur._copy_c()
             sig_on()
             while True:
                 zmod_poly_inc(next._numer, False)
                 if zmod_poly_degree(next._numer) > self.degree:
                     zmod_poly_inc(next._denom, True)
                     if zmod_poly_degree(next._denom) > self.degree:
+                nmod_poly_inc(next._numer, False)
+                if nmod_poly_degree(next._numer) > self.degree:
+                    nmod_poly_inc(next._denom, True)
+                    if nmod_poly_degree(next._denom) > self.degree:
                         sig_off()
                         raise StopIteration
                     zmod_poly_zero(next._numer)
                     zmod_poly_set_coeff_ui(next._numer, 0, 1)
                 zmod_poly_gcd(self.g, next._numer, next._denom)
                 if zmod_poly_is_one(self.g):
+                    nmod_poly_zero(next._numer)
+                    nmod_poly_set_coeff_ui(next._numer, 0, 1)
+                nmod_poly_gcd(self.g, next._numer, next._denom)
+                if nmod_poly_is_one(self.g):
                     break
             sig_off()
             self.cur = next
 #            self.cur = self.cur.next()
 #            if zmod_poly_degree(self.cur._numer) > self.degree:
+#            if nmod_poly_degree(self.cur._numer) > self.degree:
 #                raise StopIteration
         return self.cur
 …
         cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
         ans._parent = self._codomain
         ans.p = self.p
         zmod_poly_init(ans._numer, ans.p)
         zmod_poly_init(ans._denom, ans.p)
         zmod_poly_set(ans._numer, &x.x)
         zmod_poly_set_coeff_ui(ans._denom, 0, 1)
+        nmod_poly_init(ans._numer, ans.p)
+        nmod_poly_init(ans._denom, ans.p)
+        nmod_poly_set(ans._numer, &x.x)
+        nmod_poly_set_coeff_ui(ans._denom, 0, 1)
         ans.initalized = True
         return ans
 …
         cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
         ans._parent = self._codomain
         ans.p = self.p
         zmod_poly_init(ans._numer, ans.p)
         zmod_poly_init(ans._denom, ans.p)
+        nmod_poly_init(ans._numer, ans.p)
+        nmod_poly_init(ans._denom, ans.p)
         cdef long r
         zmod_poly_set(ans._numer, &x.x)
+        nmod_poly_set(ans._numer, &x.x)
         if len(args) == 0:
             zmod_poly_set_coeff_ui(ans._denom, 0, 1)
+            nmod_poly_set_coeff_ui(ans._denom, 0, 1)
         elif len(args) == 1:
             y = args[0]
             if PY_TYPE_CHECK(y, Integer):
                 r = mpz_fdiv_ui((<Integer>y).value, self.p)
                 if r == 0:
                     raise ZeroDivisionError
                 zmod_poly_set_coeff_ui(ans._denom, 0, r)
+                nmod_poly_set_coeff_ui(ans._denom, 0, r)
             else:
                 # could use the coerce keyword being set to False to not check this...
                 if not (PY_TYPE_CHECK(y, Element) and y.parent() is self._domain):
                     # We could special case integers and GF(p) elements here.
                     y = self._domain(y)
                 zmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
+                nmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
         else:
             raise ValueError, "FpT only supports two positional arguments"
         if not (kwds.has_key('reduce') and not kwds['reduce']):
 …
         """
         cdef FpTElement x = <FpTElement?>_x
         cdef Polynomial_zmod_flint ans
         if zmod_poly_degree(x._denom) != 0:
+        if nmod_poly_degree(x._denom) != 0:
             normalize(x._numer, x._denom, self.p)
             if zmod_poly_degree(x._denom) != 0:
+            if nmod_poly_degree(x._denom) != 0:
                 raise ValueError, "not integral"
         ans = PY_NEW(Polynomial_zmod_flint)
         if zmod_poly_get_coeff_ui(x._denom, 0) != 1:
+        if nmod_poly_get_coeff_ui(x._denom, 0) != 1:
             normalize(x._numer, x._denom, self.p)
         zmod_poly_init(&ans.x, self.p)
         zmod_poly_set(&ans.x, x._numer)
+        nmod_poly_init(&ans.x, self.p)
+        nmod_poly_set(&ans.x, x._numer)
         ans._parent = self._codomain
         ans._cparent = get_cparent(self._codomain)
         return ans
 …
         cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
         ans._parent = self._codomain
         ans.p = self.p
         zmod_poly_init(ans._numer, ans.p)
         zmod_poly_init(ans._denom, ans.p)
         zmod_poly_set_coeff_ui(ans._numer, 0, x.ivalue)
         zmod_poly_set_coeff_ui(ans._denom, 0, 1)
+        nmod_poly_init(ans._numer, ans.p)
+        nmod_poly_init(ans._denom, ans.p)
+        nmod_poly_set_coeff_ui(ans._numer, 0, x.ivalue)
+        nmod_poly_set_coeff_ui(ans._denom, 0, 1)
         ans.initalized = True
         return ans
 …
         cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
         ans._parent = self._codomain
         ans.p = self.p
         zmod_poly_init(ans._numer, ans.p)
         zmod_poly_init(ans._denom, ans.p)
+        nmod_poly_init(ans._numer, ans.p)
+        nmod_poly_init(ans._denom, ans.p)
         cdef long r
         zmod_poly_set_coeff_ui(ans._numer, 0, x.ivalue)
+        nmod_poly_set_coeff_ui(ans._numer, 0, x.ivalue)
         if len(args) == 0:
             zmod_poly_set_coeff_ui(ans._denom, 0, 1)
+            nmod_poly_set_coeff_ui(ans._denom, 0, 1)
         if len(args) == 1:
             y = args[0]
             if PY_TYPE_CHECK(y, Integer):
                 r = mpz_fdiv_ui((<Integer>y).value, self.p)
                 if r == 0:
                     raise ZeroDivisionError
                 zmod_poly_set_coeff_ui(ans._denom, 0, r)
+                nmod_poly_set_coeff_ui(ans._denom, 0, r)
             else:
                 R = self._codomain.ring_of_integers()
                 # could use the coerce keyword being set to False to not check this...
                 if not (PY_TYPE_CHECK(y, Element) and y.parent() is R):
                     # We could special case integers and GF(p) elements here.
                     y = R(y)
                 zmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
+                nmod_poly_set(ans._denom, &((<Polynomial_zmod_flint?>y).x))
         else:
             raise ValueError, "FpT only supports two positional arguments"
         if not (kwds.has_key('reduce') and not kwds['reduce']):
 …
         """
         cdef FpTElement x = <FpTElement?>_x
         cdef IntegerMod_int ans
         if zmod_poly_degree(x._denom) != 0 or zmod_poly_degree(x._numer) > 0:
+        if nmod_poly_degree(x._denom) != 0 or nmod_poly_degree(x._numer) > 0:
             normalize(x._numer, x._denom, self.p)
             if zmod_poly_degree(x._denom) != 0:
+            if nmod_poly_degree(x._denom) != 0:
                 raise ValueError, "not integral"
             if zmod_poly_degree(x._numer) > 0:
+            if nmod_poly_degree(x._numer) > 0:
                 raise ValueError, "not constant"
         ans = PY_NEW(IntegerMod_int)
         ans.__modulus = self._codomain._pyx_order
         if zmod_poly_get_coeff_ui(x._denom, 0) != 1:
+        if nmod_poly_get_coeff_ui(x._denom, 0) != 1:
             normalize(x._numer, x._denom, self.p)
         ans.ivalue = zmod_poly_get_coeff_ui(x._numer, 0)
+        ans.ivalue = nmod_poly_get_coeff_ui(x._numer, 0)
         ans._parent = self._codomain
         return ans
 …
         cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
         ans._parent = self._codomain
         ans.p = self.p
         zmod_poly_init(ans._numer, ans.p)
         zmod_poly_init(ans._denom, ans.p)
         zmod_poly_set_coeff_ui(ans._numer, 0, mpz_fdiv_ui(x.value, self.p))
         zmod_poly_set_coeff_ui(ans._denom, 0, 1)
+        nmod_poly_init(ans._numer, ans.p)
+        nmod_poly_init(ans._denom, ans.p)
+        nmod_poly_set_coeff_ui(ans._numer, 0, mpz_fdiv_ui(x.value, self.p))
+        nmod_poly_set_coeff_ui(ans._denom, 0, 1)
         ans.initalized = True
         return ans
 …
         cdef FpTElement ans = <FpTElement>PY_NEW(FpTElement)
         ans._parent = self._codomain
         ans.p = self.p
         zmod_poly_init(ans._numer, ans.p)
         zmod_poly_init(ans._denom, ans.p)
+        nmod_poly_init(ans._numer, ans.p)
+        nmod_poly_init(ans._denom, ans.p)
         cdef long r