| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 7.1 Functions and Variables for Simplification |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
When asksign is called,
askexp is the expression asksign is testing.
At one time, it was possible for a user to inspect askexp
by entering a Maxima break with control-A.
@ref{Category: Declarations and inferences}
askinteger (expr, integer) attempts to determine from the assume database
whether expr is an integer.
askinteger prompts the user if it cannot tell otherwise,
and attempt to install the information in the database if possible.
askinteger (expr) is equivalent to askinteger (expr, integer).
askinteger (expr, even) and askinteger (expr, odd)
likewise attempt to determine if expr is an even integer or odd integer, respectively.
@ref{Category: Declarations and inferences}
First attempts to determine whether the specified
expression is positive, negative, or zero. If it cannot, it asks the
user the necessary questions to complete its deduction. The user's
answer is recorded in the data base for the duration of the current
computation. The return value of asksign is one of pos, neg,
or zero.
@ref{Category: Declarations and inferences}
The function demoivre (expr) converts one expression
without setting the global variable demoivre.
When the variable demoivre is true,
complex exponentials are converted into equivalent expressions in terms of circular functions:
exp (a + b*%i) simplifies to %e^a * (cos(b) + %i*sin(b))
if b is free of %i.
a and b are not expanded.
The default value of demoivre is false.
exponentialize converts circular and hyperbolic functions to exponential form.
demoivre and exponentialize cannot
both be true at the same time.
@ref{Category: Complex variables} · @ref{Category: Trigonometric functions} · @ref{Category: Hyperbolic functions}
Default value: real
When domain is set to complex, sqrt (x^2) will remain
sqrt (x^2) instead of returning abs(x).
@ref{Category: Simplification flags and variables}
Expand expression expr. Products of sums and exponentiated sums are multiplied out, numerators of rational expressions which are sums are split into their respective terms, and multiplication (commutative and non-commutative) are distributed over addition at all levels of expr.
For polynomials one should usually use ratexpand which uses a
more efficient algorithm.
maxnegex and maxposex control the maximum negative and
positive exponents, respectively, which will expand.
expand (expr, p, n) expands expr,
using p for maxposex and n for maxnegex.
This is useful in order to expand part but not all of an expression.
expon - the exponent of the largest negative power which is
automatically expanded (independent of calls to expand). For example
if expon is 4 then (x+1)^(-5) will not be automatically expanded.
expop - the highest positive exponent which is automatically
expanded. Thus (x+1)^3, when typed, will be automatically expanded
only if expop is greater than or equal to 3. If it is desired to have
(x+1)^n expanded where n is greater than expop then executing
expand ((x+1)^n) will work only if maxposex is not less than n.
The expand flag used with ev causes expansion.
The file `simplification/facexp.mac'
contains several related functions (in particular facsum, factorfacsum
and collectterms, which are autoloaded) and variables (nextlayerfactor
and facsum_combine) that provide the user with the ability to structure
expressions by controlled expansion.
Brief function descriptions are available in `simplification/facexp.usg'.
A demo is available by doing demo("facexp").
@ref{Category: Expressions}
Expands expression expr with respect to the
variables x_1, ..., x_n.
All products involving the variables appear explicitly. The form returned
will be free of products of sums of expressions that are not free of
the variables. x_1, ..., x_n
may be variables, operators, or expressions.
By default, denominators are not expanded, but this can be controlled by
means of the switch expandwrt_denom.
This function is autoloaded from `simplification/stopex.mac'.
@ref{Category: Expressions}
Default value: false
expandwrt_denom controls the treatment of rational
expressions by expandwrt. If true, then both the numerator and
denominator of the expression will be expanded according to the
arguments of expandwrt, but if expandwrt_denom is false, then only the
numerator will be expanded in that way.
@ref{Category: Expressions}
is similar to expandwrt, but treats expressions that are products somewhat differently.
expandwrt_factored expands only on those factors of expr
that contain the variables x_1, ..., x_n.
This function is autoloaded from `simplification/stopex.mac'.
@ref{Category: Expressions}
Default value: 0
expon is the exponent of the largest negative power which
is automatically expanded (independent of calls to expand). For
example, if expon is 4 then (x+1)^(-5) will not be automatically
expanded.
@ref{Category: Expressions}
The function exponentialize (expr) converts
circular and hyperbolic functions in expr to exponentials,
without setting the global variable exponentialize.
When the variable exponentialize is true,
all circular and hyperbolic functions are converted to exponential form.
The default value is false.
demoivre converts complex exponentials into circular functions.
exponentialize and demoivre cannot
both be true at the same time.
@ref{Category: Complex variables} · @ref{Category: Trigonometric functions} · @ref{Category: Hyperbolic functions}
Default value: 0
expop is the highest positive exponent which is
automatically expanded. Thus (x + 1)^3, when typed, will be
automatically expanded only if expop is greater than or equal to 3.
If it is desired to have (x + 1)^n expanded where n is greater than
expop then executing expand ((x + 1)^n) will work only if maxposex is
not less than n.
@ref{Category: Expressions}
Default value: -1
factlim specifies the highest factorial which is
automatically expanded. If it is -1 then all integers are expanded.
@ref{Category: Gamma and factorial functions}
Moves multiplicative factors outside a summation to inside.
If the index is used in the
outside expression, then the function tries to find a reasonable
index, the same as it does for sumcontract. This is essentially the
reverse idea of the outative property of summations, but note that it
does not remove this property, it only bypasses it.
In some cases,
a scanmap (multthru, expr) may be necessary before the intosum.
@ref{Category: Expressions}
declare (g, lassociative) tells the
Maxima simplifier that g is left-associative. E.g., g (g (a, b), g (c, d)) will
simplify to g (g (g (a, b), c), d).
@ref{Category: Declarations and inferences} · @ref{Category: Operators} · @ref{Category: Simplification}
One of Maxima's operator properties. For univariate f so
declared, "expansion" f(x + y) yields f(x) + f(y),
f(a*x) yields a*f(x) takes
place where a is a "constant". For functions of two or more arguments,
"linearity" is defined to be as in the case of sum or integrate,
i.e., f (a*x + b, x) yields a*f(x,x) + b*f(1,x)
for a and b free of x.
linear is equivalent to additive and outative.
See also opproperties.
@ref{Category: Declarations and inferences} · @ref{Category: Operators} · @ref{Category: Simplification}
You may declare variables to be mainvar. The ordering
scale for atoms is essentially: numbers < constants (e.g., %e, %pi) <
scalars < other variables < mainvars. E.g., compare expand ((X+Y)^4)
with (declare (x, mainvar), expand ((x+y)^4)). (Note: Care should be
taken if you elect to use the above feature. E.g., if you subtract an
expression in which x is a mainvar from one in which x isn't a
mainvar, resimplification e.g. with ev (expr, simp) may be
necessary if cancellation is to occur. Also, if you save an
expression in which x is a mainvar, you probably should also save x.)
@ref{Category: Declarations and inferences} · @ref{Category: Expressions}
Default value: 10000
maxapplydepth is the maximum depth to which apply1
and apply2 will delve.
@ref{Category: Function application}
Default value: 10000
maxapplyheight is the maximum height to which applyb1
will reach before giving up.
@ref{Category: Function application}
Default value: 1000
maxnegex is the largest negative exponent which will
be expanded by the expand command (see also maxposex).
@ref{Category: Expressions}
Default value: 1000
maxposex is the largest exponent which will be
expanded with the expand command (see also maxnegex).
@ref{Category: Expressions}
declare (f, multiplicative) tells the Maxima simplifier that f is multiplicative.
f is univariate, whenever the simplifier encounters f applied
to a product, f distributes over that product. E.g., f(x*y)
simplifies to f(x)*f(y).
f is a function of 2 or more arguments, multiplicativity is
defined as multiplicativity in the first argument to f, e.g.,
f (g(x) * h(x), x) simplifies to f (g(x) ,x) * f (h(x), x).
This simplification does not occur when f is applied to expressions of
the form product (x[i], i, m, n).
@ref{Category: Declarations and inferences} · @ref{Category: Expressions} · @ref{Category: Simplification}
Default value: true
When negdistrib is true, -1 distributes
over an expression. E.g., -(x + y) becomes - y - x. Setting it to false
will allow - (x + y) to be displayed like that. This is sometimes useful
but be very careful: like the simp flag, this is one flag you do not
want to set to false as a matter of course or necessarily for other
than local use in your Maxima.
@ref{Category: Simplification flags and variables}
Default value: true
When negsumdispflag is true, x - y displays as x - y
instead of as - y + x. Setting it to false causes the special check in
display for the difference of two expressions to not be done. One
application is that thus a + %i*b and a - %i*b may both be displayed the
same way.
@ref{Category: Display flags and variables}
noeval suppresses the evaluation phase of ev. This is useful in
conjunction with other switches and in causing expressions
to be resimplified without being reevaluated.
@ref{Category: Evaluation flags}
noun is one of the options of the declare command. It makes a
function so declared a "noun", meaning that it won't be evaluated
automatically.
@ref{Category: Nouns and verbs}
Default value: false
When noundisp is true, nouns display with
a single quote. This switch is always true when displaying function
definitions.
@ref{Category: Display flags and variables} · @ref{Category: Nouns and verbs}
nouns is an evflag. When used as an option to the ev command,
nouns converts all
"noun" forms occurring in the expression being ev'd to "verbs", i.e.,
evaluates them. See also noun, nounify, verb, and verbify.
@ref{Category: Evaluation flags} · @ref{Category: Nouns and verbs}
numer causes some mathematical functions (including exponentiation)
with numerical arguments to be evaluated in floating point. It causes
variables in expr which have been given numerals to be replaced by
their values. It also sets the float switch on.
See also %enumer.
@ref{Category: Numerical evaluation}
Declares the variables x_1, ..., x_n to have
numeric values equal to expr_1, ..., expr_n.
The numeric value is evaluated and substituted for the variable
in any expressions in which the variable occurs if the numer flag is
true. See also ev.
The expressions expr_1, ..., expr_n can be any expressions,
not necessarily numeric.
@ref{Category: Declarations and inferences} · @ref{Category: Numerical evaluation}
opproperties is the list of the special operator properties recognized by
the Maxima simplifier:
linear, additive, multiplicative, outative, evenfun,
oddfun, commutative, symmetric, antisymmetric, nary,
lassociative, rassociative.
@ref{Category: Global variables} · @ref{Category: Operators}
Default value: true
When opsubst is false, subst does not attempt to
substitute into the operator of an expression. E.g.,
(opsubst: false, subst (x^2, r, r+r[0])) will work.
@ref{Category: Expressions}
declare (f, outative) tells the Maxima simplifier that constant factors
in the argument of f can be pulled out.
f is univariate, whenever the simplifier encounters f applied
to a product, that product will be partitioned into factors that are
constant and factors that are not and the constant factors will be
pulled out. E.g., f(a*x) will simplify to a*f(x) where a is a
constant. Non-atomic constant factors will not be pulled out.
f is a function of 2 or more arguments, outativity is defined
as in the case of sum or integrate, i.e., f (a*g(x), x) will simplify
to a * f(g(x), x) for a free of x.
sum, integrate, and limit are all outative.
@ref{Category: Declarations and inferences} · @ref{Category: Operators}
declare (f, posfun) declares f to be a positive function.
is (f(x) > 0) yields true.
@ref{Category: Declarations and inferences} · @ref{Category: Operators}
Simplifies expr, which can contain logs, exponentials, and
radicals, by converting it into a form which is canonical over a large
class of expressions and a given ordering of variables; that is, all
functionally equivalent forms are mapped into a unique form. For a
somewhat larger class of expressions, radcan produces a regular form.
Two equivalent expressions in this class do not necessarily have the
same appearance, but their difference can be simplified by radcan to
zero.
For some expressions radcan is quite time consuming. This
is the cost of exploring certain relationships among the components of
the expression for simplifications based on factoring and
partial-fraction expansions of exponents.
When %e_to_numlog is true,
%e^(r*log(expr)) simplifies to expr^r if r is a rational number.
When radexpand is false, certain transformations are inhibited.
radcan (sqrt (1-x)) remains sqrt (1-x)
and is not simplified to %i sqrt (x-1).
radcan (sqrt (x^2 - 2*x + 1)) remains sqrt (x^2 - 2*x + 1)
and is not simplified to x - 1.
example (radcan) displays some examples.
@ref{Category: Simplification functions}
Default value: true
radexpand controls some simplifications of radicals.
When radexpand is all, causes nth roots of
factors of a product which are powers of n to be pulled outside of the
radical. E.g. if radexpand is all, sqrt (16*x^2) simplifies to 4*x.
More particularly, consider sqrt (x^2).
radexpand is all or assume (x > 0) has been executed,
sqrt(x^2) simplifies to x.
radexpand is true and domain is real (its default),
sqrt(x^2) simplifies to abs(x).
radexpand is false, or radexpand is true and domain is complex,
sqrt(x^2) is not simplified.
Note that domain only matters when radexpand is true.
@ref{Category: Simplification flags and variables}
Default value: false
radsubstflag, if true, permits ratsubst to make
substitutions such as u for sqrt (x) in x.
@ref{Category: Simplification flags and variables}
declare (g, rassociative) tells the Maxima
simplifier that g is right-associative. E.g.,
g(g(a, b), g(c, d)) simplifies to g(a, g(b, g(c, d))).
@ref{Category: Declarations and inferences} · @ref{Category: Operators}
Sequential Comparative Simplification (method due to Stoute).
scsimp attempts to simplify expr
according to the rules rule_1, ..., rule_n.
If a smaller expression is obtained, the process
repeats. Otherwise after all simplifications are tried, it returns
the original answer.
example (scsimp) displays some examples.
@ref{Category: Simplification functions}
Default value: false
When simpsum is true, the result of a sum is
simplified. This simplification may sometimes be able to produce a
closed form. If simpsum is false or if the quoted form 'sum is used, the value is a
sum noun form which is a representation of the sigma notation used in
mathematics.
@ref{Category: Sums and products} · @ref{Category: Simplification flags and variables}
Combines all sums of an addition that have
upper and lower bounds that differ by constants. The result is an
expression containing one summation for each set of such summations
added to all appropriate extra terms that had to be extracted to form
this sum. sumcontract combines all compatible sums and uses one of
the indices from one of the sums if it can, and then try to form a
reasonable index if it cannot use any supplied.
It may be necessary to do an intosum (expr) before the sumcontract.
@ref{Category: Sums and products}
Default value: false
When sumexpand is true, products of sums and
exponentiated sums simplify to nested sums.
See also cauchysum.
Examples:
(%i1) sumexpand: true$
(%i2) sum (f (i), i, 0, m) * sum (g (j), j, 0, n);
m n
==== ====
\ \
(%o2) > > f(i1) g(i2)
/ /
==== ====
i1 = 0 i2 = 0
(%i3) sum (f (i), i, 0, m)^2;
m m
==== ====
\ \
(%o3) > > f(i3) f(i4)
/ /
==== ====
i3 = 0 i4 = 0
@ref{Category: Sums and products} · @ref{Category: Simplification flags and variables}
Default value: true
When sumsplitfact is false,
minfactorial is applied after a factcomb.
@ref{Category: Gamma and factorial functions} · @ref{Category: Simplification flags and variables}
declare (h, symmetric) tells the Maxima
simplifier that h is a symmetric function. E.g., h (x, z, y)
simplifies to h (x, y, z).
commutative is synonymous with symmetric.
@ref{Category: Declarations and inferences} · @ref{Category: Operators}
Returns true if and only if expr contains an operator or function
not recognized by the Maxima simplifier.
@ref{Category: Predicate functions} · @ref{Category: Simplification functions}
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by root on July, 13 2009 using texi2html 1.76.