Undo and Redo
-------------

If you make a mistake, you can usually correct it by pressing
shift-`U', the "undo" command.  First, clear the stack (`M-0 DEL') and
exit and restart Calc (`M-# M-# M-# M-#') to make sure things start
off with a clean slate.  Now:

     1:  2          2:  2          1:  8          2:  2          1:  6
         .          1:  3              .          1:  3              .
                        .                             .

        2 RET           3              ^              U              *

You can undo any number of times.  Calc keeps a complete record of all
you have done since you last opened the Calc window.  After the above
example, you could type:

     1:  6          2:  2          1:  2              .              .
         .          1:  3              .
                        .
                                                                  (error)
                        U              U              U              U

You can also type `D' to "redo" a command that you have undone
mistakenly.

         .          1:  2          2:  2          1:  6          1:  6
                        .          1:  3              .              .
                                       .
                                                                  (error)
                        D              D              D              D

It was not possible to redo past the `6', since that was placed there
by something other than an undo command.

You can think of undo and redo as a sort of "time machine."  Press `U'
to go backward in time, `D' to go forward.  If you go backward and do
something (like `*') then, as any science fiction reader knows, you
have changed your future and you cannot go forward again.  Thus, the
inability to redo past the `6' even though there was an earlier undo
command.

You can always recall an earlier result using the Trail.  We've
ignored the trail so far, but it has been faithfully recording
everything we did since we loaded the Calculator.  If the Trail is not
displayed, press `t d' now to turn it on.

Let's try grabbing an earlier result.  The `8' we computed was
undone by a `U' command, and was lost even to Redo when we pressed
`*', but it's still there in the trail.  There should be a little
`>' arrow (the "trail pointer") resting on the last trail
entry.  If there isn't, press `t ]' to reset the trail pointer.
Now, press `t p' to move the arrow onto the line containing
`8', and press `t y' to "yank" that number back onto the
stack.

If you press `t ]' again, you will see that even our Yank command went
into the trail.

Let's go further back in time.  Earlier in the tutorial we computed a
huge integer using the formula `2^3^4'.  We don't remember what it
was, but the first digits were "241".  Press `t r' (which stands for
trail-search-reverse), then type `241'.  The trail cursor will jump
back to the next previous occurrence of the string "241" in the trail.
This is just a regular Emacs incremental search; you can now press
`C-s' or `C-r' to continue the search forwards or backwards as you
like.

To finish the search, press RET.  This halts the incremental search
and leaves the trail pointer at the thing we found.  Now we can type
`t y' to yank that number onto the stack.  If we hadn't remembered the
"241", we could simply have searched for `2^3^4', then pressed `RET t
n' to halt and then move to the next item.

You may have noticed that all the trail-related commands begin with
the letter `t'.  (The store-and-recall commands, on the other hand,
all began with `s'.)  Calc has so many commands that there aren't
enough keys for all of them, so various commands are grouped into
two-letter sequences where the first letter is called the "prefix"
key.  If you type a prefix key by accident, you can press `C-g' to
cancel it.  (In fact, you can press `C-g' to cancel almost anything in
Emacs.)  To get help on a prefix key, press that key followed by `?'.
Some prefixes have several lines of help, so you need to press `?' 
repeatedly to see them all.  This may not work under Lucid Emacs, but
you can also type `h h' to see all the help at once.

Try pressing `t ?' now.  You will see a line of the form,

     trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank:  [MORE]  t-

The word "trail" indicates that the `t' prefix key contains
trail-related commands.  Each entry on the line shows one command,
with a single capital letter showing which letter you press to get
that command.  We have used `t n', `t p', `t ]', and `t y' so far.
The `[MORE]' means you can press `?'  again to see more `t'-prefix
comands.  Notice that the commands are roughly divided (by semicolons)
into related groups.

When you are in the help display for a prefix key, the prefix is still
active.  If you press another key, like `y' for example, it will be
interpreted as a `t y' command.  If all you wanted was to look at the
help messages, press `C-g' afterwards to cancel the prefix.

One more way to correct an error is by editing the stack entries.  The
actual Stack buffer is marked read-only and must not be edited
directly, but you can press ``' (the backquote or accent grave) to
edit a stack entry.

Try entering `3.141439' now.  If this is supposed to represent `pi',
it's got several errors.  Press ``' to edit this number.  Now use the
normal Emacs cursor motion and editing keys to change the second 4 to
a 5, and to transpose the 3 and the 9.  When you press RET, the number
on the stack will be replaced by your new number.  This works for
formulas, vectors, and all other types of values you can put on the
stack.  The ``' key also works during entry of a number or algebraic
formula.