This is Info file calc.info, produced by Makeinfo-1.55 from the input
file calc.texinfo.
   This file documents Calc, the GNU Emacs calculator.
   Copyright (C) 1990, 1991 Free Software Foundation, Inc.
   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "GNU General Public License" is included
exactly as in the original, and provided that the entire resulting
derived work is distributed under the terms of a permission notice
identical to this one.
   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled "GNU General Public License"
may be included in a translation approved by the author instead of in
the original English.
File: calc.info,  Node: Key Index,  Next: Command Index,  Prev: Summary,  Up: Top
Index of Key Sequences
**********************
* Menu:
* !:                                    Combinatorial Functions.
* ":                                    Strings.
* " (HMS forms):                        HMS Forms.
* #:                                    Integers.
* $:                                    Algebraic Entry.
* %:                                    Basic Arithmetic.
* &:                                    Basic Arithmetic.
* & (matrices):                         Vector and Matrix Arithmetic.
* ':                                    Algebraic Entry.
* ' (HMS forms):                        HMS Forms.
* (:                                    Incomplete Objects.
* ):                                    Incomplete Objects.
* *:                                    Basic Arithmetic.
* +:                                    Basic Arithmetic.
* ,:                                    Incomplete Objects.
* -:                                    Basic Arithmetic.
* .:                                    Numeric Entry.
* ..:                                   Incomplete Objects.
* /:                                    Basic Arithmetic.
* 0-9:                                  Numeric Entry.
* ::                                    Basic Arithmetic.
* ;:                                    Incomplete Objects.
* <:                                    Basic Commands.
* =:                                    Variables.
* >:                                    Basic Commands.
* ?:                                    Help Commands.
* @:                                    HMS Forms.
* {:                                    Basic Commands.
* }:                                    Basic Commands.
* A:                                    Basic Arithmetic.
* a !:                                  Logical Operations.
* a ":                                  Algebraic Manipulation.
* a #:                                  Logical Operations.
* a %:                                  Polynomials.
* a &:                                  Logical Operations.
* A (vectors):                          Vector and Matrix Arithmetic.
* a *:                                  Summations.
* a +:                                  Summations.
* a -:                                  Summations.
* a .:                                  Logical Operations.
* a /:                                  Polynomials.
* a ::                                  Logical Operations.
* a <:                                  Logical Operations.
* a =:                                  Logical Operations.
* a >:                                  Logical Operations.
* a {:                                  Logical Operations.
* a a:                                  Polynomials.
* a b:                                  Algebraic Manipulation.
* a c:                                  Polynomials.
* a d:                                  Differentiation.
* a e:                                  Unsafe Simplifications.
* a f:                                  Polynomials.
* a F:                                  Linear Fits.
* a g:                                  Polynomials.
* a I:                                  Numerical Integration.
* a i:                                  Integration.
* a m:                                  Matching Commands.
* a M:                                  Algebraic Manipulation.
* a n:                                  Polynomials.
* a N:                                  Minimization.
* a p:                                  Interpolation.
* a P:                                  Multiple Solutions.
* a R:                                  Root Finding.
* a r:                                  Rewrite Rules.
* a s:                                  Simplifying Formulas.
* a S:                                  Solving Equations.
* a t:                                  Taylor Series.
* a T:                                  Summations.
* a v:                                  Algebraic Manipulation.
* a X:                                  Minimization.
* a x:                                  Polynomials.
* a [:                                  Logical Operations.
* a \:                                  Polynomials.
* a ]:                                  Logical Operations.
* a _:                                  Extracting Elements.
* a |:                                  Logical Operations.
* B:                                    Logarithmic Functions.
* b #:                                  Related Financial Functions.
* b %:                                  Percentages.
* b a:                                  Binary Functions.
* b c:                                  Binary Functions.
* b D:                                  Depreciation Functions.
* b d:                                  Binary Functions.
* b F:                                  Future Value.
* b I:                                  Related Financial Functions.
* b l:                                  Binary Functions.
* b L:                                  Binary Functions.
* b M:                                  Related Financial Functions.
* b n:                                  Binary Functions.
* b N:                                  Present Value.
* b o:                                  Binary Functions.
* b P:                                  Present Value.
* b p:                                  Set Operations.
* b r:                                  Binary Functions.
* b R:                                  Binary Functions.
* b S:                                  Depreciation Functions.
* b t:                                  Binary Functions.
* b T:                                  Related Financial Functions.
* b u:                                  Set Operations.
* b w:                                  Binary Functions.
* b x:                                  Binary Functions.
* b Y:                                  Depreciation Functions.
* C:                                    Trigonometric and Hyperbolic Functions.
* c %:                                  Percentages.
* c 0-9:                                Conversions.
* c c:                                  Conversions.
* c d:                                  Conversions.
* c f:                                  Conversions.
* c F:                                  Conversions.
* c h:                                  Conversions.
* c p:                                  Conversions.
* c r:                                  Conversions.
* C-d:                                  Stack Manipulation.
* C-k:                                  Killing From Stack.
* C-w:                                  Killing From Stack.
* C-y:                                  Yanking Into Stack.
* C-_:                                  Undo.
* D:                                    Undo.
* d ":                                  Strings.
* d ,:                                  Grouping Digits.
* d .:                                  Float Formats.
* d 0:                                  Radix Modes.
* d 2:                                  Radix Modes.
* d 6:                                  Radix Modes.
* d 8:                                  Radix Modes.
* d <:                                  Justification.
* d =:                                  Justification.
* d >:                                  Justification.
* d {:                                  Labels.
* d }:                                  Labels.
* d b:                                  Normal Language Modes.
* d B:                                  Normal Language Modes.
* d C:                                  C FORTRAN Pascal.
* d c:                                  Complex Formats.
* d d:                                  Date Formats.
* d E:                                  Eqn Language Mode.
* d e:                                  Float Formats.
* d f:                                  Float Formats.
* d F:                                  C FORTRAN Pascal.
* d g:                                  Grouping Digits.
* d h:                                  HMS Formats.
* d i:                                  Complex Formats.
* d j:                                  Complex Formats.
* d l:                                  Stack Basics.
* d M:                                  Mathematica Language Mode.
* d n:                                  Float Formats.
* d N:                                  Normal Language Modes.
* d o:                                  Fraction Formats.
* d O:                                  Normal Language Modes.
* d p:                                  More About Embedded Mode.
* d P:                                  C FORTRAN Pascal.
* d r:                                  Radix Modes.
* d RET:                                Display Modes.
* d s:                                  Float Formats.
* d SPC:                                Basic Commands.
* d T:                                  TeX Language Mode.
* d t:                                  Truncating the Stack.
* d U:                                  Normal Language Modes.
* d W:                                  Maple Language Mode.
* d w:                                  Error Messages.
* d z:                                  Radix Modes.
* d [:                                  Truncating the Stack.
* d ]:                                  Truncating the Stack.
* DEL:                                  Stack Manipulation.
* e:                                    Numeric Entry.
* E:                                    Logarithmic Functions.
* F:                                    Integer Truncation.
* f A:                                  Basic Arithmetic.
* f B:                                  Advanced Math Functions.
* f b:                                  Advanced Math Functions.
* f e:                                  Advanced Math Functions.
* f E:                                  Logarithmic Functions.
* f g:                                  Advanced Math Functions.
* f G:                                  Advanced Math Functions.
* f h:                                  Basic Arithmetic.
* f I:                                  Logarithmic Functions.
* f i:                                  Complex Number Functions.
* f j:                                  Advanced Math Functions.
* f L:                                  Logarithmic Functions.
* f M:                                  Basic Arithmetic.
* f n:                                  Basic Arithmetic.
* f Q:                                  Basic Arithmetic.
* f r:                                  Complex Number Functions.
* f s:                                  Basic Arithmetic.
* f S:                                  Basic Arithmetic.
* f T:                                  Trigonometric and Hyperbolic Functions.
* f x:                                  Basic Arithmetic.
* f X:                                  Basic Arithmetic.
* f y:                                  Advanced Math Functions.
* f [:                                  Basic Arithmetic.
* f ]:                                  Basic Arithmetic.
* G:                                    Complex Number Functions.
* g A:                                  Managing Curves.
* g a:                                  Managing Curves.
* g b:                                  Graphics Options.
* g c:                                  Basic Graphics.
* g C:                                  Devices.
* g C-l:                                Graphics Options.
* g C-r:                                Graphics Options.
* g C-t:                                Graphics Options.
* g D:                                  Devices.
* g d:                                  Managing Curves.
* g F:                                  Three Dimensional Graphics.
* g f:                                  Basic Graphics.
* g g:                                  Graphics Options.
* g H:                                  Managing Curves.
* g h:                                  Graphics Options.
* g j:                                  Managing Curves.
* g K:                                  Devices.
* g k:                                  Graphics Options.
* g L:                                  Graphics Options.
* g l:                                  Graphics Options.
* g N:                                  Graphics Options.
* g n:                                  Graphics Options.
* g O:                                  Devices.
* g p:                                  Managing Curves.
* g P:                                  Managing Curves.
* g q:                                  Devices.
* g r:                                  Graphics Options.
* g R:                                  Graphics Options.
* g S:                                  Graphics Options.
* g s:                                  Graphics Options.
* g T:                                  Graphics Options.
* g t:                                  Graphics Options.
* g v:                                  Devices.
* g V:                                  Devices.
* g X:                                  Devices.
* g x:                                  Devices.
* g Z:                                  Graphics Options.
* g z:                                  Graphics Options.
* H:                                    Inverse and Hyperbolic.
* h (HMS forms):                        HMS Forms.
* H a /:                                Polynomials.
* H a d:                                Differentiation.
* H a F:                                Error Estimates for Fits.
* H a f:                                Polynomials.
* H a M:                                Algebraic Manipulation.
* H a N:                                Minimization.
* H a p:                                Interpolation.
* H a R:                                Root Finding.
* H a S:                                Multiple Solutions.
* H a X:                                Minimization.
* h b:                                  Help Commands.
* H b #:                                Related Financial Functions.
* H b F:                                Future Value.
* H b L:                                Binary Functions.
* H b l:                                Binary Functions.
* H b M:                                Related Financial Functions.
* H b P:                                Present Value.
* H b R:                                Binary Functions.
* H b r:                                Binary Functions.
* H b t:                                Binary Functions.
* H b T:                                Related Financial Functions.
* H C:                                  Trigonometric and Hyperbolic Functions.
* h c:                                  Help Commands.
* H c 0-9:                              Conversions.
* H c c:                                Conversions.
* H c f:                                Conversions.
* H c F:                                Conversions.
* h C-c:                                Help Commands.
* h C-d:                                Help Commands.
* h C-w:                                Help Commands.
* H E:                                  Logarithmic Functions.
* h f:                                  Help Commands.
* H F:                                  Integer Truncation.
* H f B:                                Advanced Math Functions.
* H f G:                                Advanced Math Functions.
* h h:                                  Help Commands.
* h i:                                  Help Commands.
* H I a S:                              Multiple Solutions.
* H I C:                                Trigonometric and Hyperbolic Functions.
* H I E:                                Logarithmic Functions.
* H I F:                                Integer Truncation.
* H I f G:                              Advanced Math Functions.
* H I L:                                Logarithmic Functions.
* H I P:                                Scientific Functions.
* H I R:                                Integer Truncation.
* H I S:                                Trigonometric and Hyperbolic Functions.
* H I T:                                Trigonometric and Hyperbolic Functions.
* H I u M:                              Single-Variable Statistics.
* H I u S:                              Single-Variable Statistics.
* H I v h:                              Building Vectors.
* H I V R:                              Nesting and Fixed Points.
* H I V U:                              Nesting and Fixed Points.
* H I |:                                Building Vectors.
* H j I:                                Rearranging with Selections.
* h k:                                  Help Commands.
* H k b:                                Combinatorial Functions.
* H k c:                                Combinatorial Functions.
* H k e:                                Combinatorial Functions.
* H k s:                                Combinatorial Functions.
* H L:                                  Logarithmic Functions.
* h n:                                  Help Commands.
* H P:                                  Scientific Functions.
* H R:                                  Integer Truncation.
* H S:                                  Trigonometric and Hyperbolic Functions.
* h s:                                  Help Commands.
* h t:                                  Help Commands.
* H T:                                  Trigonometric and Hyperbolic Functions.
* H u C:                                Paired-Sample Statistics.
* H u G:                                Single-Variable Statistics.
* H u M:                                Single-Variable Statistics.
* H u S:                                Single-Variable Statistics.
* h v:                                  Help Commands.
* H v e:                                Manipulating Vectors.
* H V H:                                Manipulating Vectors.
* H v h:                                Building Vectors.
* H v k:                                Building Vectors.
* H v l:                                Manipulating Vectors.
* H V R:                                Nesting and Fixed Points.
* H V U:                                Nesting and Fixed Points.
* H |:                                  Building Vectors.
* I:                                    Inverse and Hyperbolic.
* i:                                    Help Commands.
* I a F:                                Error Estimates for Fits.
* I a M:                                Algebraic Manipulation.
* I a m:                                Matching Commands.
* I a S:                                Multiple Solutions.
* I B:                                  Logarithmic Functions.
* I b #:                                Related Financial Functions.
* I b F:                                Future Value.
* I b I:                                Related Financial Functions.
* I b M:                                Related Financial Functions.
* I b N:                                Present Value.
* I b P:                                Present Value.
* I b T:                                Related Financial Functions.
* I C:                                  Trigonometric and Hyperbolic Functions.
* I c p:                                Conversions.
* I E:                                  Logarithmic Functions.
* I F:                                  Integer Truncation.
* I f e:                                Advanced Math Functions.
* I f G:                                Advanced Math Functions.
* I k B:                                Probability Distribution Functions.
* I k C:                                Probability Distribution Functions.
* I k F:                                Probability Distribution Functions.
* I k N:                                Probability Distribution Functions.
* I k n:                                Combinatorial Functions.
* I k P:                                Probability Distribution Functions.
* I k T:                                Probability Distribution Functions.
* I L:                                  Logarithmic Functions.
* I M:                                  Recursion Depth.
* I P:                                  Scientific Functions.
* I Q:                                  Scientific Functions.
* I R:                                  Integer Truncation.
* I S:                                  Trigonometric and Hyperbolic Functions.
* I T:                                  Trigonometric and Hyperbolic Functions.
* I u C:                                Paired-Sample Statistics.
* I u M:                                Single-Variable Statistics.
* I u S:                                Single-Variable Statistics.
* I V G:                                Manipulating Vectors.
* I v h:                                Building Vectors.
* I V R:                                Reducing.
* I v s:                                Extracting Elements.
* I V S:                                Manipulating Vectors.
* I V U:                                Reducing.
* I ^:                                  Basic Arithmetic.
* I |:                                  Building Vectors.
* J:                                    Complex Number Functions.
* j ":                                  Rearranging with Selections.
* j &:                                  Rearranging with Selections.
* j ':                                  Operating on Selections.
* j *:                                  Rearranging with Selections.
* j +:                                  Rearranging with Selections.
* j -:                                  Rearranging with Selections.
* j /:                                  Rearranging with Selections.
* j 1-9:                                Changing Selections.
* j a:                                  Making Selections.
* j b:                                  Making Selections.
* j c:                                  Making Selections.
* j C:                                  Rearranging with Selections.
* j d:                                  Displaying Selections.
* j D:                                  Rearranging with Selections.
* j DEL:                                Operating on Selections.
* j e:                                  Operating on Selections.
* j E:                                  Rearranging with Selections.
* j I:                                  Rearranging with Selections.
* j L:                                  Rearranging with Selections.
* j l:                                  Changing Selections.
* j m:                                  Changing Selections.
* j M:                                  Rearranging with Selections.
* j N:                                  Rearranging with Selections.
* j n:                                  Changing Selections.
* j O:                                  Making Selections.
* j o:                                  Making Selections.
* j p:                                  Changing Selections.
* j R:                                  Rearranging with Selections.
* j r:                                  Selections with Rewrite Rules.
* j RET:                                Operating on Selections.
* j S:                                  Making Selections.
* j s:                                  Making Selections.
* j u:                                  Making Selections.
* j U:                                  Rearranging with Selections.
* j v:                                  Rearranging with Selections.
* j `:                                  Operating on Selections.
* K:                                    Keep Arguments.
* k a:                                  Random Numbers.
* k b:                                  Combinatorial Functions.
* k B:                                  Probability Distribution Functions.
* k c:                                  Combinatorial Functions.
* k C:                                  Probability Distribution Functions.
* k d:                                  Combinatorial Functions.
* k E:                                  Combinatorial Functions.
* k e:                                  Combinatorial Functions.
* k f:                                  Combinatorial Functions.
* k F:                                  Probability Distribution Functions.
* k g:                                  Combinatorial Functions.
* k h:                                  Random Numbers.
* k l:                                  Combinatorial Functions.
* k m:                                  Combinatorial Functions.
* k N:                                  Probability Distribution Functions.
* k n:                                  Combinatorial Functions.
* k p:                                  Combinatorial Functions.
* k P:                                  Probability Distribution Functions.
* k r:                                  Random Numbers.
* k s:                                  Combinatorial Functions.
* k t:                                  Combinatorial Functions.
* k T:                                  Probability Distribution Functions.
* L:                                    Logarithmic Functions.
* LFD:                                  Stack Manipulation.
* M:                                    Recursion Depth.
* m (HMS forms):                        HMS Forms.
* M (modulo forms):                     Modulo Forms.
* m A:                                  Simplification Modes.
* m a:                                  Algebraic Entry.
* m B:                                  Simplification Modes.
* m C:                                  Automatic Recomputation.
* m C:                                  Evaluates-To Operator.
* m D:                                  Simplification Modes.
* m d:                                  Angular Modes.
* m E:                                  Simplification Modes.
* m f:                                  Fraction Mode.
* m F:                                  General Mode Commands.
* m g:                                  Modes Variable.
* m h:                                  Angular Modes.
* m i:                                  Infinite Mode.
* m m:                                  General Mode Commands.
* m N:                                  Simplification Modes.
* m O:                                  Simplification Modes.
* m p:                                  Polar Mode.
* m R:                                  General Mode Commands.
* m r:                                  Angular Modes.
* m S:                                  General Mode Commands.
* m s:                                  Symbolic Mode.
* m t:                                  Algebraic Entry.
* m U:                                  Simplification Modes.
* m v:                                  Matrix Mode.
* m w:                                  Working Message.
* m x:                                  General Mode Commands.
* M-# #:                                Basic Commands.
* M-# ':                                More About Embedded Mode.
* M-# 0:                                Basic Commands.
* M-# ::                                Grabbing From Buffers.
* M-# =:                                Assignments in Embedded Mode.
* M-# a:                                Assignments in Embedded Mode.
* M-# b:                                Basic Commands.
* M-# c:                                Basic Commands.
* M-# d:                                More About Embedded Mode.
* M-# e:                                Basic Embedded Mode.
* M-# f:                                More About Embedded Mode.
* M-# g:                                Grabbing From Buffers.
* M-# i:                                Help Commands.
* M-# j:                                Assignments in Embedded Mode.
* M-# k:                                Keypad Mode.
* M-# L:                                Autoloading Problems.
* M-# m:                                Naming Keyboard Macros.
* M-# M-#:                              Basic Commands.
* M-# n:                                More About Embedded Mode.
* M-# o:                                Basic Commands.
* M-# p:                                More About Embedded Mode.
* M-# q:                                Quick Calculator.
* M-# r:                                Grabbing From Buffers.
* M-# s:                                Help Commands.
* M-# t:                                Help Commands.
* M-# u:                                Assignments in Embedded Mode.
* M-# w:                                Basic Embedded Mode.
* M-# x:                                Basic Commands.
* M-# y:                                Yanking Into Buffers.
* M-# z:                                Invocation Macros.
* M-# _:                                Grabbing From Buffers.
* M-# `:                                More About Embedded Mode.
* M-%:                                  Percentages.
* M-DEL:                                Stack Manipulation.
* M-k:                                  Killing From Stack.
* M-RET:                                Undo.
* M-TAB:                                Stack Manipulation.
* M-w:                                  Killing From Stack.
* M-x:                                  Basic Commands.
* N:                                    Symbolic Mode.
* n:                                    Basic Arithmetic.
* o:                                    Stack Basics.
* o (HMS forms):                        HMS Forms.
* P:                                    Scientific Functions.
* p:                                    Precision.
* p (error forms):                      Error Forms.
* Q:                                    Basic Arithmetic.
* q:                                    Basic Commands.
* R:                                    Integer Truncation.
* r 0-9:                                Recalling Variables.
* RET:                                  Stack Manipulation.
* S:                                    Trigonometric and Hyperbolic Functions.
* s &:                                  Storing Variables.
* s (HMS forms):                        HMS Forms.
* s *:                                  Storing Variables.
* s +:                                  Storing Variables.
* s -:                                  Storing Variables.
* s /:                                  Storing Variables.
* s 0-9:                                Storing Variables.
* s ::                                  Evaluates-To Operator.
* s =:                                  Evaluates-To Operator.
* s A:                                  Operations on Variables.
* s c:                                  Storing Variables.
* s D:                                  Operations on Variables.
* s d:                                  Declaration Basics.
* s e:                                  Operations on Variables.
* s E:                                  Operations on Variables.
* s F:                                  Operations on Variables.
* s G:                                  Operations on Variables.
* s H:                                  Operations on Variables.
* s i:                                  Operations on Variables.
* s I:                                  Operations on Variables.
* s l:                                  Let Command.
* s L:                                  Operations on Variables.
* s m:                                  Storing Variables.
* s n:                                  Storing Variables.
* s P:                                  Operations on Variables.
* s p:                                  Operations on Variables.
* s R:                                  Operations on Variables.
* s r:                                  Recalling Variables.
* s s:                                  Storing Variables.
* s T:                                  Operations on Variables.
* s t:                                  Storing Variables.
* s U:                                  Operations on Variables.
* s u:                                  Storing Variables.
* s x:                                  Storing Variables.
* s X:                                  Operations on Variables.
* s [:                                  Storing Variables.
* s ]:                                  Storing Variables.
* s ^:                                  Storing Variables.
* s |:                                  Storing Variables.
* SPC:                                  Stack Manipulation.
* T:                                    Trigonometric and Hyperbolic Functions.
* t +:                                  Business Days.
* t -:                                  Business Days.
* t .:                                  Vector and Matrix Formats.
* t 0-9:                                Storing Variables.
* t <:                                  Trail Commands.
* t >:                                  Trail Commands.
* t b:                                  Trail Commands.
* t C:                                  Date Conversions.
* t d:                                  Trail Commands.
* t D:                                  Date Conversions.
* t f:                                  Trail Commands.
* t h:                                  Trail Commands.
* t I:                                  Date Functions.
* t i:                                  Trail Commands.
* t J:                                  Date Conversions.
* t k:                                  Trail Commands.
* t m:                                  Trail Commands.
* t M:                                  Date Functions.
* t n:                                  Trail Commands.
* t N:                                  Date Functions.
* t o:                                  Trail Commands.
* t P:                                  Date Functions.
* t p:                                  Trail Commands.
* t r:                                  Trail Commands.
* t s:                                  Trail Commands.
* t U:                                  Date Conversions.
* t W:                                  Date Functions.
* t Y:                                  Date Functions.
* t y:                                  Trail Commands.
* t [:                                  Trail Commands.
* t ]:                                  Trail Commands.
* TAB:                                  Stack Manipulation.
* U:                                    Undo.
* u #:                                  Single-Variable Statistics.
* u *:                                  Single-Variable Statistics.
* u +:                                  Single-Variable Statistics.
* u 0-9:                                User-Defined Units.
* u a:                                  Basic Operations on Units.
* u b:                                  Basic Operations on Units.
* u C:                                  Paired-Sample Statistics.
* u c:                                  Basic Operations on Units.
* u d:                                  User-Defined Units.
* u e:                                  The Units Table.
* u G:                                  Single-Variable Statistics.
* u g:                                  The Units Table.
* u M:                                  Single-Variable Statistics.
* u N:                                  Single-Variable Statistics.
* u p:                                  User-Defined Units.
* u r:                                  Basic Operations on Units.
* u S:                                  Single-Variable Statistics.
* u s:                                  Basic Operations on Units.
* u t:                                  Basic Operations on Units.
* u u:                                  User-Defined Units.
* u v:                                  The Units Table.
* u V:                                  The Units Table.
* u x:                                  Basic Operations on Units.
* u X:                                  Single-Variable Statistics.
* V #:                                  Set Operations.
* V (:                                  Vector and Matrix Formats.
* V +:                                  Set Operations.
* V ,:                                  Vector and Matrix Formats.
* V -:                                  Set Operations.
* V .:                                  Vector and Matrix Formats.
* V /:                                  Vector and Matrix Formats.
* V ::                                  Set Operations.
* V <:                                  Vector and Matrix Formats.
* V =:                                  Vector and Matrix Formats.
* V >:                                  Vector and Matrix Formats.
* V {:                                  Vector and Matrix Formats.
* V A:                                  Reducing and Mapping.
* v a:                                  Manipulating Vectors.
* v b:                                  Building Vectors.
* v c:                                  Extracting Elements.
* V C:                                  Vector and Matrix Arithmetic.
* v d:                                  Building Vectors.
* V D:                                  Vector and Matrix Arithmetic.
* V E:                                  Set Operations.
* v e:                                  Manipulating Vectors.
* v f:                                  Manipulating Vectors.
* V F:                                  Set Operations.
* V G:                                  Manipulating Vectors.
* V H:                                  Manipulating Vectors.
* v h:                                  Building Vectors.
* v i:                                  Building Vectors.
* V I:                                  Generalized Products.
* V J:                                  Vector and Matrix Arithmetic.
* v k:                                  Building Vectors.
* v l:                                  Manipulating Vectors.
* V L:                                  Vector and Matrix Arithmetic.
* v m:                                  Manipulating Vectors.
* V M:                                  Mapping.
* v n:                                  Vector and Matrix Arithmetic.
* V N:                                  Vector and Matrix Arithmetic.
* V O:                                  Generalized Products.
* v p:                                  Packing and Unpacking.
* v p (complex):                        Complex Number Functions.
* v r:                                  Extracting Elements.
* V R:                                  Reducing.
* v s:                                  Extracting Elements.
* V S:                                  Manipulating Vectors.
* v t:                                  Manipulating Vectors.
* V T:                                  Vector and Matrix Arithmetic.
* v u:                                  Packing and Unpacking.
* V U:                                  Reducing.
* v u (complex):                        Complex Number Functions.
* v v:                                  Manipulating Vectors.
* V V:                                  Set Operations.
* V X:                                  Set Operations.
* v x:                                  Building Vectors.
* V [:                                  Vector and Matrix Formats.
* V ]:                                  Vector and Matrix Formats.
* V ^:                                  Set Operations.
* V ~:                                  Set Operations.
* w:                                    Error Messages.
* x:                                    Basic Commands.
* X:                                    Keyboard Macros.
* y:                                    Yanking Into Buffers.
* Y:                                    Defining Simple Commands.
* Y ?:                                  Defining Simple Commands.
* z:                                    Programming.
* Z #:                                  Queries in Macros.
* Z ':                                  Local Values in Macros.
* Z (:                                  Loops in Macros.
* Z ):                                  Loops in Macros.
* Z /:                                  Loops in Macros.
* Z ::                                  Conditionals in Macros.
* Z <:                                  Loops in Macros.
* Z =:                                  Queries in Macros.
* Z >:                                  Loops in Macros.
* Z {:                                  Loops in Macros.
* Z }:                                  Loops in Macros.
* Z C:                                  User-Defined Compositions.
* Z C-g:                                Conditionals in Macros.
* Z D:                                  Creating User Keys.
* Z E:                                  Creating User Keys.
* Z F:                                  Algebraic Definitions.
* Z G:                                  Algebraic Definitions.
* Z I:                                  Invocation Macros.
* Z K:                                  Naming Keyboard Macros.
* Z P:                                  Creating User Keys.
* Z S:                                  Syntax Tables.
* Z T:                                  Debugging Calc.
* Z U:                                  Creating User Keys.
* Z [:                                  Conditionals in Macros.
* Z ]:                                  Conditionals in Macros.
* Z `:                                  Local Values in Macros.
* Z |:                                  Conditionals in Macros.
* [:                                    Incomplete Objects.
* \:                                    Basic Arithmetic.
* ]:                                    Incomplete Objects.
* ^:                                    Basic Arithmetic.
* _:                                    Numeric Entry.
* `:                                    Editing Stack Entries.
* |:                                    Building Vectors.
* ~:                                    Prefix Arguments.