Changing Selections
-------------------

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.