/*=============================================================================

    This file is part of FLINT.

    FLINT is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    FLINT is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with FLINT; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA

=============================================================================*/
/******************************************************************************

    Copyright (C) 2009, 2008 William Hart
    Copyright (C) 2011 Fredrik Johansson
    Copyright (C) 2012 Sebastian Pancratz
    Copyright (C) 2012,2013 Andres Goens
    Copyright (C) 2013 Mike Hansen

******************************************************************************/

*******************************************************************************

    Memory management

*******************************************************************************

void fq_poly_init(fq_poly_t poly, const fq_ctx_t ctx)

    Initialises \code{poly} for use, with context ctx, and setting its
    length to zero. A corresponding call to \code{fq_poly_clear()}
    must be made after finishing with the \code{fq_poly_t} to free the
    memory used by the polynomial.

void fq_poly_init2(fq_poly_t poly, slong alloc, const fq_ctx_t ctx)

    Initialises \code{poly} with space for at least \code{alloc}
    coefficients and sets the length to zero.  The allocated
    coefficients are all set to zero.  A corresponding call to
    \code{fq_poly_clear()} must be made after finishing with the
    \code{fq_poly_t} to free the memory used by the polynomial.

void fq_poly_realloc(fq_poly_t poly, slong alloc, const fq_ctx_t ctx)

    Reallocates the given polynomial to have space for \code{alloc}
    coefficients.  If \code{alloc} is zero the polynomial is cleared
    and then reinitialised.  If the current length is greater than
    \code{alloc} the polynomial is first truncated to length
    \code{alloc}.

void fq_poly_fit_length(fq_poly_t poly, slong len, const fq_ctx_t ctx)

    If \code{len} is greater than the number of coefficients currently
    allocated, then the polynomial is reallocated to have space for at
    least \code{len} coefficients.  No data is lost when calling this
    function.

    The function efficiently deals with the case where
    \code{fit_length} is called many times in small increments by at
    least doubling the number of allocated coefficients when length is
    larger than the number of coefficients currently allocated.

void _fq_poly_set_length(fq_poly_t poly, slong newlen, const fq_ctx_t ctx)

    Sets the coefficients of \code{poly} beyond \code{len} to zero and
    sets the length of \code{poly} to \code{len}.

void fq_poly_clear(fq_poly_t poly, const fq_ctx_t ctx)

    Clears the given polynomial, releasing any memory used.  It must
    be reinitialised in order to be used again.

void _fq_poly_normalise(fq_poly_t poly, const fq_ctx_t ctx)

    Sets the length of \code{poly} so that the top coefficient is
    non-zero.  If all coefficients are zero, the length is set to
    zero.  This function is mainly used internally, as all functions
    guarantee normalisation.

void _fq_poly_normalise2(fq_struct *poly, slong *length, const fq_ctx_t ctx)

    Sets the length \code{length} of \code{(poly,length)} so that the
    top coefficient is non-zero. If all coefficients are zero, the
    length is set to zero. This function is mainly used internally, as
    all functions guarantee normalisation.

void fq_poly_truncate(fq_poly_t poly, slong newlen, const fq_ctx_t ctx)

    Truncates the polynomial to length at most~$n$.

void _fq_poly_reverse(fq_struct* output, const fq_struct* input, slong len,
                      slong m, const fq_ctx_t ctx)

    Sets \code{output} to the reverse of \code{input}, which is of
    length \code{len}, but thinking of it as a polynomial of
    length~\code{m}, notionally zero-padded if necessary. The
    length~\code{m} must be non-negative, but there are no other
    restrictions. The polynomial \code{output} must have space for
    \code{m} coefficients.

void fq_poly_reverse(fq_poly_t output, const fq_poly_t input, slong m,
                     const fq_ctx_t ctx)

    Sets \code{output} to the reverse of \code{input}, thinking of it
    as a polynomial of length~\code{m}, notionally zero-padded if
    necessary).  The length~\code{m} must be non-negative, but there
    are no other restrictions. The output polynomial will be set to
    length~\code{m} and then normalised.

*******************************************************************************

    Polynomial parameters

*******************************************************************************

long fq_poly_degree(fq_poly_t poly, const fq_ctx_t ctx)

    Returns the degree of the polynomial \code{poly}.

long fq_poly_length(fq_poly_t poly, const fq_ctx_t ctx)

    Returns the length of the polynomial \code{poly}.

fq_struct * fq_poly_lead(const fq_poly_t poly, const fq_ctx_t ctx)

    Returns a pointer to the leading coefficient of \code{poly}, or
    \code{NULL} if \code{poly} is the zero polynomial.

*******************************************************************************

    Randomisation

*******************************************************************************

void fq_poly_randtest(fq_poly_t f, flint_rand_t state,
                      slong len, const fq_ctx_t ctx)

    Sets $f$ to a random polynomial of length at most \code{len}
    with entries in the field described by \code{ctx}.

void fq_poly_randtest_not_zero(fq_poly_t f, flint_rand_t state,
                               slong len, const fq_ctx_t ctx)

    Same as \code{fq_poly_randtest} but guarantees that the polynomial
    is not zero.

void fq_poly_randtest_monic(fq_poly_t f, flint_rand_t state,
                            slong len, const fq_ctx_t ctx)

    Sets $f$ to a random monic polynomial of length \code{len} with
    entries in the field described by \code{ctx}.

void fq_poly_randtest_irreducible(fq_poly_t f, flint_rand_t state,
                                  slong len, const fq_ctx_t ctx)

    Sets $f$ to a random monic, irreducible polynomial of length
    \code{len} with entries in the field described by \code{ctx}.

*******************************************************************************

    Assignment and basic manipulation

*******************************************************************************

void _fq_poly_set(fq_struct *rop, const fq_struct *op, slong len,
                  const fq_ctx_t ctx)

    Sets \code{(rop, len}) to \code{(op, len)}.

void fq_poly_set(fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx)

    Sets the polynomial \code{poly1} to the polynomial \code{poly2}.

void fq_poly_set_fq(fq_poly_t poly, const fq_t c, const fq_ctx_t ctx)

    Sets the polynomial \code{poly} to \code{c}.

void fq_poly_swap(fq_poly_t op1, fq_poly_t op2, const fq_ctx_t ctx)

    Swaps the two polynomials \code{op1} and \code{op2}.

void _fq_poly_zero(fq_struct *rop, slong len, const fq_ctx_t ctx)

    Sets \code{(rop, len)} to the zero polynomial.

void fq_poly_zero(fq_poly_t poly, const fq_ctx_t ctx)

    Sets \code{poly} to the zero polynomial.

void void fq_poly_one(fq_poly_t poly, const fq_ctx_t ctx)

    Sets \code{poly} to the constant polynomial~$1$.

void void fq_poly_gen(fq_poly_t poly, const fq_ctx_t ctx)

    Sets \code{poly} to the polynomial~$x$.

void fq_poly_make_monic(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx)

     Sets \code{rop} to \code{op}, normed to have leading coefficient 1.

void _fq_poly_make_monic(fq_struct *rop, const fq_struct *op, slong length,
      const fq_ctx_t ctx)

     Sets \code{rop} to \code{(op,length)}, normed to have leading coefficient 1.
     Assumes that \code{rop} has enough space for the polynomial, assumes that
     \code{op} is not zero (and thus has an invertible leading coefficient).

*******************************************************************************

    Getting and setting coefficients

*******************************************************************************

void fq_poly_get_coeff(fq_t x, const fq_poly_t poly, slong n, const fq_ctx_t ctx)

    Sets $x$ to the coefficient of $X^n$ in \code{poly}.

void fq_poly_set_coeff(fq_poly_t poly, slong n, const fq_t x, const fq_ctx_t ctx)

    Sets the coefficient of $X^n$ in \code{poly} to $x$.

void
fq_poly_set_coeff_fmpz(fq_poly_t poly, slong n, const fmpz_t x,
                       const fq_ctx_t ctx)

    Sets the coefficient of $X^n$ in the polynomial to $x$,
    assuming $n \geq 0$.

*******************************************************************************

    Comparison

*******************************************************************************

int fq_poly_equal(const fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx)

    Returns whether the two polynomials \code{poly1} and \code{poly2}
    are equal.

int fq_poly_is_zero(const fq_poly_t poly, const fq_ctx_t ctx)

    Returns whether the polynomial \code{poly} is the zero polynomial.

int fq_poly_is_one(const fq_poly_t op)

    Returns whether the polynomial \code{poly} is equal
    to the constant polynomial~$1$.

int fq_poly_is_gen(const fq_poly_t op, const fq_ctx_t ctx)

    Returns whether the polynomial \code{poly} is equal
    to the polynomial~$x$.

int fq_poly_is_unit(const fq_poly_t op, const fq_ctx_t ctx)

    Returns whether the polynomial \code{poly} is a unit in the polynomial
    ring $\mathbf{F}_q[X]$, i.e. if it has degree $0$ and is non-zero.

int fq_poly_equal_fq(const fq_poly_t poly, const fq_t c, const fq_ctx_t ctx)

    Returns whether the polynomial \code{poly} is equal the (constant)
    $\mathbf{F}_q$ element \code{c}

*******************************************************************************

    Addition and subtraction

*******************************************************************************

void _fq_poly_add(fq_struct *res,
                  const fq_struct *poly1, slong len1,
                  const fq_struct *poly2, slong len2,
                  const fq_ctx_t ctx)

    Sets \code{res} to the sum of \code{(poly1,len1)} and \code{(poly2,len2)}.

void fq_poly_add(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2,
                 const fq_ctx_t ctx)

    Sets \code{res} to the sum of \code{poly1} and \code{poly2}.

void _fq_poly_sub(fq_struct *res,
                  const fq_struct *poly1, slong len1,
                  const fq_struct *poly2, slong len2,
                  const fq_ctx_t ctx)

    Sets \code{res} to the difference of \code{(poly1,len1)} and \code{(poly2,len2)}.

void fq_poly_sub(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2,
                 const fq_ctx_t ctx)

    Sets \code{res} to the difference of \code{poly1} and \code{poly2}.

void _fq_poly_neg(fq_struct *rop, const fq_struct *op, slong len,
                  const fq_ctx_t ctx)

    Sets \code{res} to the additive inverse of \code{(poly,len)}.

void fq_poly_neg(fq_poly_t res, const fq_poly_t poly, const fq_ctx_t ctx)

    Sets \code{res} to the additive inverse of \code{poly}.

*******************************************************************************

    Scalar multiplication and division

*******************************************************************************

void _fq_poly_scalar_mul_fq(fq_struct *rop,
    const fq_struct *op, slong len, const fq_t x, const fq_ctx_t ctx)

    Sets \code{(rop,len)} to the product of \code{(op,len)} by the
    scalar \code{x}, in the context defined by \code{ctx}.

void fq_poly_scalar_mul_fq(fq_poly_t rop,
    const fq_poly_t op, const fq_t x, const fq_ctx_t ctx)

    Sets \code{(rop,len)} to the product of \code{(op,len)} by the
    scalar \code{x}, in the context defined by \code{ctx}.

void _fq_poly_scalar_addmul_fq(fq_struct *rop,
    const fq_struct *op, slong len, const fq_t x, const fq_ctx_t ctx)

    Adds to \code{(rop,len)} the product of \code{(op,len)} by the
    scalar \code{x}, in the context defined by \code{ctx}.
    In particular, assumes the same length for \code{op} and
    \code{rop}.

void fq_poly_scalar_addmul_fq(fq_poly_t rop,
    const fq_poly_t op, const fq_t x, const fq_ctx_t ctx)

    Adds to \code{rop} the product of \code{op} by the
    scalar \code{x}, in the context defined by \code{ctx}.

void _fq_poly_scalar_submul_fq(fq_struct *rop,
    const fq_struct *op, slong len, const fq_t x, const fq_ctx_t ctx)

    Substracts from \code{(rop,len)} the product of \code{(op,len)} by the
    scalar \code{x}, in the context defined by \code{ctx}.
    In particular, assumes the same length for \code{op} and
    \code{rop}.

void fq_poly_scalar_submul_fq(fq_poly_t rop,
    const fq_poly_t op, const fq_t x, const fq_ctx_t ctx)

    Substracts from \code{rop} the product of \code{op} by the
    scalar \code{x}, in the context defined by \code{ctx}.

*******************************************************************************

    Multiplication

*******************************************************************************

void _fq_poly_mul_classical(fq_struct *rop,
                            const fq_struct *op1, slong len1,
                            const fq_struct *op2, slong len2,
                            const fq_ctx_t ctx)

    Sets \code{(rop, len1 + len2 - 1)} to the product of \code{(op1, len1)}
    and \code{(op2, len2)}, assuming that \code{len1} is at least \code{len2}
    and neither is zero.

    Permits zero padding.  Does not support aliasing of \code{rop}
    with either \code{op1} or \code{op2}.

void fq_poly_mul_classical(fq_poly_t rop,
                           const fq_poly_t op1, const fq_poly_t op2,
                           const fq_ctx_t ctx)

    Sets \code{rop} to the product of \code{op1} and \code{op2}
    using classical polynomial multiplication.

void _fq_poly_mul_reorder(fq_struct *rop,
                           const fq_struct *op1, slong len1,
                           const fq_struct *op2, slong len2,
                           const fq_ctx_t ctx)

    Sets \code{(rop, len1 + len2 - 1)} to the product of \code{(op1, len1)}
    and \code{(op2, len2)}, assuming that \code{len1} and \code{len2} are
    non-zero.

    Permits zero padding.  Supports aliasing.

void fq_poly_mul_reorder(fq_poly_t rop,
    const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)

    Sets \code{rop} to the product of \code{op1} and \code{op2},
    reordering the two indeterminates $X$ and $Y$ when viewing
    the polynomials as elements of $\mathbf{F}_p[X,Y]$.

    Suppose $\mathbf{F}_q = \mathbf{F}_p[X]/ (f(X))$ and recall
    that elements of $\mathbf{F}_q$ are internally represented
    by elements of type \code{fmpz_poly}.  For small degree extensions
    but polynomials in $\mathbf{F}_q[Y]$ of large degree~$n$, we
    change the representation to
    \begin{equation*}
    \begin{split}
    g(Y) & = \sum_{i=0}^{n} a_i(X) Y^i \\
         & = \sum_{j=0}^{d} \sum_{i=0}^{n} \text{Coeff}(a_i(X), j) Y^i.
    \end{split}
    \end{equation*}
    This allows us to use a poor algorithm (such as classical multiplication)
    in the $X$-direction and leverage the existing fast integer
    multiplication routines in the $Y$-direction where the polynomial
    degree~$n$ is large.

void _fq_poly_mul_KS(fq_struct *rop, const fq_struct *op1, slong len1,
                                     const fq_struct *op2, slong len2,
                                     const fq_ctx_t ctx)

    Sets \code{(rop, len1 + len2 - 1)} to the product of \code{(op1, len1)}
    and \code{(op2, len2)}.

    Permits zero padding and places no assumptions on the
    lengths \code{len1} and \code{len2}.  Supports aliasing.

void fq_poly_mul_KS(fq_poly_t rop,
                    const fq_poly_t op1, const fq_poly_t op2,
                    const fq_ctx_t ctx)

    Sets \code{rop} to the product of \code{op1} and \code{op2}
    using Kronecker substitution, that is, by encoding each
    coefficient in $\mathbf{F}_{q}$ as an integer and reducing
    this problem to multiplying two polynomials over the integers.

void _fq_poly_mul(fq_struct *rop,
                  const fq_struct *op1, slong len1,
                  const fq_struct *op2, slong len2, const fq_ctx_t ctx)

    Sets \code{(rop, len1 + len2 - 1)} to the product of \code{(op1, len1)}
    and \code{(op2, len2)}, choosing an appropriate algorithm.

    Permits zero padding.  Does not support aliasing.

void fq_poly_mul(fq_poly_t rop,
    const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)

    Sets \code{rop} to the product of \code{op1} and \code{op2},
    choosing an appropriate algorithm.

void _fq_poly_mullow_classical(fq_struct *rop,
                               const fq_struct *op1, slong len1,
                               const fq_struct *op2, slong len2, slong n,
                               const fq_ctx_t ctx)

    Sets \code{(res, n)} to the first $n$ coefficients of \code{(poly1, len1)}
    multiplied by \code{(poly2, len2)}.

    Assumes \code{0 < n <= len1 + len2 - 1}.  Assumes neither \code{len1} nor
    \code{len2} is zero.

void fq_poly_mullow_classical(fq_poly_t rop,
    const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx)

    Sets \code{res} to the product of \code{poly1} and \code{poly2}, computed
    using the classical or schoolbook method.

void _fq_poly_mullow_KS(fq_struct *rop,
                        const fq_struct *op1, slong len1,
                        const fq_struct *op2, slong len2, slong n,
                        const fq_ctx_t ctx)

    Sets \code{(res, n)} to the lowest $n$ coefficients of the product of
    \code{(poly1, len1)} and \code{(poly2, len2)}.

    Assumes that \code{len1} and \code{len2} are positive, but does allow
    for the polynomials to be zero-padded.  The polynomials may be zero,
    too.  Assumes $n$ is positive.  Supports aliasing between \code{res},
    \code{poly1} and \code{poly2}.

void fq_poly_mullow_KS(fq_poly_t rop,
                       const fq_poly_t op1, const fq_poly_t op2, slong n,
                       const fq_ctx_t ctx)

    Sets \code{res} to the product of \code{poly1} and \code{poly2}.

void _fq_poly_mullow(fq_struct *rop,
                     const fq_struct *op1, slong len1,
                     const fq_struct *op2, slong len2, slong n,
                     const fq_ctx_t ctx)

    Sets \code{(res, n)} to the lowest $n$ coefficients of the product of
    \code{(poly1, len1)} and \code{(poly2, len2)}.

    Assumes \code{0 < n <= len1 + len2 - 1}.  Allows for zero-padding in
    the inputs.  Does not support aliasing between the inputs and the output.

void fq_poly_mullow(fq_poly_t rop,
                    const fq_poly_t op1, const fq_poly_t op2, slong n,
                    const fq_ctx_t ctx)

    Sets \code{res} to the lowest $n$ coefficients of the product of
    \code{poly1} and \code{poly2}.

void _fq_poly_mulmod(fq_struct* res, const fq_struct* poly1, slong len1,
                     const fq_struct* poly2, slong len2, const fq_struct* f,
                     slong lenf, const fq_ctx_t ctx)

    Sets \code{res} to the remainder of the product of \code{poly1}
    and \code{poly2} upon polynomial division by \code{f}.

    It is required that \code{len1 + len2 - lenf > 0}, which is
    equivalent to requiring that the result will actually be
    reduced. Otherwise, simply use \code{_fq_poly_mul} instead.

    Aliasing of \code{f} and \code{res} is not permitted.

void fq_poly_mulmod(fq_poly_t res,const fq_poly_t poly1, const fq_poly_t poly2,
                    const fq_poly_t f, const fq_ctx_t ctx)

    Sets \code{res} to the remainder of the product of \code{poly1}
    and \code{poly2} upon polynomial division by \code{f}.

void _fq_poly_mulmod_preinv(fq_struct* res, const fq_struct* poly1, slong len1,
                            const fq_struct* poly2, slong len2,
                            const fq_struct* f, slong lenf,
                            const fq_struct* finv, slong lenfinv,
                            const fq_ctx_t ctx)

    Sets \code{res} to the remainder of the product of \code{poly1}
    and \code{poly2} upon polynomial division by \code{f}.

    It is required that \code{finv} is the inverse of the reverse of
    \code{f} mod \code{x^lenf}. It is required that
    \code{len1 + len2 - lenf > 0}, which is equivalent to requiring that
    the result will actually be reduced.  Otherwise, simply use
    \code{_fq_poly_mul} instead.

    Aliasing of \code{f} or \code{finv} and \code{res} is not
    permitted.

void fq_poly_mulmod_preinv(fq_poly_t res, const fq_poly_t poly1,
                           const fq_poly_t poly2, const fq_poly_t f,
                           const fq_poly_t finv, const fq_ctx_t ctx)

    Sets \code{res} to the remainder of the product of \code{poly1}
    and \code{poly2} upon polynomial division by \code{f}. \code{finv}
    is the inverse of the reverse of \code{f}.

*******************************************************************************

    Squaring

*******************************************************************************

void _fq_poly_sqr_classical(fq_struct *rop,
                            const fq_struct *op, slong len,
                            const fq_ctx_t ctx)

    Sets \code{(rop, 2*len - 1)} to the square of \code{(op, len)},
    assuming that \code{(op,len)} is not zero and using classical
     polynomial multiplication.

    Permits zero padding.  Does not support aliasing of \code{rop}
    with either \code{op1} or \code{op2}.

void fq_poly_sqr_classical(fq_poly_t rop,
                           const fq_poly_t op, const fq_ctx_t ctx)

    Sets \code{rop} to the square of \code{op} using classical
     polynomial multiplication.


void _fq_poly_sqr_reorder(fq_struct *rop,
                          const fq_struct *op, slong len, const fq_ctx_t ctx)

    Sets \code{(rop, 2*len- 1)} to the square of \code{(op, len)},
    assuming that \code{len} is not zero reordering the two indeterminates
    $X$ and $Y$ when viewing the polynomials as elements of $\mathbb{F}_p[X,Y]$.

    Permits zero padding.  Supports aliasing.

void fq_poly_sqr_reorder(fq_poly_t rop,
                         const fq_poly_t op, const fq_ctx_t ctx)

    Sets \code{rop} to the square of \code{op},
    assuming that \code{len} is not zero reordering the two indeterminates
    $X$ and $Y$ when viewing the polynomials as elements of $\mathbb{F}_p[X,Y]$.
    See \code{fq_poly_mul_reorder}.


void _fq_poly_sqr_KS(fq_struct *rop, const fq_struct *op, slong len,
                                     const fq_ctx_t ctx)

    Sets \code{(rop, 2*len - 1)} to the square of \code{(op, len)}.

    Permits zero padding and places no assumptions on the
    lengths \code{len1} and \code{len2}.  Supports aliasing.

void fq_poly_sqr_KS(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx)

    Sets \code{rop} to the square \code{op} using Kronecker substitution,
    that is, by encoding each coefficient in $\mathbf{F}_{q}$ as an integer
    and reducing this problem to multiplying two polynomials over the integers.

void _fq_poly_sqr(fq_struct *rop, const fq_struct *op, slong len,
                                  const fq_ctx_t ctx)

    Sets \code{(rop, 2* len - 1)} to the square of \code{(op, len)},
    choosing an appropriate algorithm.

    Permits zero padding.  Does not support aliasing.

void fq_poly_sqr(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx)

    Sets \code{rop} to the square of \code{op},
    choosing an appropriate algorithm.


*******************************************************************************

    Powering

*******************************************************************************

void _fq_poly_pow(fq_struct *rop, const fq_struct *op, slong len, ulong e,
                                  const fq_ctx_t ctx)

    Sets \code{res = poly^e}, assuming that \code{e, len > 0} and that
    \code{res} has space for \code{e*(len - 1) + 1} coefficients.  Does
    not support aliasing.

void fq_poly_pow(fq_poly_t rop, const fq_poly_t op, ulong e,
                 const fq_ctx_t ctx)

    Computes \code{res = poly^e}.  If $e$ is zero, returns one,
    so that in particular \code{0^0 = 1}.

void _fq_poly_powmod_ui_binexp(fq_struct* res, const fq_struct* poly,
                               ulong e, const fq_struct* f, slong lenf,
                               const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using binary exponentiation. We require \code{e > 0}.

    We require \code{lenf > 1}. It is assumed that \code{poly} is
    already reduced modulo \code{f} and zero-padded as necessary to
    have length exactly \code{lenf - 1}. The output \code{res} must
    have room for \code{lenf - 1} coefficients.

void fq_poly_powmod_ui_binexp(fq_poly_t res, const fq_poly_t poly, ulong e,
                              const fq_poly_t f, const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using binary exponentiation. We require \code{e >= 0}.

void
_fq_poly_powmod_ui_binexp_preinv(fq_struct* res, const fq_struct* poly,
                                 ulong e, const fq_struct* f, slong lenf,
                                 const fq_struct* finv, slong lenfinv,
                                 const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using binary exponentiation. We require \code{e > 0}.
    We require \code{finv} to be the inverse of the reverse of
    \code{f}.

    We require \code{lenf > 1}. It is assumed that \code{poly} is
    already reduced modulo \code{f} and zero-padded as necessary to
    have length exactly \code{lenf - 1}. The output \code{res} must
    have room for \code{lenf - 1} coefficients.

void
fq_poly_powmod_ui_binexp_preinv(fq_poly_t res, const fq_poly_t poly, ulong e,
                                const fq_poly_t f, const fq_poly_t finv,
                                const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using binary exponentiation. We require \code{e >= 0}.
    We require \code{finv} to be the inverse of the reverse of
    \code{f}.

void _fq_poly_powmod_fmpz_binexp(fq_struct* res, const fq_struct* poly,
                                 fmpz_t e, const fq_struct* f,
                                 slong lenf, const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using binary exponentiation. We require \code{e > 0}.

    We require \code{lenf > 1}. It is assumed that \code{poly} is
    already reduced modulo \code{f} and zero-padded as necessary to
    have length exactly \code{lenf - 1}. The output \code{res} must
    have room for \code{lenf - 1} coefficients.

void fq_poly_powmod_fmpz_binexp(fq_poly_t res, const fq_poly_t poly, fmpz_t e,
                                const fq_poly_t f, const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using binary exponentiation. We require \code{e >= 0}.

void
_fq_poly_powmod_fmpz_binexp_preinv(fq_struct* res, const fq_struct* poly,
                                   fmpz_t e, const fq_struct* f, slong lenf,
                                   const fq_struct* finv, slong lenfinv,
                                   const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using binary exponentiation. We require \code{e > 0}.
    We require \code{finv} to be the inverse of the reverse of
    \code{f}.

    We require \code{lenf > 1}. It is assumed that \code{poly} is
    already reduced modulo \code{f} and zero-padded as necessary to
    have length exactly \code{lenf - 1}. The output \code{res} must
    have room for \code{lenf - 1} coefficients.

void
fq_poly_powmod_fmpz_binexp_preinv(fq_poly_t res, const fq_poly_t poly, fmpz_t e,
                                  const fq_poly_t f, const fq_poly_t finv,
                                  const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using binary exponentiation. We require \code{e >= 0}.
    We require \code{finv} to be the inverse of the reverse of
    \code{f}.

void
_fq_poly_powmod_fmpz_sliding_preinv(fq_struct* res, const fq_struct* poly,
                                    fmpz_t e, ulong k, const fq_struct* f, slong lenf,
                                    const fq_struct* finv, slong lenfinv,
                                    const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using sliding-window exponentiation with window size
    \code{k}. We require \code{e > 0}.  We require \code{finv} to be
    the inverse of the reverse of \code{f}. If \code{k} is set to
    zero, then an "optimum" size will be selected automatically base
    on \code{e}.

    We require \code{lenf > 1}. It is assumed that \code{poly} is
    already reduced modulo \code{f} and zero-padded as necessary to
    have length exactly \code{lenf - 1}. The output \code{res} must
    have room for \code{lenf - 1} coefficients.

void
fq_poly_powmod_fmpz_sliding_preinv(fq_poly_t res, const fq_poly_t poly, fmpz_t e,
                                   ulong k, const fq_poly_t f, const fq_poly_t finv,
                                   const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} raised to the power \code{e} modulo
    \code{f}, using sliding-window exponentiation with window size
    \code{k}. We require \code{e >= 0}.  We require \code{finv} to be
    the inverse of the reverse of \code{f}.  If \code{k} is set to
    zero, then an "optimum" size will be selected automatically base
    on \code{e}.

void
_fq_poly_powmod_x_fmpz_preinv(fq_struct * res, const fmpz_t e,
                              const fq_struct * f, slong lenf,
                              const fq_struct * finv, slong lenfinv,
                              const fq_ctx_t ctx)

    Sets \code{res} to \code{x} raised to the power \code{e} modulo \code{f},
    using sliding window exponentiation. We require \code{e > 0}.
    We require \code{finv} to be the inverse of the reverse of \code{f}.

    We require \code{lenf > 2}. The output \code{res} must have room for
    \code{lenf - 1} coefficients.

void
fq_poly_powmod_x_fmpz_preinv(fq_poly_t res, const fmpz_t e,
                             const fq_poly_t f, const fq_poly_t finv,
                             const fq_ctx_t ctx)

    Sets \code{res} to \code{x} raised to the power \code{e}
    modulo \code{f}, using sliding window exponentiation. We require
    \code{e >= 0}. We require \code{finv} to be the inverse of the reverse of
    \code{f}.

*******************************************************************************

    Shifting

*******************************************************************************

void _fq_poly_shift_left(fq_struct *rop, const fq_struct *op, slong len, slong n,
                         const fq_ctx_t ctx)

    Sets \code{(res, len + n)} to \code{(poly, len)} shifted left by
    $n$ coefficients.

    Inserts zero coefficients at the lower end.  Assumes that
    \code{len} and $n$ are positive, and that \code{res} fits
    \code{len + n} elements.  Supports aliasing between \code{res} and
    \code{poly}.

void fq_poly_shift_left(fq_poly_t rop, const fq_poly_t op, slong n,
                        const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} shifted left by $n$ coeffs.  Zero
    coefficients are inserted.

void _fq_poly_shift_right(fq_struct *rop, const fq_struct *op, slong len,
                          slong n, const fq_ctx_t ctx)

    Sets \code{(res, len - n)} to \code{(poly, len)} shifted right by
    $n$ coefficients.

    Assumes that \code{len} and $n$ are positive, that \code{len > n},
    and that \code{res} fits \code{len - n} elements.  Supports
    aliasing between \code{res} and \code{poly}, although in this case
    the top coefficients of \code{poly} are not set to zero.

void fq_poly_shift_right(fq_poly_t rop, const fq_poly_t op, slong n,
                         const fq_ctx_t ctx)

    Sets \code{res} to \code{poly} shifted right by $n$ coefficients.
    If $n$ is equal to or greater than the current length of
    \code{poly}, \code{res} is set to the zero polynomial.

*******************************************************************************

    Norms

*******************************************************************************

long _fq_poly_hamming_weight(const fq_poly *op, slong len, const fq_ctx_t ctx)

    Returns the number of non-zero entries in \code{(op, len)}.

long fq_poly_hamming_weight(const fq_poly_t op, const fq_ctx_t ctx)

    Returns the number of non-zero entries in the polynomial \code{op}.

*******************************************************************************

    Euclidean division

*******************************************************************************

void _fq_poly_divrem_basecase(fq_struct *Q, fq_struct *R,
    const fq_struct *A, slong lenA, const fq_struct *B, slong lenB,
    const fq_t invB, const fq_ctx_t ctx)

    Computes \code{(Q, lenA - lenB + 1)}, \code{(R, lenA)} such that
    $A = B Q + R$ with $0 \leq \len(R) < \len(B)$.

    Assumes that the leading coefficient of $B$ is invertible
    and that \code{invB} is its inverse.

    Assumes that $\len(A), \len(B) > 0$.  Allows zero-padding in
    \code{(A, lenA)}.  $R$ and $A$ may be aliased, but apart from
    this no aliasing of input and output operands is allowed.

void fq_poly_divrem_basecase(fq_poly_t Q, fq_poly_t R,
                             const fq_poly_t A, const fq_poly_t B,
                             const fq_ctx_t ctx)

    Computes $Q$, $R$ such that $A = B Q + R$ with
    $0 \leq \len(R) < \len(B)$.

    Assumes that the leading coefficient of $B$ is invertible.  This can
    be taken for granted the context is for a finite field, that is, when
    $p$ is prime and $f(X)$ is irreducible.

void _fq_poly_divrem(fq_struct *Q, fq_struct *R,
    const fq_struct *A, slong lenA, const fq_struct *B, slong lenB,
    const fq_t invB, const fq_ctx_t ctx)

    Computes \code{(Q, lenA - lenB + 1)}, \code{(R, lenA)} such that
    $A = B Q + R$ with $0 \leq \len(R) < \len(B)$.

    Assumes that the leading coefficient of $B$ is invertible
    and that \code{invB} is its inverse.

    Assumes that $\len(A), \len(B) > 0$.  Allows zero-padding in
    \code{(A, lenA)}.  $R$ and $A$ may be aliased, but apart from
    this no aliasing of input and output operands is allowed.

void fq_poly_divrem(fq_poly_t Q, fq_poly_t R,
                    const fq_poly_t A, const fq_poly_t B,
                    const fq_ctx_t ctx)

    Computes $Q$, $R$ such that $A = B Q + R$ with
    $0 \leq \len(R) < \len(B)$.

    Assumes that the leading coefficient of $B$ is invertible.  This can
    be taken for granted the context is for a finite field, that is, when
    $p$ is prime and $f(X)$ is irreducible.

void _fq_poly_rem(fq_struct *R, const fq_struct *A, slong lenA,
                  const fq_struct *B, slong lenB, const fq_t invB,
                  const fq_ctx_t ctx)

    Sets \code{R} to the remainder of the division of \code{(A,lenA)} by
    \code{(B,lenB)}. Assumes that the leading coefficient of \code{(B,lenB)}
    is invertible and that \code{invB} is its inverse.

void fq_poly_rem(fq_poly_t R,
                    const fq_poly_t A, const fq_poly_t B,
                    const fq_ctx_t ctx)

    Sets \code{R} to the remainder of the division of \code{A} by
    \code{B} in the context described by \code{ctx}.

void _fq_poly_div_basecase(fq_struct *Q, fq_struct *R,
                           const fq_struct *A, slong lenA,
                           const fq_struct *B, slong lenB,
                           const fq_t invB, const fq_ctx_t ctx)

    Notationally, computes $Q$, $R$ such that $A = B Q + R$ with $0
    \leq \len(R) < \len(B)$ but only sets \code{(Q, lenA - lenB + 1)}.

    Requires temporary space \code{(R, lenA)}.  If \code{R} is
    \code{NULL}, then the temporary space will be allocated.  Allows
    aliasing only between $A$ and $R$.  Allows zero-padding in $A$ but
    not in $B$.  Assumes that the leading coefficient of $B$ is a
    unit.

void fq_poly_div_basecase(fq_poly_t Q, const fq_poly_t A, const fq_poly_t B,
                          const fq_ctx_t ctx)

    Notionally finds polynomials $Q$ and $R$ such that $A = B Q + R$ with
    $\len(R) < \len(B)$, but returns only \code{Q}. If $\len(B) = 0$ an
    exception is raised.

void _fq_poly_divrem_divconquer_recursive(fq_struct * Q, fq_struct * BQ,
                                          fq_struct * W, const fq_struct * A,
                                          const fq_struct * B, slong lenB,
                                          const fq_t invB, const fq_ctx_t ctx)

    Computes \code{(Q, lenB)}, \code{(BQ, 2 lenB - 1)} such that
    $BQ = B \times Q$ and $A = B Q + R$ where $0 \leq \len(R) < \len(B)$.

    Assumes that the leading coefficient of $B$ is invertible and that
    \code{invB} is the inverse.

    Assumes $\len(B) > 0$.  Allows zero-padding in \code{(A, lenA)}.  Requires
    a temporary array \code{(W, 2 lenB - 1)}.  No aliasing of input and output
    operands is allowed.

    This function does not read the bottom $\len(B) - 1$ coefficients from
    $A$, which means that they might not even need to exist in allocated
    memory.

void _fq_poly_divrem_divconquer(fq_struct * Q, fq_struct * R,
                                const fq_struct * A, slong lenA,
                                const fq_struct * B, slong lenB,
                                const fq_t invB, const fq_ctx_t ctx)

    Computes \code{(Q, lenA - lenB + 1)}, \code{(R, lenA)} such that
    $A = B Q + R$ and $0 \leq \len(R) < \len(B)$.

    Assumes that the leading coefficient of $B$ is invertible and that
    \code{invB} is the inverse.

    Assumes $\len(A) \geq \len(B) > 0$.  Allows zero-padding in
    \code{(A, lenA)}.  No aliasing of input and output operands is
    allowed.

void fq_poly_divrem_divconquer(fq_poly_t Q, fq_poly_t R,
                               const fq_poly_t A, const fq_poly_t B,
                               const fq_ctx_t ctx)

    Computes $Q$, $R$ such that $A = B Q + R$ and $0 \leq \len(R) < \len(B)$.

    Assumes that $B$ is non-zero and that the leading coefficient of
    $B$ is invertible.

void _fq_poly_div_newton_n_preinv(fq_struct* Q, const fq_struct* A, slong lenA,
                                  const fq_struct* B, slong lenB,
                                  const fq_struct* Binv, slong lenBinv,
                                  const fq_struct ctx_t)

    Notionally computes polynomials $Q$ and $R$ such that $A = BQ + R$ with
    $\len(R)$ less than \code{lenB}, where \code{A} is of length \code{lenA}
    and \code{B} is of length \code{lenB}, but return only $Q$.

    We require that $Q$ have space for \code{lenA - lenB + 1} coefficients
    and assume that the leading coefficient of $B$ is a unit. Furthermore, we
    assume that $Binv$ is the inverse of the reverse of $B$ mod $x^{\len(B)}$.

    The algorithm used is to reverse the polynomials and divide the
    resulting power series, then reverse the result.

void fq_poly_div_newton_n_preinv(fq_poly_t Q, const fq_poly_t A,
                                 const fq_poly_t B, const fq_poly_t Binv,
                                 const fq_ctx_t ctx)

    Notionally computes $Q$ and $R$ such that $A = BQ + R$ with
    $\len(R) < \len(B)$, but returns only $Q$.

    We assume that the leading coefficient of $B$ is a unit and that $Binv$ is
    the inverse of the reverse of $B$ mod $x^{\len(B)}$.

    It is required that the length of $A$ is less than or equal to
    2*the length of $B$ - 2.

    The algorithm used is to reverse the polynomials and divide the
    resulting power series, then reverse the result.

void _fq_poly_divrem_newton_n_preinv(fq_struct* Q, fq_struct* R,
                                     const fq_struct* A, slong lenA,
                                     const fq_struct* B, slong lenB,
                                     const fq_struct* Binv, slong lenBinv,
                                     const fq_ctx_t ctx)

    Computes $Q$ and $R$ such that $A = BQ + R$ with $\len(R)$ less
    than \code{lenB}, where $A$ is of length \code{lenA} and $B$ is of
    length \code{lenB}. We require that $Q$ have space for
    \code{lenA - lenB + 1} coefficients. Furthermore, we assume that $Binv$ is
    the inverse of the reverse of $B$ mod $x^{\len(B)}$. The algorithm
    used is to call \code{div_newton_n_preinv()} and then multiply out
    and compute the remainder.

void fq_poly_divrem_newton_preinv(fq_poly_t Q, fq_poly_t R,
                                  const fq_poly_t A, const fq_poly_t B,
                                  const fq_poly_t Binv, const fq_ctx_t ctx)

    Computes $Q$ and $R$ such that $A = BQ + R$ with $\len(R) <
    \len(B)$.  We assume $Binv$ is the inverse of the reverse of $B$
    mod $x^{\len(B)}$.

    It is required that the length of $A$ is less than or equal to
    2*the length of $B$ - 2.

    The algorithm used is to call \code{div_newton_n()} and then
    multiply out and compute the remainder.

void
_fq_poly_inv_series_newton(fq_struct* Qinv, const fq_struct* Q, slong n,
                           const fq_ctx_t ctx)

    Given \code{Q} of length \code{n} whose constant coefficient is
    invertible modulo the given modulus, find a polynomial \code{Qinv}
    of length \code{n} such that \code{Q * Qinv} is \code{1} modulo
    $x^n$. Requires \code{n > 0}.  This function can be viewed as
    inverting a power series via Newton iteration.

void
fq_poly_inv_series_newton(fq_poly_t Qinv, const fq_poly_t Q, slong n,
                          const fq_ctx_t ctx)

    Given \code{Q} find \code{Qinv} such that \code{Q * Qinv} is
    \code{1} modulo $x^n$. The constant coefficient of \code{Q} must
    be invertible modulo the modulus of \code{Q}. An exception is
    raised if this is not the case or if \code{n = 0}. This function
    can be viewed as inverting a power series via Newton iteration.

*******************************************************************************

    Greatest common divisor

*******************************************************************************

void fq_poly_gcd(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2,
                 const fq_ctx_t ctx)

    Sets \code{rop} to the greatest common divisor of \code{op1} and
    \code{op2}, using the either the Euclidean or HGCD algorithm. The
    GCD of zero polynomials is defined to be zero, whereas the GCD of
    the zero polynomial and some other polynomial $P$ is defined to be
    $P$. Except in the case where the GCD is zero, the GCD $G$ is made
    monic.

long _fq_poly_gcd(fq_struct* G,const fq_struct* A, slong lenA,
                  const fq_struct* B, slong lenB, const fq_ctx_t ctx)

    Computes the GCD of $A$ of length \code{lenA} and $B$ of length
    \code{lenB}, where \code{lenA >= lenB > 0} and sets $G$ to it. The
    length of the GCD $G$ is returned by the function. No attempt is
    made to make the GCD monic. It is required that $G$ have space for
    \code{lenB} coefficients.

void fq_poly_gcd_euclidean(fq_poly_t rop, const fq_poly_t op1,
                           const fq_poly_t op2, const fq_ctx_t ctx)

    Sets \code{rop} to the greatest common divisor of \code{op1} and
    \code{op2}, using the Euclidean algorithm. The GCD of zero
    polynomials is defined to be zero, whereas the GCD of the zero
    polynomial and some other polynomial $P$ is defined to be
    $P$. Except in the case where the GCD is zero, the GCD $G$ is made
    monic.

long _fq_poly_gcd_euclidean(fq_struct* G, const fq_struct* A, slong lenA,
                            const fq_struct* B, slong lenB,
                            const fq_ctx_t ctx)

    Computes the GCD of $A$ of length \code{lenA} and $B$ of length
    \code{lenB}, where \code{lenA >= lenB > 0} and sets $G$ to it. The
    length of the GCD $G$ is returned by the function. No attempt is
    made to make the GCD monic. It is required that $G$ have space for
    \code{lenB} coefficients.

*******************************************************************************

    Divisibility testing

*******************************************************************************

int _fq_poly_divides(fq_struct *Q,
                     const fq_struct *A, slong lenA,
                     const fq_struct *B, slong lenB, const fq_t invB,
                     const fq_ctx_t ctx)

    Returns $1$ if \code{(B, lenB)} divides \code{(A, lenA)} exactly and
    sets $Q$ to the quotient, otherwise returns $0$.

    It is assumed that $\len(A) \geq \len(B) > 0$ and that $Q$ has space
    for $\len(A) - \len(B) + 1$ coefficients.

    Aliasing of $Q$ with either of the inputs is not permitted.

    This function is currently unoptimised and provided for convenience
    only.

int fq_poly_divides(fq_poly_t Q, const fq_poly_t A, const fq_poly_t B,
                                 const fq_ctx_t ctx)


    Returns $1$ if $B$ divides $A$ exactly and sets $Q$ to the quotient,
    otherwise returns $0$.

    This function is currently unoptimised and provided for convenience
    only.

*******************************************************************************

    Derivative

*******************************************************************************

void _fq_poly_derivative(fq_struct *rop, const fq_struct *op, slong len,
                                         const fq_ctx_t ctx)

    Sets \code{(rpoly, len - 1)} to the derivative of \code{(poly, len)}.
    Also handles the cases where \code{len} is $0$ or $1$ correctly.
    Supports aliasing of \code{rpoly} and \code{poly}.

void fq_poly_derivative(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx)

    Sets \code{res} to the derivative of \code{poly}.

*******************************************************************************

    Evaluation

*******************************************************************************

void _fq_poly_evaluate_fq(fq_t rop, const fq_struct *op, slong len,
                                    const fq_t a, const fq_ctx_t ctx)

    Sets \code{rop} to \code{(op, len)} evaluated at $a$.

    Supports zero padding.  There are no restrictions on \code{len}, that
    is, \code{len} is allowed to be zero, too.

void fq_poly_evaluate_fq(fq_t rop, const fq_poly_t f, const fq_t a,
                         const fq_ctx_t ctx)

    Sets \code{rop} to the value of $f(a)$.

    As the coefficient ring $\mathbf{F}_q$ is finite, Horner's method
    is sufficient.

*******************************************************************************

    Composition

*******************************************************************************

void _fq_poly_compose_divconquer(fq_struct *rop,
                                 const fq_struct *op1, slong len1,
                                 const fq_struct *op2, slong len2,
                                 const fq_ctx_t ctx)

    Computes the composition of \code{(op1, len1)} and \code{(op2, len2)}
    using a divide and conquer approach and places the result into \code{rop},
    assuming \code{rop} can hold the output of length
    \code{(len1 - 1) * (len2 - 1) + 1}.

    Assumes \code{len1, len2 > 0}.  Does not support aliasing between
    \code{rop} and any of \code{(op1, len1)} and \code{(op2, len2)}.

void fq_poly_compose_divconquer(fq_poly_t rop,
                                const fq_poly_t op1, const fq_poly_t op2,
                                const fq_ctx_t ctx)

    Sets \code{rop} to the composition of \code{op1} and \code{op2}.
    To be precise about the order of composition, denoting \code{rop},
    \code{op1}, and \code{op2} by $f$, $g$, and $h$, respectively,
    sets $f(t) = g(h(t))$.

void _fq_poly_compose_horner(fq_struct *rop, const fq_struct *op1, slong len1,
                                             const fq_struct *op2, slong len2,
                                             const fq_ctx_t ctx)

    Sets \code{rop} to the composition of \code{(op1, len1)} and
    \code{(op2, len2)}.

    Assumes that \code{rop} has space for \code{(len1-1)*(len2-1) + 1}
    coefficients.  Assumes that \code{op1} and \code{op2} are non-zero
    polynomials.  Does not support aliasing between any of the inputs and
    the output.

void fq_poly_compose_horner(fq_poly_t rop,
                            const fq_poly_t op1, const fq_poly_t op2,
                            const fq_ctx_t ctx)

    Sets \code{rop} to the composition of \code{op1} and \code{op2}.
    To be more precise, denoting \code{rop}, \code{op1}, and \code{op2}
    by $f$, $g$, and $h$, sets $f(t) = g(h(t))$.

    This implementation uses Horner's method.

void _fq_poly_compose(fq_struct *rop, const fq_struct *op1, slong len1,
                                      const fq_struct *op2, slong len2,
                                      const fq_ctx_t ctx)

    Sets \code{rop} to the composition of \code{(op1, len1)} and
    \code{(op2, len2)}.

    Assumes that \code{rop} has space for \code{(len1-1)*(len2-1) + 1}
    coefficients.  Assumes that \code{op1} and \code{op2} are non-zero
    polynomials.  Does not support aliasing between any of the inputs and
    the output.

void fq_poly_compose(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2,
                     const fq_ctx_t ctx)

    Sets \code{rop} to the composition of \code{op1} and \code{op2}.
    To be precise about the order of composition, denoting \code{rop},
    \code{op1}, and \code{op2} by $f$, $g$, and $h$, respectively,
    sets $f(t) = g(h(t))$.

void _fq_poly_compose_mod_horner(fq_struct * res,
                     const fq_struct * f, slong lenf,
                     const fq_struct * g,
                     const fq_struct * h, slong lenh,
                     const fq_ctx_t ctx)


    Sets \code{res} to the composition $f(g)$ modulo $h$. We require that
    $h$ is nonzero and that the length of $g$ is one less than the
    length of $h$ (possibly with zero padding). The output is not allowed
    to be aliased with any of the inputs.

    The algorithm used is Horner's rule.

void fq_poly_compose_mod_horner(fq_poly_t res, const fq_poly_t f,
                                const fq_poly_t g, const fq_poly_t h,
                                const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require that
    $h$ is nonzero. The algorithm used is Horner's rule.

void _fq_poly_compose_mod_horner_preinv(fq_struct * res,
                                        const fq_struct * f, slong lenf,
                                        const fq_struct * g,
                                        const fq_struct * h, slong lenh,
                                        const fq_struct * hinv, slong lenhiv,
                                        const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that the length of $g$ is one less than
    the length of $h$ (possibly with zero padding). We also require
    that the length of $f$ is less than the length of
    $h$. Furthermore, we require \code{hinv} to be the inverse of the
    reverse of \code{h}.  The output is not allowed to be aliased with
    any of the inputs.

    The algorithm used is Horner's rule.

void fq_poly_compose_mod_horner_preinv(fq_poly_t res, const fq_poly_t f,
                                       const fq_poly_t g, const fq_poly_t h,
                                       const fq_poly_t hinv,
                                       const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that $f$ has smaller degree than
    $h$. Furthermore, we require \code{hinv} to be the inverse of the
    reverse of \code{h}.  The algorithm used is Horner's rule.


void _fq_poly_compose_mod_brent_kung(fq_struct * res,
                                     const fq_struct * f, slong lenf,
                                     const fq_struct * g,
                                     const fq_struct * h, slong lenh,
                                     const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that the length of $g$ is one less than
    the length of $h$ (possibly with zero padding). We also require
    that the length of $f$ is less than the length of $h$. The output
    is not allowed to be aliased with any of the inputs.

    The algorithm used is the Brent-Kung matrix algorithm.

void fq_poly_compose_mod_brent_kung(fq_poly_t res, const fq_poly_t f,
                                    const fq_poly_t g, const fq_poly_t h,
                                    const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that $f$ has smaller degree than $h$.  The
    algorithm used is the Brent-Kung matrix algorithm.

void _fq_poly_compose_mod_brent_kung_preinv(fq_struct * res,
                                            const fq_struct * f, slong lenf,
                                            const fq_struct * g,
                                            const fq_struct * h, slong lenh,
                                            const fq_struct * hinv, slong lenhiv,
                                            const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that the length of $g$ is one less than
    the length of $h$ (possibly with zero padding). We also require
    that the length of $f$ is less than the length of
    $h$. Furthermore, we require \code{hinv} to be the inverse of the
    reverse of \code{h}.  The output is not allowed to be aliased with
    any of the inputs.

    The algorithm used is the Brent-Kung matrix algorithm.

void fq_poly_compose_mod_brent_kung_preinv(fq_poly_t res, const fq_poly_t f,
                                           const fq_poly_t g, const fq_poly_t h,
                                           const fq_poly_t hinv,
                                           const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that $f$ has smaller degree than
    $h$. Furthermore, we require \code{hinv} to be the inverse of the
    reverse of \code{h}.  The algorithm used is the Brent-Kung matrix
    algorithm.

void _fq_poly_compose_mod(fq_struct * res, const fq_struct * f, slong lenf,
                          const fq_struct * g, const fq_struct * h, slong lenh,
                          const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that the length of $g$ is one less than
    the length of $h$ (possibly with zero padding). The output is not
    allowed to be aliased with any of the inputs.

void fq_poly_compose_mod(fq_poly_t res, const fq_poly_t f, const fq_poly_t g,
                         const fq_poly_t h, const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero.

void _fq_poly_compose_mod_preinv(fq_struct * res,
                                 const fq_struct * f, slong lenf,
                                 const fq_struct * g,
                                 const fq_struct * h, slong lenh,
                                 const fq_struct * hinv, slong lenhiv,
                                 const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that the length of $g$ is one less than
    the length of $h$ (possibly with zero padding). We also require
    that the length of $f$ is less than the length of
    $h$. Furthermore, we require \code{hinv} to be the inverse of the
    reverse of \code{h}.  The output is not allowed to be aliased with
    any of the inputs.

void fq_poly_compose_mod_preinv(fq_poly_t res, const fq_poly_t f,
                                const fq_poly_t g, const fq_poly_t h,
                                const fq_poly_t hinv,
                                const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero and that $f$ has smaller degree than
    $h$. Furthermore, we require \code{hinv} to be the inverse of the
    reverse of \code{h}.

void
_fq_poly_reduce_matrix_mod_poly (fq_mat_t A, const fq_mat_t B,
                                 const fq_poly_t f, const fq_ctx_t ctx)

    Sets the ith row of \code{A} to the reduction of the ith row of $B$ modulo
    $f$ for $i=1,\ldots,\sqrt{\deg(f)}$. We require $B$ to be at least
    a $\sqrt{\deg(f)}\times \deg(f)$ matrix and $f$ to be nonzero.

void
_fq_poly_precompute_matrix (fq_mat_t A, const fq_struct* f, const fq_struct* g,
               slong leng, const fq_struct* ginv, slong lenginv,
               const fq_ctx_t ctx)

    Sets the ith row of \code{A} to $f^i$ modulo $g$ for
    $i=1,\ldots,\sqrt{\deg(g)}$. We require $A$ to be a
    $\sqrt{\deg(g)}\times \deg(g)$ matrix. We require \code{ginv} to
    be the inverse of the reverse of \code{g} and $g$ to be nonzero.

void
fq_poly_precompute_matrix (fq_mat_t A, const fq_poly_t f,
                           const fq_poly_t g, const fq_poly_t ginv,
                           const fq_ctx_t ctx)

    Sets the ith row of \code{A} to $f^i$ modulo $g$ for
    $i=1,\ldots,\sqrt{\deg(g)}$. We require $A$ to be a
    $\sqrt{\deg(g)}\times \deg(g)$ matrix. We require \code{ginv} to
    be the inverse of the reverse of \code{g}.


void
_fq_poly_compose_mod_brent_kung_precomp_preinv(fq_struct* res, const fq_struct* f,
                            slong lenf, const fq_mat_t A, const fq_struct* h,
                            slong h, const fq_struct* hinv, slong lenhinv,
                            const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that $h$ is nonzero. We require that the ith row of $A$ contains
    $g^i$ for $i=1,\ldots,\sqrt{\deg(h)}$, i.e. $A$ is a
    $\sqrt{\deg(h)}\times \deg(h)$ matrix. We also require that the
    length of $f$ is less than the length of $h$. Furthermore, we
    require \code{hinv} to be the inverse of the reverse of \code{h}.
    The output is not allowed to be aliased with any of the inputs.

    The algorithm used is the Brent-Kung matrix algorithm.

void
fq_poly_compose_mod_brent_kung_precomp_preinv(fq_poly_t res,
                    const fq_poly_t f, const fq_mat_t A,
                    const fq_poly_t h, const fq_poly_t hinv,
                    const fq_ctx_t ctx)

    Sets \code{res} to the composition $f(g)$ modulo $h$. We require
    that the ith row of $A$ contains $g^i$ for
    $i=1,\ldots,\sqrt{\deg(h)}$, i.e. $A$ is a $\sqrt{\deg(h)}\times
    \deg(h)$ matrix. We require that $h$ is nonzero and that $f$ has
    smaller degree than $h$. Furthermore, we require \code{hinv} to be
    the inverse of the reverse of \code{h}. This version of Brent-Kung
    modular composition is particularly useful if one has to perform
    several modular composition of the form $f(g)$ modulo $h$ for
    fixed $g$ and $h$.


*******************************************************************************

    Output

*******************************************************************************

int _fq_poly_fprint_pretty(FILE *file, const fq_struct *poly, slong len,
                            const char *x, const fq_ctx_t ctx)

    Prints the pretty representation of \code{(poly, len)} to the stream
    \code{file}, using the string \code{x} to represent the indeterminate.

    In case of success, returns a positive value.  In case of failure,
    returns a non-positive value.

int fq_poly_fprint_pretty(FILE * file, const fq_poly_t poly, const char *x,
                          const fq_ctx_t ctx)

    Prints the pretty representation of \code{poly} to the stream
    \code{file}, using the string \code{x} to represent the indeterminate.

    In case of success, returns a positive value.  In case of failure,
    returns a non-positive value.


int _fq_poly_print_pretty(const fq_struct *poly, slong len,
                          const char *x, const fq_ctx_t ctx)

    Prints the pretty representation of \code{(poly, len)} to \code{stdout},
    using the string \code{x} to represent the indeterminate.

    In case of success, returns a positive value.  In case of failure,
    returns a non-positive value.


int fq_poly_print_pretty(const fq_poly_t poly, const char *x,
                         const fq_ctx_t ctx)

    Prints the pretty representation of \code{poly} to \code{stdout},
    using the string \code{x} to represent the indeterminate.

    In case of success, returns a positive value.  In case of failure,
    returns a non-positive value.

int _fq_poly_fprint(FILE *file, const fq_struct *poly, slong len,
                    const fq_ctx_t ctx)

    Prints the pretty representation of \code{(poly, len)} to the stream
    \code{file}.

    In case of success, returns a positive value.  In case of failure,
    returns a non-positive value.

int fq_poly_fprint(FILE * file, const fq_poly_t poly, const fq_ctx_t ctx)

    Prints the pretty representation of \code{poly} to the stream
    \code{file}.

    In case of success, returns a positive value.  In case of failure,
    returns a non-positive value.


int _fq_poly_print(const fq_struct *poly, slong len, const fq_ctx_t ctx)

    Prints the pretty representation of \code{(poly, len)} to \code{stdout}.

    In case of success, returns a positive value.  In case of failure,
    returns a non-positive value.


int fq_poly_print(const fq_poly_t poly, const fq_ctx_t ctx)

    Prints the representation of \code{poly} to \code{stdout}.

    In case of success, returns a positive value.  In case of failure,
    returns a non-positive value.

char * _fq_poly_get_str(const fq_struct * poly, slong len, const fq_ctx_t ctx)

    Returns the plain FLINT string representation of the polynomial
    \code{(poly, len)}.

char * fq_poly_get_str(const fq_poly_t poly, const fq_ctx_t ctx)

    Returns the plain FLINT string representation of the polynomial
    \code{poly}.

char * _fq_poly_get_str_pretty(const fq_struct * poly, slong len,
                               const char * x, const fq_ctx_t ctx)

    Returns a pretty representation of the polynomial
    \code{(poly, len)} using the null-terminated string~\code{x} as the
    variable name.

char * fq_poly_get_str_pretty(const fq_poly_t poly, const char * x,
                              const fq_ctx_t ctx)

    Returns a pretty representation of the polynomial~\code{poly} using the
    null-terminated string \code{x} as the variable name

*******************************************************************************

    Inflation and deflation

*******************************************************************************

void fq_poly_inflate(fq_poly_t result, const fq_poly_t input,
                     ulong inflation, const fq_ctx_t ctx)

    Sets \code{result} to the inflated polynomial $p(x^n)$ where
    $p$ is given by \code{input} and $n$ is given by \code{inflation}.

void fq_poly_deflate(fq_poly_t result, const fq_poly_t input,
                     ulong deflation, const fq_ctx_t ctx)

    Sets \code{result} to the deflated polynomial $p(x^{1/n})$ where
    $p$ is given by \code{input} and $n$ is given by \code{deflation}.
    Requires $n > 0$.

ulong fq_poly_deflation(const fq_poly_t input, const fq_ctx_t ctx)

    Returns the largest integer by which \code{input} can be deflated.
    As special cases, returns 0 if \code{input} is the zero polynomial
    and 1 of \code{input} is a constant polynomial.
