If a sub-formula of the current formula is selected (as by j s;
see section Selecting Sub-Formulas), the a r (calc-rewrite)
command applies only to that sub-formula. Together with a negative
prefix argument, you can use this fact to apply a rewrite to one
specific part of a formula without affecting any other parts.
The j r (calc-rewrite-selection) command allows more
sophisticated operations on selections. This command prompts for
the rules in the same way as a r, but it then applies those
rules to the whole formula in question even though a sub-formula
of it has been selected. However, the selected sub-formula will
first have been surrounded by a `select( )' function call.
(Calc's evaluator does not understand the function name select;
this is only a tag used by the j r command.)
For example, suppose the formula on the stack is `2 (a + b)^2'
and the sub-formula `a + b' is selected. This formula will
be rewritten to `2 select(a + b)^2' and then the rewrite
rules will be applied in the usual way. The rewrite rules can
include references to select to tell where in the pattern
the selected sub-formula should appear.
If there is still exactly one `select( )' function call in the formula after rewriting is done, it indicates which part of the formula should be selected afterwards. Otherwise, the formula will be unselected.
You can make j r act much like a r by enclosing both parts of the rewrite rule with `select()'. However, j r allows you to use the current selection in more flexible ways. Suppose you wished to make a rule which removed the exponent from the selected term; the rule `select(a)^x := select(a)' would work. In the above example, it would rewrite `2 select(a + b)^2' to `2 select(a + b)'. This would then be returned to the stack as `2 (a + b)' with the `a + b' selected.
The j r command uses one iteration by default, unlike a r which defaults to 100 iterations. A numeric prefix argument affects j r in the same way as a r. See section Nested Formulas with Rewrite Rules.
As with other selection commands, j r operates on the stack entry that contains the cursor. (If the cursor is on the top-of-stack `.' marker, it works as if the cursor were on the formula at stack level 1.)
If you don't specify a set of rules, the rules are taken from the top of the stack, just as with a r. In this case, the cursor must indicate stack entry 2 or above as the formula to be rewritten (otherwise the same formula would be used as both the target and the rewrite rules).
If the indicated formula has no selection, the cursor position within the formula temporarily selects a sub-formula for the purposes of this command. If the cursor is not on any sub-formula (e.g., it is in the line-number area to the left of the formula), the `select( )' markers are ignored by the rewrite mechanism and the rules are allowed to apply anywhere in the formula.
As a special feature, the normal a r command also ignores `select( )' calls in rewrite rules. For example, if you used the above rule `select(a)^x := select(a)' with a r, it would apply the rule as if it were `a^x := a'. Thus, you can write general purpose rules with `select( )' hints inside them so that they will "do the right thing" in both a r and j r, both with and without selections.