Once you have selected a sub-formula, you can expand it using the
j m (calc-select-more) command. If `a + b' is
selected, pressing j m repeatedly works as follows:
3 ... 3 ___ 3 ___
(a + b) . . . (a + b) + V c (a + b) + V c
1* ............... 1* ............... 1* ---------------
. . . . . . . . 2 x + 1
In the last example, the entire formula is selected. This is roughly the same as having no selection at all, but because there are subtle differences the `*' character is still there on the line number.
With a numeric prefix argument n, j m expands n times (or until the entire formula is selected). Note that j s with argument n is equivalent to plain j s followed by j m with argument n. If j m is used when there is no current selection, it is equivalent to j s.
Even though j m does not explicitly use the location of the cursor within the formula, it nevertheless uses the cursor to determine which stack element to operate on. As usual, j m when the cursor is not on any stack element operates on the top stack element.
The j l (calc-select-less) command reduces the current
selection around the cursor position. That is, it selects the
immediate sub-formula of the current selection which contains the
cursor, the opposite of j m. If the cursor is not inside the
current selection, the command de-selects the formula.
The j 1 through j 9 (calc-select-part) commands
select the nth sub-formula of the current selection. They are
like j l (calc-select-less) except they use counting
rather than the cursor position to decide which sub-formula to select.
For example, if the current selection is a + b + c or
f(a, b, c) or [a, b, c], then j 1 selects `a',
j 2 selects `b', and j 3 selects `c'; in each of
these cases, j 4 through j 9 would be errors.
If there is no current selection, j 1 through j 9 select the nth top-level sub-formula. (In other words, they act as if the entire stack entry were selected first.) To select the nth sub-formula where n is greater than nine, you must instead invoke j 1 with n as a numeric prefix argument.
The j n (calc-select-next) and j p
(calc-select-previous) commands change the current selection
to the next or previous sub-formula at the same level. For example,
if `b' is selected in `2 + a*b*c + x', then j n
selects `c'. Further j n commands would be in error because,
even though there is something to the right of `c' (namely, `x'),
it is not at the same level; in this case, it is not a term of the
same product as `b' and `c'. However, j m (to select
the whole product `a*b*c' as a term of the sum) followed by
j n would successfully select the `x'.
Similarly, j p moves the selection from the `b' in this sample formula to the `a'. Both commands accept numeric prefix arguments to move several steps at a time.
It is interesting to compare Calc's selection commands with the
Emacs Info system's commands for navigating through hierarchically
organized documentation. Calc's j n command is completely
analogous to Info's n command. Likewise, j p maps to
p, j 2 maps to 2, and Info's u is like j m.
(Note that j u stands for calc-unselect, not "up".)
The Info m command is somewhat similar to Calc's j s and
j l; in each case, you can jump directly to a sub-component
of the hierarchy simply by pointing to it with the cursor.