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

    This file is part of FLINT.

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

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

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

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

    Copyright (C) 2011, 2012 Sebastian Pancratz
 
******************************************************************************/

#ifndef PADIC_POLY_H
#define PADIC_POLY_H

#include <limits.h>

#include <gmp.h>
#include "fmpz.h"
#include "fmpq.h"
#include "padic.h"
#include "fmpz_vec.h"
#include "fmpz_poly.h"
#include "fmpq_poly.h"

#ifdef __cplusplus
 extern "C" {
#endif


/*  Type definitions  ********************************************************/

typedef struct
{
    fmpz *coeffs;
    slong alloc;
    slong length;
    slong val;
    slong N;
} padic_poly_struct;

typedef padic_poly_struct padic_poly_t[1];

/*  Helper functions  ********************************************************/

/*
    Returns the minimum $p$-adic valuation of \code{(vec, len)}, 
    assuming this fits into a \code{signed long}.

    If \code{len} is zero, returns $0$.
 */
static __inline__ slong _fmpz_vec_ord_p(const fmpz *vec, slong len, const fmpz_t p)
{
    if (len == 0)
    {
        return 0;
    }
    else
    {
        fmpz_t t;
        slong i, min = WORD_MAX, v;

        fmpz_init(t);
        for (i = 0; (min > 0) && (i < len); i++)
        {
            if (!fmpz_is_zero(vec + i))
            {
                v   = fmpz_remove(t, vec + i, p);
                min = FLINT_MIN(min, v);
            }
        }
        fmpz_clear(t);
        return (min < WORD_MAX) ? min : 0;
    }
}

/*  Memory management  *******************************************************/

void padic_poly_init(padic_poly_t poly);

void padic_poly_init2(padic_poly_t poly, slong alloc, slong prec);

void padic_poly_clear(padic_poly_t poly);

void padic_poly_realloc(padic_poly_t f, slong alloc, const fmpz_t p);

void padic_poly_fit_length(padic_poly_t f, slong len);

static __inline__
void _padic_poly_set_length(padic_poly_t poly, slong len)
{
    if (poly->length > len)
    {
        slong i;

        for (i = len; i < poly->length; i++)
            _fmpz_demote(poly->coeffs + i); 
    }
    poly->length = len;
}

void _padic_poly_normalise(padic_poly_t f);

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);

void padic_poly_reduce(padic_poly_t f, const padic_ctx_t ctx);

static __inline__ 
void padic_poly_truncate(padic_poly_t poly, slong n, const fmpz_t p)
{
    if (poly->length > n)
    {
        slong i;

        for (i = n; i < poly->length; i++)
            _fmpz_demote(poly->coeffs + i);
        poly->length = n;
        _padic_poly_normalise(poly);
        padic_poly_canonicalise(poly, p);
    }
}

/*  Polynomial parameters  ***************************************************/

static __inline__ slong padic_poly_degree(const padic_poly_t poly)
{
    return poly->length - 1;
}

static __inline__ slong padic_poly_length(const padic_poly_t poly)
{
    return poly->length;
}

static __inline__ slong padic_poly_val(const padic_poly_t poly)
{
    return poly->val;
}

#define padic_poly_val(poly)   ((poly)->val)

#define padic_poly_prec(poly)  ((poly)->N)

/*  Randomisation  ***********************************************************/

void padic_poly_randtest(padic_poly_t f, flint_rand_t state, 
                         slong len, const padic_ctx_t ctx);

void padic_poly_randtest_not_zero(padic_poly_t f, flint_rand_t state,
                                  slong len, const padic_ctx_t ctx);

void padic_poly_randtest_val(padic_poly_t f, flint_rand_t state, 
                             slong val, slong len, const padic_ctx_t ctx);

/*  Assignment and basic manipulation  ***************************************/

void padic_poly_set(padic_poly_t f, const padic_poly_t g, 
                    const padic_ctx_t ctx);

void padic_poly_set_padic(padic_poly_t poly, const padic_t x, 
                          const padic_ctx_t ctx);

void padic_poly_set_si(padic_poly_t poly, slong x, const padic_ctx_t ctx);

void padic_poly_set_ui(padic_poly_t poly, ulong x, const padic_ctx_t ctx);

void padic_poly_set_fmpz(padic_poly_t poly, const fmpz_t x, 
                         const padic_ctx_t ctx);

void padic_poly_set_fmpq(padic_poly_t poly, const fmpq_t x, 
                         const padic_ctx_t ctx);

void padic_poly_set_fmpz_poly(padic_poly_t rop, const fmpz_poly_t op, 
                              const padic_ctx_t ctx);

void padic_poly_set_fmpq_poly(padic_poly_t rop, 
                              const fmpq_poly_t op, const padic_ctx_t ctx);

int padic_poly_get_fmpz_poly(fmpz_poly_t rop, const padic_poly_t op, 
                             const padic_ctx_t ctx);

void padic_poly_get_fmpq_poly(fmpq_poly_t rop, 
                              const padic_poly_t op, const padic_ctx_t ctx);

static __inline__ void padic_poly_zero(padic_poly_t poly)
{
    _padic_poly_set_length(poly, 0);
    poly->val = 0;
}

static __inline__ void padic_poly_one(padic_poly_t poly)
{
    if (padic_poly_prec(poly) > 0)
    {
        padic_poly_fit_length(poly, 1);
        fmpz_one(poly->coeffs);
        _padic_poly_set_length(poly, 1);
        poly->val = 0;
    }
    else
    {
        padic_poly_zero(poly);
    }
}

void padic_poly_swap(padic_poly_t poly1, padic_poly_t poly2);

/*  Getting and setting coefficients  ****************************************/

void padic_poly_get_coeff_padic(padic_t c, const padic_poly_t poly, slong n, 
                                           const padic_ctx_t ctx);

void padic_poly_set_coeff_padic(padic_poly_t f, slong n, const padic_t c, 
                                                const padic_ctx_t ctx);

/*  Comparison  **************************************************************/

int padic_poly_equal(const padic_poly_t f, const padic_poly_t g);

static __inline__ int padic_poly_is_zero(const padic_poly_t poly)
{
    return poly->length == 0;
}

static __inline__ int padic_poly_is_one(const padic_poly_t poly)
{
    return (poly->length == 1) && fmpz_is_one(poly->coeffs) && 
           (poly->val == 0);
}

/*  Addition and subtraction  ************************************************/

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);

void padic_poly_add(padic_poly_t f, 
                    const padic_poly_t g, const padic_poly_t h, 
                    const padic_ctx_t ctx);

void _padic_poly_sub(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);

void padic_poly_sub(padic_poly_t f, 
                    const padic_poly_t g, const padic_poly_t h, 
                    const padic_ctx_t ctx);

void padic_poly_neg(padic_poly_t f, const padic_poly_t g, 
                    const padic_ctx_t ctx);

/*  Scalar multiplication and division  **************************************/

void _padic_poly_scalar_mul_padic(fmpz *rop, slong *rval, slong N, 
                                  const fmpz *op, slong val, slong len, 
                                  const padic_t c, const padic_ctx_t ctx);

void padic_poly_scalar_mul_padic(padic_poly_t rop, const padic_poly_t op, 
                                 const padic_t c, const padic_ctx_t ctx);

/*  Multiplication  **********************************************************/

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);

void padic_poly_mul(padic_poly_t f, 
                    const padic_poly_t g, const padic_poly_t h, 
                    const padic_ctx_t ctx);

/*  Powering  ****************************************************************/

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

void padic_poly_pow(padic_poly_t rop, const padic_poly_t op, ulong e, 
                    const padic_ctx_t ctx);

/*  Series inversion  ********************************************************/

void padic_poly_inv_series(padic_poly_t Qinv, const padic_poly_t Q, slong n, 
                           const padic_ctx_t ctx);

/*  Derivative  **************************************************************/

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

void padic_poly_derivative(padic_poly_t rop, 
                           const padic_poly_t op, const padic_ctx_t ctx);

/*  Shifting  ****************************************************************/

void padic_poly_shift_left(padic_poly_t rop, const padic_poly_t op, slong n, 
                           const padic_ctx_t ctx);

void padic_poly_shift_right(padic_poly_t rop, const padic_poly_t op, slong n, 
                            const padic_ctx_t ctx);

/*  Evaluation  **************************************************************/

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 x, const padic_ctx_t ctx);

/*  Composition  *************************************************************/

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);

void padic_poly_compose(padic_poly_t rop, 
                        const padic_poly_t op1, const padic_poly_t op2, 
                        const padic_ctx_t ctx);

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);

void padic_poly_compose_pow(padic_poly_t rop, const padic_poly_t op, slong k, 
                            const padic_ctx_t ctx);

/*  Input and output  ********************************************************/

static __inline__ int padic_poly_debug(const padic_poly_t poly)
{
    flint_printf("(alloc = %wd, length = %wd, val = %wd, N = %wd, vec = ", 
        poly->alloc, poly->length, poly->val, poly->N);
    if (poly->coeffs)
    {
        flint_printf("{");
        _fmpz_vec_print(poly->coeffs, poly->alloc);
        flint_printf("}");
    }
    else
    {
        flint_printf("NULL");
    }
    flint_printf(")");

    return 1;
}

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);

static __inline__ 
int _padic_poly_print(const fmpz *poly, slong val, slong len, 
                      const padic_ctx_t ctx)
{
    return _padic_poly_fprint(stdout, poly, val, len, ctx);
}

static __inline__ 
int padic_poly_print(const padic_poly_t poly, const padic_ctx_t ctx)
{
    return padic_poly_fprint(stdout, poly, ctx);
}

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);

static __inline__ 
int _padic_poly_print_pretty(FILE *file, 
                             const fmpz *poly, slong val, slong len, 
                             const char *var, 
                             const padic_ctx_t ctx)
{
    return _padic_poly_fprint_pretty(stdout, poly, val, len, var, ctx);
}

static __inline__ 
int padic_poly_print_pretty(const padic_poly_t poly, const char *var, 
                            const padic_ctx_t ctx)
{
    return padic_poly_fprint_pretty(stdout, poly, var, ctx);
}

/*  Testing  *****************************************************************/

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);

#ifdef __cplusplus
}
#endif

#endif