Next: Simplifying Formulas, Previous: Selecting Subformulas, Up: Algebra

### 11.2 Algebraic Manipulation

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 as if in Algebraic Simplification mode. This is equivalent to typing `a s`; 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.)

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 Algebraic Definitions. 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. 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 `a s` command can then simplify to get ‘`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`).