[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
14.1 Introduction to Polynomials | ||
14.2 Functions and Variables for Polynomials |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Polynomials are stored in Maxima either in General Form or as Canonical Rational Expressions (CRE) form. The latter is a standard form, and is used internally by operations such as factor, ratsimp, and so on.
Canonical Rational Expressions constitute a kind of representation
which is especially suitable for expanded polynomials and rational
functions (as well as for partially factored polynomials and rational
functions when RATFAC is set to true
). In this CRE form an
ordering of variables (from most to least main) is assumed for each
expression. Polynomials are represented recursively by a list
consisting of the main variable followed by a series of pairs of
expressions, one for each term of the polynomial. The first member of
each pair is the exponent of the main variable in that term and the
second member is the coefficient of that term which could be a number or
a polynomial in another variable again represented in this form. Thus
the principal part of the CRE form of 3*X^2-1 is (X 2 3 0 -1) and that
of 2*X*Y+X-3 is (Y 1 (X 1 2) 0 (X 1 1 0 -3)) assuming Y is the main
variable, and is (X 1 (Y 1 2 0 1) 0 -3) assuming X is the main
variable. "Main"-ness is usually determined by reverse alphabetical
order. The "variables" of a CRE expression needn't be atomic. In fact
any subexpression whose main operator is not + - * / or ^ with integer
power will be considered a "variable" of the expression (in CRE form) in
which it occurs. For example the CRE variables of the expression
X+SIN(X+1)+2*SQRT(X)+1 are X, SQRT(X), and SIN(X+1). If the user does
not specify an ordering of variables by using the RATVARS function
Maxima will choose an alphabetic one. In general, CRE's represent
rational expressions, that is, ratios of polynomials, where the
numerator and denominator have no common factors, and the denominator is
positive. The internal form is essentially a pair of polynomials (the
numerator and denominator) preceded by the variable ordering list. If
an expression to be displayed is in CRE form or if it contains any
subexpressions in CRE form, the symbol /R/ will follow the line label.
See the RAT function for converting an expression to CRE form. An
extended CRE form is used for the representation of Taylor series. The
notion of a rational expression is extended so that the exponents of the
variables can be positive or negative rational numbers rather than just
positive integers and the coefficients can themselves be rational
expressions as described above rather than just polynomials. These are
represented internally by a recursive polynomial form which is similar
to and is a generalization of CRE form, but carries additional
information such as the degree of truncation. As with CRE form, the
symbol /T/ follows the line label of such expressions.
Categories: Polynomials · Rational expressions
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Default value: false
algebraic
must be set to true
in order for the simplification of
algebraic integers to take effect.
Categories: Simplification flags and variables
Default value: true
When berlefact
is false
then the Kronecker factoring
algorithm will be used otherwise the Berlekamp algorithm, which is the
default, will be used.
Categories: Polynomials
an alternative to the resultant
command. It
returns a matrix. determinant
of this matrix is the desired resultant.
Examples:
(%i1) bezout(a*x+b, c*x^2+d, x); [ b c - a d ] (%o1) [ ] [ a b ] (%i2) determinant(%); 2 2 (%o2) a d + b c (%i3) resultant(a*x+b, c*x^2+d, x); 2 2 (%o3) a d + b c
Categories: Polynomials
Returns a list whose first member is the coefficient of x in expr
(as found by ratcoef
if expr is in CRE form
otherwise by coeff
) and whose second member is the remaining part of
expr. That is, [A, B]
where expr = A*x + B
.
Example:
(%i1) islinear (expr, x) := block ([c], c: bothcoef (rat (expr, x), x), is (freeof (x, c) and c[1] # 0))$ (%i2) islinear ((r^2 - (x - r)^2)/x, x); (%o2) true
Categories: Polynomials
Returns the coefficient of x^n
in expr,
where expr is a polynomial or a monomial term in x.
coeff(expr, x^n)
is equivalent
to coeff(expr, x, n)
.
coeff(expr, x, 0)
returns the remainder of expr
which is free of x.
If omitted, n is assumed to be 1.
x may be a simple variable or a subscripted variable, or a subexpression of expr which comprises an operator and all of its arguments.
It may be possible to compute coefficients of expressions which are equivalent
to expr by applying expand
or factor
. coeff
itself
does not apply expand
or factor
or any other function.
coeff
distributes over lists, matrices, and equations.
Examples:
coeff
returns the coefficient x^n
in expr.
(%i1) coeff (b^3*a^3 + b^2*a^2 + b*a + 1, a^3); 3 (%o1) b
coeff(expr, x^n)
is equivalent
to coeff(expr, x, n)
.
(%i1) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z, 3); (%o1) - c 3 (%i2) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z^3); (%o2) - c 3
coeff(expr, x, 0)
returns the remainder of expr
which is free of x.
(%i1) coeff (a*u + b^2*u^2 + c^3*u^3, b, 0); 3 3 (%o1) c u + a u
x may be a simple variable or a subscripted variable, or a subexpression of expr which comprises an operator and all of its arguments.
(%i1) coeff (h^4 - 2*%pi*h^2 + 1, h, 2); (%o1) - 2 %pi (%i2) coeff (v[1]^4 - 2*%pi*v[1]^2 + 1, v[1], 2); (%o2) - 2 %pi (%i3) coeff (sin(1+x)*sin(x) + sin(1+x)^3*sin(x)^3, sin(1+x)^3); 3 (%o3) sin (x) (%i4) coeff ((d - a)^2*(b + c)^3 + (a + b)^4*(c - d), a + b, 4); (%o4) c - d
coeff
itself does not apply expand
or factor
or any other
function.
(%i1) coeff (c*(a + b)^3, a); (%o1) 0 (%i2) expand (c*(a + b)^3); 3 2 2 3 (%o2) b c + 3 a b c + 3 a b c + a c (%i3) coeff (%, a); 2 (%o3) 3 b c (%i4) coeff (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c, (a + b)^3); (%o4) 0 (%i5) factor (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c); 3 (%o5) (b + a) c (%i6) coeff (%, (a + b)^3); (%o6) c
coeff
distributes over lists, matrices, and equations.
(%i1) coeff ([4*a, -3*a, 2*a], a); (%o1) [4, - 3, 2] (%i2) coeff (matrix ([a*x, b*x], [-c*x, -d*x]), x); [ a b ] (%o2) [ ] [ - c - d ] (%i3) coeff (a*u - b*v = 7*u + 3*v, u); (%o3) a = 7
Categories: Polynomials
Returns a list whose first element is the greatest common divisor of the coefficients of the terms of the polynomial p_1 in the variable x_n (this is the content) and whose second element is the polynomial p_1 divided by the content.
Examples:
(%i1) content (2*x*y + 4*x^2*y^2, y); 2 (%o1) [2 x, 2 x y + y]
Categories: Polynomials
Returns the denominator of the rational expression expr.
Categories: Expressions
computes the quotient and remainder
of the polynomial p_1 divided by the polynomial p_2, in a main
polynomial variable, x_n.
The other variables are as in the ratvars
function.
The result is a list whose first element is the quotient
and whose second element is the remainder.
Examples:
(%i1) divide (x + y, x - y, x); (%o1) [1, 2 y] (%i2) divide (x + y, x - y); (%o2) [- 1, 2 x]
Note that y
is the main variable in the second example.
Categories: Polynomials
Eliminates variables from equations (or expressions assumed equal to zero) by
taking successive resultants. This returns a list of n - k
expressions with the k variables x_1, …, x_k eliminated.
First x_1 is eliminated yielding n - 1
expressions, then
x_2
is eliminated, etc. If k = n
then a single
expression in a list is returned free of the variables x_1, …,
x_k. In this case solve
is called to solve the last resultant for
the last variable.
Example:
(%i1) expr1: 2*x^2 + y*x + z; 2 (%o1) z + x y + 2 x (%i2) expr2: 3*x + 5*y - z - 1; (%o2) - z + 5 y + 3 x - 1 (%i3) expr3: z^2 + x - y^2 + 5; 2 2 (%o3) z - y + x + 5 (%i4) eliminate ([expr3, expr2, expr1], [y, z]); 8 7 6 5 4 (%o4) [7425 x - 1170 x + 1299 x + 12076 x + 22887 x 3 2 - 5154 x - 1291 x + 7688 x + 15376]
Categories: Polynomials · Algebraic equations
Returns a list whose first element is the greatest common divisor of the
polynomials p_1, p_2, p_3, … and whose remaining
elements are the polynomials divided by the greatest common divisor. This
always uses the ezgcd
algorithm.
See also gcd
, gcdex
, gcdivide
, and
poly_gcd
.
Examples:
The three polynomials have the greatest common divisor 2*x-3
. The
gcd is first calculated with the function gcd
and then with the function
ezgcd
.
(%i1) p1 : 6*x^3-17*x^2+14*x-3; 3 2 (%o1) 6 x - 17 x + 14 x - 3 (%i2) p2 : 4*x^4-14*x^3+12*x^2+2*x-3; 4 3 2 (%o2) 4 x - 14 x + 12 x + 2 x - 3 (%i3) p3 : -8*x^3+14*x^2-x-3; 3 2 (%o3) - 8 x + 14 x - x - 3 (%i4) gcd(p1, gcd(p2, p3)); (%o4) 2 x - 3 (%i5) ezgcd(p1, p2, p3); 2 3 2 2 (%o5) [2 x - 3, 3 x - 4 x + 1, 2 x - 4 x + 1, - 4 x + x + 1]
Categories: Polynomials
Default value: true
facexpand
controls whether the irreducible factors returned by
factor
are in expanded (the default) or recursive (normal CRE) form.
Categories: Polynomials
Factors the expression expr, containing any number of variables or
functions, into factors irreducible over the integers.
factor (expr, p)
factors expr over the field of
rationals with an element adjoined whose minimum polynomial is p.
factor
uses ifactors
function for factoring integers.
factorflag
if false
suppresses the factoring of integer factors
of rational expressions.
dontfactor
may be set to a list of variables with respect to which
factoring is not to occur. (It is initially empty). Factoring also
will not take place with respect to any variables which are less
important (using the variable ordering assumed for CRE form) than
those on the dontfactor
list.
savefactors
if true
causes the factors of an expression which
is a product of factors to be saved by certain functions in order to
speed up later factorizations of expressions containing some of the
same factors.
berlefact
if false
then the Kronecker factoring algorithm will
be used otherwise the Berlekamp algorithm, which is the default, will
be used.
intfaclim
if true
maxima will give up factorization of
integers if no factor is found after trial divisions and Pollard's rho
method. If set to false
(this is the case when the user calls
factor
explicitly), complete factorization of the integer will be
attempted. The user's setting of intfaclim
is used for internal
calls to factor
. Thus, intfaclim
may be reset to prevent
Maxima from taking an inordinately long time factoring large integers.
Examples:
(%i1) factor (2^63 - 1); 2 (%o1) 7 73 127 337 92737 649657 (%i2) factor (-8*y - 4*x + z^2*(2*y + x)); (%o2) (2 y + x) (z - 2) (z + 2) (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2; 2 2 2 2 2 (%o3) x y + 2 x y + y - x - 2 x - 1 (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2))); 2 (x + 2 x + 1) (y - 1) (%o4) ---------------------- 36 (y + 1) (%i5) factor (1 + %e^(3*x)); x 2 x x (%o5) (%e + 1) (%e - %e + 1) (%i6) factor (1 + x^4, a^2 - 2); 2 2 (%o6) (x - a x + 1) (x + a x + 1) (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3); 2 (%o7) - (y + x) (z - x) (z + x) (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2; x + 2 (%o8) ------------------------ 2 (x + 3) (x + b) (x + c) (%i9) ratsimp (%); 4 3 (%o9) (x + 2)/(x + (2 c + b + 3) x 2 2 2 2 + (c + (2 b + 6) c + 3 b) x + ((b + 3) c + 6 b c) x + 3 b c ) (%i10) partfrac (%, x); 2 4 3 (%o10) - (c - 4 c - b + 6)/((c + (- 2 b - 6) c 2 2 2 2 + (b + 12 b + 9) c + (- 6 b - 18 b) c + 9 b ) (x + c)) c - 2 - --------------------------------- 2 2 (c + (- b - 3) c + 3 b) (x + c) b - 2 + ------------------------------------------------- 2 2 3 2 ((b - 3) c + (6 b - 2 b ) c + b - 3 b ) (x + b) 1 - ---------------------------------------------- 2 ((b - 3) c + (18 - 6 b) c + 9 b - 27) (x + 3) (%i11) map ('factor, %); 2 c - 4 c - b + 6 c - 2 (%o11) - ------------------------- - ------------------------ 2 2 2 (c - 3) (c - b) (x + c) (c - 3) (c - b) (x + c) b - 2 1 + ------------------------ - ------------------------ 2 2 (b - 3) (c - b) (x + b) (b - 3) (c - 3) (x + 3) (%i12) ratsimp ((x^5 - 1)/(x - 1)); 4 3 2 (%o12) x + x + x + x + 1 (%i13) subst (a, x, %); 4 3 2 (%o13) a + a + a + a + 1 (%i14) factor (%th(2), %); 2 3 3 2 (%o14) (x - a) (x - a ) (x - a ) (x + a + a + a + 1) (%i15) factor (1 + x^12); 4 8 4 (%o15) (x + 1) (x - x + 1) (%i16) factor (1 + x^99); 2 6 3 (%o16) (x + 1) (x - x + 1) (x - x + 1) 10 9 8 7 6 5 4 3 2 (x - x + x - x + x - x + x - x + x - x + 1) 20 19 17 16 14 13 11 10 9 7 6 (x + x - x - x + x + x - x - x - x + x + x 4 3 60 57 51 48 42 39 33 - x - x + x + 1) (x + x - x - x + x + x - x 30 27 21 18 12 9 3 - x - x + x + x - x - x + x + 1)
Categories: Polynomials
Default value: false
When factorflag
is false
, suppresses the factoring of
integer factors of rational expressions.
Categories: Polynomials
Rearranges the sum expr into a sum of terms of the form
f (x_1, x_2, …)*g
where g
is a product of
expressions not containing any x_i and f
is factored.
Note that the option variable keepfloat
is ignored by factorout
.
Example:
(%i1) expand (a*(x+1)*(x-1)*(u+1)^2); 2 2 2 2 2 (%o1) a u x + 2 a u x + a x - a u - 2 a u - a (%i2) factorout(%,x); 2 (%o2) a u (x - 1) (x + 1) + 2 a u (x - 1) (x + 1) + a (x - 1) (x + 1)
Categories: Expressions
Tries to group terms in factors of expr which are sums into groups of
terms such that their sum is factorable. factorsum
can recover the
result of expand ((x + y)^2 + (z + w)^2)
but it can't recover
expand ((x + 1)^2 + (x + y)^2)
because the terms have variables in
common.
Example:
(%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2)); 2 2 2 2 (%o1) a x z + a z + 2 a w x z + 2 a w z + a w x + v x 2 2 2 2 + 2 u v x + u x + a w + v + 2 u v + u (%i2) factorsum (%); 2 2 (%o2) (x + 1) (a (z + w) + (v + u) )
Categories: Expressions
Returns the product of the polynomials p_1 and p_2 by using a
special algorithm for multiplication of polynomials. p_1
and p_2
should be multivariate, dense, and nearly the same size. Classical
multiplication is of order n_1 n_2
where
n_1
is the degree of p_1
and n_2
is the degree of p_2
.
fasttimes
is of order max (n_1, n_2)^1.585
.
Categories: Polynomials
fullratsimp
repeatedly
applies ratsimp
followed by non-rational simplification to an
expression until no further change occurs,
and returns the result.
When non-rational expressions are involved, one call
to ratsimp
followed as is usual by non-rational ("general")
simplification may not be sufficient to return a simplified result.
Sometimes, more than one such call may be necessary.
fullratsimp
makes this process convenient.
fullratsimp (expr, x_1, ..., x_n)
takes one or more
arguments similar to ratsimp
and rat
.
Example:
(%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1); a/2 2 a/2 2 (x - 1) (x + 1) (%o1) ----------------------- a x - 1 (%i2) ratsimp (expr); 2 a a x - 2 x + 1 (%o2) --------------- a x - 1 (%i3) fullratsimp (expr); a (%o3) x - 1 (%i4) rat (expr); a/2 4 a/2 2 (x ) - 2 (x ) + 1 (%o4)/R/ ----------------------- a x - 1
Categories: Simplification functions · Rational expressions
is the same as ratsubst
except that it calls
itself recursively on its result until that result stops changing.
This function is useful when the replacement expression and the
replaced expression have one or more variables in common.
fullratsubst
will also accept its arguments in the format of
lratsubst
. That is, the first argument may be a single substitution
equation or a list of such equations, while the second argument is the
expression being processed.
load ("lrats")
loads fullratsubst
and lratsubst
.
Examples:
(%i1) load ("lrats")$
subst
can carry out multiple substitutions.
lratsubst
is analogous to subst
.
(%i2) subst ([a = b, c = d], a + c); (%o2) d + b (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c)); (%o3) (d + a c) e + a d + b c
(%i4) lratsubst (a^2 = b, a^3); (%o4) a b
fullratsubst
is equivalent to ratsubst
except that it recurses until its result stops changing.
(%i5) ratsubst (b*a, a^2, a^3); 2 (%o5) a b (%i6) fullratsubst (b*a, a^2, a^3); 2 (%o6) a b
fullratsubst
also accepts a list of equations or a single
equation as first argument.
(%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c); (%o7) b (%i8) fullratsubst (a^2 = b*a, a^3); 2 (%o8) a b
fullratsubst
may cause an indefinite recursion.
(%i9) errcatch (fullratsubst (b*a^2, a^2, a^3)); *** - Lisp stack overflow. RESET
Categories: Rational expressions
Returns the greatest common divisor of p_1 and p_2. The flag
gcd
determines which algorithm is employed. Setting gcd
to
ez
, subres
, red
, or spmod
selects the ezgcd
,
subresultant prs
, reduced, or modular algorithm, respectively. If
gcd
false
then gcd (p_1, p_2, x)
always
returns 1 for all x. Many functions (e.g. ratsimp
,
factor
, etc.) cause gcd's to be taken implicitly. For homogeneous
polynomials it is recommended that gcd
equal to subres
be used.
To take the gcd when an algebraic is present, e.g.,
gcd (x^2 - 2*sqrt(2)* x + 2, x - sqrt(2))
, the option
variable algebraic
must be true
and gcd
must not be
ez
.
The gcd
flag, default: spmod
, if false
will also prevent
the greatest common divisor from being taken when expressions are converted to
canonical rational expression (CRE) form. This will sometimes speed the
calculation if gcds are not required.
See also ezgcd
, gcdex
, gcdivide
, and
poly_gcd
.
Example:
(%i1) p1:6*x^3+19*x^2+19*x+6; 3 2 (%o1) 6 x + 19 x + 19 x + 6 (%i2) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x; 5 4 3 2 (%o2) 6 x + 13 x + 12 x + 13 x + 6 x (%i3) gcd(p1, p2); 2 (%o3) 6 x + 13 x + 6 (%i4) p1/gcd(p1, p2), ratsimp; (%o4) x + 1 (%i5) p2/gcd(p1, p2), ratsimp; 3 (%o5) x + x
ezgcd
returns a list whose first element is the greatest common divisor
of the polynomials p_1 and p_2, and whose remaining elements are
the polynomials divided by the greatest common divisor.
(%i6) ezgcd(p1, p2); 2 3 (%o6) [6 x + 13 x + 6, x + 1, x + x]
Categories: Polynomials · Rational expressions
Returns a list [a, b, u]
where u is the greatest
common divisor (gcd) of f and g, and u is equal to
a f + b g
. The arguments f and g
should be univariate polynomials, or else polynomials in x a supplied
main variable since we need to be in a principal ideal domain for this to
work. The gcd means the gcd regarding f and g as univariate
polynomials with coefficients being rational functions in the other variables.
gcdex
implements the Euclidean algorithm, where we have a sequence of
L[i]: [a[i], b[i], r[i]]
which are all perpendicular to [f, g, -1]
and the next one is built as if q = quotient(r[i]/r[i+1])
then
L[i+2]: L[i] - q L[i+1]
, and it terminates at L[i+1]
when the
remainder r[i+2]
is zero.
The arguments f and g can be integers. For this case the function
igcdex
is called by gcdex
.
See also ezgcd
, gcd
, gcdivide
, and
poly_gcd
.
Examples:
(%i1) gcdex (x^2 + 1, x^3 + 4); 2 x + 4 x - 1 x + 4 (%o1)/R/ [- ------------, -----, 1] 17 17 (%i2) % . [x^2 + 1, x^3 + 4, -1]; (%o2)/R/ 0
Note that the gcd in the following is 1
since we work in k(y)[x]
,
not the y+1
we would expect in k[y, x]
.
(%i1) gcdex (x*(y + 1), y^2 - 1, x); 1 (%o1)/R/ [0, ------, 1] 2 y - 1
Categories: Polynomials · Rational expressions
Factors the Gaussian integer n over the Gaussian integers, i.e., numbers
of the form a + b
where a and b are
rational integers (i.e., ordinary integers). Factors are normalized by making
a and b non-negative.
%i
Categories: Integers
Factors the polynomial expr over the Gaussian integers
(that is, the integers with the imaginary unit %i
adjoined).
This is like factor (expr, a^2+1)
where a is %i
.
Example:
(%i1) gfactor (x^4 - 1); (%o1) (x - 1) (x + 1) (x - %i) (x + %i)
Categories: Polynomials
is similar to factorsum
but applies gfactor
instead
of factor
.
Categories: Expressions
Returns the highest explicit exponent of x in expr.
x may be a variable or a general expression.
If x does not appear in expr,
hipow
returns 0
.
hipow
does not consider expressions equivalent to expr
. In
particular, hipow
does not expand expr
, so
hipow (expr, x)
and
hipow (expand (expr, x))
may yield different results.
Examples:
(%i1) hipow (y^3 * x^2 + x * y^4, x); (%o1) 2 (%i2) hipow ((x + y)^5, x); (%o2) 1 (%i3) hipow (expand ((x + y)^5), x); (%o3) 5 (%i4) hipow ((x + y)^5, x + y); (%o4) 5 (%i5) hipow (expand ((x + y)^5), x + y); (%o5) 0
Categories: Expressions
Default value: true
If true
, maxima will give up factorization of
integers if no factor is found after trial divisions and Pollard's rho
method and factorization will not be complete.
When intfaclim
is false
(this is the case when the user
calls factor
explicitly), complete factorization will be
attempted. intfaclim
is set to false
when factors are
computed in divisors
, divsum
and totient
.
Internal calls to factor
respect the user-specified value of
intfaclim
. Setting intfaclim
to true
may reduce
the time spent factoring large integers.
Categories: Integers
Default value: false
When keepfloat
is true
, prevents floating
point numbers from being rationalized when expressions which contain
them are converted to canonical rational expression (CRE) form.
Note that the function solve
and those functions calling it
(eigenvalues
, for example) currently ignore this flag, converting
floating point numbers anyway.
Examples:
(%i1) rat(x/2.0); `rat' replaced 0.5 by 1/2 = 0.5 x (%o1)/R/ - 2 (%i2) rat(x/2.0), keepfloat; (%o2)/R/ 0.5 x
solve
ignores keepfloat
:
(%i3) solve(1.0-x,x), keepfloat; `rat' replaced 1.0 by 1/1 = 1.0 (%o3) [x = 1]
Categories: Numerical evaluation
Returns the lowest exponent of x which explicitly appears in expr. Thus
(%i1) lopow ((x+y)^2 + (x+y)^a, x+y); (%o1) min(a, 2)
Categories: Expressions
is analogous to subst (L, expr)
except that it uses ratsubst
instead of subst
.
The first argument of
lratsubst
is an equation or a list of equations identical in
format to that accepted by subst
. The
substitutions are made in the order given by the list of equations,
that is, from left to right.
load ("lrats")
loads fullratsubst
and lratsubst
.
Examples:
(%i1) load ("lrats")$
subst
can carry out multiple substitutions.
lratsubst
is analogous to subst
.
(%i2) subst ([a = b, c = d], a + c); (%o2) d + b (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c)); (%o3) (d + a c) e + a d + b c
(%i4) lratsubst (a^2 = b, a^3); (%o4) a b
Categories: Polynomials · Rational expressions
Default value: false
When modulus
is a positive number p, operations on rational numbers
(as returned by rat
and related functions) are carried out modulo
p, using the so-called "balanced" modulus system in which n
modulo p
is defined as an integer k in
[-(p-1)/2, ..., 0, ..., (p-1)/2]
when p is odd, or
[-(p/2 - 1), ..., 0, ...., p/2]
when p is even, such
that a p + k
equals n for some integer a.
If expr is already in canonical rational expression (CRE) form when
modulus
is reset, then you may need to re-rat expr, e.g.,
expr: rat (ratdisrep (expr))
, in order to get correct results.
Typically modulus
is set to a prime number. If modulus
is set to
a positive non-prime integer, this setting is accepted, but a warning message is
displayed. Maxima signals an error, when zero or a negative integer is
assigned to modulus
.
Examples:
(%i1) modulus:7; (%o1) 7 (%i2) polymod([0,1,2,3,4,5,6,7]); (%o2) [0, 1, 2, 3, - 3, - 2, - 1, 0] (%i3) modulus:false; (%o3) false (%i4) poly:x^6+x^2+1; 6 2 (%o4) x + x + 1 (%i5) factor(poly); 6 2 (%o5) x + x + 1 (%i6) modulus:13; (%o6) 13 (%i7) factor(poly); 2 4 2 (%o7) (x + 6) (x - 6 x - 2) (%i8) polymod(%); 6 2 (%o8) x + x + 1
Categories: Integers
Returns the numerator of expr if it is a ratio. If expr is not a ratio, expr is returned.
num
evaluates its argument.
Categories: Expressions
Decomposes the polynomial p in the variable x
into the functional composition of polynomials in x.
polydecomp
returns a list [p_1, ..., p_n]
such that
lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x)) ...))
is equal to p. The degree of p_i is greater than 1 for i less than n.
Such a decomposition is not unique.
Examples:
(%i1) polydecomp (x^210, x); 7 5 3 2 (%o1) [x , x , x , x ] (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a)); 6 4 3 2 (%o2) x - 2 x - 2 x + x + 2 x - a + 1 (%i3) polydecomp (p, x); 2 3 (%o3) [x - a, x - x - 1]
The following function composes L = [e_1, ..., e_n]
as functions in
x
; it is the inverse of polydecomp:
compose (L, x) := block ([r : x], for e in L do r : subst (e, x, r), r) $
Re-express above example using compose
:
(%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x); 2 3 (%o3) [x - a, x - x - 1]
Note that though compose (polydecomp (p, x), x)
always
returns p (unexpanded), polydecomp (compose ([p_1, ...,
p_n], x), x)
does not necessarily return
[p_1, ..., p_n]
:
(%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x); 2 2 (%o4) [x + 2, x + 1] (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x); 2 2 x + 3 x + 5 (%o5) [------, ------, 2 x + 1] 4 2
Categories: Polynomials
Converts the polynomial p to a modular representation with respect to the
current modulus which is the value of the variable modulus
.
polymod (p, m)
specifies a modulus m to be used
instead of the current value of modulus
.
See modulus
.
Categories: Polynomials
Returns the polynomial p_1 divided by the polynomial p_2. The
arguments x_1, …, x_n are interpreted as in ratvars
.
quotient
returns the first element of the two-element list returned by
divide
.
Categories: Polynomials
Converts expr to canonical rational expression (CRE) form by expanding and
combining all terms over a common denominator and cancelling out the
greatest common divisor of the numerator and denominator, as well as
converting floating point numbers to rational numbers within a
tolerance of ratepsilon
.
The variables are ordered according
to the x_1, …, x_n, if specified, as in ratvars
.
rat
does not generally simplify functions other than addition +
,
subtraction -
, multiplication *
, division /
, and
exponentiation to an integer power,
whereas ratsimp
does handle those cases.
Note that atoms (numbers and variables) in CRE form are not the
same as they are in the general form.
For example, rat(x)- x
yields
rat(0)
which has a different internal representation than 0.
When ratfac
is true
, rat
yields a partially factored
form for CRE. During rational operations the expression is
maintained as fully factored as possible without an actual call to the
factor package. This should always save space and may save some time
in some computations. The numerator and denominator are still made
relatively prime
(e.g., rat((x^2 - 1)^4/(x + 1)^2)
yields (x - 1)^4 (x + 1)^2
when ratfac
is true
),
but the factors within each part may not be relatively prime.
ratprint
if false
suppresses the printout of the message
informing the user of the conversion of floating point numbers to
rational numbers.
keepfloat
if true
prevents floating point numbers from being
converted to rational numbers.
See also ratexpand
and ratsimp
.
Examples:
(%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) / (4*y^2 + x^2); 4 (x - 2 y) (y + a) (2 y + x) (------------ + 1) 2 2 2 (x - 4 y ) (%o1) ------------------------------------ 2 2 4 y + x (%i2) rat (%, y, a, x); 2 a + 2 y (%o2)/R/ --------- x + 2 y
Categories: Rational expressions
Default value: true
When ratalgdenom
is true
, allows rationalization of denominators
with respect to radicals to take effect. ratalgdenom
has an effect only
when canonical rational expressions (CRE) are used in algebraic mode.
Categories: Simplification flags and variables
Returns the coefficient of the expression x^n
in the expression expr.
If omitted, n is assumed to be 1.
The return value is free (except possibly in a non-rational sense) of the variables in x. If no coefficient of this type exists, 0 is returned.
ratcoef
expands and rationally simplifies its first argument and thus it may
produce answers different from those of coeff
which is purely
syntactic.
Thus ratcoef ((x + 1)/y + x, x)
returns (y + 1)/y
whereas
coeff
returns 1.
ratcoef (expr, x, 0)
, viewing expr as a sum,
returns a sum of those terms which do not contain x.
Therefore if x occurs to any negative powers, ratcoef
should not
be used.
Since expr is rationally simplified before it is examined, coefficients may not appear quite the way they were envisioned.
Example:
(%i1) s: a*x + b*x + 5$ (%i2) ratcoef (s, a + b); (%o2) x
Categories: Polynomials · Rational expressions
Returns the denominator of expr, after coercing expr to a canonical rational expression (CRE). The return value is a CRE.
expr is coerced to a CRE by rat
if it is not already a CRE.
This conversion may change the form of expr by putting all terms
over a common denominator.
denom
is similar, but returns an ordinary expression instead of a CRE.
Also, denom
does not attempt to place all terms over a common
denominator, and thus some expressions which are considered ratios by
ratdenom
are not considered ratios by denom
.
Categories: Rational expressions
Default value: true
When ratdenomdivide
is true
,
ratexpand
expands a ratio in which the numerator is a sum
into a sum of ratios,
all having a common denominator.
Otherwise, ratexpand
collapses a sum of ratios into a single ratio,
the numerator of which is the sum of the numerators of each ratio.
Examples:
(%i1) expr: (x^2 + x + 1)/(y^2 + 7); 2 x + x + 1 (%o1) ---------- 2 y + 7 (%i2) ratdenomdivide: true$ (%i3) ratexpand (expr); 2 x x 1 (%o3) ------ + ------ + ------ 2 2 2 y + 7 y + 7 y + 7 (%i4) ratdenomdivide: false$ (%i5) ratexpand (expr); 2 x + x + 1 (%o5) ---------- 2 y + 7 (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3); 2 b a (%o6) ------ + ------ 2 2 b + 3 b + 3 (%i7) ratexpand (expr2); 2 b + a (%o7) ------ 2 b + 3
Categories: Simplification flags and variables · Rational expressions
Differentiates the rational expression expr with respect to x. expr must be a ratio of polynomials or a polynomial in x. The argument x may be a variable or a subexpression of expr.
The result is equivalent to diff
, although perhaps in a different form.
ratdiff
may be faster than diff
, for rational expressions.
ratdiff
returns a canonical rational expression (CRE) if expr
is
a CRE. Otherwise, ratdiff
returns a general expression.
ratdiff
considers only the dependence of expr on x,
and ignores any dependencies established by depends
.
Example:
(%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5); 3 4 x + 10 x - 11 (%o1) ---------------- 5 x + 5 (%i2) ratdiff (expr, x); 7 5 4 2 8 x + 40 x - 55 x - 60 x - 50 (%o2) - --------------------------------- 10 5 x + 10 x + 25 (%i3) expr: f(x)^3 - f(x)^2 + 7; 3 2 (%o3) f (x) - f (x) + 7 (%i4) ratdiff (expr, f(x)); 2 (%o4) 3 f (x) - 2 f(x) (%i5) expr: (a + b)^3 + (a + b)^2; 3 2 (%o5) (b + a) + (b + a) (%i6) ratdiff (expr, a + b); 2 2 (%o6) 3 b + (6 a + 2) b + 3 a + 2 a
Categories: Rational expressions
Returns its argument as a general expression. If expr is a general expression, it is returned unchanged.
Typically ratdisrep
is called to convert a canonical rational expression
(CRE) into a general expression.
This is sometimes convenient if one wishes to stop the "contagion", or
use rational functions in non-rational contexts.
See also totaldisrep
.
Categories: Rational expressions
Expands expr by multiplying out products of sums and exponentiated sums, combining fractions over a common denominator, cancelling the greatest common divisor of the numerator and denominator, then splitting the numerator (if a sum) into its respective terms divided by the denominator.
The return value of ratexpand
is a general expression,
even if expr is a canonical rational expression (CRE).
The switch ratexpand
if true
will cause CRE
expressions to be fully expanded when they are converted back to
general form or displayed, while if it is false
then they will be put
into a recursive form.
See also ratsimp
.
When ratdenomdivide
is true
,
ratexpand
expands a ratio in which the numerator is a sum
into a sum of ratios,
all having a common denominator.
Otherwise, ratexpand
collapses a sum of ratios into a single ratio,
the numerator of which is the sum of the numerators of each ratio.
When keepfloat
is true
, prevents floating
point numbers from being rationalized when expressions which contain
them are converted to canonical rational expression (CRE) form.
Examples:
(%i1) ratexpand ((2*x - 3*y)^3); 3 2 2 3 (%o1) - 27 y + 54 x y - 36 x y + 8 x (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1); x - 1 1 (%o2) -------- + ----- 2 x - 1 (x + 1) (%i3) expand (expr); x 1 1 (%o3) ------------ - ------------ + ----- 2 2 x - 1 x + 2 x + 1 x + 2 x + 1 (%i4) ratexpand (expr); 2 2 x 2 (%o4) --------------- + --------------- 3 2 3 2 x + x - x - 1 x + x - x - 1
Categories: Rational expressions
Default value: false
When ratfac
is true
, canonical rational expressions (CRE) are
manipulated in a partially factored form.
During rational operations the expression is maintained as fully factored as
possible without calling factor
.
This should always save space and may save time in some computations.
The numerator and denominator are made relatively prime, for example
factor ((x^2 - 1)^4/(x + 1)^2)
yields (x - 1)^4 (x + 1)^2
,
but the factors within each part may not be relatively prime.
In the ctensr
(Component Tensor Manipulation) package,
Ricci, Einstein, Riemann, and Weyl tensors and the scalar curvature
are factored automatically when ratfac
is true
.
ratfac
should only be
set for cases where the tensorial components are known to consist of
few terms.
The ratfac
and ratweight
schemes are incompatible and may not
both be used at the same time.
Categories: Rational expressions
Returns the numerator of expr, after coercing expr to a canonical rational expression (CRE). The return value is a CRE.
expr is coerced to a CRE by rat
if it is not already a CRE.
This conversion may change the form of expr by putting all terms
over a common denominator.
num
is similar, but returns an ordinary expression instead of a CRE.
Also, num
does not attempt to place all terms over a common denominator,
and thus some expressions which are considered ratios by ratnumer
are not considered ratios by num
.
Categories: Rational expressions
Returns true
if expr is a canonical rational expression (CRE) or
extended CRE, otherwise false
.
CRE are created by rat
and related functions.
Extended CRE are created by taylor
and related functions.
Categories: Predicate functions · Rational expressions
Default value: true
When ratprint
is true
,
a message informing the user of the conversion of floating point numbers
to rational numbers is displayed.
Categories: Rational expressions · Numerical evaluation · Console interaction
Simplifies the expression expr and all of its subexpressions, including
the arguments to non-rational functions. The result is returned as the quotient
of two polynomials in a recursive form, that is, the coefficients of the main
variable are polynomials in the other variables. Variables may include
non-rational functions (e.g., sin (x^2 + 1)
) and the arguments to any
such functions are also rationally simplified.
ratsimp (expr, x_1, ..., x_n)
enables rational simplification with the
specification of variable ordering as in ratvars
.
When ratsimpexpons
is true
,
ratsimp
is applied to the exponents of expressions during simplification.
See also ratexpand
.
Note that ratsimp
is affected by some of the
flags which affect ratexpand
.
Examples:
(%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2); 2 2 x (log(x) + 1) - log (x) (%o1) sin(------) = %e 2 x + x (%i2) ratsimp (%); 1 2 (%o2) sin(-----) = %e x x + 1 (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1)); 3/2 (x - 1) - sqrt(x - 1) (x + 1) (%o3) -------------------------------- sqrt((x - 1) (x + 1)) (%i4) ratsimp (%); 2 sqrt(x - 1) (%o4) - ------------- 2 sqrt(x - 1) (%i5) x^(a + 1/a), ratsimpexpons: true; 2 a + 1 ------ a (%o5) x
Categories: Simplification functions · Rational expressions
Default value: false
When ratsimpexpons
is true
,
ratsimp
is applied to the exponents of expressions during simplification.
Categories: Simplification flags and variables · Rational expressions
Default value: false
radsubstflag
, if true
, permits ratsubst
to make
substitutions such as u
for sqrt (x)
in x
.
Categories: Simplification flags and variables
Substitutes a for b in c and returns the resulting expression. b may be a sum, product, power, etc.
ratsubst
knows something of the meaning of expressions
whereas subst
does a purely syntactic substitution.
Thus subst (a, x + y, x + y + z)
returns x + y + z
whereas ratsubst
returns z + a
.
When radsubstflag
is true
,
ratsubst
makes substitutions for radicals in expressions
which don't explicitly contain them.
ratsubst
ignores the value true
of the option variable
keepfloat
.
Examples:
(%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8); 3 4 (%o1) a x y + a (%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1; 4 3 2 (%o2) cos (x) + cos (x) + cos (x) + cos(x) + 1 (%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %); 4 2 2 (%o3) sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3 (%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4); 4 2 (%o4) cos (x) - 2 cos (x) + 1 (%i5) radsubstflag: false$ (%i6) ratsubst (u, sqrt(x), x); (%o6) x (%i7) radsubstflag: true$ (%i8) ratsubst (u, sqrt(x), x); 2 (%o8) u
Categories: Rational expressions
Declares main variables x_1, …, x_n for rational expressions. x_n, if present in a rational expression, is considered the main variable. Otherwise, x_[n-1] is considered the main variable if present, and so on through the preceding variables to x_1, which is considered the main variable only if none of the succeeding variables are present.
If a variable in a rational expression is not present in the ratvars
list, it is given a lower priority than x_1.
The arguments to ratvars
can be either variables or non-rational
functions such as sin(x)
.
The variable ratvars
is a list of the arguments of
the function ratvars
when it was called most recently.
Each call to the function ratvars
resets the list.
ratvars ()
clears the list.
Categories: Rational expressions
Default value: true
Maxima keeps an internal list in the Lisp variable VARLIST
of the main
variables for rational expressions. If ratvarswitch
is true
,
every evaluation starts with a fresh list VARLIST
. This is the default
behavior. Otherwise, the main variables from previous evaluations are not
removed from the internal list VARLIST
.
The main variables, which are declared with the function ratvars
are
not affected by the option variable ratvarswitch
.
Examples:
If ratvarswitch
is true
, every evaluation starts with a fresh
list VARLIST
.
(%i1) ratvarswitch:true$ (%i2) rat(2*x+y^2); 2 (%o2)/R/ y + 2 x (%i3) :lisp varlist ($X $Y) (%i3) rat(2*a+b^2); 2 (%o3)/R/ b + 2 a (%i4) :lisp varlist ($A $B)
If ratvarswitch
is false
, the main variables from the last
evaluation are still present.
(%i4) ratvarswitch:false$ (%i5) rat(2*x+y^2); 2 (%o5)/R/ y + 2 x (%i6) :lisp varlist ($X $Y) (%i6) rat(2*a+b^2); 2 (%o6)/R/ b + 2 a (%i7) :lisp varlist ($A $B $X $Y)
Categories: Rational expressions · Global flags
Assigns a weight w_i to the variable x_i.
This causes a term to be replaced by 0 if its weight exceeds the
value of the variable ratwtlvl
(default yields no truncation).
The weight of a term is the sum of the products of the
weight of a variable in the term times its power.
For example, the weight of 3 x_1^2 x_2
is 2 w_1 + w_2
.
Truncation according to ratwtlvl
is carried out only when multiplying
or exponentiating canonical rational expressions (CRE).
ratweight ()
returns the cumulative list of weight assignments.
Note: The ratfac
and ratweight
schemes are incompatible and may
not both be used at the same time.
Examples:
(%i1) ratweight (a, 1, b, 1); (%o1) [a, 1, b, 1] (%i2) expr1: rat(a + b + 1)$ (%i3) expr1^2; 2 2 (%o3)/R/ b + (2 a + 2) b + a + 2 a + 1 (%i4) ratwtlvl: 1$ (%i5) expr1^2; (%o5)/R/ 2 b + 2 a + 1
Categories: Rational expressions
Default value: []
ratweights
is the list of weights assigned by ratweight
.
The list is cumulative:
each call to ratweight
places additional items in the list.
kill (ratweights)
and save (ratweights)
both work as expected.
Categories: Rational expressions
Default value: false
ratwtlvl
is used in combination with the ratweight
function to control the truncation of canonical rational expressions (CRE).
For the default value of false
, no truncation occurs.
Categories: Rational expressions
Returns the remainder of the polynomial p_1 divided by the polynomial
p_2. The arguments x_1, …, x_n are interpreted as in
ratvars
.
remainder
returns the second element
of the two-element list returned by divide
.
Categories: Polynomials
The function resultant
computes the resultant of the two polynomials
p_1 and p_2, eliminating the variable x. The resultant is a
determinant of the coefficients of x in p_1 and p_2, which
equals zero if and only if p_1 and p_2 have a non-constant factor
in common.
If p_1 or p_2 can be factored, it may be desirable to call
factor
before calling resultant
.
The option variable resultant
controls which algorithm will be used to
compute the resultant. See the option variable
resultant
.
The function bezout
takes the same arguments as resultant
and
returns a matrix. The determinant of the return value is the desired resultant.
Examples:
(%i1) resultant(2*x^2+3*x+1, 2*x^2+x+1, x); (%o1) 8 (%i2) resultant(x+1, x+1, x); (%o2) 0 (%i3) resultant((x+1)*x, (x+1), x); (%o3) 0 (%i4) resultant(a*x^2+b*x+1, c*x + 2, x); 2 (%o4) c - 2 b c + 4 a (%i5) bezout(a*x^2+b*x+1, c*x+2, x); [ 2 a 2 b - c ] (%o5) [ ] [ c 2 ] (%i6) determinant(%); (%o6) 4 a - (2 b - c) c
Categories: Polynomials
Default value: subres
The option variable resultant
controls which algorithm will be used to
compute the resultant with the function resultant
. The possible
values are:
subres
for the subresultant polynomial remainder sequence (PRS) algorithm,
mod
for the modular resultant algorithm, and
red
for the reduced polynomial remainder sequence (PRS) algorithm.
On most problems the default value subres
should be best. On some
large degree univariate or bivariate problems mod
may be better.
Categories: Polynomials
Default value: false
When savefactors
is true
, causes the factors of an
expression which is a product of factors to be saved by certain
functions in order to speed up later factorizations of expressions
containing some of the same factors.
Categories: Polynomials
Returns a list of the canonical rational expression (CRE) variables in
expression expr
.
See also ratvars
.
Categories: Rational expressions · Display functions
is similar to factor
except that the polynomial factors are
"square-free." That is, they have factors only of degree one.
This algorithm, which is also used by the first stage of factor
, utilizes
the fact that a polynomial has in common with its n'th derivative all
its factors of degree greater than n. Thus by taking greatest common divisors
with the polynomial of
the derivatives with respect to each variable in the polynomial, all
factors of degree greater than 1 can be found.
Example:
(%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1); 2 2 (%o1) (2 x + 1) (x - 1)
Categories: Polynomials
Adds to the ring of algebraic integers known to Maxima the elements which are the solutions of the polynomials p_1, …, p_n. Each argument p_i is a polynomial with integer coefficients.
tellrat (x)
effectively means substitute 0 for x in rational
functions.
tellrat ()
returns a list of the current substitutions.
algebraic
must be set to true
in order for the simplification of
algebraic integers to take effect.
Maxima initially knows about the imaginary unit %i
and all roots of integers.
There is a command untellrat
which takes kernels and
removes tellrat
properties.
When tellrat
'ing a multivariate
polynomial, e.g., tellrat (x^2 - y^2)
, there would be an ambiguity as to
whether to substitute y^2
for x^2
or vice versa.
Maxima picks a particular ordering, but if the user wants to specify which, e.g.
tellrat (y^2 = x^2)
provides a syntax which says replace
y^2
by x^2
.
Examples:
(%i1) 10*(%i + 1)/(%i + 3^(1/3)); 10 (%i + 1) (%o1) ----------- 1/3 %i + 3 (%i2) ev (ratdisrep (rat(%)), algebraic); 2/3 1/3 2/3 1/3 (%o2) (4 3 - 2 3 - 4) %i + 2 3 + 4 3 - 2 (%i3) tellrat (1 + a + a^2); 2 (%o3) [a + a + 1] (%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2)); 1 a (%o4) ------------- + ----------------- sqrt(2) a - 1 sqrt(3) + sqrt(2) (%i5) ev (ratdisrep (rat(%)), algebraic); (7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1 (%o5) ---------------------------------------------- 7 (%i6) tellrat (y^2 = x^2); 2 2 2 (%o6) [y - x , a + a + 1]
Categories: Polynomials · Rational expressions
Converts every subexpression of expr from canonical rational expressions
(CRE) to general form and returns the result.
If expr is itself in CRE form then totaldisrep
is identical to
ratdisrep
.
totaldisrep
may be useful for
ratdisrepping expressions such as equations, lists, matrices, etc., which
have some subexpressions in CRE form.
Categories: Rational expressions
Removes tellrat
properties from x_1, …, x_n.
Categories: Polynomials · Rational expressions
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Jaime Villate on October, 14 2014 using texi2html 1.76.