Next: Package functs, Previous: Package absimp, Up: simplification [Contents][Index]
The facexp
package contains several related functions that
provide the user with the ability to structure expressions by controlled
expansion. This capability is especially useful when the expression
contains variables that have physical meaning, because it is often true
that the most economical form of such an expression can be obtained by
fully expanding the expression with respect to those variables, and then
factoring their coefficients. While it is true that this procedure is
not difficult to carry out using standard Maxima functions, additional
fine-tuning may also be desirable, and these finishing touches can be
more difficult to apply.
The function facsum
and its related forms
provide a convenient means for controlling the structure of expressions
in this way. Another function, collectterms
, can be used to add two or
more expressions that have already been simplified to this form, without
resimplifying the whole expression again. This function may be
useful when the expressions are very large.
load ("facexp")
loads this package.
demo ("facexp")
shows a demonstration of this package.
Returns a form of expr which depends on the
arguments arg_1, ..., arg_n.
The arguments can be any form suitable for ratvars
, or they can be
lists of such forms. If the arguments are not lists, then the form
returned is fully expanded with respect to the arguments, and the
coefficients of the arguments are factored. These coefficients are
free of the arguments, except perhaps in a non-rational sense.
If any of the arguments are lists, then all such lists are combined
into a single list, and instead of calling factor
on the
coefficients of the arguments, facsum
calls itself on these
coefficients, using this newly constructed single list as the new
argument list for this recursive call. This process can be repeated to
arbitrary depth by nesting the desired elements in lists.
It is possible that one may wish to facsum
with respect to more
complicated subexpressions, such as log (x + y)
. Such arguments are
also permissible.
Occasionally the user may wish to obtain any of the above forms
for expressions which are specified only by their leading operators.
For example, one may wish to facsum
with respect to all log
’s. In
this situation, one may include among the arguments either the specific
log
’s which are to be treated in this way, or alternatively, either
the expression operator (log)
or 'operator (log)
. If one wished to
facsum
the expression expr with respect to the operators op_1, ..., op_n,
one would evaluate facsum (expr, operator (op_1, ..., op_n))
.
The operator
form may also appear inside list arguments.
In addition, the setting of the switches facsum_combine
and
nextlayerfactor
may affect the result of facsum
.
Default value: false
When nextlayerfactor
is true
, recursive calls of facsum
are applied to the factors of the factored form of the
coefficients of the arguments.
When false
, facsum
is applied to
each coefficient as a whole whenever recursive calls to facsum
occur.
Inclusion of the atom
nextlayerfactor
in the argument list of facsum
has the effect of
nextlayerfactor: true
, but for the next level of the expression only.
Since nextlayerfactor
is always bound to either true
or false
, it
must be presented single-quoted whenever it appears in the argument list of facsum
.
Default value: true
facsum_combine
controls the form of the final result returned by
facsum
when its argument is a quotient of polynomials. If
facsum_combine
is false
then the form will be returned as a fully
expanded sum as described above, but if true
, then the expression
returned is a ratio of polynomials, with each polynomial in the form
described above.
The true
setting of this switch is useful when one
wants to facsum
both the numerator and denominator of a rational
expression, but does not want the denominator to be multiplied
through the terms of the numerator.
Returns a form of expr which is
obtained by calling facsum
on the factors of expr with arg_1, ... arg_n as
arguments. If any of the factors of expr is raised to a power, both
the factor and the exponent will be processed in this way.
Collects all terms that contain arg_1 ... arg_n.
If several expressions have been simplified with the following functions
facsum
, factorfacsum
, factenexpand
, facexpten
or
factorfacexpten
, and they are to be added together, it may be desirable
to combine them using the function collecterms
. collecterms
can
take as arguments all of the arguments that can be given to these other
associated functions with the exception of nextlayerfactor
, which has no
effect on collectterms
. The advantage of collectterms
is that it
returns a form similar to facsum
, but since it is adding forms that have
already been processed by facsum
, it does not need to repeat that effort.
This capability is especially useful when the expressions to be summed are very
large.
See also factor
.
Example:
(%i1) (exp(x)+2)*x+exp(x); x x (%o1) x (%e + 2) + %e
(%i2) collectterms(expand(%),exp(x)); x (%o2) (x + 1) %e + 2 x
Next: Package functs, Previous: Package absimp, Up: simplification [Contents][Index]