fq_poly.h – univariate polynomials over finite fields¶
We represent a polynomial in \(\mathbf{F}_q[X]\) as a struct
which
includes an array coeffs
with the coefficients, as well as the
length length
and the number alloc
of coefficients for which
memory has been allocated.
As a data structure, we call this polynomial normalised if the top coefficient is nonzero.
Unless otherwise stated here, all functions that deal with polynomials assume that the \(\mathbf{F}_q\) context of said polynomials are compatible, i.e., it assumes that the fields are generated by the same polynomial.
Types, macros and constants¶

type fq_poly_struct¶

type fq_poly_t¶
Memory management¶

void fq_poly_init(fq_poly_t poly, const fq_ctx_t ctx)¶
Initialises
poly
for use, with context ctx, and setting its length to zero. A corresponding call tofq_poly_clear()
must be made after finishing with thefq_poly_t
to free the memory used by the polynomial.

void fq_poly_init2(fq_poly_t poly, slong alloc, const fq_ctx_t ctx)¶
Initialises
poly
with space for at leastalloc
coefficients and sets the length to zero. The allocated coefficients are all set to zero. A corresponding call tofq_poly_clear()
must be made after finishing with thefq_poly_t
to free the memory used by the polynomial.

void fq_poly_realloc(fq_poly_t poly, slong alloc, const fq_ctx_t ctx)¶
Reallocates the given polynomial to have space for
alloc
coefficients. Ifalloc
is zero the polynomial is cleared and then reinitialised. If the current length is greater thanalloc
the polynomial is first truncated to lengthalloc
.

void fq_poly_fit_length(fq_poly_t poly, slong len, const fq_ctx_t ctx)¶
If
len
is greater than the number of coefficients currently allocated, then the polynomial is reallocated to have space for at leastlen
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.

void _fq_poly_set_length(fq_poly_t poly, slong newlen, const fq_ctx_t ctx)¶
Sets the coefficients of
poly
beyondlen
to zero and sets the length ofpoly
tolen
.

void fq_poly_clear(fq_poly_t poly, const fq_ctx_t ctx)¶
Clears the given polynomial, releasing any memory used. It must be reinitialised in order to be used again.

void _fq_poly_normalise(fq_poly_t poly, const fq_ctx_t ctx)¶
Sets the length of
poly
so that the top coefficient is nonzero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.

void _fq_poly_normalise2(const fq_struct *poly, slong *length, const fq_ctx_t ctx)¶
Sets the length
length
of(poly,length)
so that the top coefficient is nonzero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.

void fq_poly_truncate(fq_poly_t poly, slong newlen, const fq_ctx_t ctx)¶
Truncates the polynomial to length at most \(n\).

void fq_poly_set_trunc(fq_poly_t poly1, fq_poly_t poly2, slong newlen, const fq_ctx_t ctx)¶
Sets
poly1
topoly2
truncated to length \(n\).

void _fq_poly_reverse(fq_struct *output, const fq_struct *input, slong len, slong m, const fq_ctx_t ctx)¶
Sets
output
to the reverse ofinput
, which is of lengthlen
, but thinking of it as a polynomial of lengthm
, notionally zeropadded if necessary. The lengthm
must be nonnegative, but there are no other restrictions. The polynomialoutput
must have space form
coefficients.

void fq_poly_reverse(fq_poly_t output, const fq_poly_t input, slong m, const fq_ctx_t ctx)¶
Sets
output
to the reverse ofinput
, thinking of it as a polynomial of lengthm
, notionally zeropadded if necessary). The lengthm
must be nonnegative, but there are no other restrictions. The output polynomial will be set to lengthm
and then normalised.
Polynomial parameters¶

slong fq_poly_degree(const fq_poly_t poly, const fq_ctx_t ctx)¶
Returns the degree of the polynomial
poly
.
Randomisation¶

void fq_poly_randtest(fq_poly_t f, flint_rand_t state, slong len, const fq_ctx_t ctx)¶
Sets \(f\) to a random polynomial of length at most
len
with entries in the field described byctx
.

void fq_poly_randtest_not_zero(fq_poly_t f, flint_rand_t state, slong len, const fq_ctx_t ctx)¶
Same as
fq_poly_randtest
but guarantees that the polynomial is not zero.

void fq_poly_randtest_monic(fq_poly_t f, flint_rand_t state, slong len, const fq_ctx_t ctx)¶
Sets \(f\) to a random monic polynomial of length
len
with entries in the field described byctx
.

void fq_poly_randtest_irreducible(fq_poly_t f, flint_rand_t state, slong len, const fq_ctx_t ctx)¶
Sets \(f\) to a random monic, irreducible polynomial of length
len
with entries in the field described byctx
.
Assignment and basic manipulation¶

void _fq_poly_set(fq_struct *rop, const fq_struct *op, slong len, const fq_ctx_t ctx)¶
Sets
(rop, len
) to(op, len)
.

void fq_poly_set(fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx)¶
Sets the polynomial
poly1
to the polynomialpoly2
.

void fq_poly_set_fq(fq_poly_t poly, const fq_t c, const fq_ctx_t ctx)¶
Sets the polynomial
poly
toc
.

void fq_poly_set_fmpz_mod_poly(fq_poly_t rop, const fmpz_mod_poly_t op, const fq_ctx_t ctx)¶
Sets the polynomial
rop
to the polynomialop

void fq_poly_set_nmod_poly(fq_poly_t rop, const nmod_poly_t op, const fq_ctx_t ctx)¶
Sets the polynomial
rop
to the polynomialop

void fq_poly_swap(fq_poly_t op1, fq_poly_t op2, const fq_ctx_t ctx)¶
Swaps the two polynomials
op1
andop2
.

void _fq_poly_zero(fq_struct *rop, slong len, const fq_ctx_t ctx)¶
Sets
(rop, len)
to the zero polynomial.
Getting and setting coefficients¶

void fq_poly_get_coeff(fq_t x, const fq_poly_t poly, slong n, const fq_ctx_t ctx)¶
Sets \(x\) to the coefficient of \(X^n\) in
poly
.
Comparison¶

int fq_poly_equal(const fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx)¶
Returns nonzero if the two polynomials
poly1
andpoly2
are equal, otherwise returns zero.

int fq_poly_equal_trunc(const fq_poly_t poly1, const fq_poly_t poly2, slong n, const fq_ctx_t ctx)¶
Notionally truncate
poly1
andpoly2
to length \(n\) and return nonzero if they are equal, otherwise return zero.

int fq_poly_is_zero(const fq_poly_t poly, const fq_ctx_t ctx)¶
Returns whether the polynomial
poly
is the zero polynomial.

int fq_poly_is_one(const fq_poly_t op, const fq_ctx_t ctx)¶
Returns whether the polynomial
poly
is equal to the constant polynomial \(1\).

int fq_poly_is_gen(const fq_poly_t op, const fq_ctx_t ctx)¶
Returns whether the polynomial
poly
is equal to the polynomial \(x\).
Addition and subtraction¶

void _fq_poly_add(fq_struct *res, const fq_struct *poly1, slong len1, const fq_struct *poly2, slong len2, const fq_ctx_t ctx)¶
Sets
res
to the sum of(poly1,len1)
and(poly2,len2)
.

void fq_poly_add(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx)¶
Sets
res
to the sum ofpoly1
andpoly2
.

void fq_poly_add_si(fq_poly_t res, const fq_poly_t poly1, slong c, const fq_ctx_t ctx)¶
Sets
res
to the sum ofpoly1
andc
.

void fq_poly_add_series(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, slong n, const fq_ctx_t ctx)¶
Notionally truncate
poly1
andpoly2
to lengthn
and setres
to the sum.

void _fq_poly_sub(fq_struct *res, const fq_struct *poly1, slong len1, const fq_struct *poly2, slong len2, const fq_ctx_t ctx)¶
Sets
res
to the difference of(poly1,len1)
and(poly2,len2)
.

void fq_poly_sub(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx)¶
Sets
res
to the difference ofpoly1
andpoly2
.

void fq_poly_sub_series(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, slong n, const fq_ctx_t ctx)¶
Notionally truncate
poly1
andpoly2
to lengthn
and setres
to the difference.
Scalar multiplication and division¶

void _fq_poly_scalar_mul_fq(fq_struct *rop, const fq_struct *op, slong len, const fq_t x, const fq_ctx_t ctx)¶
Sets
(rop,len)
to the product of(op,len)
by the scalarx
, in the context defined byctx
.

void fq_poly_scalar_mul_fq(fq_poly_t rop, const fq_poly_t op, const fq_t x, const fq_ctx_t ctx)¶
Sets
rop
to the product ofop
by the scalarx
, in the context defined byctx
.

void _fq_poly_scalar_addmul_fq(fq_struct *rop, const fq_struct *op, slong len, const fq_t x, const fq_ctx_t ctx)¶
Adds to
(rop,len)
the product of(op,len)
by the scalarx
, in the context defined byctx
. In particular, assumes the same length forop
androp
.

void fq_poly_scalar_addmul_fq(fq_poly_t rop, const fq_poly_t op, const fq_t x, const fq_ctx_t ctx)¶
Adds to
rop
the product ofop
by the scalarx
, in the context defined byctx
.

void _fq_poly_scalar_submul_fq(fq_struct *rop, const fq_struct *op, slong len, const fq_t x, const fq_ctx_t ctx)¶
Subtracts from
(rop,len)
the product of(op,len)
by the scalarx
, in the context defined byctx
. In particular, assumes the same length forop
androp
.

void fq_poly_scalar_submul_fq(fq_poly_t rop, const fq_poly_t op, const fq_t x, const fq_ctx_t ctx)¶
Subtracts from
rop
the product ofop
by the scalarx
, in the context defined byctx
.
Multiplication¶

void _fq_poly_mul_classical(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, const fq_ctx_t ctx)¶
Sets
(rop, len1 + len2  1)
to the product of(op1, len1)
and(op2, len2)
, assuming thatlen1
is at leastlen2
and neither is zero.Permits zero padding. Does not support aliasing of
rop
with eitherop1
orop2
.

void fq_poly_mul_classical(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)¶
Sets
rop
to the product ofop1
andop2
using classical polynomial multiplication.

void _fq_poly_mul_reorder(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, const fq_ctx_t ctx)¶
Sets
(rop, len1 + len2  1)
to the product of(op1, len1)
and(op2, len2)
, assuming thatlen1
andlen2
are nonzero.Permits zero padding. Supports aliasing.

void fq_poly_mul_reorder(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)¶
Sets
rop
to the product ofop1
andop2
, reordering the two indeterminates \(X\) and \(Y\) when viewing the polynomials as elements of \(\mathbf{F}_p[X,Y]\).Suppose \(\mathbf{F}_q = \mathbf{F}_p[X]/ (f(X))\) and recall that elements of \(\mathbf{F}_q\) are internally represented by elements of type
fmpz_poly
. For small degree extensions but polynomials in \(\mathbf{F}_q[Y]\) of large degree \(n\), we change the representation to\[\begin{split}\begin{split} g(Y) & = \sum_{i=0}^{n} a_i(X) Y^i \\ & = \sum_{j=0}^{d} \sum_{i=0}^{n} \text{Coeff}(a_i(X), j) Y^i. \end{split}\end{split}\]This allows us to use a poor algorithm (such as classical multiplication) in the \(X\)direction and leverage the existing fast integer multiplication routines in the \(Y\)direction where the polynomial degree \(n\) is large.

void _fq_poly_mul_univariate(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, const fq_ctx_t ctx)¶
Sets
(rop, len1 + len2  1)
to the product of(op1, len1)
and(op2, len2)
.Permits zero padding and places no assumptions on the lengths
len1
andlen2
. Supports aliasing.

void fq_poly_mul_univariate(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)¶
Sets
rop
to the product ofop1
andop2
using a bivariate to univariate transformation and reducing this problem to multiplying two univariate polynomials.

void _fq_poly_mul_KS(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, const fq_ctx_t ctx)¶
Sets
(rop, len1 + len2  1)
to the product of(op1, len1)
and(op2, len2)
.Permits zero padding and places no assumptions on the lengths
len1
andlen2
. Supports aliasing.

void fq_poly_mul_KS(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)¶
Sets
rop
to the product ofop1
andop2
using Kronecker substitution, that is, by encoding each coefficient in \(\mathbf{F}_{q}\) as an integer and reducing this problem to multiplying two polynomials over the integers.

void _fq_poly_mul(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, const fq_ctx_t ctx)¶
Sets
(rop, len1 + len2  1)
to the product of(op1, len1)
and(op2, len2)
, choosing an appropriate algorithm.Permits zero padding. Does not support aliasing.

void fq_poly_mul(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)¶
Sets
rop
to the product ofop1
andop2
, choosing an appropriate algorithm.

void _fq_poly_mullow_classical(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, slong n, const fq_ctx_t ctx)¶
Sets
(rop, n)
to the first \(n\) coefficients of(op1, len1)
multiplied by(op2, len2)
.Assumes
0 < n <= len1 + len2  1
. Assumes neitherlen1
norlen2
is zero.

void fq_poly_mullow_classical(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx)¶
Sets
rop
to the product ofpoly1
andpoly2
, computed using the classical or schoolbook method.

void _fq_poly_mullow_univariate(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, slong n, const fq_ctx_t ctx)¶
Sets
(rop, n)
to the lowest \(n\) coefficients of the product of(op1, len1)
and(op2, len2)
, computed using a bivariate to univariate transformation.Assumes that
len1
andlen2
are positive, but does allow for the polynomials to be zeropadded. The polynomials may be zero, too. Assumes \(n\) is positive. Supports aliasing betweenres
,poly1
andpoly2
.

void fq_poly_mullow_univariate(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx)¶
Sets
rop
to the lowest \(n\) coefficients of the product ofop1
andop2
, computed using a bivariate to univariate transformation.

void _fq_poly_mullow_KS(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, slong n, const fq_ctx_t ctx)¶
Sets
(rop, n)
to the lowest \(n\) coefficients of the product of(op1, len1)
and(op2, len2)
.Assumes that
len1
andlen2
are positive, but does allow for the polynomials to be zeropadded. The polynomials may be zero, too. Assumes \(n\) is positive. Supports aliasing betweenrop
,op1
andop2
.

void fq_poly_mullow_KS(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx)¶
Sets
rop
to the lowest \(n\) coefficients of the product ofop1
andop2
.

void _fq_poly_mullow(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, slong n, const fq_ctx_t ctx)¶
Sets
(rop, n)
to the lowest \(n\) coefficients of the product of(op1, len1)
and(op2, len2)
.Assumes
0 < n <= len1 + len2  1
. Allows for zeropadding in the inputs. Does not support aliasing between the inputs and the output.

void fq_poly_mullow(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx)¶
Sets
rop
to the lowest \(n\) coefficients of the product ofop1
andop2
.

void _fq_poly_mulhigh_classical(fq_struct *res, const fq_struct *poly1, slong len1, const fq_struct *poly2, slong len2, slong start, const fq_ctx_t ctx)¶
Computes the product of
(poly1, len1)
and(poly2, len2)
and writes the coefficients fromstart
onwards into the high coefficients ofres
, the remaining coefficients being arbitrary but reduced. Assumes thatlen1 >= len2 > 0
. Aliasing of inputs and output is not permitted. Algorithm is classical multiplication.

void fq_poly_mulhigh_classical(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, slong start, const fq_ctx_t ctx)¶
Computes the product of
poly1
andpoly2
and writes the coefficients fromstart
onwards into the high coefficients ofres
, the remaining coefficients being arbitrary but reduced. Algorithm is classical multiplication.

void _fq_poly_mulhigh(fq_struct *res, const fq_struct *poly1, slong len1, const fq_struct *poly2, slong len2, slong start, fq_ctx_t ctx)¶
Computes the product of
(poly1, len1)
and(poly2, len2)
and writes the coefficients fromstart
onwards into the high coefficients ofres
, the remaining coefficients being arbitrary but reduced. Assumes thatlen1 >= len2 > 0
. Aliasing of inputs and output is not permitted.

void fq_poly_mulhigh(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, slong start, const fq_ctx_t ctx)¶
Computes the product of
poly1
andpoly2
and writes the coefficients fromstart
onwards into the high coefficients ofres
, the remaining coefficients being arbitrary but reduced.

void _fq_poly_mulmod(fq_struct *res, const fq_struct *poly1, slong len1, const fq_struct *poly2, slong len2, const fq_struct *f, slong lenf, const fq_ctx_t ctx)¶
Sets
res
to the remainder of the product ofpoly1
andpoly2
upon polynomial division byf
.It is required that
len1 + len2  lenf > 0
, which is equivalent to requiring that the result will actually be reduced. Otherwise, simply use_fq_poly_mul
instead.Aliasing of
f
andres
is not permitted.

void fq_poly_mulmod(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, const fq_poly_t f, const fq_ctx_t ctx)¶
Sets
res
to the remainder of the product ofpoly1
andpoly2
upon polynomial division byf
.

void _fq_poly_mulmod_preinv(fq_struct *res, const fq_struct *poly1, slong len1, const fq_struct *poly2, slong len2, const fq_struct *f, slong lenf, const fq_struct *finv, slong lenfinv, const fq_ctx_t ctx)¶
Sets
res
to the remainder of the product ofpoly1
andpoly2
upon polynomial division byf
.It is required that
finv
is the inverse of the reverse off
modx^lenf
.Aliasing of
res
with any of the inputs is not permitted.
Squaring¶

void _fq_poly_sqr_classical(fq_struct *rop, const fq_struct *op, slong len, const fq_ctx_t ctx)¶
Sets
(rop, 2*len  1)
to the square of(op, len)
, assuming that(op,len)
is not zero and using classical polynomial multiplication.Permits zero padding. Does not support aliasing of
rop
with eitherop1
orop2
.

void fq_poly_sqr_classical(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx)¶
 Sets
rop
to the square ofop
using classical polynomial multiplication.
 Sets

void _fq_poly_sqr_reorder(fq_struct *rop, const fq_struct *op, slong len, const fq_ctx_t ctx)¶
Sets
(rop, 2*len 1)
to the square of(op, len)
, assuming thatlen
is not zero reordering the two indeterminates \(X\) and \(Y\) when viewing the polynomials as elements of \(\mathbf{F}_p[X,Y]\).Permits zero padding. Supports aliasing.

void fq_poly_sqr_reorder(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx)¶
Sets
rop
to the square ofop
, assuming thatlen
is not zero reordering the two indeterminates \(X\) and \(Y\) when viewing the polynomials as elements of \(\mathbf{F}_p[X,Y]\). Seefq_poly_mul_reorder
.

void _fq_poly_sqr_KS(fq_struct *rop, const fq_struct *op, slong len, const fq_ctx_t ctx)¶
Sets
(rop, 2*len  1)
to the square of(op, len)
.Permits zero padding and places no assumptions on the lengths
len1
andlen2
. Supports aliasing.

void fq_poly_sqr_KS(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx)¶
Sets
rop
to the squareop
using Kronecker substitution, that is, by encoding each coefficient in \(\mathbf{F}_{q}\) as an integer and reducing this problem to multiplying two polynomials over the integers.
Powering¶

void _fq_poly_pow(fq_struct *rop, const fq_struct *op, slong len, ulong e, const fq_ctx_t ctx)¶
Sets
rop = op^e
, assuming thate, len > 0
and thatrop
has space fore*(len  1) + 1
coefficients. Does not support aliasing.

void fq_poly_pow(fq_poly_t rop, const fq_poly_t op, ulong e, const fq_ctx_t ctx)¶
Computes
rop = op^e
. If \(e\) is zero, returns one, so that in particular0^0 = 1
.

void _fq_poly_powmod_ui_binexp(fq_struct *res, const fq_struct *poly, ulong e, const fq_struct *f, slong lenf, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using binary exponentiation. We requiree > 0
.We require
lenf > 1
. It is assumed thatpoly
is already reduced modulof
and zeropadded as necessary to have length exactlylenf  1
. The outputres
must have room forlenf  1
coefficients.

void fq_poly_powmod_ui_binexp(fq_poly_t res, const fq_poly_t poly, ulong e, const fq_poly_t f, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using binary exponentiation. We requiree >= 0
.

void _fq_poly_powmod_ui_binexp_preinv(fq_struct *res, const fq_struct *poly, ulong e, const fq_struct *f, slong lenf, const fq_struct *finv, slong lenfinv, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using binary exponentiation. We requiree > 0
. We requirefinv
to be the inverse of the reverse off
.We require
lenf > 1
. It is assumed thatpoly
is already reduced modulof
and zeropadded as necessary to have length exactlylenf  1
. The outputres
must have room forlenf  1
coefficients.

void fq_poly_powmod_ui_binexp_preinv(fq_poly_t res, const fq_poly_t poly, ulong e, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using binary exponentiation. We requiree >= 0
. We requirefinv
to be the inverse of the reverse off
.

void _fq_poly_powmod_fmpz_binexp(fq_struct *res, const fq_struct *poly, const fmpz_t e, const fq_struct *f, slong lenf, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using binary exponentiation. We requiree > 0
.We require
lenf > 1
. It is assumed thatpoly
is already reduced modulof
and zeropadded as necessary to have length exactlylenf  1
. The outputres
must have room forlenf  1
coefficients.

void fq_poly_powmod_fmpz_binexp(fq_poly_t res, const fq_poly_t poly, const fmpz_t e, const fq_poly_t f, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using binary exponentiation. We requiree >= 0
.

void _fq_poly_powmod_fmpz_binexp_preinv(fq_struct *res, const fq_struct *poly, const fmpz_t e, const fq_struct *f, slong lenf, const fq_struct *finv, slong lenfinv, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using binary exponentiation. We requiree > 0
. We requirefinv
to be the inverse of the reverse off
.We require
lenf > 1
. It is assumed thatpoly
is already reduced modulof
and zeropadded as necessary to have length exactlylenf  1
. The outputres
must have room forlenf  1
coefficients.

void fq_poly_powmod_fmpz_binexp_preinv(fq_poly_t res, const fq_poly_t poly, const fmpz_t e, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using binary exponentiation. We requiree >= 0
. We requirefinv
to be the inverse of the reverse off
.

void _fq_poly_powmod_fmpz_sliding_preinv(fq_struct *res, const fq_struct *poly, const fmpz_t e, ulong k, const fq_struct *f, slong lenf, const fq_struct *finv, slong lenfinv, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using slidingwindow exponentiation with window sizek
. We requiree > 0
. We requirefinv
to be the inverse of the reverse off
. Ifk
is set to zero, then an “optimum” size will be selected automatically base one
.We require
lenf > 1
. It is assumed thatpoly
is already reduced modulof
and zeropadded as necessary to have length exactlylenf  1
. The outputres
must have room forlenf  1
coefficients.

void fq_poly_powmod_fmpz_sliding_preinv(fq_poly_t res, const fq_poly_t poly, const fmpz_t e, ulong k, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx)¶
Sets
res
topoly
raised to the powere
modulof
, using slidingwindow exponentiation with window sizek
. We requiree >= 0
. We requirefinv
to be the inverse of the reverse off
. Ifk
is set to zero, then an “optimum” size will be selected automatically base one
.

void _fq_poly_powmod_x_fmpz_preinv(fq_struct *res, const fmpz_t e, const fq_struct *f, slong lenf, const fq_struct *finv, slong lenfinv, const fq_ctx_t ctx)¶
Sets
res
tox
raised to the powere
modulof
, using sliding window exponentiation. We requiree > 0
. We requirefinv
to be the inverse of the reverse off
.We require
lenf > 2
. The outputres
must have room forlenf  1
coefficients.

void fq_poly_powmod_x_fmpz_preinv(fq_poly_t res, const fmpz_t e, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx)¶
Sets
res
tox
raised to the powere
modulof
, using sliding window exponentiation. We requiree >= 0
. We requirefinv
to be the inverse of the reverse off
.

void _fq_poly_pow_trunc_binexp(fq_struct *res, const fq_struct *poly, ulong e, slong trunc, const fq_ctx_t ctx)¶
Sets
res
to the lowtrunc
coefficients ofpoly
(assumed to be zero padded if necessary to lengthtrunc
) to the powere
. This is equivalent to doing a powering followed by a truncation. We require thatres
has enough space fortrunc
coefficients, thattrunc > 0
and thate > 1
. Aliasing is not permitted. Uses the binary exponentiation method.

void fq_poly_pow_trunc_binexp(fq_poly_t res, const fq_poly_t poly, ulong e, slong trunc, const fq_ctx_t ctx)¶
Sets
res
to the lowtrunc
coefficients ofpoly
to the powere
. This is equivalent to doing a powering followed by a truncation. Uses the binary exponentiation method.

void _fq_poly_pow_trunc(fq_struct *res, const fq_struct *poly, ulong e, slong trunc, const fq_ctx_t mod)¶
Sets
res
to the lowtrunc
coefficients ofpoly
(assumed to be zero padded if necessary to lengthtrunc
) to the powere
. This is equivalent to doing a powering followed by a truncation. We require thatres
has enough space fortrunc
coefficients, thattrunc > 0
and thate > 1
. Aliasing is not permitted.
Shifting¶

void _fq_poly_shift_left(fq_struct *rop, const fq_struct *op, slong len, slong n, const fq_ctx_t ctx)¶
Sets
(rop, len + n)
to(op, len)
shifted left by \(n\) coefficients.Inserts zero coefficients at the lower end. Assumes that
len
and \(n\) are positive, and thatrop
fitslen + n
elements. Supports aliasing betweenrop
andop
.

void fq_poly_shift_left(fq_poly_t rop, const fq_poly_t op, slong n, const fq_ctx_t ctx)¶
Sets
rop
toop
shifted left by \(n\) coeffs. Zero coefficients are inserted.

void _fq_poly_shift_right(fq_struct *rop, const fq_struct *op, slong len, slong n, const fq_ctx_t ctx)¶
Sets
(rop, len  n)
to(op, len)
shifted right by \(n\) coefficients.Assumes that
len
and \(n\) are positive, thatlen > n
, and thatrop
fitslen  n
elements. Supports aliasing betweenrop
andop
, although in this case the top coefficients ofop
are not set to zero.
Norms¶
Euclidean division¶

void _fq_poly_divrem(fq_struct *Q, fq_struct *R, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_t invB, const fq_ctx_t ctx)¶
Computes
(Q, lenA  lenB + 1)
,(R, lenA)
such that \(A = B Q + R\) with \(0 \leq \operatorname{len}(R) < \operatorname{len}(B)\).Assumes that the leading coefficient of \(B\) is invertible and that
invB
is its inverse.Assumes that \(\operatorname{len}(A), \operatorname{len}(B) > 0\). Allows zeropadding in
(A, lenA)
. \(R\) and \(A\) may be aliased, but apart from this no aliasing of input and output operands is allowed.

void fq_poly_divrem(fq_poly_t Q, fq_poly_t R, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx)¶
Computes \(Q\), \(R\) such that \(A = B Q + R\) with \(0 \leq \operatorname{len}(R) < \operatorname{len}(B)\).
Assumes that the leading coefficient of \(B\) is invertible. This can be taken for granted the context is for a finite field, that is, when \(p\) is prime and \(f(X)\) is irreducible.

void fq_poly_divrem_f(fq_t f, fq_poly_t Q, fq_poly_t R, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx)¶
Either finds a nontrivial factor \(f\) of the modulus of
ctx
, or computes \(Q\), \(R\) such that \(A = B Q + R\) and \(0 \leq \operatorname{len}(R) < \operatorname{len}(B)\).If the leading coefficient of \(B\) is invertible, the division with remainder operation is carried out, \(Q\) and \(R\) are computed correctly, and \(f\) is set to \(1\). Otherwise, \(f\) is set to a nontrivial factor of the modulus and \(Q\) and \(R\) are not touched.
Assumes that \(B\) is nonzero.

void _fq_poly_rem(fq_struct *R, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_t invB, const fq_ctx_t ctx)¶
Sets
R
to the remainder of the division of(A,lenA)
by(B,lenB)
. Assumes that the leading coefficient of(B,lenB)
is invertible and thatinvB
is its inverse.

void fq_poly_rem(fq_poly_t R, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx)¶
Sets
R
to the remainder of the division ofA
byB
in the context described byctx
.

void _fq_poly_div(fq_struct *Q, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_t invB, const fq_ctx_t ctx)¶
Notationally, computes \(Q\), \(R\) such that \(A = B Q + R\) with \(0 \leq \operatorname{len}(R) < \operatorname{len}(B)\) but only sets
(Q, lenA  lenB + 1)
. Allows zeropadding in \(A\) but not in \(B\). Assumes that the leading coefficient of \(B\) is a unit.

void fq_poly_div(fq_poly_t Q, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx)¶
Notionally finds polynomials \(Q\) and \(R\) such that \(A = B Q + R\) with \(\operatorname{len}(R) < \operatorname{len}(B)\), but returns only
Q
. If \(\operatorname{len}(B) = 0\) an exception is raised.

void _fq_poly_div_newton_n_preinv(fq_struct *Q, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_struct *Binv, slong lenBinv, const fq_ctx_t ctx)¶
Notionally computes polynomials \(Q\) and \(R\) such that \(A = BQ + R\) with \(\operatorname{len}(R)\) less than
lenB
, whereA
is of lengthlenA
andB
is of lengthlenB
, but return only \(Q\).We require that \(Q\) have space for
lenA  lenB + 1
coefficients and assume that the leading coefficient of \(B\) is a unit. Furthermore, we assume that \(Binv\) is the inverse of the reverse of \(B\) mod \(x^{\operatorname{len}(B)}\).The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.

void fq_poly_div_newton_n_preinv(fq_poly_t Q, const fq_poly_t A, const fq_poly_t B, const fq_poly_t Binv, const fq_ctx_t ctx)¶
Notionally computes \(Q\) and \(R\) such that \(A = BQ + R\) with \(\operatorname{len}(R) < \operatorname{len}(B)\), but returns only \(Q\).
We assume that the leading coefficient of \(B\) is a unit and that \(Binv\) is the inverse of the reverse of \(B\) mod \(x^{\operatorname{len}(B)}\).
It is required that the length of \(A\) is less than or equal to 2*the length of \(B\)  2.
The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.

void _fq_poly_divrem_newton_n_preinv(fq_struct *Q, fq_struct *R, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_struct *Binv, slong lenBinv, const fq_ctx_t ctx)¶
Computes \(Q\) and \(R\) such that \(A = BQ + R\) with \(\operatorname{len}(R)\) less than
lenB
, where \(A\) is of lengthlenA
and \(B\) is of lengthlenB
. We require that \(Q\) have space forlenA  lenB + 1
coefficients. Furthermore, we assume that \(Binv\) is the inverse of the reverse of \(B\) mod \(x^{\operatorname{len}(B)}\). The algorithm used is to calldiv_newton_n_preinv()
and then multiply out and compute the remainder.

void fq_poly_divrem_newton_n_preinv(fq_poly_t Q, fq_poly_t R, const fq_poly_t A, const fq_poly_t B, const fq_poly_t Binv, const fq_ctx_t ctx)¶
Computes \(Q\) and \(R\) such that \(A = BQ + R\) with \(\operatorname{len}(R) < \operatorname{len}(B)\). We assume \(Binv\) is the inverse of the reverse of \(B\) mod \(x^{\operatorname{len}(B)}\).
It is required that the length of \(A\) is less than or equal to 2*the length of \(B\)  2.
The algorithm used is to call
div_newton_n()
and then multiply out and compute the remainder.

void _fq_poly_inv_series_newton(fq_struct *Qinv, const fq_struct *Q, slong n, const fq_t cinv, const fq_ctx_t ctx)¶
Given
Q
of lengthn
whose constant coefficient is invertible modulo the given modulus, find a polynomialQinv
of lengthn
such thatQ * Qinv
is1
modulo \(x^n\). Requiresn > 0
. This function can be viewed as inverting a power series via Newton iteration.

void fq_poly_inv_series_newton(fq_poly_t Qinv, const fq_poly_t Q, slong n, const fq_ctx_t ctx)¶
Given
Q
findQinv
such thatQ * Qinv
is1
modulo \(x^n\). The constant coefficient ofQ
must be invertible modulo the modulus ofQ
. An exception is raised if this is not the case or ifn = 0
. This function can be viewed as inverting a power series via Newton iteration.

void _fq_poly_inv_series(fq_struct *Qinv, const fq_struct *Q, slong n, const fq_t cinv, const fq_ctx_t ctx)¶
Given
Q
of lengthn
whose constant coefficient is invertible modulo the given modulus, find a polynomialQinv
of lengthn
such thatQ * Qinv
is1
modulo \(x^n\). Requiresn > 0
.

void fq_poly_inv_series(fq_poly_t Qinv, const fq_poly_t Q, slong n, const fq_ctx_t ctx)¶
Given
Q
findQinv
such thatQ * Qinv
is1
modulo \(x^n\). The constant coefficient ofQ
must be invertible modulo the modulus ofQ
. An exception is raised if this is not the case or ifn = 0
.
Greatest common divisor¶

void fq_poly_gcd(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)¶
Sets
rop
to the greatest common divisor ofop1
andop2
, using the either the Euclidean or HGCD algorithm. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial \(P\) is defined to be \(P\). Except in the case where the GCD is zero, the GCD \(G\) is made monic.

slong _fq_poly_gcd(fq_struct *G, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_ctx_t ctx)¶
Computes the GCD of \(A\) of length
lenA
and \(B\) of lengthlenB
, wherelenA >= lenB > 0
and sets \(G\) to it. The length of the GCD \(G\) is returned by the function. No attempt is made to make the GCD monic. It is required that \(G\) have space forlenB
coefficients.

slong _fq_poly_gcd_euclidean_f(fq_t f, fq_struct *G, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_ctx_t ctx)¶
Either sets \(f = 1\) and \(G\) to the greatest common divisor of \((A,\operatorname{len}(A))\) and \((B, \operatorname{len}(B))\) and returns its length, or sets \(f\) to a nontrivial factor of the modulus of
ctx
and leaves the contents of the vector \((G, lenB)\) undefined.Assumes that \(\operatorname{len}(A) \geq \operatorname{len}(B) > 0\) and that the vector \(G\) has space for sufficiently many coefficients.

void fq_poly_gcd_euclidean_f(fq_t f, fq_poly_t G, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx)¶
Either sets \(f = 1\) and \(G\) to the greatest common divisor of \(A\) and \(B\) or sets \(f\) to a factor of the modulus of
ctx
.

slong _fq_poly_xgcd(fq_struct *G, fq_struct *S, fq_struct *T, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_ctx_t ctx)¶
Computes the GCD of \(A\) and \(B\) together with cofactors \(S\) and \(T\) such that \(S A + T B = G\). Returns the length of \(G\).
Assumes that \(\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1\) and \((\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1)\).
No attempt is made to make the GCD monic.
Requires that \(G\) have space for \(\operatorname{len}(B)\) coefficients. Writes \(\operatorname{len}(B)1\) and \(\operatorname{len}(A)1\) coefficients to \(S\) and \(T\), respectively. Note that, in fact, \(\operatorname{len}(S) \leq \max(\operatorname{len}(B)  \operatorname{len}(G), 1)\) and \(\operatorname{len}(T) \leq \max(\operatorname{len}(A)  \operatorname{len}(G), 1)\).
No aliasing of input and output operands is permitted.

void fq_poly_xgcd(fq_poly_t G, fq_poly_t S, fq_poly_t T, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx)¶
Computes the GCD of \(A\) and \(B\). The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial \(P\) is defined to be \(P\). Except in the case where the GCD is zero, the GCD \(G\) is made monic.
Polynomials
S
andT
are computed such thatS*A + T*B = G
. The length ofS
will be at mostlenB
and the length ofT
will be at mostlenA
.

slong _fq_poly_xgcd_euclidean_f(fq_t f, fq_struct *G, fq_struct *S, fq_struct *T, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_ctx_t ctx)¶
Either sets \(f = 1\) and computes the GCD of \(A\) and \(B\) together with cofactors \(S\) and \(T\) such that \(S A + T B = G\); otherwise, sets \(f\) to a nontrivial factor of the modulus of
ctx
and leaves \(G\), \(S\), and \(T\) undefined. Returns the length of \(G\).Assumes that \(\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1\) and \((\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1)\).
No attempt is made to make the GCD monic.
Requires that \(G\) have space for \(\operatorname{len}(B)\) coefficients. Writes \(\operatorname{len}(B)1\) and \(\operatorname{len}(A)1\) coefficients to \(S\) and \(T\), respectively. Note that, in fact, \(\operatorname{len}(S) \leq \max(\operatorname{len}(B)  \operatorname{len}(G), 1)\) and \(\operatorname{len}(T) \leq \max(\operatorname{len}(A)  \operatorname{len}(G), 1)\).
No aliasing of input and output operands is permitted.

void fq_poly_xgcd_euclidean_f(fq_t f, fq_poly_t G, fq_poly_t S, fq_poly_t T, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx)¶
Either sets \(f = 1\) and computes the GCD of \(A\) and \(B\) or sets \(f\) to a nontrivial factor of the modulus of
ctx
.If the GCD is computed, polynomials
S
andT
are computed such thatS*A + T*B = G
; otherwise, they are undefined. The length ofS
will be at mostlenB
and the length ofT
will be at mostlenA
.The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial \(P\) is defined to be \(P\). Except in the case where the GCD is zero, the GCD \(G\) is made monic.
Divisibility testing¶

int _fq_poly_divides(fq_struct *Q, const fq_struct *A, slong lenA, const fq_struct *B, slong lenB, const fq_t invB, const fq_ctx_t ctx)¶
Returns \(1\) if
(B, lenB)
divides(A, lenA)
exactly and sets \(Q\) to the quotient, otherwise returns \(0\).It is assumed that \(\operatorname{len}(A) \geq \operatorname{len}(B) > 0\) and that \(Q\) has space for \(\operatorname{len}(A)  \operatorname{len}(B) + 1\) coefficients.
Aliasing of \(Q\) with either of the inputs is not permitted.
This function is currently unoptimised and provided for convenience only.
Derivative¶
Square root¶

void _fq_poly_invsqrt_series(fq_struct *g, const fq_struct *h, slong n, fq_ctx_t mod)¶
Set the first \(n\) terms of \(g\) to the series expansion of \(1/\sqrt{h}\). It is assumed that \(n > 0\), that \(h\) has constant term 1 and that \(h\) is zeropadded as necessary to length \(n\). Aliasing is not permitted.

void fq_poly_invsqrt_series(fq_poly_t g, const fq_poly_t h, slong n, fq_ctx_t ctx)¶
Set \(g\) to the series expansion of \(1/\sqrt{h}\) to order \(O(x^n)\). It is assumed that \(h\) has constant term 1.

void _fq_poly_sqrt_series(fq_struct *g, const fq_struct *h, slong n, fq_ctx_t ctx)¶
Set the first \(n\) terms of \(g\) to the series expansion of \(\sqrt{h}\). It is assumed that \(n > 0\), that \(h\) has constant term 1 and that \(h\) is zeropadded as necessary to length \(n\). Aliasing is not permitted.

void fq_poly_sqrt_series(fq_poly_t g, const fq_poly_t h, slong n, fq_ctx_t ctx)¶
Set \(g\) to the series expansion of \(\sqrt{h}\) to order \(O(x^n)\). It is assumed that \(h\) has constant term 1.
Evaluation¶
Composition¶

void _fq_poly_compose(fq_struct *rop, const fq_struct *op1, slong len1, const fq_struct *op2, slong len2, const fq_ctx_t ctx)¶
Sets
rop
to the composition of(op1, len1)
and(op2, len2)
.Assumes that
rop
has space for(len11)*(len21) + 1
coefficients. Assumes thatop1
andop2
are nonzero polynomials. Does not support aliasing between any of the inputs and the output.

void fq_poly_compose(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx)¶
Sets
rop
to the composition ofop1
andop2
. To be precise about the order of composition, denotingrop
,op1
, andop2
by \(f\), \(g\), and \(h\), respectively, sets \(f(t) = g(h(t))\).

void _fq_poly_compose_mod_horner(fq_struct *res, const fq_struct *f, slong lenf, const fq_struct *g, const fq_struct *h, slong lenh, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that the length of \(g\) is one less than the length of \(h\) (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.The algorithm used is Horner’s rule.

void fq_poly_compose_mod_horner(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero. The algorithm used is Horner’s rule.

void _fq_poly_compose_mod_horner_preinv(fq_struct *res, const fq_struct *f, slong lenf, const fq_struct *g, const fq_struct *h, slong lenh, const fq_struct *hinv, slong lenhiv, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that the length of \(g\) is one less than the length of \(h\) (possibly with zero padding). We also require that the length of \(f\) is less than the length of \(h\). Furthermore, we requirehinv
to be the inverse of the reverse ofh
. The output is not allowed to be aliased with any of the inputs.The algorithm used is Horner’s rule.

void fq_poly_compose_mod_horner_preinv(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_poly_t hinv, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that \(f\) has smaller degree than \(h\). Furthermore, we requirehinv
to be the inverse of the reverse ofh
. The algorithm used is Horner’s rule.

void _fq_poly_compose_mod_brent_kung(fq_struct *res, const fq_struct *f, slong lenf, const fq_struct *g, const fq_struct *h, slong lenh, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that the length of \(g\) is one less than the length of \(h\) (possibly with zero padding). We also require that the length of \(f\) is less than the length of \(h\). The output is not allowed to be aliased with any of the inputs.The algorithm used is the BrentKung matrix algorithm.

void fq_poly_compose_mod_brent_kung(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that \(f\) has smaller degree than \(h\). The algorithm used is the BrentKung matrix algorithm.

void _fq_poly_compose_mod_brent_kung_preinv(fq_struct *res, const fq_struct *f, slong lenf, const fq_struct *g, const fq_struct *h, slong lenh, const fq_struct *hinv, slong lenhiv, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that the length of \(g\) is one less than the length of \(h\) (possibly with zero padding). We also require that the length of \(f\) is less than the length of \(h\). Furthermore, we requirehinv
to be the inverse of the reverse ofh
. The output is not allowed to be aliased with any of the inputs.The algorithm used is the BrentKung matrix algorithm.

void fq_poly_compose_mod_brent_kung_preinv(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_poly_t hinv, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that \(f\) has smaller degree than \(h\). Furthermore, we requirehinv
to be the inverse of the reverse ofh
. The algorithm used is the BrentKung matrix algorithm.

void _fq_poly_compose_mod(fq_struct *res, const fq_struct *f, slong lenf, const fq_struct *g, const fq_struct *h, slong lenh, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that the length of \(g\) is one less than the length of \(h\) (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.

void fq_poly_compose_mod(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero.

void _fq_poly_compose_mod_preinv(fq_struct *res, const fq_struct *f, slong lenf, const fq_struct *g, const fq_struct *h, slong lenh, const fq_struct *hinv, slong lenhiv, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that the length of \(g\) is one less than the length of \(h\) (possibly with zero padding). We also require that the length of \(f\) is less than the length of \(h\). Furthermore, we requirehinv
to be the inverse of the reverse ofh
. The output is not allowed to be aliased with any of the inputs.

void fq_poly_compose_mod_preinv(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_poly_t hinv, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero and that \(f\) has smaller degree than \(h\). Furthermore, we requirehinv
to be the inverse of the reverse ofh
.

void _fq_poly_reduce_matrix_mod_poly(fq_mat_t A, const fq_mat_t B, const fq_poly_t f, const fq_ctx_t ctx)¶
Sets the ith row of
A
to the reduction of the ith row of \(B\) modulo \(f\) for \(i=1,\ldots,\sqrt{\deg(f)}\). We require \(B\) to be at least a \(\sqrt{\deg(f)}\times \deg(f)\) matrix and \(f\) to be nonzero.

void _fq_poly_precompute_matrix(fq_mat_t A, const fq_struct *f, const fq_struct *g, slong leng, const fq_struct *ginv, slong lenginv, const fq_ctx_t ctx)¶
Sets the ith row of
A
to \(f^i\) modulo \(g\) for \(i=1,\ldots,\sqrt{\deg(g)}\). We require \(A\) to be a \(\sqrt{\deg(g)}\times \deg(g)\) matrix. We requireginv
to be the inverse of the reverse ofg
and \(g\) to be nonzero.

void fq_poly_precompute_matrix(fq_mat_t A, const fq_poly_t f, const fq_poly_t g, const fq_poly_t ginv, const fq_ctx_t ctx)¶
Sets the ith row of
A
to \(f^i\) modulo \(g\) for \(i=1,\ldots,\sqrt{\deg(g)}\). We require \(A\) to be a \(\sqrt{\deg(g)}\times \deg(g)\) matrix. We requireginv
to be the inverse of the reverse ofg
.

void _fq_poly_compose_mod_brent_kung_precomp_preinv(fq_struct *res, const fq_struct *f, slong lenf, const fq_mat_t A, const fq_struct *h, slong lenh, const fq_struct *hinv, slong lenhinv, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that \(h\) is nonzero. We require that the ith row of \(A\) contains \(g^i\) for \(i=1,\ldots,\sqrt{\deg(h)}\), i.e. \(A\) is a \(\sqrt{\deg(h)}\times \deg(h)\) matrix. We also require that the length of \(f\) is less than the length of \(h\). Furthermore, we requirehinv
to be the inverse of the reverse ofh
. The output is not allowed to be aliased with any of the inputs.The algorithm used is the BrentKung matrix algorithm.

void fq_poly_compose_mod_brent_kung_precomp_preinv(fq_poly_t res, const fq_poly_t f, const fq_mat_t A, const fq_poly_t h, const fq_poly_t hinv, const fq_ctx_t ctx)¶
Sets
res
to the composition \(f(g)\) modulo \(h\). We require that the ith row of \(A\) contains \(g^i\) for \(i=1,\ldots,\sqrt{\deg(h)}\), i.e. \(A\) is a \(\sqrt{\deg(h)}\times \deg(h)\) matrix. We require that \(h\) is nonzero and that \(f\) has smaller degree than \(h\). Furthermore, we requirehinv
to be the inverse of the reverse ofh
. This version of BrentKung modular composition is particularly useful if one has to perform several modular composition of the form \(f(g)\) modulo \(h\) for fixed \(g\) and \(h\).
Output¶

int _fq_poly_fprint_pretty(FILE *file, const fq_struct *poly, slong len, const char *x, const fq_ctx_t ctx)¶
Prints the pretty representation of
(poly, len)
to the streamfile
, using the stringx
to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a nonpositive value.

int fq_poly_fprint_pretty(FILE *file, const fq_poly_t poly, const char *x, const fq_ctx_t ctx)¶
Prints the pretty representation of
poly
to the streamfile
, using the stringx
to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a nonpositive value.

int _fq_poly_print_pretty(const fq_struct *poly, slong len, const char *x, const fq_ctx_t ctx)¶
Prints the pretty representation of
(poly, len)
tostdout
, using the stringx
to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a nonpositive value.

int fq_poly_print_pretty(const fq_poly_t poly, const char *x, const fq_ctx_t ctx)¶
Prints the pretty representation of
poly
tostdout
, using the stringx
to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a nonpositive value.

int _fq_poly_fprint(FILE *file, const fq_struct *poly, slong len, const fq_ctx_t ctx)¶
Prints the pretty representation of
(poly, len)
to the streamfile
.In case of success, returns a positive value. In case of failure, returns a nonpositive value.

int fq_poly_fprint(FILE *file, const fq_poly_t poly, const fq_ctx_t ctx)¶
Prints the pretty representation of
poly
to the streamfile
.In case of success, returns a positive value. In case of failure, returns a nonpositive value.

int _fq_poly_print(const fq_struct *poly, slong len, const fq_ctx_t ctx)¶
Prints the pretty representation of
(poly, len)
tostdout
.In case of success, returns a positive value. In case of failure, returns a nonpositive value.

int fq_poly_print(const fq_poly_t poly, const fq_ctx_t ctx)¶
Prints the representation of
poly
tostdout
.In case of success, returns a positive value. In case of failure, returns a nonpositive value.

char *_fq_poly_get_str(const fq_struct *poly, slong len, const fq_ctx_t ctx)¶
Returns the plain FLINT string representation of the polynomial
(poly, len)
.

char *fq_poly_get_str(const fq_poly_t poly, const fq_ctx_t ctx)¶
Returns the plain FLINT string representation of the polynomial
poly
.
Inflation and deflation¶

void fq_poly_inflate(fq_poly_t result, const fq_poly_t input, ulong inflation, const fq_ctx_t ctx)¶
Sets
result
to the inflated polynomial \(p(x^n)\) where \(p\) is given byinput
and \(n\) is given byinflation
.