pqc/external/flint-2.4.3/padic_poly.h

430 lines
14 KiB
C
Raw Normal View History

2014-05-18 22:03:37 +00:00
/*============================================================================
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