Info Catalog calc: Selecting Subformulas calc: Algebra calc: Simplifying Formulas

calc: Algebraic Manipulation

 
 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.  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; 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’.  (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.  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.  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 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)’.  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’).
 

Info Catalog calc: Selecting Subformulas calc: Algebra calc: Simplifying Formulas