fmpq_poly.h

Initialises the polynomial for use. The length is set to zero.

Initialises the polynomial with space for at least alloc coefficients and sets the length to zero. The alloc coefficients are all set to zero.

Reallocates the given polynomial to have space for alloc coefficients. If alloc is zero then the polynomial is cleared and then reinitialised. If the current length is greater than alloc then poly is first truncated to length alloc. Note that this might leave the rational polynomial in non-canonical form.

If len is greater than the number of coefficients currently allocated, then the polynomial is reallocated to have space for at least len coefficients, at least doubling the allocation so that many calls in small increments are efficient. No data is lost.

Sets the length of the numerator polynomial to len, demoting coefficients beyond the new length. Note that this method does not guarantee that the rational polynomial is in canonical form.

Clears the given polynomial, releasing any memory used. The polynomial must be reinitialised in order to be used again.

Sets the length of poly so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. Note that this function does not guarantee the coprimality of the numerator polynomial and the integer denominator.

Puts (poly, den) of length len into canonical form.

Puts the polynomial poly into canonical form. Firstly, the length is set to the actual length of the numerator polynomial. For non-zero polynomials, it is then ensured that the numerator and denominator are coprime and that the denominator is positive. The canonical form of the zero polynomial is a zero numerator polynomial and a one denominator.

Returns whether the polynomial is in canonical form.

Returns whether the polynomial is in canonical form.

Returns the degree of poly, which is one less than its length, as a slong.

Returns the length of poly.

Sets res to the numerator of poly, the integer polynomial d \cdot \mathit{poly} where d is the denominator.

Sets den to the denominator of poly.

Sets f to a random polynomial with coefficients up to the given length and where each coefficient has up to the given number of bits. The coefficients are signed randomly. One must call flint_rand_init before calling this function.

Sets f to a random polynomial with coefficients up to the given length and where each coefficient has up to the given number of bits. One must call flint_rand_init before calling this function.

As for fmpq_poly_randtest except that len and bits may not be zero and the polynomial generated is guaranteed not to be the zero polynomial. One must call flint_rand_init before calling this function.

Sets poly1 to equal poly2.

Sets poly to the integer x.

Sets poly to the integer x.

Sets poly to the integer x.

Sets poly to the rational x, which is assumed to be given in lowest terms, which is not checked.

Sets the rational polynomial rop to the same value as the integer polynomial op.

Sets the coefficients of rop to the residues in op, normalised to the interval -m/2 \le r < m/2 where m is the modulus.

Set rop to the reduction of op modulo the modulus m of rop: the numerator coefficients are reduced modulo m and, by fmpq_poly_get_nmod_poly and by fmpq_poly_get_nmod_poly_den with den nonzero, multiplied by the inverse of the denominator modulo m, which must exist (not checked). With den = 0 only the numerator is reduced.

Sets (poly, den) to the polynomial specified by the null-terminated string str of len coefficients. The input format is a sequence of coefficients separated by one space.

Sets poly to the polynomial specified by the null-terminated string str. The input format is the same as the output format of fmpq_poly_get_str: the length given as a decimal integer, then two spaces, then the list of coefficients separated by one space.

Returns the string representation of poly.

Returns the pretty representation of poly, using the null-terminated string var not equal to "\0" as the variable name.

Sets poly to zero.

Sets poly to the constant polynomial 1.

Sets poly1 to the additive inverse of poly2.

Sets poly1 to 1/\mathit{poly2}, which requires poly2 to be a nonzero constant (the only units of \mathbb{Q}[x]); otherwise an exception (FLINT_ERROR) is raised.

Efficiently swaps the polynomials poly1 and poly2.

Truncates poly to length n (if it is longer) and brings the result into canonical form.

Sets res to a copy of poly, truncated to length n.

Sets rop to the sum of the terms of op of degree k with i \le k < j (indices are clamped to [0, \mathrm{len})), in canonical form.

This function considers the polynomial poly to be of length n, notionally truncating and zero padding if required, and reverses the result. Since the function normalises its result res may be of length less than n.

Sets x to the coefficient of x^n in the numerator of poly (zero if n is at least the length). The coefficient of poly itself is x divided by the denominator.

Sets x to the coefficient of x^n in poly, in lowest terms.

Set the coefficient of x^n, n \ge 0, in poly to x, keeping the polynomial canonical (which may change the denominator and the other numerator coefficients).

Returns 1 if poly1 is equal to poly2, otherwise returns 0.

Returns 1 if poly1 and poly2 notionally truncated to length n are equal, otherwise returns 0.

Returns 1 if poly1 and poly2 notionally truncated to length n are equal, otherwise returns 0.

Compares two non-zero polynomials, assuming they have the same length len > 0.

Compares the two polynomials left and right.

Returns 1 if poly is the constant polynomial 1, otherwise returns 0.

Returns 1 if poly is the zero polynomial, otherwise returns 0.

Returns 1 if poly is the degree 1 polynomial x, otherwise returns 0.

Forms the sum (rpoly, rden) of (poly1, den1, len1) and (poly2, den2, len2), placing the result into canonical form.

As per _fmpq_poly_add except that one can specify whether to canonicalise the output or not, for use with weak canonicalisation to prevent explosion in memory usage.

Sets res to the sum of poly1 and poly2, using Henrici's algorithm.

As per fmpq_poly_add except that one can specify whether to canonicalise the output or not, for use with weak canonicalisation to prevent explosion in memory usage.

As per _fmpq_poly_add but the inputs are first notionally truncated to length n. If n is less than len1 or len2 then the output only needs space for n coefficients. We require n \geq 0.

As per _fmpq_poly_add_can but the inputs are first notionally truncated to length n. If n is less than len1 or len2 then the output only needs space for n coefficients. We require n \geq 0.

As per fmpq_poly_add but the inputs are first notionally truncated to length n.

As per fmpq_poly_add_can but the inputs are first notionally truncated to length n.

Forms the difference (rpoly, rden) of (poly1, den1, len1) and (poly2, den2, len2), placing the result into canonical form.

As per _fmpq_poly_sub except that one can specify whether to canonicalise the output or not, for use with weak canonicalisation to prevent explosion in memory usage.

Sets res to the difference of poly1 and poly2, using Henrici's algorithm.

As per _fmpq_poly_sub except that one can specify whether to canonicalise the output or not, for use with weak canonicalisation to prevent explosion in memory usage.

As per _fmpq_poly_sub but the inputs are first notionally truncated to length n. If n is less than len1 or len2 then the output only needs space for n coefficients. We require n \geq 0.

As per _fmpq_poly_sub_can but the inputs are first notionally truncated to length n. If n is less than len1 or len2 then the output only needs space for n coefficients. We require n \geq 0.

As per fmpq_poly_sub but the inputs are first notionally truncated to length n.

As per fmpq_poly_sub_can but the inputs are first notionally truncated to length n.

Set res to \mathit{poly} + c, \mathit{poly} - c or c - \mathit{poly} for a constant c.

Sets (rpoly, rden, len) to the product of c of (poly, den, len).

Sets (rpoly, rden, len) to the product of c of (poly, den, len).

Sets (rpoly, rden, len) to the product of c of (poly, den, len).

Sets (rpoly, rden) to the product of r/s and (poly, den, len), in lowest terms.

Sets rop to c times op.

Sets rop to c times op. Assumes that the fmpz_t c is not part of rop.

Sets (rpoly, rden, len) to (poly, den, len) divided by c, in lowest terms.

Sets (rpoly, rden, len) to (poly, den, len) divided by c, in lowest terms.

Sets (rpoly, rden, len) to (poly, den, len) divided by c, in lowest terms.

Sets (rpoly, rden, len) to (poly, den, len) divided by r/s, in lowest terms.

Sets rop to op divided by the scalar c.

Sets (rpoly, rden, len1 + len2 - 1) to the product of (poly1, den1, len1) and (poly2, den2, len2). If the input is provided in canonical form, then so is the output.

Sets res to the product of poly1 and poly2.

Sets (rpoly, rden, n) to the low n coefficients of (poly1, den1) and (poly2, den2). The output is not guaranteed to be in canonical form.

Sets res to the product of poly1 and poly2, truncated to length n.

Adds the product of op1 and op2 to rop.

Subtracts the product of op1 and op2 from rop.

Sets (rpoly, rden) to (poly, den)^e, assuming e, len > 0. Assumes that rpoly is an array of length at least e * (len - 1) + 1. Supports aliasing of (rpoly, den) and (poly, den).

Sets res to poly^e, where the only special case 0^0 is defined as 1.

Sets (rpoly, rden, len) to (poly, den)^e truncated to length len, where len is at most e * (flen - 1) + 1.

Sets res to poly^e truncated to length n.

Set res to poly shifted left by n coefficients. Zero coefficients are inserted.

Set res to poly shifted right by n coefficients. If n is equal to or greater than the current length of poly, res is set to the zero polynomial.

Finds the quotient (Q, q) and remainder (R, r) of the Euclidean division of (A, a) by (B, b).

Finds the quotient Q and remainder R of the Euclidean division of poly1 by poly2, so that \mathit{poly1} = Q \cdot \mathit{poly2} + R with \deg R < \deg \mathit{poly2}. Q and R must be distinct objects (an exception is raised otherwise), and a zero poly2 raises FLINT_DIVZERO.

Finds the quotient (Q, q) of the Euclidean division of (A, a) by (B, b).

Sets Q to the quotient of the Euclidean division of poly1 by poly2. A zero poly2 raises FLINT_DIVZERO.

Finds the remainder (R, r) of the Euclidean division of (A, a) by (B, b).

Finds the remainder R of the Euclidean division of poly1 by poly2. A zero poly2 raises FLINT_DIVZERO.

Computes 2*len - 1 powers of x modulo the polynomial B of the given length. This is used as a kind of precomputed inverse in the remainder routine below.

Computes the powers x^i \bmod B, 0 \le i < 2n - 1, for the polynomial B = poly of length n \ge 1 (a zero poly raises FLINT_DIVZERO).

Clean up resources used by precomputed powers which have been computed by _fmpq_poly_powers_precompute.

Clean up resources used by precomputed powers which have been computed by fmpq_poly_powers_precompute.

Set A to the remainder of A divide B given precomputed powers mod B provided by _fmpq_poly_powers_precompute. No aliasing is allowed.

Set R to the remainder of A divide B given precomputed powers mod B provided by fmpq_poly_powers_precompute.

Return 1 if (poly2, den2, len2) divides (poly1, den1, len1) and set (qpoly, qden, len1 - len2 + 1) to the quotient. Otherwise return 0. Requires that qpoly has space for len1 - len2 + 1 coefficients and that len1 >= len2 > 0.

Return 1 if poly2 divides poly1 and set q to the quotient. Otherwise return 0.

Sets q to the quotient of poly1 by the highest power of poly2 which divides it, and returns the power. The divisor poly2 must not be constant or an exception is raised.

Computes the first n terms of the inverse power series of (poly, den, len) using Newton iteration.

Computes the first n terms of the inverse power series of poly using Newton iteration, for n \ge 1. A zero constant term raises FLINT_DIVZERO.

Computes the first n terms of the inverse power series of (poly, den, len).

Computes the first n terms of the inverse power series of poly, for n \ge 1. This is currently the same as fmpq_poly_inv_series_newton; a zero constant term raises FLINT_DIVZERO.

Divides (A, denA, lenA) by (B, denB, lenB) as power series over \mathbb{Q}, assuming B has non-zero constant term and that all lengths are positive. The constant term is not checked.

Performs power series division in \mathbb{Q}[[x]] / (x^n). The function considers the polynomials A and B as power series of length n starting with the constant terms. Requires n \ge 1; a zero B raises FLINT_DIVZERO, and B must have a nonzero constant term (not checked).

Computes the monic greatest common divisor G of A and B.

Computes the monic greatest common divisor G of A and B.

Computes polynomials G, S, and T such that G = \gcd(A, B) = S A + T B, where G is the monic greatest common divisor of A and B.

Computes polynomials G, S, and T such that G = \gcd(A, B) = S A + T B, where G is the monic greatest common divisor of A and B.

Computes the monic least common multiple L of A and B.

Computes the monic least common multiple L of A and B.

Sets (rnum, rden) to the resultant of the two input polynomials.

Returns the resultant of f and g.

Set the output to the resultant of f and g divided by divisor, assuming that this quotient is an integer of at most nbits bits. The resultant of the numerators is then computed by a multimodular algorithm that needs only enough primes for nbits bits, which is much faster than fmpq_poly_resultant when a good bound is known (for example when computing norms in number fields). A zero divisor gives zero. The underscore version requires \mathit{len1} \ge \mathit{len2} > 0.

Set res to the discriminant of (poly, den, len). Assumes len > 1.

Set res to the discriminant of poly, normalised so that \operatorname{disc}(f) = (-1)^{n(n-1)/2} \operatorname{res}(f, f')/\operatorname{lc}(f), and thus \operatorname{disc}(f) = \operatorname{lc}(f)^{2n - 2} \prod_{i < j} (r_i - r_j)^2, where n is the degree of f and the r_i are its roots. It is computed as the discriminant of the numerator (_fmpz_poly_discriminant) divided by d^{2n-2}, d being the denominator. Polynomials of degree less than 1 have discriminant zero.

Sets (rpoly, rden, len - 1) to the derivative of (poly, den, len). Does nothing if len <= 1. Supports aliasing between the two polynomials.

Sets res to the derivative of poly.

Sets (rpoly, rden, len - n) to the nth derivative of (poly, den, len). Does nothing if len <= n. Supports aliasing between the two polynomials.

Sets res to the nth derivative of poly.

Sets (rpoly, rden, len) to the integral of (poly, den, len - 1). Assumes len >= 0. Supports aliasing between the two polynomials. The output will be in canonical form if the input is in canonical form.

Sets res to the integral of poly. The constant term is set to zero.

Sets (rpoly, rden, len) to the offset integral of (poly, den, len1) mapping c_k to c_k / (k + m). Assumes len >= 0. Supports aliasing between the two polynomials. The output will be in canonical form if the input is in canonical form.

Sets (g, gden, n) to the series expansion of the square root of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 1. Does not support aliasing between the input and output polynomials.

Sets res to the series expansion of the square root of f to order n > 1. Requires f to have constant term 1.

Sets (g, gden, n) to the series expansion of the inverse square root of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 1. Does not support aliasing between the input and output polynomials.

Sets res to the series expansion of the inverse square root of f to order n > 0. Requires f to have constant term 1.

Compute the (truncated) power sums series of the polynomial (poly,len) up to length n using Newton identities.

Compute the (truncated) power sum series of the monic polynomial poly up to length n using Newton identities. That is the power series whose coefficient of degree i is the sum of the i-th power of all (complex) roots of the polynomial poly.

Compute an integer polynomial given by its power sums series (poly,den,len).

Compute the integer polynomial with content one and positive leading coefficient given by its power sums series Q.

Compute the monic polynomial from its power sums series Q.

Sets (g, gden, n) to the series expansion of the logarithm of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 1. Supports aliasing between the input and output polynomials.

Sets res to the series expansion of the logarithm of f to order n > 0. Requires f to have constant term 1.

Sets (g, gden, n) to the series expansion of the exponential function of (h, hden, hlen). Assumes n > 0, hlen > 0 and that (h, hden, hlen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res to the series expansion of the exponential function of h to order n > 0. Requires h to have constant term 0.

The same as fmpq_poly_exp_series, but simultaneously computes the exponential (in res1, res1den) and its multiplicative inverse (in res2, res2den). Supports aliasing between the input and output polynomials.

The same as fmpq_poly_exp_series, but simultaneously computes the exponential (in res1) and its multiplicative inverse (in res2).

Sets (g, gden, n) to the series expansion of the inverse tangent of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res to the series expansion of the inverse tangent of f to order n > 0. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the inverse hyperbolic tangent of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res to the series expansion of the inverse hyperbolic tangent of f to order n > 0. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the inverse sine of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res to the series expansion of the inverse sine of f to order n > 0. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the inverse hyperbolic sine of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res to the series expansion of the inverse hyperbolic sine of f to order n > 0. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the tangent function of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Does not support aliasing between the input and output polynomials.

Sets res to the series expansion of the tangent function of f to order n > 0. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the sine of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res to the series expansion of the sine of f to order n > 0. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the cosine of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res to the series expansion of the cosine of f to order n > 0. Requires f to have constant term 0.

Sets (s, sden, n) to the series expansion of the sine of (f, fden, flen), and (c, cden, n) to the series expansion of the cosine. Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res1 to the series expansion of the sine of f to order n > 0, and res2 to the series expansion of the cosine. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the hyperbolic sine of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Does not support aliasing between the input and output polynomials.

Sets res to the series expansion of the hyperbolic sine of f to order n > 0. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the hyperbolic cosine of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Does not support aliasing between the input and output polynomials.

Sets res to the series expansion of the hyperbolic cosine of f to order n > 0. Requires f to have constant term 0.

Sets (s, sden, n) to the series expansion of the hyperbolic sine of (f, fden, flen), and (c, cden, n) to the series expansion of the hyperbolic cosine. Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.

Sets res1 to the series expansion of the hyperbolic sine of f to order n > 0, and res2 to the series expansion of the hyperbolic cosine. Requires f to have constant term 0.

Sets (g, gden, n) to the series expansion of the hyperbolic tangent of (f, fden, flen). Assumes n > 0 and that (f, fden, flen) has constant term 0. Does not support aliasing between the input and output polynomials.

Sets res to the series expansion of the hyperbolic tangent of f to order n > 0. Requires f to have constant term 0.

Alternative algorithms implementing _fmpq_poly_sin_cos_series.

Sets coeffs to the coefficient array of the Legendre polynomial P_n(x), defined by (n+1) P_{n+1}(x) = (2n+1) x P_n(x) - n P_{n-1}(x), for n\ge0. Sets den to the overall denominator. The coefficients are calculated using a hypergeometric recurrence in integer arithmetic. The length of the array will be n+1. The denominator is given by \gcd(n!,2^n) = 2^{\lfloor n/2 \rfloor + \lfloor n/4 \rfloor + \ldots}. See fmpz_poly for the shifted Legendre polynomials.

Sets poly to the Legendre polynomial P_n(x), defined by (n+1) P_{n+1}(x) = (2n+1) x P_n(x) - n P_{n-1}(x), for n\ge0. The coefficients are calculated using a hypergeometric recurrence in integer arithmetic. The denominator is given by \gcd(n!,2^n) = 2^{\lfloor n/2 \rfloor + \lfloor n/4 \rfloor + \ldots}. See fmpz_poly for the shifted Legendre polynomials.

Sets coeffs to the coefficient array of the Laguerre polynomial L_n(x), defined by (n+1) L_{n+1}(x) = (2n+1-x) L_n(x) - n L_{n-1}(x), for n\ge0. Sets den to the overall denominator. The coefficients are calculated using a hypergeometric recurrence. The length of the array will be n+1.

Sets poly to the Laguerre polynomial L_n(x), defined by (n+1) L_{n+1}(x) = (2n+1-x) L_n(x) - n L_{n-1}(x), for n\ge0. The coefficients are calculated using a hypergeometric recurrence.

Sets coeffs to the coefficient array of the Gegenbauer (ultraspherical) polynomial C^{(\alpha)}_n(x) = \frac{(2\alpha)_n}{n!}\,{}_2F_1\left(-n,2\alpha+n; \alpha+\frac12;\frac{1-x}{2}\right), for integer n\ge0 and rational \alpha>0. Sets den to the overall denominator. The coefficients are calculated using a hypergeometric recurrence.

Sets poly to the Gegenbauer (ultraspherical) polynomial C^{(\alpha)}_n(x) = \frac{(2\alpha)_n}{n!}\,{}_2F_1\left(-n,2\alpha+n; \alpha+\frac12;\frac{1-x}{2}\right), for integer n\ge0 and rational \alpha>0. The coefficients are calculated using a hypergeometric recurrence.

Evaluates the polynomial (poly, den, len) at the integer a and sets (rnum, rden) to the result in lowest terms.

Evaluates the polynomial poly at the integer a and sets res to the result.

Evaluates the polynomial (poly, den, len) at the rational (anum, aden) and sets (rnum, rden) to the result in lowest terms. Aliasing between (rnum, rden) and (anum, aden) is not supported.

Evaluates the polynomial poly at the rational a and sets res to the result.

Fast polynomial interpolation using a subproduct tree assuming the evaluation points x_i are distinct. The precomp version requires a precomputed subproduct tree generated using _fmpz_poly_tree_build_fmpq_vec and precomputed interpolation weights generated using _fmpq_poly_interpolation_weights.

Sets poly (or poly / den) to the unique interpolating polynomial of degree at most n - 1 satisfying f(x_i) = y_i for every pair x_i, y_i in xs and ys.

Sets (res, den) to the composition of (poly1, den1, len1) and (poly2, den2, len2), assuming len1, len2 > 0.

Sets res to the composition of poly1 and poly2.

Sets (res, denr, len) to (poly, den, len) with the indeterminate rescaled by (anum, aden).

Sets res to poly with the indeterminate rescaled by a.

Compose with an automatic choice of algorithm: if poly2 has integer coefficients, the composition is computed over \mathbb{Z} with _fmpz_poly_compose_series; otherwise Horner's rule is used for \min(\mathit{len1}, n) < 8, the Brent–Kung algorithm for n < 250 and the Kinoshita–Li algorithm above.

Compose by Horner's rule, with \mathit{len1} - 1 truncated multiplications.

Compose by the baby-step giant-step algorithm 2.1 of Brent and Kung [BrentKung1978], with about 2\sqrt{n} truncated multiplications and a matrix product over \mathbb{Z}.

Compose by the algorithm of Kinoshita and Li [KL2024], which uses O(M(n) \log n) operations on bivariate polynomials. The underscore version does not need the condition on (\mathit{len1} - 1)(\mathit{len2} - 1) + 1.

Revert with an automatic choice of algorithm: if poly has integer coefficients and the coefficient of x is \pm 1, the reversion is computed over \mathbb{Z} with _fmpz_poly_revert_series; otherwise the fast Lagrange inversion is used for n < 20 and Newton iteration above.

Revert by the Lagrange inversion formula, [x^k] g = \frac1k [x^{k-1}] (x/\mathit{poly})^k, computing the powers one after the other (O(n M(n)) operations).

Revert by the Lagrange inversion formula with a baby-step giant-step evaluation of the needed coefficients of the powers, in O(\sqrt{n} M(n)) operations.

Revert by Newton iteration on \mathit{poly}(g) - x = 0, doubling the precision in each step, with one power series composition and one inversion per step.

Sets res to the content of (poly, den, len). If len == 0, sets res to zero.

Sets res to the content of poly. The content of the zero polynomial is defined to be zero.

Sets (rpoly, rden, len) to the primitive part, with non-negative leading coefficient, of (poly, den, len). Assumes that len > 0. Supports aliasing between the two polynomials.

Sets res to the primitive part, with non-negative leading coefficient, of poly.

Returns whether the polynomial (poly, den, len) is monic. The zero polynomial is not monic by definition.

Returns whether the polynomial poly is monic. The zero polynomial is not monic by definition.

Sets (rpoly, rden, len) to the monic scalar multiple of (poly, den, len). Assumes that len > 0. Supports aliasing between the two polynomials.

Sets res to the monic scalar multiple of poly whenever poly is non-zero. If poly is the zero polynomial, sets res to zero.

Returns whether the polynomial poly is square-free. A non-zero polynomial is defined to be square-free if it has no non-unit square factors. We also define the zero polynomial to be square-free.

Prints the polynomial (poly, den, len) to stdout.

Prints the polynomial to stdout.

Prints the pretty representation of (poly, den, len) to standard output, with variable name x.

Prints the pretty representation of poly to stdout, using the null-terminated string var not equal to "\0" as the variable name.

Prints the polynomial (poly, den, len) to the stream file.

Prints the polynomial to the stream file.

Prints the pretty representation of (poly, den, len) to file, with variable name x.

Prints the pretty representation of poly to file, using the null-terminated string var not equal to "\0" as the variable name.

Reads a polynomial from stdin, storing the result in poly.

Reads a polynomial from the stream file, storing the result in poly.

Prints the internal representation of poly (allocation, length, all allocated numerator coefficients and the denominator) to standard output, for debugging. Returns 1.