ca_poly.h

Returns a pointer to the coefficient of x^i. The index must be less than the length (or the allocation, when writing coefficients before setting the length); this is not checked.

Initialises poly as the zero polynomial, with space for len coefficients for ca_poly_init2.

Clears poly, freeing the coefficients and the coefficient array.

Ensures that poly has at least len initialised coefficients allocated, growing the array to at least twice its size if it must grow. The length is not changed.

Sets the length of poly to len, which must not exceed the allocation. Coefficients beyond the new length are set to zero; nothing is normalised.

Decreases the length of poly while the top coefficient is proved to be zero by ca_check_is_zero.

Swaps poly1 and poly2 in constant time.

Sets poly to the zero polynomial, the constant 1, or the monomial x.

Sets poly to the constant polynomial c (normalised, so the zero polynomial if c is proved zero).

Sets res to the polynomial src.

Sets the coefficient of x^n to x, extending poly with zeros if needed, and normalises.

Sets res, which belongs to the context res_ctx, to the polynomial src belonging to src_ctx, transferring each coefficient with ca_transfer.

Sets res to a symbolic expression Polynomial(List(c_0, ..., c_n)) for A, wrapped in Where(..., Def(a_1, ...), ...) that defines the extension numbers occurring in the coefficients, as for ca_get_fexpr, which also explains flags.

Sets poly to a random polynomial of length up to len whose coefficients are generated by ca_randtest with the parameters depth and bits.

Sets poly to a random polynomial of length up to len with rational coefficients of up to bits bits.

Prints the line ca_poly of length n: followed by the coefficients, from the constant term upwards, one per line with ca_print and indented by four spaces, and a blank line.

Prints decimal approximations of the coefficients with digits significant digits, comma-separated in square brackets, followed by a newline.

Returns 1 if all coefficients of poly are numbers (not special values) and the leading coefficient is proved nonzero, so that poly is an element of \mathbb{C}[x] of known degree; also returns 1 for the zero polynomial. Returns 0 otherwise.

Sets res to poly divided by its leading coefficient and returns 1, or returns 0 if poly is zero or its leading coefficient is not proved nonzero.

Sets res to the reversal x^{n-1} f(1/x) of poly considered as a polynomial of length n, truncating or zero-padding as needed. The underscore version requires 0 < \mathit{len} \le n. Wrappers of _gr_poly_reverse.

Checks whether poly1 and poly2 are equal as polynomials, comparing coefficients with ca_check_equal (and the excess coefficients of the longer one with zero). The underscore version requires \mathit{len1} \ge \mathit{len2}. Wrappers of _gr_poly_equal.

Checks whether poly is the zero polynomial or the constant 1.

Sets res to poly multiplied by x^n, or divided by x^n with the n lowest coefficients discarded. Wrappers of _gr_poly_shift_left and _gr_poly_shift_right.

Sets res to -\mathit{src}.

Sets res to the sum or difference of poly1 and poly2. The underscore versions write \max(\mathit{len1}, \mathit{len2}) coefficients and allow aliasing. Wrappers of _gr_poly_add and _gr_poly_sub.

Sets res to the product of poly1 and poly2, or to the product truncated to length n. The underscore versions require \mathit{lenA} \ge \mathit{lenB} \ge 1 and 0 < n \le \mathit{lenA} + \mathit{lenB} - 1, and write lenA + lenB - 1 or n coefficients.

Multiplies polynomials all of whose coefficients are rational numbers or elements of the number field K = \mathbb{Q}(a) of degree m, by Kronecker substitution: the coefficients are written as polynomials in a over a common denominator, packed into a single polynomial over \mathbb{Z} of length about \mathit{Alen} \cdot (2m - 1), multiplied with _fmpz_poly_mullow and unpacked, followed by reduction modulo the minimal polynomial of a. Requirements as for _ca_poly_mullow.

Sets res to poly multiplied or divided by the scalar c. Division by zero gives special values as coefficients (see _ca_vec_scalar_div_ca).

If the leading coefficient of B is proved nonzero, sets Q and R to the quotient and remainder of the division of A by B, with \deg R < \deg B, and returns 1. Otherwise, in particular if B is zero, returns 0 and leaves the outputs unspecified.

Sets res to poly raised to the power exp, truncated to length len for the trunc versions. Exponents larger than 2 use _gr_poly_pow_series_ui_binexp. The underscore trunc version writes len coefficients and the other one \mathit{exp} (\mathit{flen} - 1) + 1.

Sets res to f(a), by Horner's rule or by the default algorithm of _gr_poly_evaluate, of which these are wrappers.

Sets res to the composition \mathit{poly1}(\mathit{poly2}(x)). Wrappers of _gr_poly_compose; the underscore version writes (\mathit{len1} - 1)(\mathit{len2} - 1) + 1 coefficients.

Sets res to the derivative of poly. The underscore version writes \mathit{len} - 1 coefficients and is a wrapper of _gr_poly_derivative.

Sets res to the integral of poly with constant term zero. The underscore version writes \mathit{len} + 1 coefficients.

Sets G to the monic greatest common divisor of A and B (zero if both are zero) and returns 1. Returns 0, leaving G unspecified, if a zero test of a leading coefficient fails during the computation (in particular if the leading coefficient of an input is not proved nonzero).

Sets res to the power series inverse 1/f \bmod x^{\mathit{len}}. The constant term must be invertible: if it is zero the result consists of special values (unsigned infinity or Undefined), and Unknown values if it cannot be decided whether it is zero. Rational series are inverted over \mathbb{Q}; otherwise the classical recurrence or, for long series with fast multiplication, Newton iteration is used.

Sets res to the power series quotient f/g \bmod x^{\mathit{len}}. As for ca_poly_inv_series, the constant term of g must be nonzero; remove common factors x^k first when an exact cancellation is expected.

Sets res to the power series \exp(f) \bmod x^{\mathit{len}}. The constant term is \exp(f_0) computed with ca_exp. Rational series use _fmpq_poly_exp_series; otherwise the basecase recurrence or Newton iteration is used.

Sets res to the power series \log(f) \bmod x^{\mathit{len}}, computed as \log(f_0) + \int f'/f; the constant term must be nonzero. Binomials a + b x^d are handled directly.

Computes the squarefree factorisation F = c \, f_1^{e_1} \cdots f_k^{e_k}, where the f_i are monic, squarefree, pairwise coprime and nonconstant and e_1 < \cdots < e_k. Sets c to the leading coefficient, fac to the vector of the f_i and the first k entries of exp to the e_i, and returns 1. Returns 0 if F is not proper or if a GCD computation fails. The array exp must have room for \deg F entries.

Sets res to the monic squarefree part f / \gcd(f, f') of poly and returns 1, or returns 0 if a GCD computation fails.

Sets poly to the monic polynomial (x - r_0)^{e_0} \cdots (x - r_{n-1})^{e_{n-1}} with the roots r_i in roots (of length len, or the length of the vector) and the multiplicities e_i in exp. The product is computed by binary splitting. The underscore version writes e_0 + \cdots + e_{n-1} + 1 coefficients.

Attempts to compute all complex roots of poly. On success, returns 1, sets roots to the distinct roots in no particular order and exp to their multiplicities. Returns 0 on failure, leaving the outputs unspecified. See Roots and squarefree factorisation.

Allocates an array of len zero polynomials, or initialises res as a vector of len zero polynomials.

Ensures that vec has space for len polynomials, without changing its length.

Sets the length of vec to len, appending zero polynomials or truncating as needed.

Clears the polynomials and frees the array.

Appends a copy of f to vec.