.. _padic-poly:

**padic_poly.h** -- polynomials over p-adic numbers
===============================================================================

Module documentation
--------------------------------------------------------------------------------

We represent a polynomial in `\mathbf{Q}_p[x]` as a 
product `p^v f(x)`, where `p` is a prime number, 
`v \in \mathbf{Z}` and `f(x) \in \mathbf{Z}[x]`.
As a data structure, we call this polynomial *normalised* 
if the polynomial `f(x)` is *normalised*, that is, if the top 
coefficient is non-zero.
We say this polynomial is in *canonical form* if one of the 
coefficients of `f(x)` is a `p`-adic unit.  If `f(x)` is the zero 
polynomial, we require that `v = 0`.
We say this polynomial is *reduced* modulo `p^N` if it is 
canonical form and if all coefficients lie in the range `[0, p^N)`.


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


.. function:: void padic_poly_init(padic_poly_t poly)

    Initialises ``poly`` for use, setting its length to zero.  
    The precision of the polynomial is set to ``PADIC_DEFAULT_PREC``. 
    A corresponding call to :func:`padic_poly_clear` must be made 
    after finishing with the :type:`padic_poly_t` to free the memory 
    used by the polynomial.

.. function:: void padic_poly_init2(padic_poly_t poly, slong alloc, slong prec)

    Initialises ``poly`` with space for at least ``alloc`` coefficients 
    and sets the length to zero.  The allocated coefficients are all set to 
    zero.  The precision is set to ``prec``.

.. function:: void padic_poly_realloc(padic_poly_t poly, slong alloc, const fmpz_t p)

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

.. function:: void padic_poly_fit_length(padic_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 ``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.

.. function:: void _padic_poly_set_length(padic_poly_t poly, slong len)

    Demotes the coefficients of ``poly`` beyond ``len`` and sets 
    the length of ``poly`` to ``len``.

    Note that if the current length is greater than ``len`` the 
    polynomial may no slonger be in canonical form.

.. function:: void padic_poly_clear(padic_poly_t poly)

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

.. function:: void _padic_poly_normalise(padic_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.  This function 
    is mainly used internally, as all functions guarantee normalisation.

.. function:: void _padic_poly_canonicalise(fmpz *poly, slong *v, slong len, const fmpz_t p)
              void padic_poly_canonicalise(padic_poly_t poly, const fmpz_t p)

    Brings the polynomial ``poly`` into canonical form, 
    assuming that it is normalised already.  Does *not* 
    carry out any reduction.

.. function:: void padic_poly_reduce(padic_poly_t poly, const padic_ctx_t ctx)

    Reduces the polynomial ``poly`` modulo `p^N`, assuming 
    that it is in canonical form already.

.. function:: void padic_poly_truncate(padic_poly_t poly, slong n, const fmpz_t p)

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


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


.. function:: slong padic_poly_degree(padic_poly_t poly)

    Returns the degree of the polynomial ``poly``.

.. function:: slong padic_poly_length(padic_poly_t poly)

    Returns the length of the polynomial ``poly``.

.. function:: slong padic_poly_val(padic_poly_t poly)

    Returns the valuation of the polynomial ``poly``, 
    which is defined to be the minimum valuation of all 
    its coefficients.

    The valuation of the zero polynomial is~`0`.

    Note that this is implemented as a macro and can be 
    used as either a ``lvalue`` or a ``rvalue``.

.. function:: slong padic_poly_prec(padic_poly_t poly)

    Returns the precision of the polynomial ``poly``. 

    Note that this is implemented as a macro and can be 
    used as either a ``lvalue`` or a ``rvalue``.

    Note that increasing the precision might require 
    a call to :func:`padic_poly_reduce`.


Randomisation
--------------------------------------------------------------------------------


.. function:: void padic_poly_randtest(padic_poly_t f, flint_rand_t state, slong len, const padic_ctx_t ctx)

    Sets `f` to a random polynomial of length at most ``len`` 
    with entries reduced modulo `p^N`.

.. function:: void padic_poly_randtest_not_zero(padic_poly_t f, flint_rand_t state, slong len, const padic_ctx_t ctx)

    Sets `f` to a non-zero random polynomial of length at most ``len`` 
    with entries reduced modulo `p^N`.

.. function:: void padic_poly_randtest_val(padic_poly_t f, flint_rand_t state, slong val, slong len, const padic_ctx_t ctx)

    Sets `f` to a random polynomial of length at most ``len`` 
    with at most the prescribed valuation ``val`` and entries 
    reduced modulo `p^N`.

    Specifically, we aim to set the valuation to be exactly equal 
    to ``val``, but do not check for additional cancellation 
    when creating the coefficients.


Assignment and basic manipulation
--------------------------------------------------------------------------------


.. function:: void padic_poly_set_padic(padic_poly_t poly, const padic_t x, const padic_ctx_t ctx)

    Sets the polynomial ``poly`` to the `p`-adic number `x`, 
    reduced to the precision of the polynomial.

.. function:: void padic_poly_set(padic_poly_t poly1, const padic_poly_t poly2, const padic_ctx_t ctx)

    Sets the polynomial ``poly1`` to the polynomial ``poly2``, 
    reduced to the precision of ``poly1``.

.. function:: void padic_poly_set_si(padic_poly_t poly, slong x, const padic_ctx_t ctx)

    Sets the polynomial ``poly`` to the ``signed slong`` 
    integer `x` reduced to the precision of the polynomial.

.. function:: void padic_poly_set_ui(padic_poly_t poly, ulong x, const padic_ctx_t ctx)

    Sets the polynomial ``poly`` to the ``unsigned slong`` 
    integer `x` reduced to the precision of the polynomial.

.. function:: void padic_poly_set_fmpz(padic_poly_t poly, const fmpz_t x, const padic_ctx_t ctx)

    Sets the polynomial ``poly`` to the integer `x` 
    reduced to the precision of the polynomial.

.. function:: void padic_poly_set_fmpq(padic_poly_t poly, const fmpq_t x, const padic_ctx_t ctx)

    Sets the polynomial ``poly`` to the value of the rational `x`, 
    reduced to the precision of the polynomial.

.. function:: void padic_poly_set_fmpz_poly(padic_poly_t rop, const fmpz_poly_t op, const padic_ctx_t ctx)

    Sets the polynomial ``rop`` to the integer polynomial ``op``
    reduced to the precision of the polynomial.

.. function:: void padic_poly_set_fmpq_poly(padic_poly_t rop, const fmpq_poly_t op, const padic_ctx_t ctx)

    Sets the polynomial ``rop`` to the value of the rational 
    polynomial ``op``, reduced to the precision of the polynomial.

.. function:: int padic_poly_get_fmpz_poly(fmpz_poly_t rop, const padic_poly_t op, const padic_ctx_t ctx)

    Sets the integer polynomial ``rop`` to the value of the `p`-adic 
    polynomial ``op`` and returns `1` if the polynomial is `p`-adically 
    integral.  Otherwise, returns `0`.

.. function:: void padic_poly_get_fmpq_poly(fmpq_poly_t rop, const padic_poly_t op, const padic_ctx_t ctx)

    Sets ``rop`` to the rational polynomial corresponding to 
    the `p`-adic polynomial ``op``.

.. function:: void padic_poly_zero(padic_poly_t poly)

    Sets ``poly`` to the zero polynomial.

.. function:: void padic_poly_one(padic_poly_t poly)

    Sets ``poly`` to the constant polynomial `1`, 
    reduced to the precision of the polynomial.

.. function:: void padic_poly_swap(padic_poly_t poly1, padic_poly_t poly2)

    Swaps the two polynomials ``poly1`` and ``poly2``, 
    including their precisions.

    This is done efficiently by swapping pointers.


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


.. function:: void padic_poly_get_coeff_padic(padic_t c, const padic_poly_t poly, slong n, const padic_ctx_t ctx)

    Sets `c` to the coefficient of `x^n` in the polynomial, 
    reduced modulo the precision of `c`.

.. function:: void padic_poly_set_coeff_padic(padic_poly_t f, slong n, const padic_t c, const padic_ctx_t ctx)

    Sets the coefficient of `x^n` in the polynomial `f` to `c`, 
    reduced to the precision of the polynomial `f`.

    Note that this operation can take linear time in the length 
    of the polynomial.


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


.. function:: int padic_poly_equal(const padic_poly_t poly1, const padic_poly_t poly2)

    Returns whether the two polynomials ``poly1`` and ``poly2`` 
    are equal.

.. function:: int padic_poly_is_zero(const padic_poly_t poly)

    Returns whether the polynomial ``poly`` is the zero polynomial.

.. function:: int padic_poly_is_one(const padic_poly_t poly, const padic_ctx_t ctx)

    Returns whether the polynomial ``poly`` is equal 
    to the constant polynomial~`1`, taking the precision 
    of the polynomial into account.


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


.. function:: void _padic_poly_add(fmpz *rop, slong *rval, slong N, const fmpz *op1, slong val1, slong len1, slong N1, const fmpz *op2, slong val2, slong len2, slong N2, const padic_ctx_t ctx)

    Sets ``(rop, *val, FLINT_MAX(len1, len2)`` to the sum of 
    ``(op1, val1, len1)`` and ``(op2, val2, len2)``.

    Assumes that the input is reduced and guarantees that this is 
    also the case for the output.

    Assumes that `\min\{v_1, v_2\} < N`.

    Supports aliasing between the output and input arguments.

.. function:: void padic_poly_add(padic_poly_t f, const padic_poly_t g, const padic_poly_t h, const padic_ctx_t ctx)

    Sets `f` to the sum `g + h`.

.. function:: void _padic_poly_sub(fmpz *rop, slong *rval, const fmpz *op1, slong val1, slong len1, const fmpz *op2, slong val2, slong len2, const padic_ctx_t ctx)

    Sets ``(rop, *val, FLINT_MAX(len1, len2)`` to the difference of 
    ``(op1, val1, len1)`` and ``(op2, val2, len2)``.

    Assumes that the input is reduced and guarantees that this is 
    also the case for the output.

    Assumes that `\min\{v_1, v_2\} < N`.

    Support aliasing between the output and input arguments.

.. function:: void padic_poly_sub(padic_poly_t f, const padic_poly_t g, const padic_poly_t h, const padic_ctx_t ctx)

    Sets `f` to the difference `g - h`.

.. function:: void padic_poly_neg(padic_poly_t f, const padic_poly_t g, const padic_ctx_t ctx)

    Sets `f` to `-g`.


Scalar multiplication
--------------------------------------------------------------------------------


.. function:: void _padic_poly_scalar_mul_padic(fmpz *rop, slong *rval, const fmpz *op, slong val, slong len, const padic_t c, const padic_ctx_t ctx)

    Sets ``(rop, *rval, len)`` to ``(op, val, len)`` multiplied 
    by the scalar `c`.

    The result will only be correctly reduced if the polynomial 
    is non-zero.  Otherwise, the array ``(rop, len)`` will be 
    set to zero but the valuation ``*rval`` might be wrong.

.. function:: void padic_poly_scalar_mul_padic(padic_poly_t rop, const padic_poly_t op, const padic_t c, const padic_ctx_t ctx)

    Sets the polynomial ``rop`` to the product of the 
    polynomial ``op`` and the `p`-adic number `c`, 
    reducing the result modulo `p^N`.


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


.. function:: void _padic_poly_mul(fmpz *rop, slong *rval, slong N, const fmpz *op1, slong val1, slong len1, const fmpz *op2, slong val2, slong len2, const padic_ctx_t ctx)

    Sets ``(rop, *rval, len1 + len2 - 1)`` to the product of 
    ``(op1, val1, len1)`` and ``(op2, val2, len2)``.

    Assumes that the resulting valuation ``*rval``, which is 
    the sum of the valuations ``val1`` and ``val2``, is less 
    than the precision~`N` of the context.

    Assumes that ``len1 >= len2 > 0``.

.. function:: void padic_poly_mul(padic_poly_t res, const padic_poly_t poly1, const padic_poly_t poly2, const padic_ctx_t ctx)

    Sets the polynomial ``res`` to the product of the two polynomials 
    ``poly1`` and ``poly2``, reduced modulo `p^N`.


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


.. function:: void _padic_poly_pow(fmpz *rop, slong *rval, slong N, const fmpz *op, slong val, slong len, ulong e, const padic_ctx_t ctx)

    Sets the polynomial ``(rop, *rval, e (len - 1) + 1)`` to the 
    polynomial ``(op, val, len)`` raised to the power~`e`.

    Assumes that `e > 1` and ``len > 0``.

    Does not support aliasing between the input and output arguments.

.. function:: void padic_poly_pow(padic_poly_t rop, const padic_poly_t op, ulong e, const padic_ctx_t ctx)

    Sets the polynomial ``rop`` to the polynomial ``op`` raised 
    to the power~`e`, reduced to the precision in ``rop``.

    In the special case `e = 0`, sets ``rop`` to the constant 
    polynomial one reduced to the precision of ``rop``.  
    Also note that when `e = 1`, this operation sets ``rop`` to 
    ``op`` and then reduces ``rop``.

    When the valuation of the input polynomial is negative, 
    this results in a loss of `p`-adic precision.  Suppose 
    that the input polynomial is given to precision~`N` and 
    has valuation~`v < 0`.  The result then has valuation 
    `e v < 0` but is only correct to precision `N + (e - 1) v`.


Series inversion
--------------------------------------------------------------------------------


.. function:: void padic_poly_inv_series(padic_poly_t g, const padic_poly_t f, slong n, const padic_ctx_t ctx)

    Computes the power series inverse `g` of `f` modulo `X^n`, 
    where `n \geq 1`.

    Given the polynomial `f \in \mathbf{Q}[X] \subset \mathbf{Q}_p[X]`, 
    there exists a unique polynomial `f^{-1} \in \mathbf{Q}[X]` such that 
    `f f^{-1} = 1` modulo `X^n`.  This function sets `g` to `f^{-1}` 
    reduced modulo `p^N`.

    Assumes that the constant coefficient of `f` is non-zero.

    Moreover, assumes that the valuation of the constant coefficient 
    of `f` is minimal among the coefficients of `f`.

    Note that the result `g` is zero if and only if  `- \operatorname{ord}_p(f) \geq N`.


Derivative
--------------------------------------------------------------------------------


.. function:: void _padic_poly_derivative(fmpz *rop, slong *rval, slong N, const fmpz *op, slong val, slong len, const padic_ctx_t ctx)

    Sets ``(rop, rval)`` to the derivative of ``(op, val)`` reduced 
    modulo `p^N`.

    Supports aliasing of the input and the output parameters.

.. function:: void padic_poly_derivative(padic_poly_t rop, const padic_poly_t op, const padic_ctx_t ctx)

    Sets ``rop`` to the derivative of ``op``, reducing the 
    result modulo the precision of ``rop``.


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


.. function:: void padic_poly_shift_left(padic_poly_t rop, const padic_poly_t op, slong n, const padic_ctx_t ctx)

    Notationally, sets the polynomial ``rop`` to the polynomial ``op`` 
    multiplied by `x^n`, where `n \geq 0`, and reduces the result.

.. function:: void padic_poly_shift_right(padic_poly_t rop, const padic_poly_t op, slong n)

    Notationally, sets the polynomial ``rop`` to the polynomial 
    ``op`` after floor division by `x^n`, where `n \geq 0`, ensuring 
    the result is reduced.


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


.. function:: void _padic_poly_evaluate_padic(fmpz_t u, slong *v, slong N, const fmpz *poly, slong val, slong len, const fmpz_t a, slong b, const padic_ctx_t ctx)
              void padic_poly_evaluate_padic(padic_t y, const padic_poly_t poly, const padic_t a, const padic_ctx_t ctx)

    Sets the `p`-adic number ``y`` to ``poly`` evaluated at `a`, 
    reduced in the given context.

    Suppose that the polynomial can be written as `F(X) = p^w f(X)` 
    with `\operatorname{ord}_p(f) = 1`, that `\operatorname{ord}_p(a) = b` and that both are 
    defined to precision~`N`.  Then `f` is defined to precision 
    `N-w` and so `f(a)` is defined to precision `N-w` when `a` is 
    integral and `N-w+(n-1)b` when `b < 0`, where `n = \deg(f)`.  Thus, 
    `y = F(a)` is defined to precision `N` when `a` is integral and 
    `N+(n-1)b` when `b < 0`.


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


.. function:: void _padic_poly_compose(fmpz *rop, slong *rval, slong N, const fmpz *op1, slong val1, slong len1, const fmpz *op2, slong val2, slong len2, const padic_ctx_t ctx)

    Sets ``(rop, *rval, (len1-1)*(len2-1)+1)`` to the composition 
    of the two input polynomials, reducing the result modulo `p^N`.

    Assumes that ``len1`` is non-zero.

    Does not support aliasing.

.. function:: void padic_poly_compose(padic_poly_t rop, const padic_poly_t op1, const padic_poly_t op2, const padic_ctx_t ctx)

    Sets ``rop`` to the composition of ``op1`` and ``op2``, 
    reducing the result in the given context.

    To be clear about the order of composition, let `f(X)` and `g(X)` 
    denote the polynomials ``op1`` and ``op2``, respectively. 
    Then ``rop`` is set to `f(g(X))`.

.. function:: void _padic_poly_compose_pow(fmpz *rop, slong *rval, slong N, const fmpz *op, slong val, slong len, slong k, const padic_ctx_t ctx)

    Sets ``(rop, *rval, (len - 1)*k + 1)`` to the composition of 
    ``(op, val, len)`` and the monomial `x^k`, where `k \geq 1`.

    Assumes that ``len`` is positive.

    Supports aliasing between the input and output polynomials.

.. function:: void padic_poly_compose_pow(padic_poly_t rop, const padic_poly_t op, slong k, const padic_ctx_t ctx)

    Sets ``rop`` to the composition of ``op`` and the monomial `x^k`, 
    where `k \geq 1`.

    Note that no reduction takes place.


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


.. function:: int padic_poly_debug(const padic_poly_t poly)

    Prints the data defining the `p`-adic polynomial ``poly`` 
    in a simple format useful for debugging purposes.

    In the current implementation, always returns `1`.

.. function:: int _padic_poly_fprint(FILE *file, const fmpz *poly, slong val, slong len, const padic_ctx_t ctx)
              int padic_poly_fprint(FILE *file, const padic_poly_t poly, const padic_ctx_t ctx)

    Prints a simple representation of the polynomial ``poly`` 
    to the stream ``file``.

    A non-zero polynomial is represented by the number of coeffients, 
    two spaces, followed by a list of the coefficients, which are printed 
    in a way depending on the print mode,

    In the ``PADIC_TERSE`` mode, the coefficients are printed as 
    rational numbers.

    The ``PADIC_SERIES`` mode is currently not supported and will 
    raise an abort signal.

    In the ``PADIC_VAL_UNIT`` mode, the coefficients are printed 
    in the form `p^v u`.

    The zero polynomial is represented by ``"0"``.

    In the current implementation, always returns `1`.

.. function:: int _padic_poly_print(const fmpz *poly, slong val, slong len, const padic_ctx_t ctx)
              int padic_poly_print(const padic_poly_t poly, const padic_ctx_t ctx)

    Prints a simple representation of the polynomial ``poly`` 
    to ``stdout``.

    In the current implementation, always returns `1`.

.. function:: int _padic_poly_fprint_pretty(FILE *file, const fmpz *poly, slong val, slong len, const char *var, const padic_ctx_t ctx)
              int padic_poly_fprint_pretty(FILE *file, const padic_poly_t poly, const char *var, const padic_ctx_t ctx)
              int _padic_poly_print_pretty(FILE *file, const fmpz *poly, slong val, slong len, const char *var, const padic_ctx_t ctx)
              int padic_poly_print_pretty(const padic_poly_t poly, const char *var, const padic_ctx_t ctx)


Testing
--------------------------------------------------------------------------------


.. function:: int _padic_poly_is_canonical(const fmpz *op, slong val, slong len, const padic_ctx_t ctx)
              int padic_poly_is_canonical(const padic_poly_t op, const padic_ctx_t ctx)
              int _padic_poly_is_reduced(const fmpz *op, slong val, slong len, slong N, const padic_ctx_t ctx)
              int padic_poly_is_reduced(const padic_poly_t op, const padic_ctx_t ctx)

