The commands in this section perform general-purpose algebraic manipulations. They work on the whole formula at the top of the stack (unless, of course, you have made a selection in that formula).

Many algebra commands prompt for a variable name or formula. If you answer the prompt with a blank line, the variable or formula is taken from top-of-stack, and the normal argument for the command is taken from the second-to-top stack level.

The `a v` (`calc-alg-evaluate`

) command performs the normal
default simplifications on a formula; for example, ‘`a - -b`’ is
changed to ‘`a + b`’. These simplifications are normally done
automatically on all Calc results, so this command is useful only if
you have turned default simplifications off with an `m O`
command. See Simplification Modes.

It is often more convenient to type `=`, which is like `a v`
but which also substitutes stored values for variables in the formula.
Use `a v` if you want the variables to ignore their stored values.

If you give a numeric prefix argument of 2 to `a v`, it simplifies
using Calc’s algebraic simplifications; see Simplifying Formulas.
If you give a numeric prefix of 3 or more, it uses Extended
Simplification mode (`a e`).

If you give a negative prefix argument *-1*, *-2*, or *-3*,
it simplifies in the corresponding mode but only works on the top-level
function call of the formula. For example, ‘`(2 + 3) * (2 + 3)`’ will
simplify to ‘`(2 + 3)^2`’, without simplifying the sub-formulas
‘`2 + 3`’. As another example, typing `V R +` to sum the vector
‘`[1, 2, 3, 4]`’ produces the formula ‘`reduce(add, [1, 2, 3, 4])`’
in No-Simplify mode. Using `a v` will evaluate this all the way to
10; using `C-u - a v` will evaluate it only to ‘`1 + 2 + 3 + 4`’.
(See Reducing and Mapping Vectors.)

The `=` command corresponds to the `evalv`

function, and
the related `N` command, which is like `=` but temporarily
disables Symbolic mode (`m s`) during the evaluation, corresponds
to the `evalvn`

function. (These commands interpret their prefix
arguments differently than `a v`; `=` treats the prefix as
the number of stack elements to evaluate at once, and `N` treats
it as a temporary different working precision.)

The `evalvn`

function can take an alternate working precision
as an optional second argument. This argument can be either an
integer, to set the precision absolutely, or a vector containing
a single integer, to adjust the precision relative to the current
precision. Note that `evalvn`

with a larger than current
precision will do the calculation at this higher precision, but the
result will as usual be rounded back down to the current precision
afterward. For example, ‘`evalvn(pi - 3.1415)`’ at a precision
of 12 will return ‘`9.265359e-5`’; ‘`evalvn(pi - 3.1415, 30)`’
will return ‘`9.26535897932e-5`’ (computing a 25-digit result which
is then rounded down to 12); and ‘`evalvn(pi - 3.1415, [-2])`’
will return ‘`9.2654e-5`’.

The `a "` (`calc-expand-formula`

) command expands functions
into their defining formulas wherever possible. For example,
‘`deg(x^2)`’ is changed to ‘`180 x^2 / pi`’. Most functions,
like `sin`

and `gcd`

, are not defined by simple formulas
and so are unaffected by this command. One important class of
functions which *can* be expanded is the user-defined functions
created by the `Z F` command. See Programming with Formulas.
Other functions which `a "` can expand include the probability
distribution functions, most of the financial functions, and the
hyperbolic and inverse hyperbolic functions. A numeric prefix argument
affects `a "` in the same way as it does `a v`: A positive
argument expands all functions in the formula and then simplifies in
various ways; a negative argument expands and simplifies only the
top-level function call.

The `a M` (`calc-map-equation`

) [`mapeq`

] command applies
a given function or operator to one or more equations. It is analogous
to `V M`, which operates on vectors instead of equations.
see Reducing and Mapping Vectors. For example, `a M S` changes
‘`x = y+1`’ to ‘`sin(x) = sin(y+1)`’, and `a M +` with
‘`x = y+1`’ and ‘`6`’ on the stack produces ‘`x+6 = y+7`’.
With two equations on the stack, `a M +` would add the lefthand
sides together and the righthand sides together to get the two
respective sides of a new equation.

Mapping also works on inequalities. Mapping two similar inequalities
produces another inequality of the same type. Mapping an inequality
with an equation produces an inequality of the same type. Mapping a
‘`<=`’ with a ‘`<`’ or ‘`!=`’ (not-equal) produces a ‘`<`’.
If inequalities with opposite direction (e.g., ‘`<`’ and ‘`>`’)
are mapped, the direction of the second inequality is reversed to
match the first: Using `a M +` on ‘`a < b`’ and ‘`a > 2`’
reverses the latter to get ‘`2 < a`’, which then allows the
combination ‘`a + 2 < b + a`’, which the algebraic simplifications
can reduce to ‘`2 < b`’.

Using `a M *`, `a M /`, `a M n`, or `a M &` to negate
or invert an inequality will reverse the direction of the inequality.
Other adjustments to inequalities are *not* done automatically;
`a M S` will change ‘`x < y`’ to ‘`sin(x) < sin(y)`’ even
though this is not true for all values of the variables.

With the Hyperbolic flag, `H a M` [`mapeqp`

] does a plain
mapping operation without reversing the direction of any inequalities.
Thus, `H a M &` would change `x > 2` to `1/x > 0.5`.
(This change is mathematically incorrect, but perhaps you were
fixing an inequality which was already incorrect.)

With the Inverse flag, `I a M` [`mapeqr`

] always reverses
the direction of the inequality. You might use `I a M C` to
change ‘`x < y`’ to ‘`cos(x) > cos(y)`’ if you know you are
working with small positive angles.

The `a b` (`calc-substitute`

) [`subst`

] command substitutes
all occurrences
of some variable or sub-expression of an expression with a new
sub-expression. For example, substituting ‘`sin(x)`’ with ‘`cos(y)`’
in ‘`2 sin(x)^2 + x sin(x) + sin(2 x)`’ produces
‘`2 cos(y)^2 + x cos(y) + sin(2 x)`’.
Note that this is a purely structural substitution; the lone ‘`x`’ and
the ‘`sin(2 x)`’ stayed the same because they did not look like
‘`sin(x)`’. See Rewrite Rules, for a more general method for
doing substitutions.

The `a b` command normally prompts for two formulas, the old
one and the new one. If you enter a blank line for the first
prompt, all three arguments are taken from the stack (new, then old,
then target expression). If you type an old formula but then enter a
blank line for the new one, the new formula is taken from top-of-stack
and the target from second-to-top. If you answer both prompts, the
target is taken from top-of-stack as usual.

Note that `a b` has no understanding of commutativity or
associativity. The pattern ‘`x+y`’ will not match the formula
‘`y+x`’. Also, ‘`y+z`’ will not match inside the formula ‘`x+y+z`’
because the ‘`+`’ operator is left-associative, so the “deep
structure” of that formula is ‘`(x+y) + z`’. Use `d U`
(`calc-unformatted-language`

) mode to see the true structure of
a formula. The rewrite rule mechanism, discussed later, does not have
these limitations.

As an algebraic function, `subst`

takes three arguments:
Target expression, old, new. Note that `subst`

is always
evaluated immediately, even if its arguments are variables, so if
you wish to put a call to `subst`

onto the stack you must
turn the default simplifications off first (with `m O`).