.. _fmpq-poly:

**fmpq_poly.h** -- univariate polynomials over the rational numbers
===============================================================================

The :type:`fmpq_poly_t` data type represents elements of
`\mathbb{Q}[x]`. The ``fmpq_poly`` module provides routines for memory
management, basic arithmetic, and conversions from or to other types.

A rational polynomial is stored as the quotient of an integer
polynomial and an integer denominator. To be more precise, the
coefficient vector of the numerator can be accessed with the function
``fmpq_poly_numref()`` and the denominator with
``fmpq_poly_denref()``. Although one can construct use cases in which
a representation as a list of rational coefficients would be
beneficial, the choice made here is typically more efficient.

We can obtain a unique representation based on this choice by
enforcing, for non-zero polynomials, that the numerator and
denominator are coprime and that the denominator is positive. The
unique representation of the zero polynomial is chosen as $0/1$.

Similar to the situation in the :type:`fmpz_poly_t` case, an
:type:`fmpq_poly_t` object also has a ``length`` parameter, which
denotes the length of the vector of coefficients of the numerator. We
say a polynomial is *normalised* either if this length is zero or if
the leading coefficient is non-zero.

We say a polynomial is in *canonical* form if it is given in the
unique representation discussed above and normalised.

The functions provided in this module roughly fall into two
categories:

On the one hand, there are functions mainly provided for the user,
whose names do not begin with an underscore. These typically operate
on polynomials of type :type:`fmpq_poly_t` in canonical form and,
unless specified otherwise, permit aliasing between their input
arguments and between their output arguments.

On the other hand, there are versions of these functions whose names
are prefixed with a single underscore. These typically operate on
polynomials given in the form of a triple of object of types ``fmpz
*``, :type:`fmpz_t`, and :type:`slong`, containing the numerator,
denominator and length, respectively. In general, these functions
expect their input to be normalised, i.e. they do not allow zero
padding, and to be in lowest terms, and they do not allow their input
and output arguments to be aliased.

Types, macros and constants
-------------------------------------------------------------------------------

.. type:: fmpq_poly_struct

.. type:: fmpq_poly_t

Memory management
--------------------------------------------------------------------------------


.. function:: void fmpq_poly_init(fmpq_poly_t poly)

    Initialises the polynomial for use.  The length is set to zero.

.. function:: void fmpq_poly_init2(fmpq_poly_t poly, slong alloc)

    Initialises the polynomial with space for at least ``alloc``
    coefficients and sets the length to zero. The ``alloc`` coefficients
    are all set to zero.

.. function:: void fmpq_poly_realloc(fmpq_poly_t poly, slong alloc)

    Reallocates the given polynomial to have space for ``alloc``
    coefficients. If ``alloc`` is zero then the polynomial is cleared
    and then reinitialised.  If the current length is greater than
    ``alloc`` then ``poly`` is first truncated to length
    ``alloc``. Note that this might leave the rational polynomial in
    non-canonical form.

.. function:: void fmpq_poly_fit_length(fmpq_poly_t poly, slong len)

    If ``len`` is greater than the number of coefficients currently
    allocated, then the polynomial is reallocated to have space for at
    least ``len`` coefficients. No data is lost when calling this
    function. The function efficiently deals with the case where
    :func:`fit_length` is called many times in small increments by at
    least doubling the number of allocated coefficients when ``len``
    is larger than the number of coefficients currently allocated.

.. function:: void _fmpq_poly_set_length(fmpq_poly_t poly, slong len)

    Sets the length of the numerator polynomial to ``len``, demoting
    coefficients beyond the new length.  Note that this method does
    not guarantee that the rational polynomial is in canonical form.

.. function:: void fmpq_poly_clear(fmpq_poly_t poly)

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

.. function:: void _fmpq_poly_normalise(fmpq_poly_t poly)

    Sets the length of ``poly`` so that the top coefficient is
    non-zero. If all coefficients are zero, the length is set to zero.
    Note that this function does not guarantee the coprimality of the
    numerator polynomial and the integer denominator.

.. function:: void _fmpq_poly_canonicalise(fmpz * poly, fmpz_t den, slong len)

    Puts ``(poly, den)`` of length ``len`` into canonical form.

    It is assumed that the array ``poly`` contains a non-zero entry in
    position ``len - 1`` whenever ``len > 0``.  Assumes that ``den``
    is non-zero.

.. function:: void fmpq_poly_canonicalise(fmpq_poly_t poly)

    Puts the polynomial ``poly`` into canonical form.  Firstly, the length
    is set to the actual length of the numerator polynomial.  For non-zero
    polynomials, it is then ensured that the numerator and denominator are
    coprime and that the denominator is positive.  The canonical form of the
    zero polynomial is a zero numerator polynomial and a one denominator.

.. function:: int _fmpq_poly_is_canonical(const fmpz * poly, const fmpz_t den, slong len)

    Returns whether the polynomial is in canonical form.

.. function:: int fmpq_poly_is_canonical(const fmpq_poly_t poly)

    Returns whether the polynomial is in canonical form.


Polynomial parameters
--------------------------------------------------------------------------------


.. function:: slong fmpq_poly_degree(const fmpq_poly_t poly)

    Returns the degree of ``poly``, which is one less than its length, as
    a ``slong``.

.. function:: slong fmpq_poly_length(const fmpq_poly_t poly)

    Returns the length of ``poly``.


Accessing the numerator and denominator
--------------------------------------------------------------------------------


.. function:: fmpz * fmpq_poly_numref(fmpq_poly_t poly)

    Returns a reference to the numerator polynomial as an array.

    Note that, because of a delayed initialisation approach, this might
    be ``NULL`` for zero polynomials.  This situation can be salvaged
    by calling either :func:`fmpq_poly_fit_length` or
    :func:`fmpq_poly_realloc`.

    This function is implemented as a macro returning ``(poly)->coeffs``.

.. function:: fmpz_t fmpq_poly_denref(fmpq_poly_t poly)

    Returns a reference to the denominator as a ``fmpz_t``.  The integer
    is guaranteed to be properly initialised.

    This function is implemented as a macro returning ``(poly)->den``.

.. function:: void fmpq_poly_get_numerator(fmpz_poly_t res, const fmpq_poly_t poly)

    Sets ``res`` to the numerator of ``poly``, e.g. the primitive part
    as an ``fmpz_poly_t`` if it is in canonical form.

.. function:: void fmpq_poly_get_denominator(fmpz_t den, const fmpq_poly_t poly)

    Sets ``res`` to the denominator of ``poly``.

Random testing
--------------------------------------------------------------------------------

The functions :func:`fmpq_poly_randtest_foo` provide random
polynomials suitable for testing.  On an integer level, this
means that long strings of zeros and ones in the binary
representation are favoured as well as the special absolute
values `0`, `1`, ``COEFF_MAX``, and ``WORD_MAX``.  On a
polynomial level, the integer numerator has a reasonable chance
to have a non-trivial content.

.. function:: void fmpq_poly_randtest(fmpq_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits)

    Sets `f` to a random polynomial with coefficients up to the given
    length and where each coefficient has up to the given number of bits.
    The coefficients are signed randomly.  One must call
    :func:`flint_randinit` before calling this function.

.. function:: void fmpq_poly_randtest_unsigned(fmpq_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits)

    Sets `f` to a random polynomial with coefficients up to the given length
    and where each coefficient has up to the given number of bits.  One must
    call :func:`flint_randinit` before calling this function.

.. function:: void fmpq_poly_randtest_not_zero(fmpq_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits)

    As for :func:`fmpq_poly_randtest` except that ``len`` and ``bits``
    may not be zero and the polynomial generated is guaranteed not to be the
    zero polynomial.  One must call :func:`flint_randinit` before calling
    this function.


Assignment, swap, negation
--------------------------------------------------------------------------------


.. function:: void fmpq_poly_set(fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Sets ``poly1`` to equal ``poly2``.

.. function:: void fmpq_poly_set_si(fmpq_poly_t poly, slong x)

    Sets ``poly`` to the integer `x`.

.. function:: void fmpq_poly_set_ui(fmpq_poly_t poly, ulong x)

    Sets ``poly`` to the integer `x`.

.. function:: void fmpq_poly_set_fmpz(fmpq_poly_t poly, const fmpz_t x)

    Sets ``poly`` to the integer `x`.

.. function:: void fmpq_poly_set_fmpq(fmpq_poly_t poly, const fmpq_t x)

    Sets ``poly`` to the rational `x`, which is assumed to be
    given in lowest terms.

.. function:: void fmpq_poly_set_fmpz_poly(fmpq_poly_t rop, const fmpz_poly_t op)

    Sets the rational polynomial ``rop`` to the same value
    as the integer polynomial ``op``.

.. function:: void fmpq_poly_set_nmod_poly(fmpq_poly_t rop, const nmod_poly_t op)

    Sets the coefficients of ``rop`` to the residues in ``op``,
    normalised to the interval `-m/2 \le r < m/2` where `m` is the modulus.

.. function:: void fmpq_poly_get_nmod_poly(nmod_poly_t rop, const fmpq_poly_t op)

    Sets the coefficients of ``rop`` to the coefficients in the denominator of ``op``,
    reduced by the modulus of ``rop``. The result is multiplied by the inverse of the
    denominator of ``op``. It is assumed that the reduction of the denominator of ``op``
    is invertible.

.. function:: void fmpq_poly_get_nmod_poly_den(nmod_poly_t rop, const fmpq_poly_t op, int den)

    Sets the coefficients of ``rop`` to the coefficients in the denominator
    of ``op``, reduced by the modulus of ``rop``. If ``den == 1``, the result is
    multiplied by the inverse of the denominator of ``op``. In this case it is
    assumed that the reduction of the denominator of ``op`` is invertible.

.. function:: int _fmpq_poly_set_str(fmpz * poly, fmpz_t den, const char * str, slong len)

    Sets ``(poly, den)`` to the polynomial specified by the
    null-terminated string ``str`` of ``len`` coefficients. The input
    format is a sequence of coefficients separated by one space.

    The result is only guaranteed to be in lowest terms if all
    coefficients in the input string are in lowest terms.

    Returns `0` if no error occurred. Otherwise, returns -1
    in which case the resulting value of ``(poly, den)`` is undefined.
    If ``str`` is not null-terminated, calling this method might result
    in a segmentation fault.

.. function:: int fmpq_poly_set_str(fmpq_poly_t poly, const char * str)

    Sets ``poly`` to the polynomial specified by the null-terminated
    string ``str``. The input format is the same as the output format
    of ``fmpq_poly_get_str``: the length given as a decimal integer,
    then two spaces, then the list of coefficients separated by one space.

    The result is only guaranteed to be in canonical form if all
    coefficients in the input string are in lowest terms.

    Returns `0` if no error occurred.  Otherwise, returns -1 in which case
    the resulting value of ``poly`` is set to zero. If ``str`` is not
    null-terminated, calling this method might result in a segmentation fault.

.. function:: char * fmpq_poly_get_str(const fmpq_poly_t poly)

    Returns the string representation of ``poly``.

.. function:: char * fmpq_poly_get_str_pretty(const fmpq_poly_t poly, const char * var)

    Returns the pretty representation of ``poly``, using the
    null-terminated string ``var`` not equal to ``"\0"`` as
    the variable name.

.. function:: void fmpq_poly_zero(fmpq_poly_t poly)

    Sets ``poly`` to zero.

.. function:: void fmpq_poly_one(fmpq_poly_t poly)

    Sets ``poly`` to the constant polynomial `1`.

.. function:: void fmpq_poly_neg(fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Sets ``poly1`` to the additive inverse of ``poly2``.

.. function:: void fmpq_poly_inv(fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Sets ``poly1`` to the multiplicative inverse of ``poly2``
    if possible.  Otherwise, if ``poly2`` is not a unit, leaves
    ``poly1`` unmodified and calls :func:`abort`.

.. function:: void fmpq_poly_swap(fmpq_poly_t poly1, fmpq_poly_t poly2)

    Efficiently swaps the polynomials ``poly1`` and ``poly2``.

.. function:: void fmpq_poly_truncate(fmpq_poly_t poly, slong n)

    If the current length of ``poly`` is greater than `n`, it is
    truncated to the given length.  Discarded coefficients are demoted,
    but they are not necessarily set to zero.

.. function:: void fmpq_poly_set_trunc(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Sets ``res`` to a copy of ``poly``, truncated to length ``n``.

.. function:: void fmpq_poly_get_slice(fmpq_poly_t rop, const fmpq_poly_t op, slong i, slong j)

    Returns the slice with coefficients from `x^i` (including) to
    `x^j` (excluding).

.. function:: void fmpq_poly_reverse(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    This function considers the polynomial ``poly`` to be of length `n`,
    notionally truncating and zero padding if required, and reverses
    the result.  Since the function normalises its result ``res`` may be
    of length less than `n`.


Getting and setting coefficients
--------------------------------------------------------------------------------


.. function:: void fmpq_poly_get_coeff_fmpz(fmpz_t x, const fmpq_poly_t poly, slong n)

    Retrieves the `n`\th coefficient of the numerator of ``poly``.

.. function:: void fmpq_poly_get_coeff_fmpq(fmpq_t x, const fmpq_poly_t poly, slong n)

    Retrieves the `n`\th coefficient of ``poly``, in lowest terms.

.. function:: void fmpq_poly_set_coeff_si(fmpq_poly_t poly, slong n, slong x)

    Sets the `n`\th coefficient in ``poly`` to the integer `x`.

.. function:: void fmpq_poly_set_coeff_ui(fmpq_poly_t poly, slong n, ulong x)

    Sets the `n`\th coefficient in ``poly`` to the integer `x`.

.. function:: void fmpq_poly_set_coeff_fmpz(fmpq_poly_t poly, slong n, const fmpz_t x)

    Sets the `n`\th coefficient in ``poly`` to the integer `x`.

.. function:: void fmpq_poly_set_coeff_fmpq(fmpq_poly_t poly, slong n, const fmpq_t x)

    Sets the `n`\th coefficient in ``poly`` to the rational `x`.


Comparison
--------------------------------------------------------------------------------


.. function:: int fmpq_poly_equal(const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Returns `1` if ``poly1`` is equal to ``poly2``,
    otherwise returns `0`.

.. function:: int _fmpq_poly_equal_trunc(const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n)

    Returns `1` if ``poly1`` and ``poly2`` notionally truncated to length
    `n` are equal, otherwise returns `0`.

.. function:: int fmpq_poly_equal_trunc(const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n)

    Returns `1` if ``poly1`` and ``poly2`` notionally truncated to length
    `n` are equal, otherwise returns `0`.

.. function:: int _fmpq_poly_cmp(const fmpz * lpoly, const fmpz_t lden, const fmpz * rpoly, const fmpz_t rden, slong len)

    Compares two non-zero polynomials, assuming they have the same length
    ``len > 0``.

    The polynomials are expected to be provided in canonical form.

.. function:: int fmpq_poly_cmp(const fmpq_poly_t left, const fmpq_poly_t right)

    Compares the two polynomials ``left`` and ``right``.

    Compares the two polynomials ``left`` and ``right``, returning
    `-1`, `0`, or `1` as ``left`` is less than, equal to, or greater
    than ``right``.  The comparison is first done by the degree, and
    then, in case of a tie, by the individual coefficients from highest
    to lowest.

.. function:: int fmpq_poly_is_one(const fmpq_poly_t poly)

    Returns `1` if ``poly`` is the constant polynomial `1`, otherwise
    returns `0`.

.. function:: int fmpq_poly_is_zero(const fmpq_poly_t poly)

    Returns `1` if ``poly`` is the zero polynomial, otherwise returns `0`.

.. function:: int fmpq_poly_is_gen(const fmpq_poly_t poly)

    Returns `1` if ``poly`` is the degree `1` polynomial `x`, otherwise returns
    `0`.

Addition and subtraction
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_add(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2)

    Forms the sum ``(rpoly, rden)`` of ``(poly1, den1, len1)`` and
    ``(poly2, den2, len2)``, placing the result into canonical form.

    Assumes that ``rpoly`` is an array of length the maximum of
    ``len1`` and ``len2``.  The input operands are assumed to
    be in canonical form and are also allowed to be of length `0`.

    ``(rpoly, rden)`` and ``(poly1, den1)`` may be aliased,
    but ``(rpoly, rden)`` and ``(poly2, den2)`` may *not*
    be aliased.

.. function:: void _fmpq_poly_add_can(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, int can)

    As per ``_fmpq_poly_add`` except that one can specify whether to
    canonicalise the output or not. This function is intended to be used with
    weak canonicalisation to prevent explosion in memory usage. It exists for
    performance reasons.

.. function:: void fmpq_poly_add(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Sets ``res`` to the sum of ``poly1`` and ``poly2``, using
    Henrici's algorithm.

.. function:: void fmpq_poly_add_can(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, int can)

    As per ``mpq_poly_add`` except that one can specify whether to
    canonicalise the output or not. This function is intended to be used with
    weak canonicalisation to prevent explosion in memory usage. It exists for
    performance reasons.

.. function:: void _fmpq_poly_add_series(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n)

    As per ``_fmpq_poly_add`` but the inputs are first notionally truncated
    to length `n`. If `n` is less than ``len1`` or ``len2`` then the
    output only needs space for `n` coefficients. We require `n \geq 0`.

.. function:: void _fmpq_poly_add_series_can(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n, int can)

    As per ``_fmpq_poly_add_can`` but the inputs are first notionally
    truncated to length `n`. If `n` is less than ``len1`` or ``len2``
    then the output only needs space for `n` coefficients. We require
    `n \geq 0`.

.. function:: void fmpq_poly_add_series(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n)

    As per ``fmpq_poly_add`` but the inputs are first notionally
    truncated to length `n`.

.. function:: void fmpq_poly_add_series_can(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n, int can)

    As per ``fmpq_poly_add_can`` but the inputs are first notionally
    truncated to length `n`.

.. function:: void _fmpq_poly_sub(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2)

    Forms the difference ``(rpoly, rden)`` of ``(poly1, den1, len1)``
    and ``(poly2, den2, len2)``, placing the result into canonical form.

    Assumes that ``rpoly`` is an array of length the maximum of
    ``len1`` and ``len2``.  The input operands are assumed to be in
    canonical form and are also allowed to be of length `0`.

    ``(rpoly, rden)`` and ``(poly1, den1, len1)`` may be aliased,
    but ``(rpoly, rden)`` and ``(poly2, den2, len2)`` may *not* be
    aliased.

.. function:: void _fmpq_poly_sub_can(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, int can)

    As per ``_fmpq_poly_sub`` except that one can specify whether to
    canonicalise the output or not. This function is intended to be used with
    weak canonicalisation to prevent explosion in memory usage. It exists for
    performance reasons.

.. function:: void fmpq_poly_sub(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Sets ``res`` to the difference of ``poly1`` and ``poly2``,
    using Henrici's algorithm.

.. function:: void fmpq_poly_sub_can(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, int can)

    As per ``_fmpq_poly_sub`` except that one can specify whether to
    canonicalise the output or not. This function is intended to be used with
    weak canonicalisation to prevent explosion in memory usage. It exists for
    performance reasons.

.. function:: void _fmpq_poly_sub_series(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n)

    As per ``_fmpq_poly_sub`` but the inputs are first notionally truncated
    to length `n`. If `n` is less than ``len1`` or ``len2`` then the
    output only needs space for `n` coefficients. We require `n \geq 0`.

.. function:: void _fmpq_poly_sub_series_can(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n, int can)

    As per ``_fmpq_poly_sub_can`` but the inputs are first notionally
    truncated to length `n`. If `n` is less than ``len1`` or ``len2``
    then the output only needs space for `n` coefficients. We require
    `n \geq 0`.

.. function:: void fmpq_poly_sub_series(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n)

    As per ``fmpq_poly_sub`` but the inputs are first notionally
    truncated to length `n`.

.. function:: void fmpq_poly_sub_series_can(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n, int can)

    As per ``fmpq_poly_sub_can`` but the inputs are first notionally
    truncated to length `n`.


Scalar multiplication and division
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_scalar_mul_si(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, slong c)

    Sets ``(rpoly, rden, len)`` to the product of `c` of
    ``(poly, den, len)``.

    If the input is normalised, then so is the output, provided it is
    non-zero.  If the input is in lowest terms, then so is the output.
    However, even if neither of these conditions are met, the result
    will be (mathematically) correct.

    Supports exact aliasing between ``(rpoly, den)``
    and ``(poly, den)``.

.. function:: void _fmpq_poly_scalar_mul_ui(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, ulong c)

    Sets ``(rpoly, rden, len)`` to the product of `c` of
    ``(poly, den, len)``.

    If the input is normalised, then so is the output, provided it is
    non-zero.  If the input is in lowest terms, then so is the output.
    However, even if neither of these conditions are met, the result
    will be (mathematically) correct.

    Supports exact aliasing between ``(rpoly, den)``
    and ``(poly, den)``.

.. function:: void _fmpq_poly_scalar_mul_fmpz(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, const fmpz_t c)

    Sets ``(rpoly, rden, len)`` to the product of `c` of
    ``(poly, den, len)``.

    If the input is normalised, then so is the output, provided it is
    non-zero.  If the input is in lowest terms, then so is the output.
    However, even if neither of these conditions are met, the result
    will be (mathematically) correct.

    Supports exact aliasing between ``(rpoly, den)``
    and ``(poly, den)``.

.. function:: void _fmpq_poly_scalar_mul_fmpq(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, const fmpz_t r, const fmpz_t s)

    Sets ``(rpoly, rden)`` to the product of `r/s` and
    ``(poly, den, len)``, in lowest terms.

    Assumes that ``(poly, den, len)`` and `r/s` are provided in lowest
    terms.  Assumes that ``rpoly`` is an array of length ``len``.
    Supports aliasing of ``(rpoly, den)`` and ``(poly, den)``.
    The ``fmpz_t``'s `r` and `s` may not be part of ``(rpoly, rden)``.

.. function:: void fmpq_poly_scalar_mul_fmpq(fmpq_poly_t rop, const fmpq_poly_t op, const fmpq_t c)
              void fmpq_poly_scalar_mul_si(fmpq_poly_t rop, const fmpq_poly_t op, slong c)
              void fmpq_poly_scalar_mul_ui(fmpq_poly_t rop, const fmpq_poly_t op, ulong c)

    Sets ``rop`` to `c` times ``op``.

.. function:: void fmpq_poly_scalar_mul_fmpz(fmpq_poly_t rop, const fmpq_poly_t op, const fmpz_t c)

    Sets ``rop`` to `c` times ``op``.  Assumes that the ``fmpz_t c``
    is not part of ``rop``.

.. function:: void _fmpq_poly_scalar_div_fmpz(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, const fmpz_t c)

    Sets ``(rpoly, rden, len)`` to ``(poly, den, len)`` divided by `c`,
    in lowest terms.

    Assumes that ``len`` is positive.  Assumes that `c` is non-zero.
    Supports aliasing between ``(rpoly, rden)`` and ``(poly, den)``.
    Assumes that `c` is not part of ``(rpoly, rden)``.

.. function:: void _fmpq_poly_scalar_div_si(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, slong c)

    Sets ``(rpoly, rden, len)`` to ``(poly, den, len)`` divided by `c`,
    in lowest terms.

    Assumes that ``len`` is positive.  Assumes that `c` is non-zero.
    Supports aliasing between ``(rpoly, rden)`` and ``(poly, den)``.

.. function:: void _fmpq_poly_scalar_div_ui(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, ulong c)

    Sets ``(rpoly, rden, len)`` to ``(poly, den, len)`` divided by `c`,
    in lowest terms.

    Assumes that ``len`` is positive.  Assumes that `c` is non-zero.
    Supports aliasing between ``(rpoly, rden)`` and ``(poly, den)``.

.. function:: void _fmpq_poly_scalar_div_fmpq(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, const fmpz_t r, const fmpz_t s)

    Sets ``(rpoly, rden, len)`` to ``(poly, den, len)`` divided by `r/s`,
    in lowest terms.

    Assumes that ``len`` is positive.  Assumes that `r/s` is non-zero and
    in lowest terms.  Supports aliasing between ``(rpoly, rden)`` and
    ``(poly, den)``. The ``fmpz_t``'s `r` and `s` may not be part of
    ``(rpoly, poly)``.

.. function:: void fmpq_poly_scalar_div_si(fmpq_poly_t rop, const fmpq_poly_t op, slong c)
              void fmpq_poly_scalar_div_ui(fmpq_poly_t rop, const fmpq_poly_t op, ulong c)
              void fmpq_poly_scalar_div_fmpz(fmpq_poly_t rop, const fmpq_poly_t op, const fmpz_t c)
              void fmpq_poly_scalar_div_fmpq(fmpq_poly_t rop, const fmpq_poly_t op, const fmpq_t c)

    Sets ``rop`` to ``op`` divided by the scalar ``c``.

Multiplication
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_mul(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2)

    Sets ``(rpoly, rden, len1 + len2 - 1)`` to the product of
    ``(poly1, den1, len1)`` and ``(poly2, den2, len2)``. If the
    input is provided in canonical form, then so is the output.

    Assumes ``len1 >= len2 > 0``.  Allows zero-padding in the input.
    Does not allow aliasing between the inputs and outputs.

.. function:: void fmpq_poly_mul(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Sets ``res`` to the product of ``poly1`` and ``poly2``.

.. function:: void _fmpq_poly_mullow(fmpz * rpoly, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n)

    Sets ``(rpoly, rden, n)`` to the low `n` coefficients of
    ``(poly1, den1)`` and ``(poly2, den2)``.  The output is
    not guaranteed to be in canonical form.

    Assumes ``len1 >= len2 > 0`` and ``0 < n <= len1 + len2 - 1``.
    Allows for zero-padding in the inputs.  Does not allow aliasing between
    the inputs and outputs.

.. function:: void fmpq_poly_mullow(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n)

    Sets ``res`` to the product of ``poly1`` and ``poly2``,
    truncated to length `n`.

.. function:: void fmpq_poly_addmul(fmpq_poly_t rop, const fmpq_poly_t op1, const fmpq_poly_t op2)

    Adds the product of ``op1`` and ``op2`` to ``rop``.

.. function:: void fmpq_poly_submul(fmpq_poly_t rop, const fmpq_poly_t op1, const fmpq_poly_t op2)

    Subtracts the product of ``op1`` and ``op2`` from ``rop``.


Powering
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_pow(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, ulong e)

    Sets ``(rpoly, rden)`` to ``(poly, den)^e``, assuming
    ``e, len > 0``.  Assumes that ``rpoly`` is an array of
    length at least ``e * (len - 1) + 1``.  Supports aliasing
    of ``(rpoly, den)`` and ``(poly, den)``.

.. function:: void fmpq_poly_pow(fmpq_poly_t res, const fmpq_poly_t poly, ulong e)

    Sets ``res`` to ``poly^e``, where the only special case `0^0` is
    defined as `1`.

.. function:: void _fmpq_poly_pow_trunc(fmpz * res, fmpz_t rden, const fmpz * f, const fmpz_t fden, slong flen, ulong exp, slong len)

    Sets ``(rpoly, rden, len)`` to ``(poly, den)^e`` truncated to length ``len``,
    where ``len`` is at most ``e * (flen - 1) + 1``.

.. function:: void fmpq_poly_pow_trunc(fmpq_poly_t res, const fmpq_poly_t poly, ulong e, slong n)

    Sets ``res`` to ``poly^e`` truncated to length ``n``.


Shifting
--------------------------------------------------------------------------------


.. function:: void fmpq_poly_shift_left(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Set ``res`` to ``poly`` shifted left by `n` coefficients. Zero
    coefficients are inserted.

.. function:: void fmpq_poly_shift_right(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Set ``res`` to ``poly`` shifted right by `n` coefficients.
    If `n` is equal to or greater than the current length of ``poly``,
    ``res`` is set to the zero polynomial.


Euclidean division
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_divrem(fmpz * Q, fmpz_t q, fmpz * R, fmpz_t r, const fmpz * A, const fmpz_t a, slong lenA, const fmpz * B, const fmpz_t b, slong lenB, const fmpz_preinvn_t inv)

    Finds the quotient ``(Q, q)`` and remainder ``(R, r)`` of the
    Euclidean division of ``(A, a)`` by ``(B, b)``.

    Assumes that ``lenA >= lenB > 0``.  Assumes that `R` has space for
    ``lenA`` coefficients, although only the bottom ``lenB - 1`` will
    carry meaningful data on exit.  Supports no aliasing between the two
    outputs, or between the inputs and the outputs.

    An optional precomputed inverse of the leading coefficient of `B` from
    ``fmpz_preinvn_init`` can be supplied. Otherwise ``inv`` should be
    ``NULL``.

    Note: ``fmpz.h`` has to be included before ``fmpq_poly.h`` in order for the
    latter to declare this function.

.. function:: void fmpq_poly_divrem(fmpq_poly_t Q, fmpq_poly_t R, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Finds the quotient `Q` and remainder `R` of the Euclidean division of
    ``poly1`` by ``poly2``.

.. function:: void _fmpq_poly_div(fmpz * Q, fmpz_t q, const fmpz * A, const fmpz_t a, slong lenA, const fmpz * B, const fmpz_t b, slong lenB, const fmpz_preinvn_t inv)

    Finds the quotient ``(Q, q)`` of the Euclidean division
    of ``(A, a)`` by ``(B, b)``.

    Assumes that ``lenA >= lenB > 0``.  Supports no aliasing
    between the inputs and the outputs.

    An optional precomputed inverse of the leading coefficient of `B` from
    ``fmpz_preinvn_init`` can be supplied. Otherwise ``inv`` should be
    ``NULL``.

    Note: ``fmpz.h`` has to be included before ``fmpq_poly.h`` in order for the
    latter to declare this function.

.. function:: void fmpq_poly_div(fmpq_poly_t Q, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Finds the quotient `Q` and remainder `R` of the Euclidean division
    of ``poly1`` by ``poly2``.

.. function:: void _fmpq_poly_rem(fmpz * R, fmpz_t r, const fmpz * A, const fmpz_t a, slong lenA, const fmpz * B, const fmpz_t b, slong lenB, const fmpz_preinvn_t inv)

    Finds the remainder ``(R, r)`` of the Euclidean division
    of ``(A, a)`` by ``(B, b)``.

    Assumes that ``lenA >= lenB > 0``.  Supports no aliasing between
    the inputs and the outputs.

    An optional precomputed inverse of the leading coefficient of `B` from
    ``fmpz_preinvn_init`` can be supplied. Otherwise ``inv`` should be
    ``NULL``.

    Note: ``fmpz.h`` has to be included before ``fmpq_poly.h`` in order for the
    latter to declare this function.

.. function:: void fmpq_poly_rem(fmpq_poly_t R, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Finds the remainder `R` of the Euclidean division
    of ``poly1`` by ``poly2``.


Powering
--------------------------------------------------------------------------------


.. function:: fmpq_poly_struct * _fmpq_poly_powers_precompute(const fmpz * B, const fmpz_t denB, slong len)

    Computes ``2*len - 1`` powers of `x` modulo the polynomial `B` of
    the given length. This is used as a kind of precomputed inverse in
    the remainder routine below.

.. function:: void fmpq_poly_powers_precompute(fmpq_poly_powers_precomp_t pinv, fmpq_poly_t poly)

    Computes ``2*len - 1`` powers of `x` modulo the polynomial `B` of the given length. This is used as a kind of precomputed inverse in the remainder routine below.

.. function:: void _fmpq_poly_powers_clear(fmpq_poly_struct * powers, slong len)

    Clean up resources used by precomputed powers which have been computed
    by ``_fmpq_poly_powers_precompute``.

.. function:: void fmpq_poly_powers_clear(fmpq_poly_powers_precomp_t pinv)

    Clean up resources used by precomputed powers which have been computed
    by ``fmpq_poly_powers_precompute``.

.. function:: void _fmpq_poly_rem_powers_precomp(fmpz * A, fmpz_t denA, slong m, const fmpz * B, const fmpz_t denB, slong n, fmpq_poly_struct * const powers)

    Set `A` to the remainder of `A` divide `B` given precomputed powers mod `B`
    provided by ``_fmpq_poly_powers_precompute``. No aliasing is allowed.

    This function is only faster if `m \leq 2\cdot n - 1`.

    The output of this function is *not* canonicalised.

.. function:: void fmpq_poly_rem_powers_precomp(fmpq_poly_t R, const fmpq_poly_t A, const fmpq_poly_t B, const fmpq_poly_powers_precomp_t B_inv)

    Set `R` to the remainder of `A` divide `B` given precomputed powers mod `B`
    provided by ``fmpq_poly_powers_precompute``.

    This function is only faster if ``A->length <= 2*B->length - 1``.

    The output of this function is *not* canonicalised.


Divisibility testing
--------------------------------------------------------------------------------


.. function:: int _fmpq_poly_divides(fmpz * qpoly, fmpz_t qden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2)

    Return `1` if ``(poly2, den2, len2)`` divides ``(poly1, den1, len1)`` and
    set ``(qpoly, qden, len1 - len2 + 1)`` to the quotient. Otherwise return
    `0`. Requires that ``qpoly`` has space for ``len1 - len2 + 1``
    coefficients and that ``len1 >= len2 > 0``.

.. function:: int fmpq_poly_divides(fmpq_poly_t q, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Return `1` if ``poly2`` divides ``poly1`` and set ``q`` to the quotient.
    Otherwise return `0`.

.. function:: slong fmpq_poly_remove(fmpq_poly_t q, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Sets ``q`` to the quotient of ``poly1`` by the highest power of ``poly2``
    which divides it, and returns the power. The divisor ``poly2`` must not be
    constant or an exception is raised.


Power series division
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_inv_series_newton(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, slong n)

    Computes the first `n` terms of the inverse power series of
    ``(poly, den, len)`` using Newton iteration.

    The result is produced in canonical form.

    Assumes that `n \geq 1` and that ``poly`` has non-zero constant term.
    Does not support aliasing.

.. function:: void fmpq_poly_inv_series_newton(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Computes the first `n` terms of the inverse power series
    of ``poly`` using Newton iteration, assuming that ``poly``
    has non-zero constant term and `n \geq 1`.

.. function:: void _fmpq_poly_inv_series(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong den_len, slong n)

    Computes the first `n` terms of the inverse power series of
    ``(poly, den, len)``.

    The result is produced in canonical form.

    Assumes that `n \geq 1` and that ``poly`` has non-zero constant term.
    Does not support aliasing.

.. function:: void fmpq_poly_inv_series(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Computes the first `n` terms of the inverse power series of ``poly``,
    assuming that ``poly`` has non-zero constant term and `n \geq 1`.

.. function:: void _fmpq_poly_div_series(fmpz * Q, fmpz_t denQ, const fmpz * A, const fmpz_t denA, slong lenA, const fmpz * B, const fmpz_t denB, slong lenB, slong n)

    Divides ``(A, denA, lenA)`` by ``(B, denB, lenB)`` as power series
    over `\mathbb{Q}`, assuming `B` has non-zero constant term and that
    all lengths are positive.

    Aliasing is not supported.

    This function ensures that the numerator and denominator
    are coprime on exit.

.. function:: void fmpq_poly_div_series(fmpq_poly_t Q, const fmpq_poly_t A, const fmpq_poly_t B, slong n)

    Performs power series division in `\mathbb{Q}[[x]] / (x^n)`.  The function
    considers the polynomials `A` and `B` as power series of length `n`
    starting with the constant terms.  The function assumes that `B` has
    non-zero constant term and `n \geq 1`.


Greatest common divisor
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_gcd(fmpz * G, fmpz_t denG, const fmpz * A, slong lenA, const fmpz * B, slong lenB)

    Computes the monic greatest common divisor `G` of `A` and `B`.

    Assumes that `G` has space for `\operatorname{len}(B)` coefficients,
    where `\operatorname{len}(A) \geq \operatorname{len}(B) > 0`.

    Aliasing between the output and input arguments is not supported.

    Does not support zero-padding.

.. function:: void fmpq_poly_gcd(fmpq_poly_t G, const fmpq_poly_t A, const fmpq_poly_t B)

    Computes the monic greatest common divisor `G` of `A` and `B`.

    In the special case when `A = B = 0`, sets `G = 0`.

.. function:: void _fmpq_poly_xgcd(fmpz * G, fmpz_t denG, fmpz * S, fmpz_t denS, fmpz * T, fmpz_t denT, const fmpz * A, const fmpz_t denA, slong lenA, const fmpz * B, const fmpz_t denB, slong lenB)

    Computes polynomials `G`, `S`, and `T` such that
    `G = \gcd(A, B) = S A + T B`, where `G` is the monic
    greatest common divisor of `A` and `B`.

    Assumes that `G`, `S`, and `T` have space for `\operatorname{len}(B)`,
    `\operatorname{len}(B)`, and `\operatorname{len}(A)` coefficients, respectively,
    where it is also assumed that `\operatorname{len}(A) \geq \operatorname{len}(B) > 0`.

    Does not support zero padding of the input arguments.

.. function:: void fmpq_poly_xgcd(fmpq_poly_t G, fmpq_poly_t S, fmpq_poly_t T, const fmpq_poly_t A, const fmpq_poly_t B)

    Computes polynomials `G`, `S`, and `T` such that
    `G = \gcd(A, B) = S A + T B`, where `G` is the monic
    greatest common divisor of `A` and `B`.

    Corner cases are handled as follows.  If `A = B = 0`, returns
    `G = S = T = 0`.  If `A \neq 0`, `B = 0`, returns the suitable
    scalar multiple of `G = A`, `S = 1`, and `T = 0`.  The case
    when `A = 0`, `B \neq 0` is handled similarly.

.. function:: void _fmpq_poly_lcm(fmpz * L, fmpz_t denL, const fmpz * A, slong lenA, const fmpz * B, slong lenB)

    Computes the monic least common multiple `L` of `A` and `B`.

    Assumes that `L` has space for `\operatorname{len}(A) + \operatorname{len}(B) - 1` coefficients,
    where `\operatorname{len}(A) \geq \operatorname{len}(B) > 0`.

    Aliasing between the output and input arguments is not supported.

    Does not support zero-padding.

.. function:: void fmpq_poly_lcm(fmpq_poly_t L, const fmpq_poly_t A, const fmpq_poly_t B)

    Computes the monic least common multiple `L` of `A` and `B`.

    In the special case when `A = B = 0`, sets `L = 0`.

.. function:: void _fmpq_poly_resultant(fmpz_t rnum, fmpz_t rden, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2)

    Sets ``(rnum, rden)`` to the resultant of the two input
    polynomials.

    Assumes that ``len1 >= len2 > 0``.  Does not support zero-padding
    of the input polynomials.  Does not support aliasing of the input and
    output arguments.

.. function:: void fmpq_poly_resultant(fmpq_t r, const fmpq_poly_t f, const fmpq_poly_t g)

    Returns the resultant of `f` and `g`.

    Enumerating the roots of `f` and `g` over `\bar{\mathbf{Q}}` as
    `r_1, \dotsc, r_m` and `s_1, \dotsc, s_n`, respectively, and
    letting `x` and `y` denote the leading coefficients, the resultant
    is defined as

    .. math::


         x^{\deg(f)} y^{\deg(g)} \prod_{1 \leq i, j \leq n} (r_i - s_j).



    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.

.. function:: void fmpq_poly_resultant_div(fmpq_t r, const fmpq_poly_t f, const fmpq_poly_t g, const fmpz_t div, slong nbits)

    Returns the resultant of `f` and `g` divided by ``div`` under the
    assumption that the result has at most ``nbits`` bits. The result must
    be an integer.


Derivative and integral
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_derivative(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len)

    Sets ``(rpoly, rden, len - 1)`` to the derivative of
    ``(poly, den, len)``.  Does nothing if ``len <= 1``.
    Supports aliasing between the two polynomials.

.. function:: void fmpq_poly_derivative(fmpq_poly_t res, const fmpq_poly_t poly)

    Sets ``res`` to the derivative of ``poly``.

.. function:: void _fmpq_poly_nth_derivative(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, ulong n, slong len)

    Sets ``(rpoly, rden, len - n)`` to the nth derivative of
    ``(poly, den, len)``.  Does nothing if ``len <= n``.
    Supports aliasing between the two polynomials.

.. function:: void fmpq_poly_nth_derivative(fmpq_poly_t res, const fmpq_poly_t poly, ulong n)

    Sets ``res`` to the nth derivative of ``poly``.

.. function:: void _fmpq_poly_integral(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len)

    Sets ``(rpoly, rden, len)`` to the integral of
    ``(poly, den, len - 1)``.  Assumes ``len >= 0``.
    Supports aliasing between the two polynomials.
    The output will be in canonical form if the input is
    in canonical form.

.. function:: void fmpq_poly_integral(fmpq_poly_t res, const fmpq_poly_t poly)

    Sets ``res`` to the integral of ``poly``. The constant
    term is set to zero. In particular, the integral of the zero
    polynomial is the zero polynomial.


Square roots
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_sqrt_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    square root of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 1.
    Does not support aliasing between the input and output polynomials.

.. function:: void fmpq_poly_sqrt_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the square root of ``f``
    to order ``n > 1``. Requires ``f`` to have constant term 1.

.. function:: void _fmpq_poly_invsqrt_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the inverse
    square root of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 1.
    Does not support aliasing between the input and output polynomials.

.. function:: void fmpq_poly_invsqrt_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the inverse square root of
    ``f`` to order ``n > 0``. Requires ``f`` to have constant term 1.


Power sums
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_power_sums(fmpz * res, fmpz_t rden, const fmpz * poly, slong len, slong n)

    Compute the (truncated) power sums series of the polynomial
    ``(poly,len)`` up to length `n` using Newton identities.

.. function:: void fmpq_poly_power_sums(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Compute the (truncated) power sum series of the monic polynomial
    ``poly`` up to length `n` using Newton identities. That is the power
    series whose coefficient of degree `i` is the sum of the `i`-th power of
    all (complex) roots of the polynomial ``poly``.

.. function:: void _fmpq_poly_power_sums_to_poly(fmpz * res, const fmpz * poly, const fmpz_t den, slong len)

    Compute an integer polynomial given by its power sums series ``(poly,den,len)``.

.. function:: void fmpq_poly_power_sums_to_fmpz_poly(fmpz_poly_t res, const fmpq_poly_t Q)

    Compute the integer polynomial with content one and positive leading
    coefficient given by its power sums series ``Q``.

.. function:: void fmpq_poly_power_sums_to_poly(fmpq_poly_t res, const fmpq_poly_t Q)

    Compute the monic polynomial from its power sums series ``Q``.


Transcendental functions
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_log_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    logarithm of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 1.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_log_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the logarithm of ``f``
    to order ``n > 0``. Requires ``f`` to have constant term 1.

.. function:: void _fmpq_poly_exp_series(fmpz * g, fmpz_t gden, const fmpz * h, const fmpz_t hden, slong hlen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    exponential function of ``(h, hden, hlen)``.  Assumes
    ``n > 0, hlen > 0`` and
    that ``(h, hden, hlen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_exp_series(fmpq_poly_t res, const fmpq_poly_t h, slong n)

    Sets ``res`` to the series expansion of the exponential function
    of ``h`` to order ``n > 0``. Requires ``f`` to have
    constant term 0.

.. function:: void _fmpq_poly_exp_expinv_series(fmpz * res1, fmpz_t res1den, fmpz * res2, fmpz_t res2den, const fmpz * h, const fmpz_t hden, slong hlen, slong n)

    The same as ``fmpq_poly_exp_series``, but simultaneously computes
    the exponential (in ``res1``, ``res1den``) and its multiplicative inverse
    (in ``res2``, ``res2den``).
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_exp_expinv_series(fmpq_poly_t res1, fmpq_poly_t res2, const fmpq_poly_t h, slong n)

    The same as ``fmpq_poly_exp_series``, but simultaneously computes
    the exponential (in ``res1``) and its multiplicative inverse
    (in ``res2``).

.. function:: void _fmpq_poly_atan_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    inverse tangent of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_atan_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the inverse tangent of ``f``
    to order ``n > 0``. Requires ``f`` to have constant term 0.

.. function:: void _fmpq_poly_atanh_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the inverse
    hyperbolic tangent of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_atanh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the inverse hyperbolic
    tangent of ``f`` to order ``n > 0``. Requires ``f`` to have
    constant term 0.

.. function:: void _fmpq_poly_asin_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    inverse sine of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_asin_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the inverse sine of ``f``
    to order ``n > 0``. Requires ``f`` to have constant term 0.

.. function:: void _fmpq_poly_asinh_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the inverse
    hyperbolic sine of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_asinh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the inverse hyperbolic
    sine of ``f`` to order ``n > 0``. Requires ``f`` to have
    constant term 0.

.. function:: void _fmpq_poly_tan_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    tangent function of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Does not support aliasing between the input and output polynomials.

.. function:: void fmpq_poly_tan_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the tangent function
    of ``f`` to order ``n > 0``. Requires ``f`` to have
    constant term 0.

.. function:: void _fmpq_poly_sin_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    sine of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_sin_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the sine of ``f``
    to order ``n > 0``. Requires ``f`` to have constant term 0.

.. function:: void _fmpq_poly_cos_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    cosine of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_cos_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the cosine of ``f``
    to order ``n > 0``. Requires ``f`` to have constant term 0.

.. function:: void _fmpq_poly_sin_cos_series(fmpz * s, fmpz_t sden, fmpz * c, fmpz_t cden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(s, sden, n)`` to the series expansion of the
    sine of ``(f, fden, flen)``, and ``(c, cden, n)`` to the series
    expansion of the cosine.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_sin_cos_series(fmpq_poly_t res1, fmpq_poly_t res2, const fmpq_poly_t f, slong n)

    Sets ``res1`` to the series expansion of the sine of ``f``
    to order ``n > 0``, and ``res2`` to the series expansion
    of the cosine. Requires ``f`` to have constant term 0.

.. function:: void _fmpq_poly_sinh_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    hyperbolic sine of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Does not support aliasing between the input and output polynomials.

.. function:: void fmpq_poly_sinh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the hyperbolic sine of ``f``
    to order ``n > 0``. Requires ``f`` to have constant term 0.

.. function:: void _fmpq_poly_cosh_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the hyperbolic
    cosine of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Does not support aliasing between the input and output polynomials.

.. function:: void fmpq_poly_cosh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the hyperbolic cosine of
    ``f`` to order ``n > 0``. Requires ``f`` to have constant term 0.

.. function:: void _fmpq_poly_sinh_cosh_series(fmpz * s, fmpz_t sden, fmpz * c, fmpz_t cden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(s, sden, n)`` to the series expansion of the hyperbolic
    sine of ``(f, fden, flen)``, and ``(c, cden, n)`` to the series
    expansion of the hyperbolic cosine.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Supports aliasing between the input and output polynomials.

.. function:: void fmpq_poly_sinh_cosh_series(fmpq_poly_t res1, fmpq_poly_t res2, const fmpq_poly_t f, slong n)

    Sets ``res1`` to the series expansion of the hyperbolic sine of ``f``
    to order ``n > 0``, and ``res2`` to the series expansion
    of the hyperbolic cosine. Requires ``f`` to have constant term 0.

.. function:: void _fmpq_poly_tanh_series(fmpz * g, fmpz_t gden, const fmpz * f, const fmpz_t fden, slong flen, slong n)

    Sets ``(g, gden, n)`` to the series expansion of the
    hyperbolic tangent of ``(f, fden, flen)``.  Assumes ``n > 0`` and
    that ``(f, fden, flen)`` has constant term 0.
    Does not support aliasing between the input and output polynomials.

.. function:: void fmpq_poly_tanh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n)

    Sets ``res`` to the series expansion of the hyperbolic tangent of
    ``f`` to order ``n > 0``. Requires ``f`` to have constant term 0.


Orthogonal polynomials
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_legendre_p(fmpz * coeffs, fmpz_t den, ulong n)

    Sets ``coeffs`` to the coefficient array of the Legendre polynomial
    `P_n(x)`, defined by `(n+1) P_{n+1}(x) = (2n+1) x P_n(x) - n P_{n-1}(x)`,
    for `n\ge0`. Sets ``den`` to the overall denominator.
    The coefficients are calculated using a hypergeometric recurrence.
    The length of the array will be ``n+1``.
    To improve performance, the common denominator is computed in one step
    and the coefficients are evaluated using integer arithmetic. The
    denominator is given by
    `\gcd(n!,2^n) = 2^{\lfloor n/2 \rfloor + \lfloor n/4 \rfloor + \ldots}.`
    See ``fmpz_poly`` for the shifted Legendre polynomials.

.. function:: void fmpq_poly_legendre_p(fmpq_poly_t poly, ulong n)

    Sets ``poly`` to the Legendre polynomial `P_n(x)`, defined
    by `(n+1) P_{n+1}(x) = (2n+1) x P_n(x) - n P_{n-1}(x)`, for `n\ge0`.
    The coefficients are calculated using a hypergeometric recurrence.
    To improve performance, the common denominator is computed in one step
    and the coefficients are evaluated using integer arithmetic. The
    denominator is given by
    `\gcd(n!,2^n) = 2^{\lfloor n/2 \rfloor + \lfloor n/4 \rfloor + \ldots}.`
    See ``fmpz_poly`` for the shifted Legendre polynomials.

.. function:: void _fmpq_poly_laguerre_l(fmpz * coeffs, fmpz_t den, ulong n)

    Sets ``coeffs`` to the coefficient array of the Laguerre polynomial
    `L_n(x)`, defined by `(n+1) L_{n+1}(x) = (2n+1-x) L_n(x) - n L_{n-1}(x)`,
    for `n\ge0`. Sets ``den`` to the overall denominator.
    The coefficients are calculated using a hypergeometric recurrence.
    The length of the array will be ``n+1``.

.. function:: void fmpq_poly_laguerre_l(fmpq_poly_t poly, ulong n)

    Sets ``poly`` to the Laguerre polynomial `L_n(x)`, defined by
    `(n+1) L_{n+1}(x) = (2n+1-x) L_n(x) - n L_{n-1}(x)`, for `n\ge0`.
    The coefficients are calculated using a hypergeometric recurrence.

.. function:: void _fmpq_poly_gegenbauer_c(fmpz * coeffs, fmpz_t den, ulong n, const fmpq_t a)

    Sets ``coeffs`` to the coefficient array of the Gegenbauer
    (ultraspherical) polynomial
    `C^{(\alpha)}_n(x) = \frac{(2\alpha)_n}{n!}{}_2F_1\left(-n,2\alpha+n;
    \alpha+\frac12;\frac{1-x}{2}\right)`, for integer `n\ge0` and rational
    `\alpha>0`. Sets ``den`` to the overall denominator.
    The coefficients are calculated using a hypergeometric recurrence.

.. function:: void fmpq_poly_gegenbauer_c(fmpq_poly_t poly, ulong n, const fmpq_t a)

    Sets ``poly`` to the Gegenbauer (ultraspherical) polynomial
    `C^{(\alpha)}_n(x) = \frac{(2\alpha)_n}{n!}{}_2F_1\left(-n,2\alpha+n;
    \alpha+\frac12;\frac{1-x}{2}\right)`, for integer `n\ge0` and rational
    `\alpha>0`.
    The coefficients are calculated using a hypergeometric recurrence.


Evaluation
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_evaluate_fmpz(fmpz_t rnum, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, const fmpz_t a)

    Evaluates the polynomial ``(poly, den, len)`` at the integer `a` and
    sets ``(rnum, rden)`` to the result in lowest terms.

.. function:: void fmpq_poly_evaluate_fmpz(fmpq_t res, const fmpq_poly_t poly, const fmpz_t a)

    Evaluates the polynomial ``poly`` at the integer `a` and sets
    ``res`` to the result.

.. function:: void _fmpq_poly_evaluate_fmpq(fmpz_t rnum, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len, const fmpz_t anum, const fmpz_t aden)

    Evaluates the polynomial ``(poly, den, len)`` at the rational
    ``(anum, aden)`` and sets ``(rnum, rden)`` to the result in
    lowest terms.  Aliasing between ``(rnum, rden)`` and
    ``(anum, aden)`` is not supported.

.. function:: void fmpq_poly_evaluate_fmpq(fmpq_t res, const fmpq_poly_t poly, const fmpq_t a)

    Evaluates the polynomial ``poly`` at the rational `a` and
    sets ``res`` to the result.


Interpolation
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_interpolate_fmpz_vec(fmpz * poly, fmpz_t den, const fmpz * xs, const fmpz * ys, slong n)

    Sets ``poly`` / ``den`` to the unique interpolating polynomial of
    degree at most `n - 1` satisfying `f(x_i) = y_i` for every pair `x_i, y_i`
    in ``xs`` and ``ys``.

    The vector ``poly`` must have room for ``n+1`` coefficients,
    even if the interpolating polynomial is shorter.
    Aliasing of ``poly`` or ``den`` with any other argument is not
    allowed.

    It is assumed that the `x` values are distinct.

    This function uses a simple `O(n^2)` implementation of Lagrange
    interpolation, clearing denominators to avoid working with fractions.
    It is currently not designed to be efficient for large `n`.

.. function:: void fmpq_poly_interpolate_fmpz_vec(fmpq_poly_t poly, const fmpz * xs, const fmpz * ys, slong n)

    Sets ``poly`` to the unique interpolating polynomial of degree
    at most `n - 1` satisfying `f(x_i) = y_i` for every pair `x_i, y_i`
    in ``xs`` and ``ys``. It is assumed that the `x` values are distinct.


Composition
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_compose(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2)

    Sets ``(res, den)`` to the composition of ``(poly1, den1, len1)``
    and ``(poly2, den2, len2)``, assuming ``len1, len2 > 0``.

    Assumes that ``res`` has space for ``(len1 - 1) * (len2 - 1) + 1``
    coefficients.  Does not support aliasing.

.. function:: void fmpq_poly_compose(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2)

    Sets ``res`` to the composition of ``poly1`` and ``poly2``.

.. function:: void _fmpq_poly_rescale(fmpz * res, fmpz_t denr, const fmpz * poly, const fmpz_t den, slong len, const fmpz_t anum, const fmpz_t aden)

    Sets ``(res, denr, len)`` to ``(poly, den, len)`` with the
    indeterminate rescaled by ``(anum, aden)``.

    Assumes that ``len > 0`` and that ``(anum, aden)`` is non-zero and
    in lowest terms.  Supports aliasing between ``(res, denr, len)`` and
    ``(poly, den, len)``.

.. function:: void fmpq_poly_rescale(fmpq_poly_t res, const fmpq_poly_t poly, const fmpq_t a)

    Sets ``res`` to ``poly`` with the indeterminate rescaled by `a`.


Power series composition
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_compose_series_horner(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n)

    Sets ``(res, den, n)`` to the composition of
    ``(poly1, den1, len1)`` and ``(poly2, den2, len2)`` modulo `x^n`,
    where the constant term of ``poly2`` is required to be zero.

    Assumes that ``len1, len2, n > 0``, that ``len1, len2 <= n``,
    that ``(len1-1) * (len2-1) + 1 <= n``, and that ``res`` has
    space for ``n`` coefficients. Does not support aliasing between any
    of the inputs and the output.

    This implementation uses the Horner scheme.
    The default ``fmpz_poly`` composition algorithm is automatically
    used when the composition can be performed over the integers.

.. function:: void fmpq_poly_compose_series_horner(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n)

    Sets ``res`` to the composition of ``poly1`` and ``poly2``
    modulo `x^n`, where the constant term of ``poly2`` is required
    to be zero.

    This implementation uses the Horner scheme.
    The default ``fmpz_poly`` composition algorithm is automatically
    used when the composition can be performed over the integers.

.. function:: void _fmpq_poly_compose_series_brent_kung(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n)

    Sets ``(res, den, n)`` to the composition of
    ``(poly1, den1, len1)`` and ``(poly2, den2, len2)`` modulo `x^n`,
    where the constant term of ``poly2`` is required to be zero.

    Assumes that ``len1, len2, n > 0``, that ``len1, len2 <= n``,
    that ``(len1-1) * (len2-1) + 1 <= n``, and that ``res`` has
    space for ``n`` coefficients. Does not support aliasing between any
    of the inputs and the output.

    This implementation uses Brent-Kung algorithm 2.1 [BrentKung1978]_.
    The default ``fmpz_poly`` composition algorithm is automatically
    used when the composition can be performed over the integers.

.. function:: void fmpq_poly_compose_series_brent_kung(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n)

    Sets ``res`` to the composition of ``poly1`` and ``poly2``
    modulo `x^n`, where the constant term of ``poly2`` is required
    to be zero.

    This implementation uses Brent-Kung algorithm 2.1 [BrentKung1978]_.
    The default ``fmpz_poly`` composition algorithm is automatically
    used when the composition can be performed over the integers.

.. function:: void _fmpq_poly_compose_series(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1, slong len1, const fmpz * poly2, const fmpz_t den2, slong len2, slong n)

    Sets ``(res, den, n)`` to the composition of
    ``(poly1, den1, len1)`` and ``(poly2, den2, len2)`` modulo `x^n`,
    where the constant term of ``poly2`` is required to be zero.

    Assumes that ``len1, len2, n > 0``, that ``len1, len2 <= n``,
    that ``(len1-1) * (len2-1) + 1 <= n``, and that ``res`` has
    space for ``n`` coefficients. Does not support aliasing between any
    of the inputs and the output.

    This implementation automatically switches between the Horner scheme
    and Brent-Kung algorithm 2.1 depending on the size of the inputs.
    The default ``fmpz_poly`` composition algorithm is automatically
    used when the composition can be performed over the integers.

.. function:: void fmpq_poly_compose_series(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n)

    Sets ``res`` to the composition of ``poly1`` and ``poly2``
    modulo `x^n`, where the constant term of ``poly2`` is required
    to be zero.

    This implementation automatically switches between the Horner scheme
    and Brent-Kung algorithm 2.1 depending on the size of the inputs.
    The default ``fmpz_poly`` composition algorithm is automatically
    used when the composition can be performed over the integers.


Power series reversion
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_revert_series_lagrange(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1, slong len1, slong n)

    Sets ``(res, den)`` to the power series reversion of
    ``(poly1, den1, len1)`` modulo `x^n`.

    The constant term of ``poly2`` is required to be zero and
    the linear term is required to be nonzero. Assumes that `n > 0`.
    Does not support aliasing between any of the inputs and the output.

    This implementation uses the Lagrange inversion formula.
    The default ``fmpz_poly`` reversion algorithm is automatically
    used when the reversion can be performed over the integers.

.. function:: void fmpq_poly_revert_series_lagrange(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Sets ``res`` to the power series reversion of ``poly1`` modulo `x^n`.
    The constant term of ``poly2`` is required to be zero and
    the linear term is required to be nonzero.

    This implementation uses the Lagrange inversion formula.
    The default ``fmpz_poly`` reversion algorithm is automatically
    used when the reversion can be performed over the integers.

.. function:: void _fmpq_poly_revert_series_lagrange_fast(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1, slong len1, slong n)

    Sets ``(res, den)`` to the power series reversion of
    ``(poly1, den1, len1)`` modulo `x^n`.

    The constant term of ``poly2`` is required to be zero and
    the linear term is required to be nonzero. Assumes that `n > 0`.
    Does not support aliasing between any of the inputs and the output.

    This implementation uses a reduced-complexity implementation
    of the Lagrange inversion formula.
    The default ``fmpz_poly`` reversion algorithm is automatically
    used when the reversion can be performed over the integers.

.. function:: void fmpq_poly_revert_series_lagrange_fast(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Sets ``res`` to the power series reversion of ``poly1`` modulo `x^n`.
    The constant term of ``poly2`` is required to be zero and
    the linear term is required to be nonzero.

    This implementation uses a reduced-complexity implementation
    of the Lagrange inversion formula.
    The default ``fmpz_poly`` reversion algorithm is automatically
    used when the reversion can be performed over the integers.

.. function:: void _fmpq_poly_revert_series_newton(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1, slong len1, slong n)

    Sets ``(res, den)`` to the power series reversion of
    ``(poly1, den1, len1)`` modulo `x^n`.

    The constant term of ``poly2`` is required to be zero and
    the linear term is required to be nonzero. Assumes that `n > 0`.
    Does not support aliasing between any of the inputs and the output.

    This implementation uses Newton iteration.
    The default ``fmpz_poly`` reversion algorithm is automatically
    used when the reversion can be performed over the integers.

.. function:: void fmpq_poly_revert_series_newton(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Sets ``res`` to the power series reversion of ``poly1`` modulo `x^n`.
    The constant term of ``poly2`` is required to be zero and
    the linear term is required to be nonzero.

    This implementation uses Newton iteration.
    The default ``fmpz_poly`` reversion algorithm is automatically
    used when the reversion can be performed over the integers.

.. function:: void _fmpq_poly_revert_series(fmpz * res, fmpz_t den, const fmpz * poly1, const fmpz_t den1, slong len1, slong n)

    Sets ``(res, den)`` to the power series reversion of
    ``(poly1, den1, len1)`` modulo `x^n`.

    The constant term of ``poly2`` is required to be zero and
    the linear term is required to be nonzero. Assumes that `n > 0`.
    Does not support aliasing between any of the inputs and the output.

    This implementation defaults to using Newton iteration.
    The default ``fmpz_poly`` reversion algorithm is automatically
    used when the reversion can be performed over the integers.

.. function:: void fmpq_poly_revert_series(fmpq_poly_t res, const fmpq_poly_t poly, slong n)

    Sets ``res`` to the power series reversion of ``poly1`` modulo `x^n`.
    The constant term of ``poly2`` is required to be zero and
    the linear term is required to be nonzero.

    This implementation defaults to using Newton iteration.
    The default ``fmpz_poly`` reversion algorithm is automatically
    used when the reversion can be performed over the integers.


Gaussian content
--------------------------------------------------------------------------------


.. function:: void _fmpq_poly_content(fmpq_t res, const fmpz * poly, const fmpz_t den, slong len)

    Sets ``res`` to the content of ``(poly, den, len)``.
    If ``len == 0``, sets ``res`` to zero.

.. function:: void fmpq_poly_content(fmpq_t res, const fmpq_poly_t poly)

    Sets ``res`` to the content of ``poly``.  The content of the zero
    polynomial is defined to be zero.

.. function:: void _fmpq_poly_primitive_part(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len)

    Sets ``(rpoly, rden, len)`` to the primitive part, with non-negative
    leading coefficient, of ``(poly, den, len)``.  Assumes that
    ``len > 0``.  Supports aliasing between the two polynomials.

.. function:: void fmpq_poly_primitive_part(fmpq_poly_t res, const fmpq_poly_t poly)

    Sets ``res`` to the primitive part, with non-negative leading
    coefficient, of ``poly``.

.. function:: int _fmpq_poly_is_monic(const fmpz * poly, const fmpz_t den, slong len)

    Returns whether the polynomial ``(poly, den, len)`` is monic.
    The zero polynomial is not monic by definition.

.. function:: int fmpq_poly_is_monic(const fmpq_poly_t poly)

    Returns whether the polynomial ``poly`` is monic. The zero
    polynomial is not monic by definition.

.. function:: void _fmpq_poly_make_monic(fmpz * rpoly, fmpz_t rden, const fmpz * poly, const fmpz_t den, slong len)

    Sets ``(rpoly, rden, len)`` to the monic scalar multiple of
    ``(poly, den, len)``.  Assumes that ``len > 0``.  Supports
    aliasing between the two polynomials.

.. function:: void fmpq_poly_make_monic(fmpq_poly_t res, const fmpq_poly_t poly)

    Sets ``res`` to the monic scalar multiple of ``poly`` whenever
    ``poly`` is non-zero.  If ``poly`` is the zero polynomial, sets
    ``res`` to zero.


Square-free
--------------------------------------------------------------------------------


.. function:: int fmpq_poly_is_squarefree(const fmpq_poly_t poly)

    Returns whether the polynomial ``poly`` is square-free.  A non-zero
    polynomial is defined to be square-free if it has no non-unit square
    factors.  We also define the zero polynomial to be square-free.


Input and output
--------------------------------------------------------------------------------


.. function:: int _fmpq_poly_print(const fmpz * poly, const fmpz_t den, slong len)

    Prints the polynomial ``(poly, den, len)`` to ``stdout``.

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

.. function:: int fmpq_poly_print(const fmpq_poly_t poly)

    Prints the polynomial to ``stdout``.

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

.. function:: int _fmpq_poly_print_pretty(const fmpz * poly, const fmpz_t den, slong len, const char * x)

.. function:: int fmpq_poly_print_pretty(const fmpq_poly_t poly, const char * var)

    Prints the pretty representation of ``poly`` to ``stdout``, using
    the null-terminated string ``var`` not equal to ``"\0"`` as the
    variable name.

    In the current implementation always returns `1`.

.. function:: int _fmpq_poly_fprint(FILE * file, const fmpz * poly, const fmpz_t den, slong len)

    Prints the polynomial ``(poly, den, len)`` to the stream ``file``.

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

.. function:: int fmpq_poly_fprint(FILE * file, const fmpq_poly_t poly)

    Prints the polynomial to the stream ``file``.

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

.. function:: int _fmpq_poly_fprint_pretty(FILE * file, const fmpz * poly, const fmpz_t den, slong len, const char * x)

.. function:: int fmpq_poly_fprint_pretty(FILE * file, const fmpq_poly_t poly, const char * var)

    Prints the pretty representation of ``poly`` to ``stdout``, using
    the null-terminated string ``var`` not equal to ``"\0"`` as the
    variable name.

    In the current implementation, always returns `1`.

.. function:: int fmpq_poly_read(fmpq_poly_t poly)

    Reads a polynomial from ``stdin``, storing the result
    in ``poly``.

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

.. function:: int fmpq_poly_fread(FILE * file, fmpq_poly_t poly)

    Reads a polynomial from the stream ``file``, storing the result
    in ``poly``.

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