If a sub-formula of the current formula is selected (as by `j s`;
see 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 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.