fmpz_mod_mpoly.h

Initialises ctx for polynomials in nvars variables with the monomial ordering ord (ORD_LEX, ORD_DEGLEX or ORD_DEGREVLEX) and coefficients modulo modulus, which must be positive.

Initialise ctx with a random number of variables in [0, max_nvars] and a random ordering, and the given modulus, a random modulus of at most max_bits bits, or a random prime of at most max_bits bits. Used for testing.

Return the number of variables and the ordering of ctx.

Return a pointer to the modulus of ctx (owned by the context), or set m to it.

Frees the memory used by ctx.

Initialise A as the zero polynomial, allocating nothing, space for alloc terms, or space for alloc terms with bits bits per exponent field.

Frees the memory used by A.

Ensure space for length terms; the second also repacks the exponents to at least bits bits, the third sets the field width to bits and leaves the exponent data undefined.

Keeps only the newlen leading terms of A if it is longer.

Set A to B (resp. modify A) with exponents repacked into Abits bits per field; return 0 if some exponent does not fit, setting A to zero.

Return a string representing A, which the caller frees with flint_free, or print it to file or stdout. The printing functions return a positive value on success.

Parses str as in nmod_mpoly_set_str_pretty: integers, the variables in x, +, -, *, exact / and ^. Returns 0 on success, and -1 (setting A to zero) on failure.

Set A to the variable of index var; return whether A is that variable, or, for var < 0, any variable.

Assignment, swap and equality test.

Return whether A is constant, and set c to the value of the constant A, throwing if A is not constant.

Set A to the constant c; fmpz_mod_mpoly_set_fmpz_mod requires c to be reduced, the other functions reduce it.

Set A to 0 or 1.

Return whether A equals the constant c \bmod n, zero or one.

Set degs to the degrees of A in all variables, and test whether they fit an slong.

The degree of A in the variable of index var.

The total degree of A, and whether it fits an slong.

Sets used[i] to a nonzero value if the variable of index i appears in A, and to zero otherwise.

Get or set the coefficient of the monomial M, which must be a monomial (throws otherwise).

Get or set the coefficient of the monomial with exponent vector exp, given as fmpz pointers or as ulong. Setting a coefficient to zero removes the term. Each call costs time linear in the length of A.

Sets C to the coefficient of \prod_i x_{v_i}^{e_i} in A viewed as a polynomial in the distinct variables x_{v_i}, v_i = vars[i], e_i = exps[i], 0 \le i < length, with coefficients in the other variables.

Returns a pointer to the leading coefficient of A, which must be nonzero.

Test whether A involves only the variable of index var; convert such a polynomial to an fmpz_mod_poly (returning 0 if it involves another variable); and set A to the univariate polynomial B in that variable.

Returns 1, -1 or 0 according as A is greater than, less than or equal to B in a total order on polynomials that agrees with the monomial ordering on monomials.

Return whether A is canonical (sorted, nonzero reduced coefficients, valid exponents), or throw if it is not.

Return the number of terms, or change it to new_length, deleting terms at the end or appending zero terms.

Get or set the coefficient of the term of index i (reduced modulo n).

Test whether the exponents of the term of index i fit a ulong or slong, and get its exponent vector or the exponent of one variable; the ulong and slong versions throw if a value does not fit.

Set the exponent vector of the term of index i.

Set M to the term of index i, or to its monomial with coefficient 1.

Append a term with coefficient c \bmod n and exponent vector exp in constant amortised time. The exponents are an array of pointers to fmpz (_fmpz), an array of fmpz (_ffmpz) or of ulong (_ui).

Sort the terms into the order of the context (without combining), and combine adjacent equal monomials and remove zero coefficients; together they make A canonical.

Set A to a random polynomial with at most length terms and exponents below exp_bound, below exp_bounds[i] for variable i, or of at most exp_bits bits.

Set A to B + c or B - c. fmpz_mod_mpoly_add_fmpz_mod requires c to be reduced.

Set A to B + C or B - C.

Sets A to -B.

Set A to c B. The last version requires c to be reduced and invertible.

Sets A to B + d C.

Sets A to B divided by its leading coefficient; throws if B is zero or the leading coefficient is not invertible.

Sets A to the derivative of B with respect to the variable of index var.

Sets eval to the value of A at the point with coordinates alphas[0], alphas[1], ... (one per variable).

Sets A to B with the variable of index var replaced by val.

Set A to B evaluated at the polynomials C[i] of the context ctxAC, one per variable of ctxB. A must not alias B or any C[i]. Return 1 for success and 0 if the computation would be too large. The main function transforms exponents by a matrix when every C[i] is zero or a monomial with coefficient 1, and otherwise uses a Horner scheme or a geobucket sum.

Sets A to B with the variable of index i of ctxB replaced by the variable of index c[i] of ctxAC, or by zero if c[i] is negative.

Sets A to B C, by Kronecker substitution if the product is dense enough and otherwise by Johnson's heap algorithm.

Sets A to B C by Johnson's heap algorithm [Joh1974].

Tries to set A to B C by Kronecker substitution into fmpz_mod_poly; returns 0 if the dense representation would be too large.

Set A to B^k. fmpz_mod_mpoly_pow_fmpz throws if k < 0 and returns 0 if k does not fit an slong and B has more than one term; otherwise both return 1.

Sets A to B^k by repeated multiplication.

If B divides A, sets Q to A/B and returns 1; otherwise sets Q to zero and returns 0.

Sets Q to A/B, assuming that the division is exact.

Variants of fmpz_mod_mpoly_divides: the heap algorithm of Monagan and Pearce [MonPea2011], and Kronecker substitution, which returns -1 if the dense representation would be too large.

Set Q and R to the quotient and remainder of A divided by B: A = QB + R with no term of R divisible by the leading monomial of B.

Divides A by the len polynomials B[i]: A = R + \sum_i Q_i B_i with no term of R divisible by any leading monomial of a B_i.

Heap implementations of the division functions.

If A is a square, set Q to a square root and return 1, otherwise return 0. The modulus must be prime. A word-size modulus is handled by nmod_mpoly_sqrt.

If Q^2 + AQ = B has a solution, sets Q to one and returns 1; otherwise returns 0. The modulus must be prime.

Sets M to the GCD of the terms of A: zero, or the monomial with coefficient 1 whose exponents are the minima over the terms of A.

Sets g to the GCD of the coefficients of A viewed as a polynomial in the variables vars[i], and returns 1 for success.

Set G to the monic GCD of A and B (zero if both are zero), and fmpz_mod_mpoly_gcd_cofactors also \bar{A} = A/G and \bar{B} = B/G. For a word-size modulus the computation is done by nmod_mpoly.

Set G to the monic GCD by one algorithm: Brown's dense interpolation, Hensel lifting, Zippel's sparse interpolation, sparse interpolation with two main variables, or the subresultant pseudo-remainder sequence in one variable. Return 0 if the algorithm cannot be applied.

As nmod_mpoly_deflation, nmod_mpoly_deflate and nmod_mpoly_inflate: the shifts and strides of the exponents of each variable, and the substitutions e \mapsto (e - \mathit{shift})/\mathit{stride} and e \mapsto \mathit{shift} + \mathit{stride} \cdot e.

Set R to the resultant of A and B, or the discriminant of A, with respect to the variable of index var, by the subresultant algorithm of Ducos [Duc2000]. Return 1 for success. The modulus must be prime.

Memory management, printing and consistency check.

Convert B to a polynomial in the variable of index var, and back (the coefficients must not involve that variable).

Access the terms: whether the degree fits an slong, the number of terms, the exponent and the coefficient of the term of index i, and setting the coefficient of x^e.

A GCD up to factors free of the main variable, the resultant and the discriminant with respect to the main variable, by subresultants. Return 1 for success.

Initialise vec to len zero polynomials, free it, swap two vectors, ensure room for len entries, and set the length (truncating or appending zeros).

Copy a vector, append a copy of f, and insert f unless it is already present, returning its index.

Print a vector, and set it to len random nonzero polynomials with at most poly_len terms and exponents below exp_bound.

Sets res to the S-polynomial of f and g, computed after making f and g monic: \mathrm{lcm}/\mathrm{lm}(f) \cdot f/\mathrm{lc}(f) - \mathrm{lcm}/\mathrm{lm}(g) \cdot g/\mathrm{lc}(g), where lcm is the least common multiple of the leading monomials.

Sets res to the remainder of f on division by the polynomials in Iv (with fmpz_mod_mpoly_divrem_ideal), made monic unless it is zero.

Returns whether G is a Gröbner basis of the ideal it generates (all S-polynomials reduce to zero) and, if F is not NULL, every element of F reduces to zero modulo G, so that the ideal of F is contained in that of G. The converse inclusion is not checked.

Returns whether G is autoreduced (inter-reduced).

Sets H to the autoreduction of the Gröbner basis G, which is the reduced Gröbner basis of the ideal, unique up to the order of the entries.

Sets G to the nonzero entries of F made monic, without duplicates.

Set G to a Gröbner basis of the ideal generated by F, by Buchberger's algorithm in the form GROEBNERNEW2 of [BW1993], which discards useless pairs with the criteria of Gebauer and Möller [GM1988]. The basis is not reduced in general; fmpz_mod_mpoly_vec_autoreduction_groebner reduces it. The second version stops if the basis gets more than ideal_len_limit elements or a polynomial gets more than poly_len_limit terms, and returns 0 in that case (G then generates the ideal but need not be a Gröbner basis); otherwise it returns 1.

Sets res to the reduction modulo n of the integer polynomial f of the context ctx, which must have the same number of variables and ordering as ctxm.

Sets res to f with its coefficients lifted to integers in [0, n).

Ensure room for length coefficients and exponent vectors of N words in the given arrays, and set the length field.

Radix sort of the terms left to right - 1 (coefficients and exponent arrays given explicitly), appending a term with undefined coefficient, and setting a coefficient given an array of fmpz exponents.

Evaluation of term arrays at a point, and substitution of monomials by a matrix acting on the exponent vectors.

Multiplication and division methods given the maximum exponent fields of the inputs.

Set up D as a dense univariate polynomial holding the Kronecker substitution of A with the given degree bounds, and free it.

Conversions to and from univariate representations with given exponent bits, shifts and strides.

Convert between an fmpz_mod_mpoly with a word-size modulus and an nmod_mpoly in a context with the same variables, ordering and modulus.

For A viewed as a polynomial in its first num_vars variables (in a lexicographic context): the leading coefficient, and the GCD of the coefficients (returning 1 for success).

Permute, deflate and convert to a lexicographic context lctx, and undo this with Abits-bit exponents.

Sets res to f divided by its leading coefficient, or to zero if f is zero. Throws if the leading coefficient is not invertible. Not used in FLINT.

Sets up the generic ring interface R used by the parser and the subresultant code.

Throws if some term of r is divisible by the leading monomial of g.

As the nmod_mpoly_geobucket functions: set swaps p into the geobucket, add and sub add or subtract p, empty returns the sum in p.