Calc has two built-in rewrite rules called `IntegRules`

and
`IntegAfterRules`

which you can edit to define new integration
methods. See section Rewrite Rules. At each step of the integration process,
Calc wraps the current integrand in a call to the fictitious function
``integtry( expr,var)'`, where

`integtry`

), then
Calc will use this formula as the integral of `mysin`

that acts like the sine function.
Then, putting `IntegRules`

.
As a more serious example, the expression ``exp(x)/x'` cannot be
integrated in terms of the standard functions, so the "exponential
integral" function @c{${\rm Ei}(x)$}
Ei(x) was invented to describe it.
We can get Calc to do this integral in terms of a made-up `Ei`

function by adding the rule ``[integtry(exp(x)/x, x) := Ei(x)]'`
to `IntegRules`

. Now entering ``exp(2x)/x'` on the stack
and typing `a i x` yields ``Ei(2 x)'`. This new rule will
work with Calc's various built-in integration methods (such as
integration by substitution) to solve a variety of other problems
involving `Ei`

: For example, now Calc will also be able to
integrate ``exp(exp(x))'` and ``ln(ln(x))'` (to get ``Ei(exp(x))'`
and ``x ln(ln(x)) - Ei(ln(x))'`, respectively).

Your rule may do further integration by calling `integ`

. For
example, ``integtry(twice(u),x) := twice(integ(u))'` allows Calc
to integrate ``twice(sin(x))'` to get ``twice(-cos(x))'`.
Note that `integ`

was called with only one argument. This notation
is allowed only within `IntegRules`

; it means "integrate this
with respect to the same integration variable." If Calc is unable
to integrate `u`

, the integration that invoked `IntegRules`

also fails. Thus integrating ``twice(f(x))'` fails, returning the
unevaluated integral ``integ(twice(f(x)), x)'`. It is still legal
to call `integ`

with two or more arguments, however; in this case,
if `u`

is not integrable, `twice`

itself will still be
integrated: If the above rule is changed to ``... := twice(integ(u,x))'`,
then integrating ``twice(f(x))'` will yield ``twice(integ(f(x),x))'`.

If a rule instead produces the formula ``integsubst( sexpr,
svar)'`, either replacing the top-level

`integtry`

call or
nested anywhere inside the expression, then Calc will apply the
substitution `integtry`

, but
it need not be.
When integrating according to an `integsubst`

, Calc uses the
equation solver to find the inverse of `sexpr` (if the integrand
refers to `var` anywhere except in subexpressions that exactly
match `sexpr`). It uses the differentiator to find the derivative
of `sexpr` and/or its inverse (it has two methods that use one
derivative or the other). You can also specify these items by adding
extra arguments to the `integsubst`

your rules construct; the
general form is ``integsubst( sexpr, svar, sinv,
sprime)'`, where

Calc applies `IntegRules`

as if by `C-u 1 a r IntegRules`;
in other words, Calc stops rewriting as soon as any rule in your rule
set succeeds. (If it weren't for this, the ``integsubst(sqrt(x),x)'`
example above would keep on adding layers of `integsubst`

calls
forever!)

Another set of rules, stored in `IntegSimpRules`

, are applied
every time the integrator uses `a s` to simplify an intermediate
result. For example, putting the rule ``twice(x) := 2 x'` into
`IntegSimpRules`

would tell Calc to convert the `twice`

function into a form it knows whenever integration is attempted.

One more way to influence the integrator is to define a function with
the `Z F` command (see section Programming with Formulas). Calc's
integrator automatically expands such functions according to their
defining formulas, even if you originally asked for the function to
be left unevaluated for symbolic arguments. (Certain other Calc
systems, such as the differentiator and the equation solver, also
do this.)

Sometimes Calc is able to find a solution to your integral, but it
expresses the result in a way that is unnecessarily complicated. If
this happens, you can either use `integsubst`

as described
above to try to hint at a more direct path to the desired result, or
you can use `IntegAfterRules`

. This is an extra rule set that
runs after the main integrator returns its result; basically, Calc does
an `a r IntegAfterRules` on the result before showing it to you.
(It also does an `a s`, without `IntegSimpRules`

, after that
to further simplify the result.) For example, Calc's integrator
sometimes produces expressions of the form ``ln(1+x) - ln(1-x)'`;
the default `IntegAfterRules`

rewrite this into the more readable
form ``2 arctanh(x)'`. Note that, unlike `IntegRules`

,
`IntegSimpRules`

and `IntegAfterRules`

are applied any number
of times until no further changes are possible. Rewriting by
`IntegAfterRules`

occurs only after the main integrator has
finished, not at every step as for `IntegRules`

and
`IntegSimpRules`

.

Go to the first, previous, next, last section, table of contents.