(maxima.info)Functions and Variables for to_poly_solve
86.1 Functions and Variables for to_poly_solve
==============================================
The packages 'to_poly' and 'to_poly_solve' are experimental; the
specifications of the functions in these packages might change or the
some of the functions in these packages might be merged into other
Maxima functions.
Barton Willis (Professor of Mathematics, University of Nebraska at
Kearney) wrote the 'to_poly' and 'to_poly_solve' packages and the
English language user documentation for these packages.
-- Operator: %and
The operator '%and' is a simplifying nonshort-circuited logical
conjunction. Maxima simplifies an '%and' expression to either
true, false, or a logically equivalent, but simplified, expression.
The operator '%and' is associative, commutative, and idempotent.
Thus when '%and' returns a noun form, the arguments of '%and' form
a non-redundant sorted list; for example
(%i1) a %and (a %and b);
(%o1) a %and b
If one argument to a conjunction is the explicit the negation of
another argument, '%and' returns false:
(%i2) a %and (not a);
(%o2) false
If any member of the conjunction is false, the conjunction
simplifies to false even if other members are manifestly
non-boolean; for example
(%i3) 42 %and false;
(%o3) false
Any argument of an '%and' expression that is an inequation (that
is, an inequality or equation), is simplified using the Fourier
elimination package. The Fourier elimination simplifier has a
pre-processor that converts some, but not all, nonlinear
inequations into linear inequations; for example the Fourier
elimination code simplifies 'abs(x) + 1 > 0' to true, so
(%i4) (x < 1) %and (abs(x) + 1 > 0);
(%o4) x < 1
Notes
* The option variable 'prederror' does not alter the
simplification '%and' expressions.
* To avoid operator precedence errors, compound expressions
involving the operators '%and, %or', and 'not' should be fully
parenthesized.
* The Maxima operators 'and' and 'or' are both short-circuited.
Thus 'and' isn't associative or commutative.
Limitations The conjunction '%and' simplifies inequations locally,
not globally. This means that conjunctions such as
(%i5) (x < 1) %and (x > 1);
(%o5) (x > 1) %and (x < 1)
do not simplify to false. Also, the Fourier elimination code
ignores the fact database;
(%i6) assume(x > 5);
(%o6) [x > 5]
(%i7) (x > 1) %and (x > 2);
(%o7) (x > 1) %and (x > 2)
Finally, nonlinear inequations that aren't easily converted into an
equivalent linear inequation aren't simplified.
There is no support for distributing '%and' over '%or'; neither is
there support for distributing a logical negation over '%and'.
To use 'load(to_poly_solve)'
Related functions '%or, %if, and, or, not'
Status The operator '%and' is experimental; the specifications of
this function might change and its functionality might be merged
into other Maxima functions.
-- Operator: %if (<bool>, <a>, <b>)
The operator '%if' is a simplifying conditional. The conditional
<bool> should be boolean-valued. When the conditional is true,
return the second argument; when the conditional is false, return
the third; in all other cases, return a noun form.
Maxima inequations (either an inequality or an equality) are not
boolean-valued; for example, Maxima does not simplify 5 < 6 to
true, and it does not simplify 5 = 6 to false; however, in the
context of a conditional to an '%if' statement, Maxima
automatically attempts to determine the truth value of an
inequation. Examples:
(%i1) f : %if(x # 1, 2, 8);
(%o1) %if(x - 1 # 0, 2, 8)
(%i2) [subst(x = -1,f), subst(x=1,f)];
(%o2) [2, 8]
If the conditional involves an inequation, Maxima simplifies it
using the Fourier elimination package.
Notes
* If the conditional is manifestly non-boolean, Maxima returns a
noun form:
(%i3) %if(42,1,2);
(%o3) %if(42, 1, 2)
* The Maxima operator 'if' is nary, the operator '%if' isn't
nary.
Limitations The Fourier elimination code only simplifies nonlinear
inequations that are readily convertible to an equivalent linear
inequation.
To use: 'load(to_poly_solve)'
Status: The operator '%if' is experimental; its specifications
might change and its functionality might be merged into other
Maxima functions.
-- Operator: %or
The operator '%or' is a simplifying nonshort-circuited logical
disjunction. Maxima simplifies an '%or' expression to either true,
false, or a logically equivalent, but simplified, expression. The
operator '%or' is associative, commutative, and idempotent. Thus
when '%or' returns a noun form, the arguments of '%or' form a
non-redundant sorted list; for example
(%i1) a %or (a %or b);
(%o1) a %or b
If one member of the disjunction is the explicit the negation of
another member, '%or' returns true:
(%i2) a %or (not a);
(%o2) true
If any member of the disjunction is true, the disjunction
simplifies to true even if other members of the disjunction are
manifestly non-boolean; for example
(%i3) 42 %or true;
(%o3) true
Any argument of an '%or' expression that is an inequation (that is,
an inequality or equation), is simplified using the Fourier
elimination package. The Fourier elimination code simplifies
'abs(x) + 1 > 0' to true, so we have
(%i4) (x < 1) %or (abs(x) + 1 > 0);
(%o4) true
Notes
* The option variable 'prederror' does not alter the
simplification of '%or' expressions.
* You should parenthesize compound expressions involving the
operators '%and, %or', and 'not'; the binding powers of these
operators might not match your expectations.
* The Maxima operators 'and' and 'or' are both short-circuited.
Thus 'or' isn't associative or commutative.
Limitations The conjunction '%or' simplifies inequations locally,
not globally. This means that conjunctions such as
(%i1) (x < 1) %or (x >= 1);
(%o1) (x > 1) %or (x >= 1)
do not simplify to true. Further, the Fourier elimination code
ignores the fact database;
(%i2) assume(x > 5);
(%o2) [x > 5]
(%i3) (x > 1) %and (x > 2);
(%o3) (x > 1) %and (x > 2)
Finally, nonlinear inequations that aren't easily converted into an
equivalent linear inequation aren't simplified.
The algorithm that looks for terms that cannot both be false is
weak; also there is no support for distributing '%or' over '%and';
neither is there support for distributing a logical negation over
'%or'.
To use 'load(to_poly_solve)'
Related functions '%or, %if, and, or, not'
Status The operator '%or' is experimental; the specifications of
this function might change and its functionality might be merged
into other Maxima functions.
-- Function: complex_number_p (<x>)
The predicate 'complex_number_p' returns true if its argument is
either 'a + %i * b', 'a', '%i b', or '%i', where 'a' and 'b' are
either rational or floating point numbers (including big floating
point); for all other inputs, 'complex_number_p' returns false; for
example
(%i1) map('complex_number_p,[2/3, 2 + 1.5 * %i, %i]);
(%o1) [true, true, true]
(%i2) complex_number_p((2+%i)/(5-%i));
(%o2) false
(%i3) complex_number_p(cos(5 - 2 * %i));
(%o3) false
Related functions 'isreal_p'
To use 'load(to_poly_solve)'
Status The operator 'complex_number_p' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Function: compose_functions (<l>)
The function call 'compose_functions(l)' returns a lambda form that
is the composition of the functions in the list <l>. The functions
are applied from right to left; for example
(%i1) compose_functions([cos, exp]);
%g151
(%o1) lambda([%g151], cos(%e ))
(%i2) %(x);
x
(%o2) cos(%e )
When the function list is empty, return the identity function:
(%i3) compose_functions([]);
(%o3) lambda([%g152], %g152)
(%i4) %(x);
(%o4) x
Notes
* When Maxima determines that a list member isn't a symbol or a
lambda form, 'funmake' (not 'compose_functions') signals an
error:
(%i5) compose_functions([a < b]);
funmake: first argument must be a symbol, subscripted symbol,
string, or lambda expression; found: a < b
#0: compose_functions(l=[a < b])(to_poly_solve.mac line 40)
-- an error. To debug this try: debugmode(true);
* To avoid name conflicts, the independent variable is
determined by the function 'new_variable'.
(%i6) compose_functions([%g0]);
(%o6) lambda([%g154], %g0(%g154))
(%i7) compose_functions([%g0]);
(%o7) lambda([%g155], %g0(%g155))
Although the independent variables are different, Maxima is
able to to deduce that these lambda forms are semantically
equal:
(%i8) is(equal(%o6,%o7));
(%o8) true
To use 'load(to_poly_solve)'
Status The function 'compose_functions' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Function: dfloat (<x>)
The function 'dfloat' is a similar to 'float', but the function
'dfloat' applies 'rectform' when 'float' fails to evaluate to an
IEEE double floating point number; thus
(%i1) float(4.5^(1 + %i));
%i + 1
(%o1) 4.5
(%i2) dfloat(4.5^(1 + %i));
(%o2) 4.48998802962884 %i + .3000124893895671
Notes
* The rectangular form of an expression might be poorly suited
for numerical evaluation-for example, the rectangular form
might needlessly involve the difference of floating point
numbers (subtractive cancellation).
* The identifier 'float' is both an option variable (default
value false) and a function name.
Related functions 'float, bfloat'
To use 'load(to_poly_solve)'
Status The function 'dfloat' is experimental; its specifications
might change and its functionality might be merged into other
Maxima functions.
-- Function: elim (<l>, <x>)
The function 'elim' eliminates the variables in the set or list 'x'
from the equations in the set or list 'l'. Each member of 'x' must
be a symbol; the members of 'l' can either be equations, or
expressions that are assumed to equal zero.
The function 'elim' returns a list of two lists; the first is the
list of expressions with the variables eliminated; the second is
the list of pivots; thus, the second list is a list of expressions
that 'elim' used to eliminate the variables.
Here is a example of eliminating between linear equations:
(%i1) elim(set(x + y + z = 1, x - y - z = 8, x - z = 1),
set(x,y));
(%o1) [[2 z - 7], [y + 7, z - x + 1]]
Eliminating 'x' and 'y' yields the single equation '2 z - 7 = 0';
the equations 'y + 7 = 0' and 'z - z + 1 = 1' were used as pivots.
Eliminating all three variables from these equations,
triangularizes the linear system:
(%i2) elim(set(x + y + z = 1, x - y - z = 8, x - z = 1),
set(x,y,z));
(%o2) [[], [2 z - 7, y + 7, z - x + 1]]
Of course, the equations needn't be linear:
(%i3) elim(set(x^2 - 2 * y^3 = 1, x - y = 5), [x,y]);
3 2
(%o3) [[], [2 y - y - 10 y - 24, y - x + 5]]
The user doesn't control the order the variables are eliminated.
Instead, the algorithm uses a heuristic to attempt to choose the
best pivot and the best elimination order.
Notes
* Unlike the related function 'eliminate', the function 'elim'
does not invoke 'solve' when the number of equations equals
the number of variables.
* The function 'elim' works by applying resultants; the option
variable 'resultant' determines which algorithm Maxima uses.
Using 'sqfr', Maxima factors each resultant and suppresses
multiple zeros.
* The 'elim' will triangularize a nonlinear set of polynomial
equations; the solution set of the triangularized set can be
larger than that solution set of the untriangularized set.
Thus, the triangularized equations can have spurious
solutions.
Related functions elim_allbut, eliminate_using, eliminate
Option variables resultant
To use 'load(to_poly)'
Status The function 'elim' is experimental; its specifications
might change and its functionality might be merged into other
Maxima functions.
-- Function: elim_allbut (<l>, <x>)
This function is similar to 'elim', except that it eliminates all
the variables in the list of equations 'l' except for those
variables that in in the list 'x'
(%i1) elim_allbut([x+y = 1, x - 5*y = 1],[]);
(%o1) [[], [y, y + x - 1]]
(%i2) elim_allbut([x+y = 1, x - 5*y = 1],[x]);
(%o2) [[x - 1], [y + x - 1]]
To use 'load(to_poly)'
Option variables resultant
Related functions elim, eliminate_using, eliminate
Status The function 'elim_allbut' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Function: eliminate_using (<l>, <e>, <x>)
Using 'e' as the pivot, eliminate the symbol 'x' from the list or
set of equations in 'l'. The function 'eliminate_using' returns a
set.
(%i1) eq : [x^2 - y^2 - z^3 , x*y - z^2 - 5, x - y + z];
3 2 2 2
(%o1) [- z - y + x , - z + x y - 5, z - y + x]
(%i2) eliminate_using(eq,first(eq),z);
3 2 2 3 2
(%o2) {y + (1 - 3 x) y + 3 x y - x - x ,
4 3 3 2 2 4
y - x y + 13 x y - 75 x y + x + 125}
(%i3) eliminate_using(eq,second(eq),z);
2 2 4 3 3 2 2 4
(%o3) {y - 3 x y + x + 5, y - x y + 13 x y - 75 x y + x
+ 125}
(%i4) eliminate_using(eq, third(eq),z);
2 2 3 2 2 3 2
(%o4) {y - 3 x y + x + 5, y + (1 - 3 x) y + 3 x y - x - x }
Option variables resultant
Related functions elim, eliminate, elim_allbut
To use 'load(to_poly)'
Status The function 'eliminate_using' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Function: fourier_elim ([<eq1>, <eq2>, ...], [<var1>, <var>, ...])
Fourier elimination is the analog of Gauss elimination for linear
inequations (equations or inequalities). The function call
'fourier_elim([eq1, eq2, ...], [var1, var2, ...])' does Fourier
elimination on a list of linear inequations '[eq1, eq2, ...]' with
respect to the variables '[var1, var2, ...]'; for example
(%i1) fourier_elim([y-x < 5, x - y < 7, 10 < y],[x,y]);
(%o1) [y - 5 < x, x < y + 7, 10 < y]
(%i2) fourier_elim([y-x < 5, x - y < 7, 10 < y],[y,x]);
(%o2) [max(10, x - 7) < y, y < x + 5, 5 < x]
Eliminating first with respect to x and second with respect to y
yields lower and upper bounds for x that depend on y, and lower and
upper bounds for y that are numbers. Eliminating in the other
order gives x dependent lower and upper bounds for y, and numerical
lower and upper bounds for x.
When necessary, 'fourier_elim' returns a _disjunction_ of lists of
inequations:
(%i3) fourier_elim([x # 6],[x]);
(%o3) [x < 6] or [6 < x]
When the solution set is empty, 'fourier_elim' returns 'emptyset',
and when the solution set is all reals, 'fourier_elim' returns
'universalset'; for example
(%i4) fourier_elim([x < 1, x > 1],[x]);
(%o4) emptyset
(%i5) fourier_elim([minf < x, x < inf],[x]);
(%o5) universalset
For nonlinear inequations, 'fourier_elim' returns a (somewhat)
simplified list of inequations:
(%i6) fourier_elim([x^3 - 1 > 0],[x]);
2 2
(%o6) [1 < x, x + x + 1 > 0] or [x < 1, - (x + x + 1) > 0]
(%i7) fourier_elim([cos(x) < 1/2],[x]);
(%o7) [1 - 2 cos(x) > 0]
Instead of a list of inequations, the first argument to
'fourier_elim' may be a logical disjunction or conjunction:
(%i8) fourier_elim((x + y < 5) and (x - y >8),[x,y]);
3
(%o8) [y + 8 < x, x < 5 - y, y < - -]
2
(%i9) fourier_elim(((x + y < 5) and x < 1) or (x - y >8),[x,y]);
(%o9) [y + 8 < x] or [x < min(1, 5 - y)]
The function 'fourier_elim' supports the inequation operators '<,
<=, >, >=, #', and '='.
The Fourier elimination code has a preprocessor that converts some
nonlinear inequations that involve the absolute value, minimum, and
maximum functions into linear in equations. Additionally, the
preprocessor handles some expressions that are the product or
quotient of linear terms:
(%i10) fourier_elim([max(x,y) > 6, x # 8, abs(y-1) > 12],[x,y]);
(%o10) [6 < x, x < 8, y < - 11] or [8 < x, y < - 11]
or [x < 8, 13 < y] or [x = y, 13 < y] or [8 < x, x < y, 13 < y]
or [y < x, 13 < y]
(%i11) fourier_elim([(x+6)/(x-9) <= 6],[x]);
(%o11) [x = 12] or [12 < x] or [x < 9]
(%i12) fourier_elim([x^2 - 1 # 0],[x]);
(%o12) [- 1 < x, x < 1] or [1 < x] or [x < - 1]
To use 'load(fourier_elim)'
-- Function: isreal_p (<e>)
The predicate 'isreal_p' returns true when Maxima is able to
determine that 'e' is real-valued on the entire real line; it
returns false when Maxima is able to determine that 'e' isn't
real-valued on some nonempty subset of the real line; and it
returns a noun form for all other cases.
(%i1) map('isreal_p, [-1, 0, %i, %pi]);
(%o1) [true, true, false, true]
Maxima variables are assumed to be real; thus
(%i2) isreal_p(x);
(%o2) true
The function 'isreal_p' examines the fact database:
(%i3) declare(z,complex)$
(%i4) isreal_p(z);
(%o4) isreal_p(z)
Limitations Too often, 'isreal_p' returns a noun form when it
should be able to return false; a simple example: the logarithm
function isn't real-valued on the entire real line, so
'isreal_p(log(x))' should return false; however
(%i5) isreal_p(log(x));
(%o5) isreal_p(log(x))
To use 'load(to_poly_solve)'
Related functions complex_number_p
Status The function 'isreal_p' is experimental; its specifications
might change and its functionality might be merged into other
Maxima functions.
-- Function: new_variable (type)
Return a unique symbol of the form '%[z,n,r,c,g]k', where 'k' is an
integer. The allowed values for type are integer, natural_number,
real, natural_number, and general. (By natural number, we mean the
nonnegative integers; thus zero is a natural number. Some, but not
all,definitions of natural number exclude zero.)
When type isn't one of the allowed values, type defaults to
general. For integers, natural numbers, and complex numbers,
Maxima automatically appends this information to the fact database.
(%i1) map('new_variable,
['integer, 'natural_number, 'real, 'complex, 'general]);
(%o1) [%z144, %n145, %r146, %c147, %g148]
(%i2) nicedummies(%);
(%o2) [%z0, %n0, %r0, %c0, %g0]
(%i3) featurep(%z0, 'integer);
(%o3) true
(%i4) featurep(%n0, 'integer);
(%o4) true
(%i5) is(%n0 >= 0);
(%o5) true
(%i6) featurep(%c0, 'complex);
(%o6) true
Note Generally, the argument to 'new_variable' should be quoted.
The quote will protect against errors similar to
(%i7) integer : 12$
(%i8) new_variable(integer);
(%o8) %g149
(%i9) new_variable('integer);
(%o9) %z150
Related functions nicedummies
To use 'load(to_poly_solve)'
Status The function 'new_variable' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Function: nicedummies
Starting with zero, the function 'nicedummies' re-indexes the
variables in an expression that were introduced by 'new_variable';
(%i1) new_variable('integer) + 52 * new_variable('integer);
(%o1) 52 %z136 + %z135
(%i2) new_variable('integer) - new_variable('integer);
(%o2) %z137 - %z138
(%i3) nicedummies(%);
(%o3) %z0 - %z1
Related functions new_variable
To use 'load(to_poly_solve)'
Status The function 'nicedummies' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Function: parg (<x>)
The function 'parg' is a simplifying version of the complex
argument function 'carg'; thus
(%i1) map('parg,[1,1+%i,%i, -1 + %i, -1]);
%pi %pi 3 %pi
(%o1) [0, ---, ---, -----, %pi]
4 2 4
Generally, for a non-constant input, 'parg' returns a noun form;
thus
(%i2) parg(x + %i * sqrt(x));
(%o2) parg(x + %i sqrt(x))
When 'sign' can determine that the input is a positive or negative
real number, 'parg' will return a non-noun form for a non-constant
input. Here are two examples:
(%i3) parg(abs(x));
(%o3) 0
(%i4) parg(-x^2-1);
(%o4) %pi
Note The 'sign' function mostly ignores the variables that are
declared to be complex ('declare(x,complex)'); for variables that
are declared to be complex, the 'parg' can return incorrect values;
for example
(%i1) declare(x,complex)$
(%i2) parg(x^2 + 1);
(%o2) 0
Related function carg, isreal_p
To use 'load(to_poly_solve)'
Status The function 'parg' is experimental; its specifications
might change and its functionality might be merged into other
Maxima functions.
-- Function: real_imagpart_to_conjugate (<e>)
The function 'real_imagpart_to_conjugate' replaces all occurrences
of 'realpart' and 'imagpart' to algebraically equivalent
expressions involving the 'conjugate'.
(%i1) declare(x, complex)$
(%i2) real_imagpart_to_conjugate(realpart(x) + imagpart(x) = 3);
conjugate(x) + x %i (x - conjugate(x))
(%o2) ---------------- - --------------------- = 3
2 2
To use 'load(to_poly_solve)'
Status The function 'real_imagpart_to_conjugate' is experimental;
its specifications might change and its functionality might be
merged into other Maxima functions.
-- Function: rectform_log_if_constant (<e>)
The function 'rectform_log_if_constant' converts all terms of the
form ' log(c)' to 'rectform(log(c))', where 'c' is either a
declared constant expression or explicitly declared constant
(%i1) rectform_log_if_constant(log(1-%i) - log(x - %i));
log(2) %i %pi
(%o1) - log(x - %i) + ------ - ------
2 4
(%i2) declare(a,constant, b,constant)$
(%i3) rectform_log_if_constant(log(a + %i*b));
2 2
log(b + a )
(%o3) ------------ + %i atan2(b, a)
2
To use 'load(to_poly_solve)'
Status The function 'rectform_log_if_constant' is experimental; the
specifications of this function might change might change and its
functionality might be merged into other Maxima functions.
-- Function: simp_inequality (<e>)
The function 'simp_inequality' applies some simplifications to
conjunctions and disjunctions of inequations.
Limitations The function 'simp_inequality' is limited in at least
two ways; first, the simplifications are local; thus
(%i1) simp_inequality((x > minf) %and (x < 0));
(%o1) (x>1) %and (x<1)
And second, 'simp_inequality' doesn't consult the fact database:
(%i2) assume(x > 0)$
(%i3) simp_inequality(x > 0);
(%o3) x > 0
To use 'load(fourier_elim)'
Status The function 'simp_inequality' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Function: standardize_inverse_trig (<e>)
This function applies the identities 'cot(x) = atan(1/x), acsc(x) =
asin(1/x),' and similarly for 'asec, acoth, acsch' and 'asech' to
an expression. See Abramowitz and Stegun, Eqs. 4.4.6 through
4.4.8 and 4.6.4 through 4.6.6.
To use 'load(to_poly_solve)'
Status The function 'standardize_inverse_trig' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Function: subst_parallel (<l>, <e>)
When 'l' is a single equation or a list of equations, substitute
the right hand side of each equation for the left hand side. The
substitutions are made in parallel; for example
(%i1) load(to_poly_solve)$
(%i2) subst_parallel([x=y,y=x], [x,y]);
(%o2) [y, x]
Compare this to substitutions made serially:
(%i3) subst([x=y,y=x],[x,y]);
(%o3) [x, x]
The function 'subst_parallel' is similar to 'sublis' except that
'subst_parallel' allows for substitution of nonatoms; for example
(%i4) subst_parallel([x^2 = a, y = b], x^2 * y);
(%o4) a b
(%i5) sublis([x^2 = a, y = b], x^2 * y);
2
sublis: left-hand side of equation must be a symbol; found: x
-- an error. To debug this try: debugmode(true);
The substitutions made by 'subst_parallel' are literal, not
semantic; thus 'subst_parallel' does not recognize that x * y is a
subexpression of x^2 * y
(%i6) subst_parallel([x * y = a], x^2 * y);
2
(%o6) x y
The function 'subst_parallel' completes all substitutions before
simplifications. This allows for substitutions into conditional
expressions where errors might occur if the simplifications were
made earlier:
(%i7) subst_parallel([x = 0], %if(x < 1, 5, log(x)));
(%o7) 5
(%i8) subst([x = 0], %if(x < 1, 5, log(x)));
log: encountered log(0).
-- an error. To debug this try: debugmode(true);
Related functions subst, sublis, ratsubst
To use 'load(to_poly_solve_extra.lisp)'
Status The function 'subst_parallel' is experimental; the
specifications of this function might change might change and its
functionality might be merged into other Maxima functions.
-- Function: to_poly (<e>, <l>)
The function 'to_poly' attempts to convert the equation 'e' into a
polynomial system along with inequality constraints; the solutions
to the polynomial system that satisfy the constraints are solutions
to the equation 'e'. Informally, 'to_poly' attempts to
polynomialize the equation <e>; an example might clarify:
(%i1) load(to_poly_solve)$
(%i2) to_poly(sqrt(x) = 3, [x]);
2
(%o2) [[%g130 - 3, x = %g130 ],
%pi %pi
[- --- < parg(%g130), parg(%g130) <= ---], []]
2 2
The conditions '-%pi/2<parg(%g130),parg(%g130)<=%pi/2' tell us that
'%g130' is in the range of the square root function. When this is
true, the solution set to 'sqrt(x) = 3' is the same as the solution
set to '%g130-3,x=%g130^2'.
To polynomialize trigonometric expressions, it is necessary to
introduce a non algebraic substitution; these non algebraic
substitutions are returned in the third list returned by 'to_poly';
for example
(%i3) to_poly(cos(x),[x]);
2 %i x
(%o3) [[%g131 + 1], [2 %g131 # 0], [%g131 = %e ]]
Constant terms aren't polynomializied unless the number one is a
member of the variable list; for example
(%i4) to_poly(x = sqrt(5),[x]);
(%o4) [[x - sqrt(5)], [], []]
(%i5) to_poly(x = sqrt(5),[1,x]);
2
(%o5) [[x - %g132, 5 = %g132 ],
%pi %pi
[- --- < parg(%g132), parg(%g132) <= ---], []]
2 2
To generate a polynomial with sqrt(5) + sqrt(7) as one of its
roots, use the commands
(%i6) first(elim_allbut(first(to_poly(x = sqrt(5) + sqrt(7),
[1,x])), [x]));
4 2
(%o6) [x - 24 x + 4]
Related functions to_poly_solve
To use 'load(to_poly)'
Status: The function 'to_poly' is experimental; its specifications
might change and its functionality might be merged into other
Maxima functions.
-- Function: to_poly_solve (<e>, <l>, [options])
The function 'to_poly_solve' tries to solve the equations e for the
variables l. The equation(s) e can either be a single expression
or a set or list of expressions; similarly, l can either be a
single symbol or a list of set of symbols. When a member of e
isn't explicitly an equation, for example x^2 -1, the solver
asummes that the expression vanishes.
The basic strategy of 'to_poly_solve' is to convert the input into
a polynomial form and to call 'algsys' on the polynomial system.
Internally 'to_poly_solve' defaults 'algexact' to true. To change
the default for 'algexact', append 'algexact=false to the
'to_poly_solve' argument list.
When 'to_poly_solve' is able to determine the solution set, each
member of the solution set is a list in a '%union' object:
(%i1) load(to_poly_solve)$
(%i2) to_poly_solve(x*(x-1) = 0, x);
(%o2) %union([x = 0], [x = 1])
When 'to_poly_solve' is unable to determine the solution set, a
'%solve' nounform is returned (in this case, a warning is printed)
(%i3) to_poly_solve(x^k + 2* x + 1 = 0, x);
Nonalgebraic argument given to 'to_poly'
unable to solve
k
(%o3) %solve([x + 2 x + 1 = 0], [x])
Subsitution into a '%solve' nounform can sometimes result in the
solution
(%i4) subst(k = 2, %);
(%o4) %union([x = - 1])
Especially for trigonometric equations, the solver sometimes needs
to introduce an arbitrary integer. These arbitrary integers have
the form '%zXXX', where 'XXX' is an integer; for example
(%i5) to_poly_solve(sin(x) = 0, x);
(%o5) %union([x = 2 %pi %z33 + %pi], [x = 2 %pi %z35])
To re-index these variables to zero, use 'nicedummies':
(%i6) nicedummies(%);
(%o6) %union([x = 2 %pi %z0 + %pi], [x = 2 %pi %z1])
Occasionally, the solver introduces an arbitrary complex number of
the form '%cXXX' or an arbitrary real number of the form '%rXXX'.
The function 'nicedummies' will re-index these identifiers to zero.
The solution set sometimes involves simplifing versions of various
of logical operators including '%and', '%or', or '%if' for
conjunction, disjuntion, and implication, respectively; for example
(%i7) sol : to_poly_solve(abs(x) = a, x);
(%o7) %union(%if(isnonnegative_p(a), [x = - a], %union()),
%if(isnonnegative_p(a), [x = a], %union()))
(%i8) subst(a = 42, sol);
(%o8) %union([x = - 42], [x = 42])
(%i9) subst(a = -42, sol);
(%o9) %union()
The empty set is represented by '%union()'.
The function 'to_poly_solve' is able to solve some, but not all,
equations involving rational powers, some nonrational powers,
absolute values, trigonometric functions, and minimum and maximum.
Also, some it can solve some equations that are solvable in in
terms of the Lambert W function; some examples:
(%i1) load(to_poly_solve)$
(%i2) to_poly_solve(set(max(x,y) = 5, x+y = 2), set(x,y));
(%o2) %union([x = - 3, y = 5], [x = 5, y = - 3])
(%i3) to_poly_solve(abs(1-abs(1-x)) = 10,x);
(%o3) %union([x = - 10], [x = 12])
(%i4) to_poly_solve(set(sqrt(x) + sqrt(y) = 5, x + y = 10),
set(x,y));
3/2 3/2
5 %i - 10 5 %i + 10
(%o4) %union([x = - ------------, y = ------------],
2 2
3/2 3/2
5 %i + 10 5 %i - 10
[x = ------------, y = - ------------])
2 2
(%i5) to_poly_solve(cos(x) * sin(x) = 1/2,x,
'simpfuncs = ['expand, 'nicedummies]);
%pi
(%o5) %union([x = %pi %z0 + ---])
4
(%i6) to_poly_solve(x^(2*a) + x^a + 1,x);
2 %i %pi %z81
-------------
1/a a
(sqrt(3) %i - 1) %e
(%o6) %union([x = -----------------------------------],
1/a
2
2 %i %pi %z83
-------------
1/a a
(- sqrt(3) %i - 1) %e
[x = -------------------------------------])
1/a
2
(%i7) to_poly_solve(x * exp(x) = a, x);
(%o7) %union([x = lambert_w(a)])
For linear inequalities, 'to_poly_solve' automatically does Fourier
elimination:
(%i8) to_poly_solve([x + y < 1, x - y >= 8], [x,y]);
7
(%o8) %union([x = y + 8, y < - -],
2
7
[y + 8 < x, x < 1 - y, y < - -])
2
Each optional argument to 'to_poly_solve' must be an equation;
generally, the order of these options does not matter.
* 'simpfuncs = l', where 'l' is a list of functions. Apply the
composition of the members of l to each solution.
(%i1) to_poly_solve(x^2=%i,x);
1/4 1/4
(%o1) %union([x = - (- 1) ], [x = (- 1) ])
(%i2) to_poly_solve(x^2= %i,x, 'simpfuncs = ['rectform]);
%i 1 %i 1
(%o2) %union([x = - ------- - -------], [x = ------- + -------])
sqrt(2) sqrt(2) sqrt(2) sqrt(2)
Sometimes additional simplification can revert a
simplification; for example
(%i3) to_poly_solve(x^2=1,x);
(%o3) %union([x = - 1], [x = 1])
(%i4) to_poly_solve(x^2= 1,x, 'simpfuncs = [polarform]);
%i %pi
(%o4) %union([x = 1], [x = %e ]
Maxima doesn't try to check that each member of the function
list 'l' is purely a simplification; thus
(%i5) to_poly_solve(x^2 = %i,x, 'simpfuncs = [lambda([s],s^2)]);
(%o5) %union([x = %i])
To convert each solution to a double float, use 'simpfunc =
['dfloat]':
(%i6) to_poly_solve(x^3 +x + 1 = 0,x,
'simpfuncs = ['dfloat]), algexact : true;
(%o6) %union([x = - .6823278038280178],
[x = .3411639019140089 - 1.161541399997251 %i],
[x = 1.161541399997251 %i + .3411639019140089])
* 'use_grobner = true' With this option, the function
'poly_reduced_grobner' is applied to the equations before
attempting their solution. Primarily, this option provides a
workaround for weakness in the function 'algsys'. Here is an
example of such a workaround:
(%i7) to_poly_solve([x^2+y^2=2^2,(x-1)^2+(y-1)^2=2^2],[x,y],
'use_grobner = true);
sqrt(7) - 1 sqrt(7) + 1
(%o7) %union([x = - -----------, y = -----------],
2 2
sqrt(7) + 1 sqrt(7) - 1
[x = -----------, y = - -----------])
2 2
(%i8) to_poly_solve([x^2+y^2=2^2,(x-1)^2+(y-1)^2=2^2],[x,y]);
(%o8) %union()
* 'maxdepth = k', where 'k' is a positive integer. This
function controls the maximum recursion depth for the solver.
The default value for 'maxdepth' is five. When the recursions
depth is exceeded, the solver signals an error:
(%i9) to_poly_solve(cos(x) = x,x, 'maxdepth = 2);
Unable to solve
Unable to solve
(%o9) %solve([cos(x) = x], [x], maxdepth = 2)
* 'parameters = l', where 'l' is a list of symbols. The solver
attempts to return a solution that is valid for all members of
the list 'l'; for example:
(%i10) to_poly_solve(a * x = x, x);
(%o10) %union([x = 0])
(%i11) to_poly_solve(a * x = x, x, 'parameters = [a]);
(%o11) %union(%if(a - 1 = 0, [x = %c111], %union()),
%if(a - 1 # 0, [x = 0], %union()))
In '(%o2)', the solver introduced a dummy variable; to
re-index the these dummy variables, use the function
'nicedummies':
(%i12) nicedummies(%);
(%o12) %union(%if(a - 1 = 0, [x = %c0], %union()),
%if(a - 1 # 0, [x = 0], %union()))
The 'to_poly_solve' uses data stored in the hashed array
'one_to_one_reduce' to solve equations of the form f(a) = f(b).
The assignment 'one_to_one_reduce['f,'f] : lambda([a,b], a=b)'
tells 'to_poly_solve' that the solution set of f(a) = f(b) equals
the solution set of a=b; for example
(%i13) one_to_one_reduce['f,'f] : lambda([a,b], a=b)$
(%i14) to_poly_solve(f(x^2-1) = f(0),x);
(%o14) %union([x = - 1], [x = 1])
More generally, the assignment 'one_to_one_reduce['f,'g] :
lambda([a,b], w(a, b) = 0' tells 'to_poly_solve' that the solution
set of f(a) = f(b) equals the solution set of w(a,b) = 0; for
example
(%i15) one_to_one_reduce['f,'g] : lambda([a,b], a = 1 + b/2)$
(%i16) to_poly_solve(f(x) - g(x),x);
(%o16) %union([x = 2])
Additionally, the function 'to_poly_solve' uses data stored in the
hashed array 'function_inverse' to solve equations of the form f(a)
= b. The assignment 'function_inverse['f] : lambda([s], g(s))'
informs 'to_poly_solve' that the solution set to 'f(x) = b' equals
the solution set to 'x = g(b)'; two examples:
(%i17) function_inverse['Q] : lambda([s], P(s))$
(%i18) to_poly_solve(Q(x-1) = 2009,x);
(%o18) %union([x = P(2009) + 1])
(%i19) function_inverse['G] : lambda([s], s+new_variable(integer));
(%o19) lambda([s], s + new_variable(integer))
(%i20) to_poly_solve(G(x - a) = b,x);
(%o20) %union([x = b + a + %z125])
Notes
* The solve variables needn't be symbols; when 'fullratsubst' is
able to appropriately make substitutions, the solve variables
can be nonsymbols:
(%i1) to_poly_solve([x^2 + y^2 + x * y = 5, x * y = 8],
[x^2 + y^2, x * y]);
2 2
(%o1) %union([x y = 8, y + x = - 3])
* For equations that involve complex conjugates, the solver
automatically appends the conjugate equations; for example
(%i1) declare(x,complex)$
(%i2) to_poly_solve(x + (5 + %i) * conjugate(x) = 1, x);
%i + 21
(%o2) %union([x = - -----------])
25 %i - 125
(%i3) declare(y,complex)$
(%i4) to_poly_solve(set(conjugate(x) - y = 42 + %i,
x + conjugate(y) = 0), set(x,y));
%i - 42 %i + 42
(%o4) %union([x = - -------, y = - -------])
2 2
* For an equation that involves the absolute value function, the
'to_poly_solve' consults the fact database to decide if the
argument to the absolute value is complex valued. When
(%i1) to_poly_solve(abs(x) = 6, x);
(%o1) %union([x = - 6], [x = 6])
(%i2) declare(z,complex)$
(%i3) to_poly_solve(abs(z) = 6, z);
(%o3) %union(%if((%c11 # 0) %and (%c11 conjugate(%c11) - 36 =
0), [z = %c11], %union()))
This is the only situation that the solver consults the fact
database. If a solve variable is declared to be an integer,
for example, 'to_poly_solve' ignores this declaration.
Relevant option variables algexact, resultant, algebraic
Related functions to_poly
To use 'load(to_poly_solve)'
Status: The function 'to_poly_solve' is experimental; its
specifications might change and its functionality might be merged
into other Maxima functions.
-- Operator: %union (<soln_1>, <soln_2>, <soln_3>, ...)
-- Operator: %union ()
'%union(<soln_1>, <soln_2>, <soln_3>, ...)' represents the union of
its arguments, each of which represents a solution set, as
determined by 'to_poly_solve'. '%union()' represents the empty
set.
In many cases, a solution is a list of equations '[<x> = ..., <y> =
..., <z> = ...]' where <x>, <y>, and <z> are one or more unknowns.
In such cases, 'to_poly_solve' returns a '%union' expression
containing one or more such lists.
The solution set sometimes involves simplifing versions of various
of logical operators including '%and', '%or', or '%if' for
conjunction, disjuntion, and implication, respectively.
Examples:
'%union(...)' represents the union of its arguments, each of which
represents a solution set, as determined by 'to_poly_solve'. In
many cases, a solution is a list of equations.
(%i1) load ("to_poly_solve") $
(%i2) to_poly_solve ([sqrt(x^2 - y^2), x + y], [x, y]);
(%o2) %union([x = 0, y = 0], [x = %c13, y = - %c13])
'%union()' represents the empty set.
(%i1) load ("to_poly_solve") $
(%i2) to_poly_solve (abs(x) = -1, x);
(%o2) %union()
The solution set sometimes involves simplifing versions of various
of logical operators.
(%i1) load ("to_poly_solve") $
(%i2) sol : to_poly_solve (abs(x) = a, x);
(%o2) %union(%if(isnonnegative_p(a), [x = - a], %union()),
%if(isnonnegative_p(a), [x = a], %union()))
(%i3) subst (a = 42, sol);
(%o3) %union([x = - 42], [x = 42])
(%i4) subst (a = -42, sol);
(%o4) %union()
automatically generated by info2www version 1.2.2.9