gr_mpoly.h

Initialises ctx as the ring of polynomials in nvars variables over base_ring, with the monomial ordering ord (ORD_LEX, ORD_DEGLEX or ORD_DEGREVLEX).

Initialises ctx with a random number of variables between 0 and max_nvars and a random ordering, for testing.

Clears the context (but not the coefficient ring).

Sets the names of the n generators to copies of the strings s[0], …, s[n-1].

Context methods: a description of the ring, and structural predicates inherited from the coefficient ring. The polynomial ring is a field only if it has no variables and the coefficient ring is a field.

Initialise A as the zero polynomial; init2 and init3 allocate space for alloc terms, with the default number of bits per exponent or with bits bits.

Clears A.

Ensure space for len terms, or exponent fields of at least bits bits (repacking the existing exponents), or both. The reset_bits version sets the number of bits to bits without preserving the exponents, for use before writing a new polynomial.

Grows the arrays *coeffs and *exps (with N words per exponent vector) to hold at least length terms, updating the allocation counters. Here cctx is the coefficient ring.

Set the number of terms of A (which must be allocated), without normalising, and return the number of terms.

Removes the terms whose coefficient is provably zero. All functions return normalised polynomials; this is for code that writes terms directly.

Swap two polynomials in constant time, and make res a shallow copy of poly sharing its arrays (which must then not be cleared twice).

Initialise vec as len zero polynomials, and clear it.

Return a pointer to the entry with index 0 \le i < length, and the length.

Allocate space for len entries, change the length (appending zero polynomials), copy a vector, and append a copy of f.

Set A to a copy of B, to zero or to one.

Set A to the constant polynomial c.

Converts the element A of the ring A_ctx into the polynomial ring.

Set A to the generator with index var (from 0), res to the vector of the generators X_1, \ldots, X_n, or vec to the generators of the coefficient ring (recursively, as constants) followed by X_1, \ldots, X_n.

Return whether A is zero, one, the generator with index var, or equal to B, comparing terms and deciding coefficients in the coefficient ring.

Set A to a random polynomial with up to length terms, with exponents of up to exp_bits bits or less than exp_bound, and random coefficients (gr_randtest). The default version, used for gr_randtest, chooses small random parameters.

Write the polynomial as an expression in the generator names of the context, with the terms in decreasing order; gr_mpoly_write is the same as gr_mpoly_write_pretty. Polynomials can be parsed with gr_set_str.

Set c to the coefficient of the monomial with exponent vector exp (zero if there is no such term).

Set the coefficient of the monomial with exponent vector exp (given as fmpz or ulong entries) to c, inserting or removing the term as needed. Each call costs time linear in the number of terms; to build a polynomial term by term, use the push functions below.

Append a term with exponent vector exp at the end of A, increasing the number of bits per exponent if necessary; the underscore versions append only the monomial and leave the new coefficient for the caller to set. The result is in general not sorted and may contain repeated monomials or zero coefficients: call gr_mpoly_sort_terms and gr_mpoly_combine_like_terms afterwards.

Sort the terms of A by the monomial ordering, and add the coefficients of terms with equal monomials, removing provably zero terms; the second assumes sorted terms.

Check that A is in canonical form: terms strictly sorted, exponents fitting in the bit size, and no provably zero coefficients. gr_mpoly_assert_canonical aborts with an error message otherwise.

Set A to -B, B + C or B - C, by merging the sorted term lists.

Set A to B c for a scalar c (removing terms that become zero).

Set A to the product BC. The heap version uses Johnson's algorithm, which merges the |B| sorted rows b_i C with a heap of size |B|, with O(|B| |C| \log |B|) monomial comparisons and memory proportional to the output; the heap_threaded version divides the output among threads. The monomial version requires C to have one term.

Set poly1 to the square of poly2. The commutative versions require a commutative (or approximately commutative) coefficient ring and compute only the products b_i b_j with i \le j, doubling the off-diagonal ones; the default uses them (threaded above 100 terms) and the monomial version for a single term.

Checked exact division. If B divides A, set Q = A / B and return GR_SUCCESS; if not, set Q to zero and return GR_DOMAIN; if divisibility cannot be decided, return GR_UNABLE. Division by zero gives GR_DOMAIN (except in the zero ring).

Set Q = A / B, assuming without checking that B divides A, which saves the divisibility checks. The default is threaded under the same conditions as gr_mpoly_divides.

Multivariate division with remainder: A = QB + R where no monomial of R is divisible by the leading monomial of B. The div versions return only Q. Over a field this always works; over other rings it works whenever each division by the leading coefficient of B that occurs is exact, and returns GR_DOMAIN (with Q and R set to zero) otherwise. The defaults use the threaded algorithm for |A| > 500, |B| > 2 and a thread-safe ring when threads are available.

Weak division with remainder over rings that are not fields: when a coefficient division by the leading coefficient of B is not exact, the coefficients are divided with remainder (gr_euclidean_divrem in the coefficient ring, the analogue of fmpz_fdiv_qr over \mathbb{Z}) and the remainder is kept, instead of failing. The result satisfies A = QB + R, but monomials of R may still be divisible by the leading monomial of B.

Division by a vector of divisors B_1, \ldots, B_k: A = \sum_i Q_i B_i + R, where no monomial of R is divisible by any leading monomial \operatorname{lm}(B_i) (the multivariate division algorithm, [CLO2015, §2.3]); the result depends on the order of the divisors unless they form a Gröbner basis. The weak versions accumulate inexact coefficient remainders as for gr_mpoly_divrem_weak. The output vector Q is resized to k entries.

Pseudo-division: compute a scalar scale (an element of the coefficient ring, a product of powers of leading coefficients of the divisors) with \mathit{scale} \cdot A = QB + R, respectively \mathit{scale} \cdot A = \sum_i Q_i B_i + R, and no monomial of R divisible by a leading monomial of the divisors. This divides over the fraction field of an integral domain without leaving the ring.

Sets res to the inverse of poly if it is a constant with an invertible coefficient. Returns GR_DOMAIN if poly is zero (outside the zero ring) or, over an integral domain, nonconstant; returns GR_UNABLE if invertibility cannot be decided (over rings with nilpotents a nonconstant polynomial can be a unit).

Sets res to the canonical associate of poly: poly multiplied by the unit c that makes its leading coefficient canonical in the coefficient ring (gr_canonical_associate: monic over a field, positive over \mathbb{Z}). If u is not NULL it is set to c, so that \mathit{res} = u \cdot \mathit{poly}.

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

Sets A to the integral of B with respect to the variable with index var, with zero constant of integration; this divides coefficients by the new exponents (gr_div_ui), which must be possible in the coefficient ring.