Initial Commit

[packages] / xemacs-packages / calc / calc.texinfo

\input texinfo                  @c -*-texinfo-*-
@comment %**start of header (This is for running Texinfo on a region.)
@c smallbook
@setfilename calc.info
@c [title]
@settitle GNU Emacs Calc 2.02 Manual
@comment %**end of header (This is for running Texinfo on a region.)
@setchapternewpage odd

@tex
% Some special kludges to make TeX formatting prettier.
% Because makeinfo.c exists, we can't just define new commands.
% So instead, we take over little-used existing commands.
%
% Redefine @cite{text} to act like $text$ in regular TeX.
% Info will typeset this same as @samp{text}.
\gdef\goodtex{\tex \let\rm\goodrm \let\t\ttfont \turnoffactive}
\gdef\goodrm{\fam0\tenrm}
\gdef\cite{\goodtex$\citexxx}
\gdef\citexxx#1{#1$\Etex}
\global\let\oldxrefX=\xrefX
\gdef\xrefX[#1]{\begingroup\let\cite=\dfn\oldxrefX[#1]\endgroup}
%
% Redefine @i{text} to be equivalent to @cite{text}, i.e., to use math mode.
% This looks the same in TeX but omits the surrounding ` ' in Info.
\global\let\i=\cite
%
% Redefine @c{tex-stuff} \n @whatever{info-stuff}.
\gdef\c{\futurelet\next\mycxxx}
\gdef\mycxxx{%
  \ifx\next\bgroup \goodtex\let\next\mycxxy
  \else\ifx\next\mindex \let\next\relax
  \else\ifx\next\kindex \let\next\relax
  \else\ifx\next\starindex \let\next\relax \else \let\next\comment
  \fi\fi\fi\fi \next
}
\gdef\mycxxy#1#2{#1\Etex\mycxxz}
\gdef\mycxxz#1{}
@end tex

@c Fix some things to make math mode work properly.
@iftex
@textfont0=@tenrm
@font@teni=cmmi10 scaled @magstephalf   @textfont1=@teni
@font@seveni=cmmi7 scaled @magstephalf  @scriptfont1=@seveni
@font@fivei=cmmi5 scaled @magstephalf   @scriptscriptfont1=@fivei
@font@tensy=cmsy10 scaled @magstephalf  @textfont2=@tensy
@font@sevensy=cmsy7 scaled @magstephalf @scriptfont2=@sevensy
@font@fivesy=cmsy5 scaled @magstephalf  @scriptscriptfont2=@fivesy
@font@tenex=cmex10 scaled @magstephalf  @textfont3=@tenex
@scriptfont3=@tenex  @scriptscriptfont3=@tenex
@textfont7=@tentt  @scriptfont7=@tentt  @scriptscriptfont7=@tentt
@end iftex

@c Fix some other things specifically for this manual.
@iftex
@finalout
@mathcode`@:=`@:  @c Make Calc fractions come out right in math mode
@tocindent=.5pc   @c Indent subsections in table of contents less
@rightskip=0pt plus 2pt  @c Favor short lines rather than overfull hboxes
@tex
\gdef\coloneq{\mathrel{\mathord:\mathord=}}
\ifdim\parskip>17pt
  \global\parskip=12pt   % Standard parskip looks a bit too large
\fi
\gdef\internalBitem{\parskip=7pt\kyhpos=\tableindent\kyvpos=0pt
\smallbreak\parsearg\itemzzy}
\gdef\itemzzy#1{\itemzzz{#1}\relax\ifvmode\kern-7pt\fi}
\gdef\trademark{${}^{\rm TM}$}
\gdef\group{%
  \par\vskip8pt\begingroup
  \def\Egroup{\egroup\endgroup}%
  \let\aboveenvbreak=\relax  % so that nothing gets between vtop and first box
  \def\singlespace{\baselineskip=\singlespaceskip}%
  \vtop\bgroup
}
%
%\global\abovedisplayskip=0pt
%\global\abovedisplayshortskip=-10pt
%\global\belowdisplayskip=7pt
%\global\belowdisplayshortskip=2pt
\gdef\beforedisplay{\vskip-10pt}
\gdef\afterdisplay{\vskip-5pt}
\gdef\beforedisplayh{\vskip-25pt}
\gdef\afterdisplayh{\vskip-10pt}
%
\gdef\printindex{\parsearg\calcprintindex}
\gdef\calcprintindex#1{%
  \doprintindex{#1}%
  \openin1 \jobname.#1s
  \ifeof1{\let\s=\indexskip \csname indexsize#1\endcsname}\fi
  \closein1
}
\gdef\indexskip{(This page intentionally left blank)\vfill\eject}
\gdef\indexsizeky{\s\s\s\s\s\s\s\s}
\gdef\indexsizepg{\s\s\s\s\s\s}
\gdef\indexsizetp{\s\s\s\s\s\s}
\gdef\indexsizecp{\s\s\s\s}
\gdef\indexsizevr{}
\gdef\indexsizefn{\s\s}
\gdef\langle#1\rangle{\it XXX}   % Avoid length mismatch with true expansion
%
% Ensure no indentation at beginning of sections, and avoid club paragraphs.
\global\let\calcchapternofonts=\chapternofonts
\gdef\chapternofonts{\aftergroup\calcfixclub\calcchapternofonts}
\gdef\calcfixclub{\calcclubpenalty=10000\noindent}
\global\let\calcdobreak=\dobreak
\gdef\dobreak{{\penalty-9999\dimen0=\pagetotal\advance\dimen0by1.5in
\ifdim\dimen0>\pagegoal\vfill\eject\fi}\calcdobreak}
%
\gdef\kindex{\def\indexname{ky}\futurelet\next\calcindexer}
\gdef\tindex{\def\indexname{tp}\futurelet\next\calcindexer}
\gdef\mindex{\let\indexname\relax\futurelet\next\calcindexer}
\gdef\calcindexer{\catcode`\ =\active\parsearg\calcindexerxx}
\gdef\calcindexerxx#1{%
  \catcode`\ =10%
  \ifvmode \indent \fi \setbox0=\lastbox \advance\kyhpos\wd0 \fixoddpages \box0
  \setbox0=\hbox{\ninett #1}%
  \calcindexersh{\llap{\hbox to 4em{\bumpoddpages\lower\kyvpos\box0\hss}\hskip\kyhpos}}%
  \global\let\calcindexersh=\calcindexershow
  \advance\clubpenalty by 5000%
  \ifx\indexname\relax \else
    \singlecodeindexer{#1\indexstar}%
    \global\def\indexstar{}%
  \fi
  \futurelet\next\calcindexerxxx
}
\gdef\indexstar{}
\gdef\bumpoddpages{\ifodd\calcpageno\hskip7.3in\fi}
%\gdef\bumpoddpages{\hskip7.3in}   % for marginal notes on right side always
%\gdef\bumpoddpages{}              % for marginal notes on left side always
\gdef\fixoddpages{%
\global\calcpageno=\pageno
{\dimen0=\pagetotal
\advance\dimen0 by2\baselineskip
\ifdim\dimen0>\pagegoal
\global\advance\calcpageno by 1
\vfill\eject\noindent
\fi}%
}
\gdef\calcindexershow#1{\smash{#1}\advance\kyvpos by 11pt}
\gdef\calcindexernoshow#1{}
\global\let\calcindexersh=\calcindexershow
\gdef\calcindexerxxx{%
  \ifx\indexname\relax
    \ifx\next\kindex \global\let\calcindexersh=\calcindexernoshow \fi
    \ifx\next\tindex \global\let\calcindexersh=\calcindexernoshow \fi
  \fi
  \calcindexerxxxx
}
\gdef\calcindexerxxxx#1{\next}
\gdef\indexstarxx{\thinspace{\rm *}}
\gdef\starindex{\global\let\indexstar=\indexstarxx}
\gdef\calceverypar{%
\kyhpos=\leftskip\kyvpos=0pt\clubpenalty=\calcclubpenalty
\calcclubpenalty=1000\relax
}
\gdef\idots{{\indrm...}}
@end tex
@newdimen@kyvpos @kyvpos=0pt
@newdimen@kyhpos @kyhpos=0pt
@newcount@calcclubpenalty @calcclubpenalty=1000
@newcount@calcpageno
@newtoks@calcoldeverypar @calcoldeverypar=@everypar
@everypar={@calceverypar@the@calcoldeverypar}
@ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi
@ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
@catcode`@\=0 \catcode`\@=11
\r@ggedbottomtrue
\catcode`\@=0 @catcode`@\=@active
@end iftex

@ifinfo
@direntry
* Calc: (calc).               Scientific, financial, and symbolic calculator
                              for Emacs
@end direntry

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.

@ignore
Permission is granted to process this file through TeX and print the
results, provided the printed document carries copying permission notice
identical to this one except for the removal of this paragraph (this
paragraph not being relevant to the printed manual).

@end ignore
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.
@end ifinfo

@titlepage
@sp 6
@center @titlefont{Calc Manual}
@sp 4
@center GNU Emacs Calc Version 2.02
@c [volume]
@sp 1
@center January 1992
@sp 5
@center Dave Gillespie
@center daveg@@synaptics.com
@page

@vskip 0pt plus 1filll
Copyright @copyright{} 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.

@ignore
Permission is granted to process this file through TeX and print the
results, provided the printed document carries copying permission notice
identical to this one except for the removal of this paragraph (this
paragraph not being relevant to the printed manual).

@end ignore
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.
@end titlepage

@c [begin]
@ifnottex
@node Top, Copying,, (dir)
@chapter The GNU Emacs Calculator

@noindent
@dfn{Calc 2.02} is an advanced desk calculator and mathematical tool
that runs as part of the GNU Emacs environment.

This manual is divided into three major parts: "Getting Started," the
"Calc Tutorial," and the "Calc Reference."  The Tutorial introduces all
the major aspects of Calculator use in an easy, hands-on way.  The
remainder of the manual is a complete reference to the features of the
Calculator.

For help in the Emacs Info system (which you are using to read this
file), type @kbd{?}.  (You can also type @kbd{h} to run through a
longer Info tutorial.)

@end ifnottex
@menu
* Copying::               How you can copy and share Calc.

* Getting Started::       General description and overview.
@ifinfo
* Interactive Tutorial::  Same as tutorial.
@end ifinfo
* Tutorial::              A step-by-step introduction for beginners.

* Introduction::          Introduction to the Calc reference manual.
* Data Types::            Types of objects manipulated by Calc.
* Stack and Trail::       Manipulating the stack and trail buffers.
* Mode Settings::         Adjusting display format and other modes.
* Arithmetic::            Basic arithmetic functions.
* Scientific Functions::  Transcendentals and other scientific functions.
* Matrix Functions::      Operations on vectors and matrices.
* Algebra::               Manipulating expressions algebraically.
* Units::                 Operations on numbers with units.
* Store and Recall::      Storing and recalling variables.
* Graphics::              Commands for making graphs of data.
* Kill and Yank::         Moving data into and out of Calc.
* Embedded Mode::         Working with formulas embedded in a file.
* Programming::           Calc as a programmable calculator.

* Installation::          Installing Calc as a part of GNU Emacs.
* Reporting Bugs::        How to report bugs and make suggestions.

* Summary::               Summary of Calc commands and functions.

* Key Index::             The standard Calc key sequences.
* Command Index::         The interactive Calc commands.
* Function Index::        Functions (in algebraic formulas).
* Concept Index::         General concepts.
* Variable Index::        Variables used by Calc (both user and internal).
* Lisp Function Index::   Internal Lisp math functions.
@end menu

@node Copying, Getting Started, Top, Top
@unnumbered GNU GENERAL PUBLIC LICENSE
@center Version 1, February 1989

@display
Copyright @copyright{} 1989 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
@end display

@unnumberedsec Preamble

  The license agreements of most software companies try to keep users
at the mercy of those companies.  By contrast, our General Public
License is intended to guarantee your freedom to share and change free
software---to make sure the software is free for all its users.  The
General Public License applies to the Free Software Foundation's
software and to any other program whose authors commit to using it.
You can use it for your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Specifically, the General Public License is designed to make
sure that you have the freedom to give away or sell copies of free
software, that you receive source code or can get it if you want it,
that you can change the software or use pieces of it in new free
programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of a such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must tell them their rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  The precise terms and conditions for copying, distribution and
modification follow.

@iftex
@unnumberedsec TERMS AND CONDITIONS
@end iftex
@ifnottex
@center TERMS AND CONDITIONS
@end ifnottex

@enumerate
@item
This License Agreement applies to any program or other work which
contains a notice placed by the copyright holder saying it may be
distributed under the terms of this General Public License.  The
``Program'', below, refers to any such program or work, and a ``work based
on the Program'' means either the Program or any work containing the
Program or a portion of it, either verbatim or with modifications.  Each
licensee is addressed as ``you''.

@item
You may copy and distribute verbatim copies of the Program's source
code as you receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice and
disclaimer of warranty; keep intact all the notices that refer to this
General Public License and to the absence of any warranty; and give any
other recipients of the Program a copy of this General Public License
along with the Program.  You may charge a fee for the physical act of
transferring a copy.

@item
You may modify your copy or copies of the Program or any portion of
it, and copy and distribute such modifications under the terms of Paragraph
1 above, provided that you also do the following:

@itemize @bullet
@item
cause the modified files to carry prominent notices stating that
you changed the files and the date of any change; and

@item
cause the whole of any work that you distribute or publish, that
in whole or in part contains the Program or any part thereof, either
with or without modifications, to be licensed at no charge to all
third parties under the terms of this General Public License (except
that you may choose to grant warranty protection to some or all
third parties, at your option).

@item
If the modified program normally reads commands interactively when
run, you must cause it, when started running for such interactive use
in the simplest and most usual way, to print or display an
announcement including an appropriate copyright notice and a notice
that there is no warranty (or else, saying that you provide a
warranty) and that users may redistribute the program under these
conditions, and telling the user how to view a copy of this General
Public License.

@item
You may charge a fee for the physical act of transferring a
copy, and you may at your option offer warranty protection in
exchange for a fee.
@end itemize

Mere aggregation of another independent work with the Program (or its
derivative) on a volume of a storage or distribution medium does not bring
the other work under the scope of these terms.

@item
You may copy and distribute the Program (or a portion or derivative of
it, under Paragraph 2) in object code or executable form under the terms of
Paragraphs 1 and 2 above provided that you also do one of the following:

@itemize @bullet
@item
accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of
Paragraphs 1 and 2 above; or,

@item
accompany it with a written offer, valid for at least three
years, to give any third party free (except for a nominal charge
for the cost of distribution) a complete machine-readable copy of the
corresponding source code, to be distributed under the terms of
Paragraphs 1 and 2 above; or,

@item
accompany it with the information you received as to where the
corresponding source code may be obtained.  (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form alone.)
@end itemize

Source code for a work means the preferred form of the work for making
modifications to it.  For an executable file, complete source code means
all the source code for all modules it contains; but, as a special
exception, it need not include source code for modules which are standard
libraries that accompany the operating system on which the executable
file runs, or for standard header files or definitions files that
accompany that operating system.

@item
You may not copy, modify, sublicense, distribute or transfer the
Program except as expressly provided under this General Public License.
Any attempt otherwise to copy, modify, sublicense, distribute or transfer
the Program is void, and will automatically terminate your rights to use
the Program under this License.  However, parties who have received
copies, or rights to use copies, from you under this General Public
License will not have their licenses terminated so long as such parties
remain in full compliance.

@item
By copying, distributing or modifying the Program (or any work based
on the Program) you indicate your acceptance of this license to do so,
and all its terms and conditions.

@item
Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the original
licensor to copy, distribute or modify the Program subject to these
terms and conditions.  You may not impose any further restrictions on the
recipients' exercise of the rights granted herein.

@item
The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of the license which applies to it and ``any
later version'', you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
the license, you may choose any version ever published by the Free Software
Foundation.

@item
If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

@iftex
@heading NO WARRANTY
@end iftex
@ifnottex
@center NO WARRANTY
@end ifnottex

@item
BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

@item
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
@end enumerate

@node Getting Started, Tutorial, Copying, Top
@chapter Getting Started

@noindent
This chapter provides a general overview of Calc, the GNU Emacs
Calculator:  What it is, how to start it and how to exit from it,
and what are the various ways that it can be used.

@menu
* What is Calc::
* About This Manual::
* Notations Used in This Manual::
* Using Calc::
* Demonstration of Calc::
* History and Acknowledgements::
@end menu

@node What is Calc, About This Manual, Getting Started, Getting Started
@section What is Calc?

@noindent
@dfn{Calc} is an advanced calculator and mathematical tool that runs as
part of the GNU Emacs environment.  Very roughly based on the HP-28/48
series of calculators, its many features include:

@itemize @bullet
@item
Choice of algebraic or RPN (stack-based) entry of calculations.

@item
Arbitrary precision integers and floating-point numbers.

@item
Arithmetic on rational numbers, complex numbers (rectangular and polar),
error forms with standard deviations, open and closed intervals, vectors
and matrices, dates and times, infinities, sets, quantities with units,
and algebraic formulas.

@item
Mathematical operations such as logarithms and trigonometric functions.

@item
Programmer's features (bitwise operations, non-decimal numbers).

@item
Financial functions such as future value and internal rate of return.

@item
Number theoretical features such as prime factorization and arithmetic
modulo @i{M} for any @i{M}.

@item
Algebraic manipulation features, including symbolic calculus.

@item
Moving data to and from regular editing buffers.

@item
``Embedded mode'' for manipulating Calc formulas and data directly
inside any editing buffer.

@item
Graphics using GNUPLOT, a versatile (and free) plotting program.

@item
Easy programming using keyboard macros, algebraic formulas,
algebraic rewrite rules, or extended Emacs Lisp.
@end itemize

Calc tries to include a little something for everyone; as a result it is
large and might be intimidating to the first-time user.  If you plan to
use Calc only as a traditional desk calculator, all you really need to
read is the ``Getting Started'' chapter of this manual and possibly the
first few sections of the tutorial.  As you become more comfortable with
the program you can learn its additional features.  In terms of efficiency,
scope and depth, Calc cannot replace a powerful tool like Mathematica.
@c Removed this per RMS' request:
@c Mathematica@c{\trademark} @asis{ (tm)}.
But Calc has the advantages of convenience, portability, and availability
of the source code.  And, of course, it's free!

@node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
@section About This Manual

@noindent
This document serves as a complete description of the GNU Emacs
Calculator.  It works both as an introduction for novices, and as
a reference for experienced users.  While it helps to have some
experience with GNU Emacs in order to get the most out of Calc,
this manual ought to be readable even if you don't know or use Emacs
regularly.

@ifnottex
The manual is divided into three major parts:@: the ``Getting
Started'' chapter you are reading now, the Calc tutorial (chapter 2),
and the Calc reference manual (the remaining chapters and appendices).
@end ifnottex
@iftex
The manual is divided into three major parts:@: the ``Getting
Started'' chapter you are reading now, the Calc tutorial (chapter 2),
and the Calc reference manual (the remaining chapters and appendices).
@c [when-split]
@c This manual has been printed in two volumes, the @dfn{Tutorial} and the
@c @dfn{Reference}.  Both volumes include a copy of the ``Getting Started''
@c chapter.
@end iftex

If you are in a hurry to use Calc, there is a brief ``demonstration''
below which illustrates the major features of Calc in just a couple of
pages.  If you don't have time to go through the full tutorial, this
will show you everything you need to know to begin.
@xref{Demonstration of Calc}.

The tutorial chapter walks you through the various parts of Calc
with lots of hands-on examples and explanations.  If you are new
to Calc and you have some time, try going through at least the
beginning of the tutorial.  The tutorial includes about 70 exercises
with answers.  These exercises give you some guided practice with
Calc, as well as pointing out some interesting and unusual ways
to use its features.

The reference section discusses Calc in complete depth.  You can read
the reference from start to finish if you want to learn every aspect
of Calc.  Or, you can look in the table of contents or the Concept
Index to find the parts of the manual that discuss the things you
need to know.

@cindex Marginal notes
Every Calc keyboard command is listed in the Calc Summary, and also
in the Key Index.  Algebraic functions, @kbd{M-x} commands, and
variables also have their own indices.  @c{Each}
@asis{In the printed manual, each}
paragraph that is referenced in the Key or Function Index is marked
in the margin with its index entry.

@c [fix-ref Help Commands]
You can access this manual on-line at any time within Calc by
pressing the @kbd{h i} key sequence.  Outside of the Calc window,
you can press @kbd{M-# i} to read the manual on-line.  Also, you
can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{M-# t},
or to the Summary by pressing @kbd{h s} or @kbd{M-# s}.  Within Calc,
you can also go to the part of the manual describing any Calc key,
function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v},
respectively.  @xref{Help Commands}.

Printed copies of this manual are also available from the Free Software
Foundation.

@node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
@section Notations Used in This Manual

@noindent
This section describes the various notations that are used
throughout the Calc manual.

In keystroke sequences, uppercase letters mean you must hold down
the shift key while typing the letter.  Keys pressed with Control
held down are shown as @kbd{C-x}.  Keys pressed with Meta held down
are shown as @kbd{M-x}.  Other notations are @key{RET} for the
Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
@key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.

(If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
If you don't have a Meta key, look for Alt or Extend Char.  You can
also press @key{ESC} or @key{C-[} first to get the same effect, so
that @kbd{M-x}, @kbd{ESC x}, and @kbd{C-[ x} are all equivalent.)

Sometimes the @key{RET} key is not shown when it is ``obvious''
that you must press @kbd{RET} to proceed.  For example, the @key{RET}
is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.

Commands are generally shown like this:  @kbd{p} (@code{calc-precision})
or @kbd{M-# k} (@code{calc-keypad}).  This means that the command is
normally used by pressing the @kbd{p} key or @kbd{M-# k} key sequence,
but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.

Commands that correspond to functions in algebraic notation
are written:  @kbd{C} (@code{calc-cos}) [@code{cos}].  This means
the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
the corresponding function in an algebraic-style formula would
be @samp{cos(@var{x})}.

A few commands don't have key equivalents:  @code{calc-sincos}
[@code{sincos}].@refill

@node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
@section A Demonstration of Calc

@noindent
@cindex Demonstration of Calc
This section will show some typical small problems being solved with
Calc.  The focus is more on demonstration than explanation, but
everything you see here will be covered more thoroughly in the
Tutorial.

To begin, start Emacs if necessary (usually the command @code{emacs}
does this), and type @kbd{M-# c} (or @kbd{ESC # c}) to start the
Calculator.  (@xref{Starting Calc}, if this doesn't work for you.)

Be sure to type all the sample input exactly, especially noting the
difference between lower-case and upper-case letters.  Remember,
@kbd{RET}, @kbd{TAB}, @kbd{DEL}, and @kbd{SPC} are the Return, Tab,
Delete, and Space keys.

@strong{RPN calculation.}  In RPN, you type the input number(s) first,
then the command to operate on the numbers.

@noindent
Type @kbd{2 RET 3 + Q} to compute @c{$\sqrt{2+3} = 2.2360679775$}
@asis{the square root of 2+3, which is 2.2360679775}.

@noindent
Type @kbd{P 2 ^} to compute @c{$\pi^2 = 9.86960440109$}
@asis{the value of `pi' squared, 9.86960440109}.

@noindent
Type @kbd{TAB} to exchange the order of these two results.

@noindent
Type @kbd{- I H S} to subtract these results and compute the Inverse
Hyperbolic sine of the difference, 2.72996136574.

@noindent
Type @kbd{DEL} to erase this result.

@strong{Algebraic calculation.}  You can also enter calculations using
conventional ``algebraic'' notation.  To enter an algebraic formula,
use the apostrophe key.

@noindent
Type @kbd{' sqrt(2+3) RET} to compute @c{$\sqrt{2+3}$}
@asis{the square root of 2+3}.

@noindent
Type @kbd{' pi^2 RET} to enter @c{$\pi^2$}
@asis{`pi' squared}.  To evaluate this symbolic
formula as a number, type @kbd{=}.

@noindent
Type @kbd{' arcsinh($ - $$) RET} to subtract the second-most-recent
result from the most-recent and compute the Inverse Hyperbolic sine.

@strong{Keypad mode.}  If you are using the X window system, press
@w{@kbd{M-# k}} to get Keypad mode.  (If you don't use X, skip to
the next section.)

@noindent
Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
``buttons'' using your left mouse button.

@noindent
Click on @key{PI}, @key{2}, and @t{y^x}.

@noindent
Click on @key{INV}, then @key{ENTER} to swap the two results.

@noindent
Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.

@noindent
Click on @key{<-} to erase the result, then click @key{OFF} to turn
the Keypad Calculator off.

@strong{Grabbing data.}  Type @kbd{M-# x} if necessary to exit Calc.
Now select the following numbers as an Emacs region:  ``Mark'' the
front of the list by typing control-@kbd{SPC} or control-@kbd{@@} there,
then move to the other end of the list.  (Either get this list from
the on-line copy of this manual, accessed by @w{@kbd{M-# i}}, or just
type these numbers into a scratch file.)  Now type @kbd{M-# g} to
``grab'' these numbers into Calc.

@group
@example
1.23  1.97
1.6   2
1.19  1.08
@end example
@end group

@noindent
The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
Type @w{@kbd{V R +}} to compute the sum of these numbers.

@noindent
Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
the product of the numbers.

@noindent
You can also grab data as a rectangular matrix.  Place the cursor on
the upper-leftmost @samp{1} and set the mark, then move to just after
the lower-right @samp{8} and press @kbd{M-# r}.

@noindent
Type @kbd{v t} to transpose this @c{$3\times2$}
@asis{3x2} matrix into a @c{$2\times3$}
@asis{2x3} matrix.  Type
@w{@kbd{v u}} to unpack the rows into two separate vectors.  Now type
@w{@kbd{V R + TAB V R +}} to compute the sums of the two original columns.
(There is also a special grab-and-sum-columns command, @kbd{M-# :}.)

@strong{Units conversion.}  Units are entered algebraically.
Type @w{@kbd{' 43 mi/hr RET}} to enter the quantity 43 miles-per-hour.
Type @w{@kbd{u c km/hr RET}}.  Type @w{@kbd{u c m/s RET}}.

@strong{Date arithmetic.}  Type @kbd{t N} to get the current date and
time.  Type @kbd{90 +} to find the date 90 days from now.  Type
@kbd{' <25 dec 87> RET} to enter a date, then @kbd{- 7 /} to see how
many weeks have passed since then.

@strong{Algebra.}  Algebraic entries can also include formulas
or equations involving variables.  Type @kbd{@w{' [x + y} = a, x y = 1] RET}
to enter a pair of equations involving three variables.
(Note the leading apostrophe in this example; also, note that the space
between @samp{x y} is required.)  Type @w{@kbd{a S x,y RET}} to solve
these equations for the variables @cite{x} and @cite{y}.@refill

@noindent
Type @kbd{d B} to view the solutions in more readable notation.
Type @w{@kbd{d C}} to view them in C language notation, and @kbd{d T}
to view them in the notation for the @TeX{} typesetting system.
Type @kbd{d N} to return to normal notation.

@noindent
Type @kbd{7.5}, then @kbd{s l a RET} to let @cite{a = 7.5} in these formulas.
(That's a letter @kbd{l}, not a numeral @kbd{1}.)

@iftex
@strong{Help functions.}  You can read about any command in the on-line
manual.  Type @kbd{M-# c} to return to Calc after each of these
commands: @kbd{h k t N} to read about the @kbd{t N} command,
@kbd{h f sqrt RET} to read about the @code{sqrt} function, and
@kbd{h s} to read the Calc summary.
@end iftex
@ifnottex
@strong{Help functions.}  You can read about any command in the on-line
manual.  Remember to type the letter @kbd{l}, then @kbd{M-# c}, to
return here after each of these commands: @w{@kbd{h k t N}} to read
about the @w{@kbd{t N}} command, @kbd{h f sqrt RET} to read about the
@code{sqrt} function, and @kbd{h s} to read the Calc summary.
@end ifnottex

Press @kbd{DEL} repeatedly to remove any leftover results from the stack.
To exit from Calc, press @kbd{q} or @kbd{M-# c} again.

@node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
@section Using Calc

@noindent
Calc has several user interfaces that are specialized for
different kinds of tasks.  As well as Calc's standard interface,
there are Quick Mode, Keypad Mode, and Embedded Mode.

@c [fix-ref Installation]
Calc must be @dfn{installed} before it can be used.  @xref{Installation},
for instructions on setting up and installing Calc.  We will assume
you or someone on your system has already installed Calc as described
there.

@menu
* Starting Calc::
* The Standard Interface::
* Quick Mode Overview::
* Keypad Mode Overview::
* Standalone Operation::
* Embedded Mode Overview::
* Other M-# Commands::
@end menu

@node Starting Calc, The Standard Interface, Using Calc, Using Calc
@subsection Starting Calc

@noindent
On most systems, you can type @kbd{M-#} to start the Calculator.
The notation @kbd{M-#} is short for Meta-@kbd{#}.  On most
keyboards this means holding down the Meta (or Alt) and
Shift keys while typing @kbd{3}.

@cindex META key
Once again, if you don't have a Meta key on your keyboard you can type
@key{ESC} first, then @kbd{#}, to accomplish the same thing.  If you
don't even have an @key{ESC} key, you can fake it by holding down
Control or @key{CTRL} while typing a left square bracket
(that's @kbd{C-[} in Emacs notation).@refill

@kbd{M-#} is a @dfn{prefix key}; when you press it, Emacs waits for
you to press a second key to complete the command.  In this case,
you will follow @kbd{M-#} with a letter (upper- or lower-case, it
doesn't matter for @kbd{M-#}) that says which Calc interface you
want to use.

To get Calc's standard interface, type @kbd{M-# c}.  To get
Keypad Mode, type @kbd{M-# k}.  Type @kbd{M-# ?} to get a brief
list of the available options, and type a second @kbd{?} to get
a complete list.

To ease typing, @kbd{M-# M-#} (or @kbd{M-# #} if that's easier)
also works to start Calc.  It starts the same interface (either
@kbd{M-# c} or @w{@kbd{M-# k}}) that you last used, selecting the
@kbd{M-# c} interface by default.  (If your installation has
a special function key set up to act like @kbd{M-#}, hitting that
function key twice is just like hitting @kbd{M-# M-#}.)

If @kbd{M-#} doesn't work for you, you can always type explicit
commands like @kbd{M-x calc} (for the standard user interface) or
@w{@kbd{M-x calc-keypad}} (for Keypad Mode).  First type @kbd{M-x}
(that's Meta with the letter @kbd{x}), then, at the prompt,
type the full command (like @kbd{calc-keypad}) and press Return.

If you type @kbd{M-x calc} and Emacs still doesn't recognize the
command (it will say @samp{[No match]} when you try to press
@key{RET}), then Calc has not been properly installed.

The same commands (like @kbd{M-# c} or @kbd{M-# M-#}) that start
the Calculator also turn it off if it is already on.

@node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
@subsection The Standard Calc Interface

@noindent
@cindex Standard user interface
Calc's standard interface acts like a traditional RPN calculator,
operated by the normal Emacs keyboard.  When you type @kbd{M-# c}
to start the Calculator, the Emacs screen splits into two windows
with the file you were editing on top and Calc on the bottom.

@group
@iftex
@advance@hsize20pt
@end iftex
@smallexample

...
--**-Emacs: myfile             (Fundamental)----All----------------------
--- Emacs Calculator Mode ---                   |Emacs Calc Mode v2.00...
2:  17.3                                        |    17.3
1:  -5                                          |    3
    .                                           |    2
                                                |    4
                                                |  * 8
                                                |  ->-5
                                                |
--%%-Calc: 12 Deg       (Calculator)----All----- --%%-Emacs: *Calc Trail*
@end smallexample
@end group

In this figure, the mode-line for @file{myfile} has moved up and the
``Calculator'' window has appeared below it.  As you can see, Calc
actually makes two windows side-by-side.  The lefthand one is
called the @dfn{stack window} and the righthand one is called the
@dfn{trail window.}  The stack holds the numbers involved in the
calculation you are currently performing.  The trail holds a complete
record of all calculations you have done.  In a desk calculator with
a printer, the trail corresponds to the paper tape that records what
you do.

In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
were first entered into the Calculator, then the 2 and 4 were
multiplied to get 8, then the 3 and 8 were subtracted to get @i{-5}.
(The @samp{>} symbol shows that this was the most recent calculation.)
The net result is the two numbers 17.3 and @i{-5} sitting on the stack.

Most Calculator commands deal explicitly with the stack only, but
there is a set of commands that allow you to search back through
the trail and retrieve any previous result.

Calc commands use the digits, letters, and punctuation keys.
Shifted (i.e., upper-case) letters are different from lowercase
letters.  Some letters are @dfn{prefix} keys that begin two-letter
commands.  For example, @kbd{e} means ``enter exponent'' and shifted
@kbd{E} means @cite{e^x}.  With the @kbd{d} (``display modes'') prefix
the letter ``e'' takes on very different meanings:  @kbd{d e} means
``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''

There is nothing stopping you from switching out of the Calc
window and back into your editing window, say by using the Emacs
@w{@kbd{C-x o}} (@code{other-window}) command.  When the cursor is
inside a regular window, Emacs acts just like normal.  When the
cursor is in the Calc stack or trail windows, keys are interpreted
as Calc commands.

When you quit by pressing @kbd{M-# c} a second time, the Calculator
windows go away but the actual Stack and Trail are not gone, just
hidden.  When you press @kbd{M-# c} once again you will get the
same stack and trail contents you had when you last used the
Calculator.

The Calculator does not remember its state between Emacs sessions.
Thus if you quit Emacs and start it again, @kbd{M-# c} will give you
a fresh stack and trail.  There is a command (@kbd{m m}) that lets
you save your favorite mode settings between sessions, though.
One of the things it saves is which user interface (standard or
Keypad) you last used; otherwise, a freshly started Emacs will
always treat @kbd{M-# M-#} the same as @kbd{M-# c}.

The @kbd{q} key is another equivalent way to turn the Calculator off.

If you type @kbd{M-# b} first and then @kbd{M-# c}, you get a
full-screen version of Calc (@code{full-calc}) in which the stack and
trail windows are still side-by-side but are now as tall as the whole
Emacs screen.  When you press @kbd{q} or @kbd{M-# c} again to quit,
the file you were editing before reappears.  The @kbd{M-# b} key
switches back and forth between ``big'' full-screen mode and the
normal partial-screen mode.

Finally, @kbd{M-# o} (@code{calc-other-window}) is like @kbd{M-# c}
except that the Calc window is not selected.  The buffer you were
editing before remains selected instead.  @kbd{M-# o} is a handy
way to switch out of Calc momentarily to edit your file; type
@kbd{M-# c} to switch back into Calc when you are done.

@node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
@subsection Quick Mode (Overview)

@noindent
@dfn{Quick Mode} is a quick way to use Calc when you don't need the
full complexity of the stack and trail.  To use it, type @kbd{M-# q}
(@code{quick-calc}) in any regular editing buffer.

Quick Mode is very simple:  It prompts you to type any formula in
standard algebraic notation (like @samp{4 - 2/3}) and then displays
the result at the bottom of the Emacs screen (@i{3.33333333333}
in this case).  You are then back in the same editing buffer you
were in before, ready to continue editing or to type @kbd{M-# q}
again to do another quick calculation.  The result of the calculation
will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
at this point will yank the result into your editing buffer.

Calc mode settings affect Quick Mode, too, though you will have to
go into regular Calc (with @kbd{M-# c}) to change the mode settings.

@c [fix-ref Quick Calculator mode]
@xref{Quick Calculator}, for further information.

@node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
@subsection Keypad Mode (Overview)

@noindent
@dfn{Keypad Mode} is a mouse-based interface to the Calculator.
It is designed for use with the X window system.  If you don't
have X, you will have to operate keypad mode with your arrow
keys (which is probably more trouble than it's worth).  Keypad
mode is currently not supported under Emacs 19.

Type @kbd{M-# k} to turn Keypad Mode on or off.  Once again you
get two new windows, this time on the righthand side of the screen
instead of at the bottom.  The upper window is the familiar Calc
Stack; the lower window is a picture of a typical calculator keypad.

@tex
\dimen0=\pagetotal%
\advance \dimen0 by 24\baselineskip%
\ifdim \dimen0>\pagegoal \vfill\eject \fi%
\medskip
@end tex
@smallexample
                                        |--- Emacs Calculator Mode ---
                                        |2:  17.3
                                        |1:  -5
                                        |    .
                                        |--%%-Calc: 12 Deg       (Calcul
                                        |----+-----Calc 2.00-----+----1
                                        |FLR |CEIL|RND |TRNC|CLN2|FLT |
                                        |----+----+----+----+----+----|
                                        | LN |EXP |    |ABS |IDIV|MOD |
                                        |----+----+----+----+----+----|
                                        |SIN |COS |TAN |SQRT|y^x |1/x |
                                        |----+----+----+----+----+----|
                                        |  ENTER  |+/- |EEX |UNDO| <- |
                                        |-----+---+-+--+--+-+---++----|
                                        | INV |  7  |  8  |  9  |  /  |
                                        |-----+-----+-----+-----+-----|
                                        | HYP |  4  |  5  |  6  |  *  |
                                        |-----+-----+-----+-----+-----|
                                        |EXEC |  1  |  2  |  3  |  -  |
                                        |-----+-----+-----+-----+-----|
                                        | OFF |  0  |  .  | PI  |  +  |
                                        |-----+-----+-----+-----+-----+
@end smallexample
@iftex
@begingroup
@ifdim@hsize=5in
@vskip-3.7in
@advance@hsize-2.2in
@else
@vskip-3.89in
@advance@hsize-3.05in
@advance@vsize.1in
@fi
@end iftex

Keypad Mode is much easier for beginners to learn, because there
is no need to memorize lots of obscure key sequences.  But not all
commands in regular Calc are available on the Keypad.  You can
always switch the cursor into the Calc stack window to use
standard Calc commands if you need.  Serious Calc users, though,
often find they prefer the standard interface over Keypad Mode.

To operate the Calculator, just click on the ``buttons'' of the
keypad using your left mouse button.  To enter the two numbers
shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
add them together you would then click @kbd{+} (to get 12.3 on
the stack).

If you click the right mouse button, the top three rows of the
keypad change to show other sets of commands, such as advanced
math functions, vector operations, and operations on binary
numbers.

@iftex
@endgroup
@end iftex
Because Keypad Mode doesn't use the regular keyboard, Calc leaves
the cursor in your original editing buffer.  You can type in
this buffer in the usual way while also clicking on the Calculator
keypad.  One advantage of Keypad Mode is that you don't need an
explicit command to switch between editing and calculating.

If you press @kbd{M-# b} first, you get a full-screen Keypad Mode
(@code{full-calc-keypad}) with three windows:  The keypad in the lower
left, the stack in the lower right, and the trail on top.

@c [fix-ref Keypad Mode]
@xref{Keypad Mode}, for further information.

@node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
@subsection Standalone Operation

@noindent
@cindex Standalone Operation
If you are not in Emacs at the moment but you wish to use Calc,
you must start Emacs first.  If all you want is to run Calc, you
can give the commands:

@example
emacs -f full-calc
@end example

@noindent
or

@example
emacs -f full-calc-keypad
@end example

@noindent
which run a full-screen Calculator (as if by @kbd{M-# b M-# c}) or
a full-screen X-based Calculator (as if by @kbd{M-# b M-# k}).
In standalone operation, quitting the Calculator (by pressing
@kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
itself.

@node Embedded Mode Overview, Other M-# Commands, Standalone Operation, Using Calc
@subsection Embedded Mode (Overview)

@noindent
@dfn{Embedded Mode} is a way to use Calc directly from inside an
editing buffer.  Suppose you have a formula written as part of a
document like this:

@group
@smallexample
The derivative of

                                   ln(ln(x))

is
@end smallexample
@end group

@noindent
and you wish to have Calc compute and format the derivative for
you and store this derivative in the buffer automatically.  To
do this with Embedded Mode, first copy the formula down to where
you want the result to be:

@group
@smallexample
The derivative of

                                   ln(ln(x))

is

                                   ln(ln(x))
@end smallexample
@end group

Now, move the cursor onto this new formula and press @kbd{M-# e}.
Calc will read the formula (using the surrounding blank lines to
tell how much text to read), then push this formula (invisibly)
onto the Calc stack.  The cursor will stay on the formula in the
editing buffer, but the buffer's mode line will change to look
like the Calc mode line (with mode indicators like @samp{12 Deg}
and so on).  Even though you are still in your editing buffer,
the keyboard now acts like the Calc keyboard, and any new result
you get is copied from the stack back into the buffer.  To take
the derivative, you would type @kbd{a d x @key{RET}}.

@group
@smallexample
The derivative of

                                   ln(ln(x))

is

1 / ln(x) x
@end smallexample
@end group

To make this look nicer, you might want to press @kbd{d =} to center
the formula, and even @kbd{d B} to use ``big'' display mode.

@group
@smallexample
The derivative of

                                   ln(ln(x))

is
% [calc-mode: justify: center]
% [calc-mode: language: big]

                                       1
                                    -------
                                    ln(x) x
@end smallexample
@end group

Calc has added annotations to the file to help it remember the modes
that were used for this formula.  They are formatted like comments
in the @TeX{} typesetting language, just in case you are using @TeX{}.
(In this example @TeX{} is not being used, so you might want to move
these comments up to the top of the file or otherwise put them out
of the way.)

As an extra flourish, we can add an equation number using a
righthand label:  Type @kbd{d @} (1) RET}.

@group
@smallexample
% [calc-mode: justify: center]
% [calc-mode: language: big]
% [calc-mode: right-label: " (1)"]

                                       1
                                    -------                      (1)
                                    ln(x) x
@end smallexample
@end group

To leave Embedded Mode, type @kbd{M-# e} again.  The mode line
and keyboard will revert to the way they were before.  (If you have
actually been trying this as you read along, you'll want to press
@kbd{M-# 0} [with the digit zero] now to reset the modes you changed.)

The related command @kbd{M-# w} operates on a single word, which
generally means a single number, inside text.  It uses any
non-numeric characters rather than blank lines to delimit the
formula it reads.  Here's an example of its use:

@smallexample
A slope of one-third corresponds to an angle of 1 degrees.
@end smallexample

Place the cursor on the @samp{1}, then type @kbd{M-# w} to enable
Embedded Mode on that number.  Now type @kbd{3 /} (to get one-third),
and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
then @w{@kbd{M-# w}} again to exit Embedded mode.

@smallexample
A slope of one-third corresponds to an angle of 18.4349488229 degrees.
@end smallexample

@c [fix-ref Embedded Mode]
@xref{Embedded Mode}, for full details.

@node Other M-# Commands, , Embedded Mode Overview, Using Calc
@subsection Other @kbd{M-#} Commands

@noindent
Two more Calc-related commands are @kbd{M-# g} and @kbd{M-# r},
which ``grab'' data from a selected region of a buffer into the
Calculator.  The region is defined in the usual Emacs way, by
a ``mark'' placed at one end of the region, and the Emacs
cursor or ``point'' placed at the other.

The @kbd{M-# g} command reads the region in the usual left-to-right,
top-to-bottom order.  The result is packaged into a Calc vector
of numbers and placed on the stack.  Calc (in its standard
user interface) is then started.  Type @kbd{v u} if you want
to unpack this vector into separate numbers on the stack.  Also,
@kbd{C-u M-# g} interprets the region as a single number or
formula.

The @kbd{M-# r} command reads a rectangle, with the point and
mark defining opposite corners of the rectangle.  The result
is a matrix of numbers on the Calculator stack.

Complementary to these is @kbd{M-# y}, which ``yanks'' the
value at the top of the Calc stack back into an editing buffer.
If you type @w{@kbd{M-# y}} while in such a buffer, the value is
yanked at the current position.  If you type @kbd{M-# y} while
in the Calc buffer, Calc makes an educated guess as to which
editing buffer you want to use.  The Calc window does not have
to be visible in order to use this command, as long as there
is something on the Calc stack.

Here, for reference, is the complete list of @kbd{M-#} commands.
The shift, control, and meta keys are ignored for the keystroke
following @kbd{M-#}.

@noindent
Commands for turning Calc on and off:

@table @kbd
@item #
Turn Calc on or off, employing the same user interface as last time.

@item C
Turn Calc on or off using its standard bottom-of-the-screen
interface.  If Calc is already turned on but the cursor is not
in the Calc window, move the cursor into the window.

@item O
Same as @kbd{C}, but don't select the new Calc window.  If
Calc is already turned on and the cursor is in the Calc window,
move it out of that window.

@item B
Control whether @kbd{M-# c} and @kbd{M-# k} use the full screen.

@item Q
Use Quick Mode for a single short calculation.

@item K
Turn Calc Keypad mode on or off.

@item E
Turn Calc Embedded mode on or off at the current formula.

@item J
Turn Calc Embedded mode on or off, select the interesting part.

@item W
Turn Calc Embedded mode on or off at the current word (number).

@item Z
Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.

@item X
Quit Calc; turn off standard, Keypad, or Embedded mode if on.
(This is like @kbd{q} or @key{OFF} inside of Calc.)
@end table
@iftex
@sp 2
@end iftex

@group
@noindent
Commands for moving data into and out of the Calculator:

@table @kbd
@item G
Grab the region into the Calculator as a vector.

@item R
Grab the rectangular region into the Calculator as a matrix.

@item :
Grab the rectangular region and compute the sums of its columns.

@item _
Grab the rectangular region and compute the sums of its rows.

@item Y
Yank a value from the Calculator into the current editing buffer.
@end table
@iftex
@sp 2
@end iftex
@end group

@group
@noindent
Commands for use with Embedded Mode:

@table @kbd
@item A
``Activate'' the current buffer.  Locate all formulas that
contain @samp{:=} or @samp{=>} symbols and record their locations
so that they can be updated automatically as variables are changed.

@item D
Duplicate the current formula immediately below and select
the duplicate.

@item F
Insert a new formula at the current point.

@item N
Move the cursor to the next active formula in the buffer.

@item P
Move the cursor to the previous active formula in the buffer.

@item U
Update (i.e., as if by the @kbd{=} key) the formula at the current point.

@item `
Edit (as if by @code{calc-edit}) the formula at the current point.
@end table
@iftex
@sp 2
@end iftex
@end group

@group
@noindent
Miscellaneous commands:

@table @kbd
@item I
Run the Emacs Info system to read the Calc manual.
(This is the same as @kbd{h i} inside of Calc.)

@item T
Run the Emacs Info system to read the Calc Tutorial.

@item S
Run the Emacs Info system to read the Calc Summary.

@item L
Load Calc entirely into memory.  (Normally the various parts
are loaded only as they are needed.)

@item M
Read a region of written keystroke names (like @samp{C-n a b c RET})
and record them as the current keyboard macro.

@item 0
(This is the ``zero'' digit key.)  Reset the Calculator to
its default state:  Empty stack, and default mode settings.
With any prefix argument, reset everything but the stack.
@end table
@end group

@node History and Acknowledgements, , Using Calc, Getting Started
@section History and Acknowledgements

@noindent
Calc was originally started as a two-week project to occupy a lull
in the author's schedule.  Basically, a friend asked if I remembered
the value of @c{$2^{32}$}
@cite{2^32}.  I didn't offhand, but I said, ``that's
easy, just call up an @code{xcalc}.''  @code{Xcalc} duly reported
that the answer to our question was @samp{4.294967e+09}---with no way to
see the full ten digits even though we knew they were there in the
program's memory!  I was so annoyed, I vowed to write a calculator
of my own, once and for all.

I chose Emacs Lisp, a) because I had always been curious about it
and b) because, being only a text editor extension language after
all, Emacs Lisp would surely reach its limits long before the project
got too far out of hand.

To make a long story short, Emacs Lisp turned out to be a distressingly
solid implementation of Lisp, and the humble task of calculating
turned out to be more open-ended than one might have expected.

Emacs Lisp doesn't have built-in floating point math, so it had to be
simulated in software.  In fact, Emacs integers will only comfortably
fit six decimal digits or so---not enough for a decent calculator.  So
I had to write my own high-precision integer code as well, and once I had
this I figured that arbitrary-size integers were just as easy as large
integers.  Arbitrary floating-point precision was the logical next step.
Also, since the large integer arithmetic was there anyway it seemed only
fair to give the user direct access to it, which in turn made it practical
to support fractions as well as floats.  All these features inspired me
to look around for other data types that might be worth having.

Around this time, my friend Rick Koshi showed me his nifty new HP-28
calculator.  It allowed the user to manipulate formulas as well as
numerical quantities, and it could also operate on matrices.  I decided
that these would be good for Calc to have, too.  And once things had
gone this far, I figured I might as well take a look at serious algebra
systems like Mathematica, Macsyma, and Maple for further ideas.  Since
these systems did far more than I could ever hope to implement, I decided
to focus on rewrite rules and other programming features so that users
could implement what they needed for themselves.

Rick complained that matrices were hard to read, so I put in code to
format them in a 2D style.  Once these routines were in place, Big mode
was obligatory.  Gee, what other language modes would be useful?

Scott Hemphill and Allen Knutson, two friends with a strong mathematical
bent, contributed ideas and algorithms for a number of Calc features
including modulo forms, primality testing, and float-to-fraction conversion.

Units were added at the eager insistence of Mass Sivilotti.  Later,
Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
expert assistance with the units table.  As far as I can remember, the
idea of using algebraic formulas and variables to represent units dates
back to an ancient article in Byte magazine about muMath, an early
algebra system for microcomputers.

Many people have contributed to Calc by reporting bugs and suggesting
features, large and small.  A few deserve special mention:  Tim Peters,
who helped develop the ideas that led to the selection commands, rewrite
rules, and many other algebra features; @c{Fran\c cois}
@asis{Francois} Pinard, who contributed
an early prototype of the Calc Summary appendix as well as providing
valuable suggestions in many other areas of Calc; Carl Witty, whose eagle
eyes discovered many typographical and factual errors in the Calc manual;
Tim Kay, who drove the development of Embedded mode; Ove Ewerlid, who
made many suggestions relating to the algebra commands and contributed
some code for polynomial operations; Randal Schwartz, who suggested the
@code{calc-eval} function; Robert J. Chassell, who suggested the Calc
Tutorial and exercises; and Juha Sarlin, who first worked out how to split
Calc into quickly-loading parts.  Bob Weiner helped immensely with the
Lucid Emacs port.

@cindex Bibliography
@cindex Knuth, Art of Computer Programming
@cindex Numerical Recipes
@c Should these be expanded into more complete references?
Among the books used in the development of Calc were Knuth's @emph{Art
of Computer Programming} (especially volume II, @emph{Seminumerical
Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
and Vetterling; Bevington's @emph{Data Reduction and Error Analysis for
the Physical Sciences}; @emph{Concrete Mathematics} by Graham, Knuth,
and Patashnik; Steele's @emph{Common Lisp, the Language}; the @emph{CRC
Standard Math Tables} (William H. Beyer, ed.); and Abramowitz and
Stegun's venerable @emph{Handbook of Mathematical Functions}.  I
consulted the user's manuals for the HP-28 and HP-48 calculators, as
well as for the programs Mathematica, SMP, Macsyma, Maple, MathCAD,
Gnuplot, and others.  Also, of course, Calc could not have been written
without the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil
Lewis and Dan LaLiberte.

Final thanks go to Richard Stallman, without whose fine implementations
of the Emacs editor, language, and environment, Calc would have been
finished in two weeks.

@c [tutorial]

@ifinfo
@c This node is accessed by the `M-# t' command.
@node Interactive Tutorial, , , Top
@chapter Tutorial

@noindent
Some brief instructions on using the Emacs Info system for this tutorial:

Press the space bar and Delete keys to go forward and backward in a
section by screenfuls (or use the regular Emacs scrolling commands
for this).

Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
If the section has a @dfn{menu}, press a digit key like @kbd{1}
or @kbd{2} to go to a sub-section from the menu.  Press @kbd{u} to
go back up from a sub-section to the menu it is part of.

Exercises in the tutorial all have cross-references to the
appropriate page of the ``answers'' section.  Press @kbd{f}, then
the exercise number, to see the answer to an exercise.  After
you have followed a cross-reference, you can press the letter
@kbd{l} to return to where you were before.

You can press @kbd{?} at any time for a brief summary of Info commands.

Press @kbd{1} now to enter the first section of the Tutorial.

@menu
* Tutorial::
@end menu
@end ifinfo

@node Tutorial, Introduction, Getting Started, Top
@chapter Tutorial

@noindent
This chapter explains how to use Calc and its many features, in
a step-by-step, tutorial way.  You are encouraged to run Calc and
work along with the examples as you read (@pxref{Starting Calc}).
If you are already familiar with advanced calculators, you may wish
@c [not-split]
to skip on to the rest of this manual.
@c [when-split]
@c to skip on to volume II of this manual, the @dfn{Calc Reference}.

@c [fix-ref Embedded Mode]
This tutorial describes the standard user interface of Calc only.
The ``Quick Mode'' and ``Keypad Mode'' interfaces are fairly
self-explanatory.  @xref{Embedded Mode}, for a description of
the ``Embedded Mode'' interface.

@ifnottex
The easiest way to read this tutorial on-line is to have two windows on
your Emacs screen, one with Calc and one with the Info system.  (If you
have a printed copy of the manual you can use that instead.)  Press
@kbd{M-# c} to turn Calc on or to switch into the Calc window, and
press @kbd{M-# i} to start the Info system or to switch into its window.
Or, you may prefer to use the tutorial in printed form.
@end ifnottex
@iftex
The easiest way to read this tutorial on-line is to have two windows on
your Emacs screen, one with Calc and one with the Info system.  (If you
have a printed copy of the manual you can use that instead.)  Press
@kbd{M-# c} to turn Calc on or to switch into the Calc window, and
press @kbd{M-# i} to start the Info system or to switch into its window.
@end iftex

This tutorial is designed to be done in sequence.  But the rest of this
manual does not assume you have gone through the tutorial.  The tutorial
does not cover everything in the Calculator, but it touches on most
general areas.

@ifnottex
You may wish to print out a copy of the Calc Summary and keep notes on
it as you learn Calc.  @xref{Installation}, to see how to make a printed
summary.  @xref{Summary}.
@end ifnottex
@iftex
The Calc Summary at the end of the reference manual includes some blank
space for your own use.  You may wish to keep notes there as you learn
Calc.
@end iftex

@menu
* Basic Tutorial::
* Arithmetic Tutorial::
* Vector/Matrix Tutorial::
* Types Tutorial::
* Algebra Tutorial::
* Programming Tutorial::

* Answers to Exercises::
@end menu

@node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
@section Basic Tutorial

@noindent
In this section, we learn how RPN and algebraic-style calculations
work, how to undo and redo an operation done by mistake, and how
to control various modes of the Calculator.

@menu
* RPN Tutorial::            Basic operations with the stack.
* Algebraic Tutorial::      Algebraic entry; variables.
* Undo Tutorial::           If you make a mistake: Undo and the trail.
* Modes Tutorial::          Common mode-setting commands.
@end menu

@node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
@subsection RPN Calculations and the Stack

@cindex RPN notation
@ifnottex
@noindent
Calc normally uses RPN notation.  You may be familiar with the RPN
system from Hewlett-Packard calculators, FORTH, or PostScript.
(Reverse Polish Notation, RPN, is named after the Polish mathematician
Jan Lukasiewicz.)
@end ifnottex
@tex
\noindent
Calc normally uses RPN notation.  You may be familiar with the RPN
system from Hewlett-Packard calculators, FORTH, or PostScript.
(Reverse Polish Notation, RPN, is named after the Polish mathematician
Jan \L ukasiewicz.)
@end tex

The central component of an RPN calculator is the @dfn{stack}.  A
calculator stack is like a stack of dishes.  New dishes (numbers) are
added at the top of the stack, and numbers are normally only removed
from the top of the stack.

@cindex Operators
@cindex Operands
In an operation like @cite{2+3}, the 2 and 3 are called the @dfn{operands}
and the @cite{+} is the @dfn{operator}.  In an RPN calculator you always
enter the operands first, then the operator.  Each time you type a
number, Calc adds or @dfn{pushes} it onto the top of the Stack.
When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
number of operands from the stack and pushes back the result.

Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
@kbd{2 @key{RET} 3 @key{RET} +}.  (The @key{RET} key, Return, corresponds to
the @key{ENTER} key on traditional RPN calculators.)  Try this now if
you wish; type @kbd{M-# c} to switch into the Calc window (you can type
@kbd{M-# c} again or @kbd{M-# o} to switch back to the Tutorial window).
The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
and pushes the result (5) back onto the stack.  Here's how the stack
will look at various points throughout the calculation:@refill

@group
@smallexample
    .          1:  2          2:  2          1:  5              .
                   .          1:  3              .
                                  .

  M-# c          2 RET          3 RET            +             DEL
@end smallexample
@end group

The @samp{.} symbol is a marker that represents the top of the stack.
Note that the ``top'' of the stack is really shown at the bottom of
the Stack window.  This may seem backwards, but it turns out to be
less distracting in regular use.

@cindex Stack levels
@cindex Levels of stack
The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
numbers}.  Old RPN calculators always had four stack levels called
@cite{x}, @cite{y}, @cite{z}, and @cite{t}.  Calc's stack can grow
as large as you like, so it uses numbers instead of letters.  Some
stack-manipulation commands accept a numeric argument that says
which stack level to work on.  Normal commands like @kbd{+} always
work on the top few levels of the stack.@refill

@c [fix-ref Truncating the Stack]
The Stack buffer is just an Emacs buffer, and you can move around in
it using the regular Emacs motion commands.  But no matter where the
cursor is, even if you have scrolled the @samp{.} marker out of
view, most Calc commands always move the cursor back down to level 1
before doing anything.  It is possible to move the @samp{.} marker
upwards through the stack, temporarily ``hiding'' some numbers from
commands like @kbd{+}.  This is called @dfn{stack truncation} and
we will not cover it in this tutorial; @pxref{Truncating the Stack},
if you are interested.

You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
@key{RET} +}.  That's because if you type any operator name or
other non-numeric key when you are entering a number, the Calculator
automatically enters that number and then does the requested command.
Thus @kbd{2 @key{RET} 3 +} will work just as well.@refill

Examples in this tutorial will often omit @key{RET} even when the
stack displays shown would only happen if you did press @key{RET}:

@group
@smallexample
1:  2          2:  2          1:  5
    .          1:  3              .
                   .

  2 RET            3              +
@end smallexample
@end group

@noindent
Here, after pressing @kbd{3} the stack would really show @samp{1:  2}
with @samp{Calc:@: 3} in the minibuffer.  In these situations, you can
press the optional @key{RET} to see the stack as the figure shows.

(@bullet{}) @strong{Exercise 1.}  (This tutorial will include exercises
at various points.  Try them if you wish.  Answers to all the exercises
are located at the end of the Tutorial chapter.  Each exercise will
include a cross-reference to its particular answer.  If you are
reading with the Emacs Info system, press @kbd{f} and the
exercise number to go to the answer, then the letter @kbd{l} to
return to where you were.)

@noindent
Here's the first exercise:  What will the keystrokes @kbd{1 @key{RET} 2
@key{RET} 3 @key{RET} 4 + * -} compute?  (@samp{*} is the symbol for
multiplication.)  Figure it out by hand, then try it with Calc to see
if you're right.  @xref{RPN Answer 1, 1}. (@bullet{})

(@bullet{}) @strong{Exercise 2.}  Compute @c{$(2\times4) + (7\times9.4) + {5\over4}$}
@cite{2*4 + 7*9.5 + 5/4} using the
stack.  @xref{RPN Answer 2, 2}. (@bullet{})

The @key{DEL} key is called Backspace on some keyboards.  It is
whatever key you would use to correct a simple typing error when
regularly using Emacs.  The @key{DEL} key pops and throws away the
top value on the stack.  (You can still get that value back from
the Trail if you should need it later on.)  There are many places
in this tutorial where we assume you have used @key{DEL} to erase the
results of the previous example at the beginning of a new example.
In the few places where it is really important to use @key{DEL} to
clear away old results, the text will remind you to do so.

(It won't hurt to let things accumulate on the stack, except that
whenever you give a display-mode-changing command Calc will have to
spend a long time reformatting such a large stack.)

Since the @kbd{-} key is also an operator (it subtracts the top two
stack elements), how does one enter a negative number?  Calc uses
the @kbd{_} (underscore) key to act like the minus sign in a number.
So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.

You can also press @kbd{n}, which means ``change sign.''  It changes
the number at the top of the stack (or the number being entered)
from positive to negative or vice-versa:  @kbd{5 n @key{RET}}.

@cindex Duplicating a stack entry
If you press @key{RET} when you're not entering a number, the effect
is to duplicate the top number on the stack.  Consider this calculation:

@group
@smallexample
1:  3          2:  3          1:  9          2:  9          1:  81
    .          1:  3              .          1:  9              .
                   .                             .

  3 RET           RET             *             RET             *
@end smallexample
@end group

@noindent
(Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
to raise 3 to the fourth power.)

The space-bar key (denoted @key{SPC} here) performs the same function
as @key{RET}; you could replace all three occurrences of @key{RET} in
the above example with @key{SPC} and the effect would be the same.

@cindex Exchanging stack entries
Another stack manipulation key is @key{TAB}.  This exchanges the top
two stack entries.  Suppose you have computed @kbd{2 @key{RET} 3 +}
to get 5, and then you realize what you really wanted to compute
was @cite{20 / (2+3)}.

@group
@smallexample
1:  5          2:  5          2:  20         1:  4
    .          1:  20         1:  5              .
                   .              .

 2 RET 3 +         20            TAB             /
@end smallexample
@end group

@noindent
Planning ahead, the calculation would have gone like this:

@group
@smallexample
1:  20         2:  20         3:  20         2:  20         1:  4
    .          1:  2          2:  2          1:  5              .
                   .          1:  3              .
                                  .

  20 RET         2 RET            3              +              /
@end smallexample
@end group

A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
@key{TAB}).  It rotates the top three elements of the stack upward,
bringing the object in level 3 to the top.

@group
@smallexample
1:  10         2:  10         3:  10         3:  20         3:  30
    .          1:  20         2:  20         2:  30         2:  10
                   .          1:  30         1:  10         1:  20
                                  .              .              .

  10 RET         20 RET         30 RET         M-TAB          M-TAB
@end smallexample
@end group

(@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
on the stack.  Figure out how to add one to the number in level 2
without affecting the rest of the stack.  Also figure out how to add
one to the number in level 3.  @xref{RPN Answer 3, 3}. (@bullet{})

Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
arguments from the stack and push a result.  Operations like @kbd{n} and
@kbd{Q} (square root) pop a single number and push the result.  You can
think of them as simply operating on the top element of the stack.

@group
@smallexample
1:  3          1:  9          2:  9          1:  25         1:  5
    .              .          1:  16             .              .
                                  .

  3 RET          RET *        4 RET RET *        +              Q
@end smallexample
@end group

@noindent
(Note that capital @kbd{Q} means to hold down the Shift key while
typing @kbd{q}.  Remember, plain unshifted @kbd{q} is the Quit command.)

@cindex Pythagorean Theorem
Here we've used the Pythagorean Theorem to determine the hypotenuse of a
right triangle.  Calc actually has a built-in command for that called
@kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
We can still enter it by its full name using @kbd{M-x} notation:

@group
@smallexample
1:  3          2:  3          1:  5
    .          1:  4              .
                   .

  3 RET          4 RET      M-x calc-hypot
@end smallexample
@end group

All Calculator commands begin with the word @samp{calc-}.  Since it
gets tiring to type this, Calc provides an @kbd{x} key which is just
like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
prefix for you:

@group
@smallexample
1:  3          2:  3          1:  5
    .          1:  4              .
                   .

  3 RET          4 RET         x hypot
@end smallexample
@end group

What happens if you take the square root of a negative number?

@group
@smallexample
1:  4          1:  -4         1:  (0, 2)
    .              .              .

  4 RET            n              Q
@end smallexample
@end group

@noindent
The notation @cite{(a, b)} represents a complex number.
Complex numbers are more traditionally written @c{$a + b i$}
@cite{a + b i};
Calc can display in this format, too, but for now we'll stick to the
@cite{(a, b)} notation.

If you don't know how complex numbers work, you can safely ignore this
feature.  Complex numbers only arise from operations that would be
errors in a calculator that didn't have complex numbers.  (For example,
taking the square root or logarithm of a negative number produces a
complex result.)

Complex numbers are entered in the notation shown.  The @kbd{(} and
@kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''

@group
@smallexample
1:  ( ...      2:  ( ...      1:  (2, ...    1:  (2, ...    1:  (2, 3)
    .          1:  2              .              3              .
                   .                             .

    (              2              ,              3              )
@end smallexample
@end group

You can perform calculations while entering parts of incomplete objects.
However, an incomplete object cannot actually participate in a calculation:

@group
@smallexample
1:  ( ...      2:  ( ...      3:  ( ...      1:  ( ...      1:  ( ...
    .          1:  2          2:  2              5              5
                   .          1:  3              .              .
                                  .
                                                             (error)
    (             2 RET           3              +              +
@end smallexample
@end group

@noindent
Adding 5 to an incomplete object makes no sense, so the last command
produces an error message and leaves the stack the same.

Incomplete objects can't participate in arithmetic, but they can be
moved around by the regular stack commands.

@group
@smallexample
2:  2          3:  2          3:  3          1:  ( ...      1:  (2, 3)
1:  3          2:  3          2:  ( ...          2              .
    .          1:  ( ...      1:  2              3
                   .              .              .

2 RET 3 RET        (            M-TAB          M-TAB            )
@end smallexample
@end group

@noindent
Note that the @kbd{,} (comma) key did not have to be used here.
When you press @kbd{)} all the stack entries between the incomplete
entry and the top are collected, so there's never really a reason
to use the comma.  It's up to you.

(@bullet{}) @strong{Exercise 4.}  To enter the complex number @cite{(2, 3)},
your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}.  What happened?
(Joe thought of a clever way to correct his mistake in only two
keystrokes, but it didn't quite work.  Try it to find out why.)
@xref{RPN Answer 4, 4}. (@bullet{})

Vectors are entered the same way as complex numbers, but with square
brackets in place of parentheses.  We'll meet vectors again later in
the tutorial.

Any Emacs command can be given a @dfn{numeric prefix argument} by
typing a series of @key{META}-digits beforehand.  If @key{META} is
awkward for you, you can instead type @kbd{C-u} followed by the
necessary digits.  Numeric prefix arguments can be negative, as in
@kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}.  Calc commands use numeric
prefix arguments in a variety of ways.  For example, a numeric prefix
on the @kbd{+} operator adds any number of stack entries at once:

@group
@smallexample
1:  10         2:  10         3:  10         3:  10         1:  60
    .          1:  20         2:  20         2:  20             .
                   .          1:  30         1:  30
                                  .              .

  10 RET         20 RET         30 RET         C-u 3            +
@end smallexample
@end group

For stack manipulation commands like @key{RET}, a positive numeric
prefix argument operates on the top @var{n} stack entries at once.  A
negative argument operates on the entry in level @var{n} only.  An
argument of zero operates on the entire stack.  In this example, we copy
the second-to-top element of the stack:

@group
@smallexample
1:  10         2:  10         3:  10         3:  10         4:  10
    .          1:  20         2:  20         2:  20         3:  20
                   .          1:  30         1:  30         2:  30
                                  .              .          1:  20
                                                                .

  10 RET         20 RET         30 RET         C-u -2          RET
@end smallexample
@end group

@cindex Clearing the stack
@cindex Emptying the stack
Another common idiom is @kbd{M-0 DEL}, which clears the stack.
(The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
entire stack.)

@node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
@subsection Algebraic-Style Calculations

@noindent
If you are not used to RPN notation, you may prefer to operate the
Calculator in ``algebraic mode,'' which is closer to the way
non-RPN calculators work.  In algebraic mode, you enter formulas
in traditional @cite{2+3} notation.

You don't really need any special ``mode'' to enter algebraic formulas.
You can enter a formula at any time by pressing the apostrophe (@kbd{'})
key.  Answer the prompt with the desired formula, then press @key{RET}.
The formula is evaluated and the result is pushed onto the RPN stack.
If you don't want to think in RPN at all, you can enter your whole
computation as a formula, read the result from the stack, then press
@key{DEL} to delete it from the stack.

Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
The result should be the number 9.

Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
@samp{/}, and @samp{^}.  You can use parentheses to make the order
of evaluation clear.  In the absence of parentheses, @samp{^} is
evaluated first, then @samp{*}, then @samp{/}, then finally
@samp{+} and @samp{-}.  For example, the expression

@example
2 + 3*4*5 / 6*7^8 - 9
@end example

@noindent
is equivalent to

@example
2 + ((3*4*5) / (6*(7^8)) - 9
@end example

@noindent
or, in large mathematical notation,

@ifnottex
@group
@example
    3 * 4 * 5
2 + --------- - 9
          8
     6 * 7
@end example
@end group
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
\afterdisplay
@end tex

@noindent
The result of this expression will be the number @i{-6.99999826533}.

Calc's order of evaluation is the same as for most computer languages,
except that @samp{*} binds more strongly than @samp{/}, as the above
example shows.  As in normal mathematical notation, the @samp{*} symbol
can often be omitted:  @samp{2 a} is the same as @samp{2*a}.

Operators at the same level are evaluated from left to right, except
that @samp{^} is evaluated from right to left.  Thus, @samp{2-3-4} is
equivalent to @samp{(2-3)-4} or @i{-5}, whereas @samp{2^3^4} is equivalent
to @samp{2^(3^4)} (a very large integer; try it!).

If you tire of typing the apostrophe all the time, there is an
``algebraic mode'' you can select in which Calc automatically senses
when you are about to type an algebraic expression.  To enter this
mode, press the two letters @w{@kbd{m a}}.  (An @samp{Alg} indicator
should appear in the Calc window's mode line.)

Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.

In algebraic mode, when you press any key that would normally begin
entering a number (such as a digit, a decimal point, or the @kbd{_}
key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
an algebraic entry.

Functions which do not have operator symbols like @samp{+} and @samp{*}
must be entered in formulas using function-call notation.  For example,
the function name corresponding to the square-root key @kbd{Q} is
@code{sqrt}.  To compute a square root in a formula, you would use
the notation @samp{sqrt(@var{x})}.

Press the apostrophe, then type @kbd{sqrt(5*2) - 3}.  The result should
be @cite{0.16227766017}.

Note that if the formula begins with a function name, you need to use
the apostrophe even if you are in algebraic mode.  If you type @kbd{arcsin}
out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
command, and the @kbd{csin} will be taken as the name of the rewrite
rule to use!

Some people prefer to enter complex numbers and vectors in algebraic
form because they find RPN entry with incomplete objects to be too
distracting, even though they otherwise use Calc as an RPN calculator.

Still in algebraic mode, type:

@group
@smallexample
1:  (2, 3)     2:  (2, 3)     1:  (8, -1)    2:  (8, -1)    1:  (9, -1)
    .          1:  (1, -2)        .          1:  1              .
                   .                             .

 (2,3) RET      (1,-2) RET        *              1 RET          +
@end smallexample
@end group

Algebraic mode allows us to enter complex numbers without pressing
an apostrophe first, but it also means we need to press @key{RET}
after every entry, even for a simple number like @cite{1}.

(You can type @kbd{C-u m a} to enable a special ``incomplete algebraic
mode'' in which the @kbd{(} and @kbd{[} keys use algebraic entry even
though regular numeric keys still use RPN numeric entry.  There is also
a ``total algebraic mode,'' started by typing @kbd{m t}, in which all
normal keys begin algebraic entry.  You must then use the @key{META} key
to type Calc commands:  @kbd{M-m t} to get back out of total algebraic
mode, @kbd{M-q} to quit, etc.  Total algebraic mode is not supported
under Emacs 19.)

If you're still in algebraic mode, press @kbd{m a} again to turn it off.

Actual non-RPN calculators use a mixture of algebraic and RPN styles.
In general, operators of two numbers (like @kbd{+} and @kbd{*})
use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
use RPN form.  Also, a non-RPN calculator allows you to see the
intermediate results of a calculation as you go along.  You can
accomplish this in Calc by performing your calculation as a series
of algebraic entries, using the @kbd{$} sign to tie them together.
In an algebraic formula, @kbd{$} represents the number on the top
of the stack.  Here, we perform the calculation @c{$\sqrt{2\times4+1}$}
@cite{sqrt(2*4+1)},
which on a traditional calculator would be done by pressing
@kbd{2 * 4 + 1 =} and then the square-root key.

@group
@smallexample
1:  8          1:  9          1:  3
    .              .              .

  ' 2*4 RET        $+1 RET        Q
@end smallexample
@end group

@noindent
Notice that we didn't need to press an apostrophe for the @kbd{$+1},
because the dollar sign always begins an algebraic entry.

(@bullet{}) @strong{Exercise 1.}  How could you get the same effect as
pressing @kbd{Q} but using an algebraic entry instead?  How about
if the @kbd{Q} key on your keyboard were broken?
@xref{Algebraic Answer 1, 1}. (@bullet{})

The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
entries.  For example, @kbd{' $$+$ RET} is just like typing @kbd{+}.

Algebraic formulas can include @dfn{variables}.  To store in a
variable, press @kbd{s s}, then type the variable name, then press
@key{RET}.  (There are actually two flavors of store command:
@kbd{s s} stores a number in a variable but also leaves the number
on the stack, while @w{@kbd{s t}} removes a number from the stack and
stores it in the variable.)  A variable name should consist of one
or more letters or digits, beginning with a letter.

@group
@smallexample
1:  17             .          1:  a + a^2    1:  306
    .                             .              .

    17          s t a RET      ' a+a^2 RET       =
@end smallexample
@end group

@noindent
The @kbd{=} key @dfn{evaluates} a formula by replacing all its
variables by the values that were stored in them.

For RPN calculations, you can recall a variable's value on the
stack either by entering its name as a formula and pressing @kbd{=},
or by using the @kbd{s r} command.

@group
@smallexample
1:  17         2:  17         3:  17         2:  17         1:  306
    .          1:  17         2:  17         1:  289            .
                   .          1:  2              .
                                  .

  s r a RET     ' a RET =         2              ^              +
@end smallexample
@end group

If you press a single digit for a variable name (as in @kbd{s t 3}, you
get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
They are ``quick'' simply because you don't have to type the letter
@code{q} or the @key{RET} after their names.  In fact, you can type
simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
@kbd{t 3} and @w{@kbd{r 3}}.

Any variables in an algebraic formula for which you have not stored
values are left alone, even when you evaluate the formula.

@group
@smallexample
1:  2 a + 2 b     1:  34 + 2 b
    .                 .

 ' 2a+2b RET          =
@end smallexample
@end group

Calls to function names which are undefined in Calc are also left
alone, as are calls for which the value is undefined.

@group
@smallexample
1:  2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
    .

 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) RET
@end smallexample
@end group

@noindent
In this example, the first call to @code{log10} works, but the other
calls are not evaluated.  In the second call, the logarithm is
undefined for that value of the argument; in the third, the argument
is symbolic, and in the fourth, there are too many arguments.  In the
fifth case, there is no function called @code{foo}.  You will see a
``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
Press the @kbd{w} (``why'') key to see any other messages that may
have arisen from the last calculation.  In this case you will get
``logarithm of zero,'' then ``number expected: @code{x}''.  Calc
automatically displays the first message only if the message is
sufficiently important; for example, Calc considers ``wrong number
of arguments'' and ``logarithm of zero'' to be important enough to
report automatically, while a message like ``number expected: @code{x}''
will only show up if you explicitly press the @kbd{w} key.

(@bullet{}) @strong{Exercise 2.}  Joe entered the formula @samp{2 x y},
stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
@samp{10 y}.  He then tried the same for the formula @samp{2 x (1+y)},
expecting @samp{10 (1+y)}, but it didn't work.  Why not?
@xref{Algebraic Answer 2, 2}. (@bullet{})

(@bullet{}) @strong{Exercise 3.}  What result would you expect
@kbd{1 @key{RET} 0 /} to give?  What if you then type @kbd{0 *}?
@xref{Algebraic Answer 3, 3}. (@bullet{})

One interesting way to work with variables is to use the
@dfn{evaluates-to} (@samp{=>}) operator.  It works like this:
Enter a formula algebraically in the usual way, but follow
the formula with an @samp{=>} symbol.  (There is also an @kbd{s =}
command which builds an @samp{=>} formula using the stack.)  On
the stack, you will see two copies of the formula with an @samp{=>}
between them.  The lefthand formula is exactly like you typed it;
the righthand formula has been evaluated as if by typing @kbd{=}.

@group
@smallexample
2:  2 + 3 => 5                     2:  2 + 3 => 5
1:  2 a + 2 b => 34 + 2 b          1:  2 a + 2 b => 20 + 2 b
    .                                  .

' 2+3 => RET  ' 2a+2b RET s =          10 s t a RET
@end smallexample
@end group

@noindent
Notice that the instant we stored a new value in @code{a}, all
@samp{=>} operators already on the stack that referred to @cite{a}
were updated to use the new value.  With @samp{=>}, you can push a
set of formulas on the stack, then change the variables experimentally
to see the effects on the formulas' values.

You can also ``unstore'' a variable when you are through with it:

@group
@smallexample
2:  2 + 5 => 5
1:  2 a + 2 b => 2 a + 2 b
    .

    s u a RET
@end smallexample
@end group

We will encounter formulas involving variables and functions again
when we discuss the algebra and calculus features of the Calculator.

@node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
@subsection Undo and Redo

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

@group
@smallexample
1:  2          2:  2          1:  8          2:  2          1:  6
    .          1:  3              .          1:  3              .
                   .                             .

   2 RET           3              ^              U              *
@end smallexample
@end group

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:

@group
@smallexample
1:  6          2:  2          1:  2              .              .
    .          1:  3              .
                   .
                                                             (error)
                   U              U              U              U
@end smallexample
@end group

You can also type @kbd{D} to ``redo'' a command that you have undone
mistakenly.

@group
@smallexample
    .          1:  2          2:  2          1:  6          1:  6
                   .          1:  3              .              .
                                  .
                                                             (error)
                   D              D              D              D
@end smallexample
@end group

@noindent
It was not possible to redo past the @cite{6}, since that was placed there
by something other than an undo command.

@cindex Time travel
You can think of undo and redo as a sort of ``time machine.''  Press
@kbd{U} to go backward in time, @kbd{D} to go forward.  If you go
backward and do something (like @kbd{*}) 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 @cite{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 @kbd{t d} now to turn it on.

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

If you press @kbd{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 @samp{2^3^4}.  We don't remember
what it was, but the first digits were ``241''.  Press @kbd{t r}
(which stands for trail-search-reverse), then type @kbd{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 @kbd{C-s} or @kbd{C-r} to
continue the search forwards or backwards as you like.

To finish the search, press @key{RET}.  This halts the incremental
search and leaves the trail pointer at the thing we found.  Now we
can type @kbd{t y} to yank that number onto the stack.  If we hadn't
remembered the ``241'', we could simply have searched for @kbd{2^3^4},
then pressed @kbd{@key{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 @kbd{t}.  (The store-and-recall commands, on the other hand,
all began with @kbd{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 @dfn{prefix}
key.  If you type a prefix key by accident, you can press @kbd{C-g}
to cancel it.  (In fact, you can press @kbd{C-g} to cancel almost
anything in Emacs.)  To get help on a prefix key, press that key
followed by @kbd{?}.  Some prefixes have several lines of help,
so you need to press @kbd{?} repeatedly to see them all.  This may
not work under Lucid Emacs, but you can also type @kbd{h h} to
see all the help at once.

Try pressing @kbd{t ?} now.  You will see a line of the form,

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

@noindent
The word ``trail'' indicates that the @kbd{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 @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
@kbd{t y} so far.  The @samp{[MORE]} means you can press @kbd{?}
again to see more @kbd{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 @kbd{y} for example,
it will be interpreted as a @kbd{t y} command.  If all you wanted
was to look at the help messages, press @kbd{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 @kbd{`} (the backquote or accent grave)
to edit a stack entry.

Try entering @samp{3.141439} now.  If this is supposed to represent
@c{$\pi$}
@cite{pi}, it's got several errors.  Press @kbd{`} 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 @key{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 @kbd{`} key also works
during entry of a number or algebraic formula.

@node Modes Tutorial, , Undo Tutorial, Basic Tutorial
@subsection Mode-Setting Commands

@noindent
Calc has many types of @dfn{modes} that affect the way it interprets
your commands or the way it displays data.  We have already seen one
mode, namely algebraic mode.  There are many others, too; we'll
try some of the most common ones here.

Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
Notice the @samp{12} on the Calc window's mode line:

@smallexample
--%%-Calc: 12 Deg       (Calculator)----All------
@end smallexample

@noindent
Most of the symbols there are Emacs things you don't need to worry
about, but the @samp{12} and the @samp{Deg} are mode indicators.
The @samp{12} means that calculations should always be carried to
12 significant figures.  That is why, when we type @kbd{1 @key{RET} 7 /},
we get @cite{0.142857142857} with exactly 12 digits, not counting
leading and trailing zeros.

You can set the precision to anything you like by pressing @kbd{p},
then entering a suitable number.  Try pressing @kbd{p 30 @key{RET}},
then doing @kbd{1 @key{RET} 7 /} again:

@group
@smallexample
1:  0.142857142857
2:  0.142857142857142857142857142857
    .
@end smallexample
@end group

Although the precision can be set arbitrarily high, Calc always
has to have @emph{some} value for the current precision.  After
all, the true value @cite{1/7} is an infinitely repeating decimal;
Calc has to stop somewhere.

Of course, calculations are slower the more digits you request.
Press @w{@kbd{p 12}} now to set the precision back down to the default.

Calculations always use the current precision.  For example, even
though we have a 30-digit value for @cite{1/7} on the stack, if
we use it in a calculation in 12-digit mode it will be rounded
down to 12 digits before it is used.  Try it; press @key{RET} to
duplicate the number, then @w{@kbd{1 +}}.  Notice that the @key{RET}
key didn't round the number, because it doesn't do any calculation.
But the instant we pressed @kbd{+}, the number was rounded down.

@group
@smallexample
1:  0.142857142857
2:  0.142857142857142857142857142857
3:  1.14285714286
    .
@end smallexample
@end group

@noindent
In fact, since we added a digit on the left, we had to lose one
digit on the right from even the 12-digit value of @cite{1/7}.

How did we get more than 12 digits when we computed @samp{2^3^4}?  The
answer is that Calc makes a distinction between @dfn{integers} and
@dfn{floating-point} numbers, or @dfn{floats}.  An integer is a number
that does not contain a decimal point.  There is no such thing as an
``infinitely repeating fraction integer,'' so Calc doesn't have to limit
itself.  If you asked for @samp{2^10000} (don't try this!), you would
have to wait a long time but you would eventually get an exact answer.
If you ask for @samp{2.^10000}, you will quickly get an answer which is
correct only to 12 places.  The decimal point tells Calc that it should
use floating-point arithmetic to get the answer, not exact integer
arithmetic.

You can use the @kbd{F} (@code{calc-floor}) command to convert a
floating-point value to an integer, and @kbd{c f} (@code{calc-float})
to convert an integer to floating-point form.

Let's try entering that last calculation:

@group
@smallexample
1:  2.         2:  2.         1:  1.99506311689e3010
    .          1:  10000          .
                   .

  2.0 RET          10000 RET      ^
@end smallexample
@end group

@noindent
@cindex Scientific notation, entry of
Notice the letter @samp{e} in there.  It represents ``times ten to the
power of,'' and is used by Calc automatically whenever writing the
number out fully would introduce more extra zeros than you probably
want to see.  You can enter numbers in this notation, too.

@group
@smallexample
1:  2.         2:  2.         1:  1.99506311678e3010
    .          1:  10000.         .
                   .

  2.0 RET          1e4 RET        ^
@end smallexample
@end group

@cindex Round-off errors
@noindent
Hey, the answer is different!  Look closely at the middle columns
of the two examples.  In the first, the stack contained the
exact integer @cite{10000}, but in the second it contained
a floating-point value with a decimal point.  When you raise a
number to an integer power, Calc uses repeated squaring and
multiplication to get the answer.  When you use a floating-point
power, Calc uses logarithms and exponentials.  As you can see,
a slight error crept in during one of these methods.  Which
one should we trust?  Let's raise the precision a bit and find
out:

@group
@smallexample
    .          1:  2.         2:  2.         1:  1.995063116880828e3010
                   .          1:  10000.         .
                                  .

 p 16 RET        2. RET           1e4            ^    p 12 RET
@end smallexample
@end group

@noindent
@cindex Guard digits
Presumably, it doesn't matter whether we do this higher-precision
calculation using an integer or floating-point power, since we
have added enough ``guard digits'' to trust the first 12 digits
no matter what.  And the verdict is@dots{}  Integer powers were more
accurate; in fact, the result was only off by one unit in the
last place.

@cindex Guard digits
Calc does many of its internal calculations to a slightly higher
precision, but it doesn't always bump the precision up enough.
In each case, Calc added about two digits of precision during
its calculation and then rounded back down to 12 digits
afterward.  In one case, it was enough; in the other, it
wasn't.  If you really need @var{x} digits of precision, it
never hurts to do the calculation with a few extra guard digits.

What if we want guard digits but don't want to look at them?
We can set the @dfn{float format}.  Calc supports four major
formats for floating-point numbers, called @dfn{normal},
@dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
notation}.  You get them by pressing @w{@kbd{d n}}, @kbd{d f},
@kbd{d s}, and @kbd{d e}, respectively.  In each case, you can
supply a numeric prefix argument which says how many digits
should be displayed.  As an example, let's put a few numbers
onto the stack and try some different display modes.  First,
use @kbd{M-0 DEL} to clear the stack, then enter the four
numbers shown here:

@group
@smallexample
4:  12345      4:  12345      4:  12345      4:  12345      4:  12345
3:  12345.     3:  12300.     3:  1.2345e4   3:  1.23e4     3:  12345.000
2:  123.45     2:  123.       2:  1.2345e2   2:  1.23e2     2:  123.450
1:  12.345     1:  12.3       1:  1.2345e1   1:  1.23e1     1:  12.345
    .              .              .              .              .

   d n          M-3 d n          d s          M-3 d s        M-3 d f
@end smallexample
@end group

@noindent
Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
to three significant digits, but then when we typed @kbd{d s} all
five significant figures reappeared.  The float format does not
affect how numbers are stored, it only affects how they are
displayed.  Only the current precision governs the actual rounding
of numbers in the Calculator's memory.

Engineering notation, not shown here, is like scientific notation
except the exponent (the power-of-ten part) is always adjusted to be
a multiple of three (as in ``kilo,'' ``micro,'' etc.).  As a result
there will be one, two, or three digits before the decimal point.

Whenever you change a display-related mode, Calc redraws everything
in the stack.  This may be slow if there are many things on the stack,
so Calc allows you to type shift-@kbd{H} before any mode command to
prevent it from updating the stack.  Anything Calc displays after the
mode-changing command will appear in the new format.

@group
@smallexample
4:  12345      4:  12345      4:  12345      4:  12345      4:  12345
3:  12345.000  3:  12345.000  3:  12345.000  3:  1.2345e4   3:  12345.
2:  123.450    2:  123.450    2:  1.2345e1   2:  1.2345e1   2:  123.45
1:  12.345     1:  1.2345e1   1:  1.2345e2   1:  1.2345e2   1:  12.345
    .              .              .              .              .

    H d s          DEL U          TAB            d SPC          d n
@end smallexample
@end group

@noindent
Here the @kbd{H d s} command changes to scientific notation but without
updating the screen.  Deleting the top stack entry and undoing it back
causes it to show up in the new format; swapping the top two stack
entries reformats both entries.  The @kbd{d SPC} command refreshes the
whole stack.  The @kbd{d n} command changes back to the normal float
format; since it doesn't have an @kbd{H} prefix, it also updates all
the stack entries to be in @kbd{d n} format.

Notice that the integer @cite{12345} was not affected by any
of the float formats.  Integers are integers, and are always
displayed exactly.

@cindex Large numbers, readability
Large integers have their own problems.  Let's look back at
the result of @kbd{2^3^4}.

@example
2417851639229258349412352
@end example

@noindent
Quick---how many digits does this have?  Try typing @kbd{d g}:

@example
2,417,851,639,229,258,349,412,352
@end example

@noindent
Now how many digits does this have?  It's much easier to tell!
We can actually group digits into clumps of any size.  Some
people prefer @kbd{M-5 d g}:

@example
24178,51639,22925,83494,12352
@end example

Let's see what happens to floating-point numbers when they are grouped.
First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
to get ourselves into trouble.  Now, type @kbd{1e13 /}:

@example
24,17851,63922.9258349412352
@end example

@noindent
The integer part is grouped but the fractional part isn't.  Now try
@kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):

@example
24,17851,63922.92583,49412,352
@end example

If you find it hard to tell the decimal point from the commas, try
changing the grouping character to a space with @kbd{d , @key{SPC}}:

@example
24 17851 63922.92583 49412 352
@end example

Type @kbd{d , ,} to restore the normal grouping character, then
@kbd{d g} again to turn grouping off.  Also, press @kbd{p 12} to
restore the default precision.

Press @kbd{U} enough times to get the original big integer back.
(Notice that @kbd{U} does not undo each mode-setting command; if
you want to undo a mode-setting command, you have to do it yourself.)
Now, type @kbd{d r 16 @key{RET}}:

@example
16#200000000000000000000
@end example

@noindent
The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
Suddenly it looks pretty simple; this should be no surprise, since we
got this number by computing a power of two, and 16 is a power of 2.
In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
form:

@example
2#1000000000000000000000000000000000000000000000000000000 @dots{}
@end example

@noindent
We don't have enough space here to show all the zeros!  They won't
fit on a typical screen, either, so you will have to use horizontal
scrolling to see them all.  Press @kbd{<} and @kbd{>} to scroll the
stack window left and right by half its width.  Another way to view
something large is to press @kbd{`} (back-quote) to edit the top of
stack in a separate window.  (Press @kbd{M-# M-#} when you are done.)

You can enter non-decimal numbers using the @kbd{#} symbol, too.
Let's see what the hexadecimal number @samp{5FE} looks like in
binary.  Type @kbd{16#5FE} (the letters can be typed in upper or
lower case; they will always appear in upper case).  It will also
help to turn grouping on with @kbd{d g}:

@example
2#101,1111,1110
@end example

Notice that @kbd{d g} groups by fours by default if the display radix
is binary or hexadecimal, but by threes if it is decimal, octal, or any
other radix.

Now let's see that number in decimal; type @kbd{d r 10}:

@example
1,534
@end example

Numbers are not @emph{stored} with any particular radix attached.  They're
just numbers; they can be entered in any radix, and are always displayed
in whatever radix you've chosen with @kbd{d r}.  The current radix applies
to integers, fractions, and floats.

@cindex Roundoff errors, in non-decimal numbers
(@bullet{}) @strong{Exercise 1.}  Your friend Joe tried to enter one-third
as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12.  He got
@samp{3#0.0222222...} (with 25 2's) in the display.  When he multiplied
that by three, he got @samp{3#0.222222...} instead of the expected
@samp{3#1}.  Next, Joe entered @samp{3#0.2} and, to his great relief,
saw @samp{3#0.2} on the screen.  But when he typed @kbd{2 /}, he got
@samp{3#0.10000001} (some zeros omitted).  What's going on here?
@xref{Modes Answer 1, 1}. (@bullet{})

@cindex Scientific notation, in non-decimal numbers
(@bullet{}) @strong{Exercise 2.}  Scientific notation works in non-decimal
modes in the natural way (the exponent is a power of the radix instead of
a power of ten, although the exponent itself is always written in decimal).
Thus @samp{8#1.23e3 = 8#1230.0}.  Suppose we have the hexadecimal number
@samp{f.e8f} times 16 to the 15th power:  We write @samp{16#f.e8fe15}.
What is wrong with this picture?  What could we write instead that would
work better?  @xref{Modes Answer 2, 2}. (@bullet{})

The @kbd{m} prefix key has another set of modes, relating to the way
Calc interprets your inputs and does computations.  Whereas @kbd{d}-prefix
modes generally affect the way things look, @kbd{m}-prefix modes affect
the way they are actually computed.

The most popular @kbd{m}-prefix mode is the @dfn{angular mode}.  Notice
the @samp{Deg} indicator in the mode line.  This means that if you use
a command that interprets a number as an angle, it will assume the
angle is measured in degrees.  For example,

@group
@smallexample
1:  45         1:  0.707106781187   1:  0.500000000001    1:  0.5
    .              .                    .                     .

    45             S                    2 ^                   c 1
@end smallexample
@end group

@noindent
The shift-@kbd{S} command computes the sine of an angle.  The sine
of 45 degrees is @c{$\sqrt{2}/2$}
@cite{sqrt(2)/2}; squaring this yields @cite{2/4 = 0.5}.
However, there has been a slight roundoff error because the
representation of @c{$\sqrt{2}/2$}
@cite{sqrt(2)/2} wasn't exact.  The @kbd{c 1}
command is a handy way to clean up numbers in this case; it
temporarily reduces the precision by one digit while it
re-rounds the number on the top of the stack.

@cindex Roundoff errors, examples
(@bullet{}) @strong{Exercise 3.}  Your friend Joe computed the sine
of 45 degrees as shown above, then, hoping to avoid an inexact
result, he increased the precision to 16 digits before squaring.
What happened?  @xref{Modes Answer 3, 3}. (@bullet{})

To do this calculation in radians, we would type @kbd{m r} first.
(The indicator changes to @samp{Rad}.)  45 degrees corresponds to
@c{$\pi\over4$}
@cite{pi/4} radians.  To get @c{$\pi$}
@cite{pi}, press the @kbd{P} key.  (Once
again, this is a shifted capital @kbd{P}.  Remember, unshifted
@kbd{p} sets the precision.)

@group
@smallexample
1:  3.14159265359   1:  0.785398163398   1:  0.707106781187
    .                   .                .

    P                   4 /       m r    S
@end smallexample
@end group

Likewise, inverse trigonometric functions generate results in
either radians or degrees, depending on the current angular mode.

@group
@smallexample
1:  0.707106781187   1:  0.785398163398   1:  45.
    .                    .                    .

    .5 Q        m r      I S        m d       U I S
@end smallexample
@end group

@noindent
Here we compute the Inverse Sine of @c{$\sqrt{0.5}$}
@cite{sqrt(0.5)}, first in
radians, then in degrees.

Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
and vice-versa.

@group
@smallexample
1:  45         1:  0.785398163397     1:  45.
    .              .                      .

    45             c r                    c d
@end smallexample
@end group

Another interesting mode is @dfn{fraction mode}.  Normally,
dividing two integers produces a floating-point result if the
quotient can't be expressed as an exact integer.  Fraction mode
causes integer division to produce a fraction, i.e., a rational
number, instead.

@group
@smallexample
2:  12         1:  1.33333333333    1:  4:3
1:  9              .                    .
    .

 12 RET 9          /          m f       U /      m f
@end smallexample
@end group

@noindent
In the first case, we get an approximate floating-point result.
In the second case, we get an exact fractional result (four-thirds).

You can enter a fraction at any time using @kbd{:} notation.
(Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
because @kbd{/} is already used to divide the top two stack
elements.)  Calculations involving fractions will always
produce exact fractional results; fraction mode only says
what to do when dividing two integers.

@cindex Fractions vs. floats
@cindex Floats vs. fractions
(@bullet{}) @strong{Exercise 4.}  If fractional arithmetic is exact,
why would you ever use floating-point numbers instead?
@xref{Modes Answer 4, 4}. (@bullet{})

Typing @kbd{m f} doesn't change any existing values in the stack.
In the above example, we had to Undo the division and do it over
again when we changed to fraction mode.  But if you use the
evaluates-to operator you can get commands like @kbd{m f} to
recompute for you.

@group
@smallexample
1:  12 / 9 => 1.33333333333    1:  12 / 9 => 1.333    1:  12 / 9 => 4:3
    .                              .                      .

   ' 12/9 => RET                   p 4 RET                m f
@end smallexample
@end group

@noindent
In this example, the righthand side of the @samp{=>} operator
on the stack is recomputed when we change the precision, then
again when we change to fraction mode.  All @samp{=>} expressions
on the stack are recomputed every time you change any mode that
might affect their values.

@node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
@section Arithmetic Tutorial

@noindent
In this section, we explore the arithmetic and scientific functions
available in the Calculator.

The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
and @kbd{^}.  Each normally takes two numbers from the top of the stack
and pushes back a result.  The @kbd{n} and @kbd{&} keys perform
change-sign and reciprocal operations, respectively.

@group
@smallexample
1:  5          1:  0.2        1:  5.         1:  -5.        1:  5.
    .              .              .              .              .

    5              &              &              n              n
@end smallexample
@end group

@cindex Binary operators
You can apply a ``binary operator'' like @kbd{+} across any number of
stack entries by giving it a numeric prefix.  You can also apply it
pairwise to several stack elements along with the top one if you use
a negative prefix.

@group
@smallexample
3:  2          1:  9          3:  2          4:  2          3:  12
2:  3              .          2:  3          3:  3          2:  13
1:  4                         1:  4          2:  4          1:  14
    .                             .          1:  10             .
                                                 .

2 RET 3 RET 4     M-3 +           U              10          M-- M-3 +
@end smallexample
@end group

@cindex Unary operators
You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
stack entries with a numeric prefix, too.

@group
@smallexample
3:  2          3:  0.5                3:  0.5
2:  3          2:  0.333333333333     2:  3.
1:  4          1:  0.25               1:  4.
    .              .                      .

2 RET 3 RET 4      M-3 &                  M-2 &
@end smallexample
@end group

Notice that the results here are left in floating-point form.
We can convert them back to integers by pressing @kbd{F}, the
``floor'' function.  This function rounds down to the next lower
integer.  There is also @kbd{R}, which rounds to the nearest
integer.

@group
@smallexample
7:  2.         7:  2          7:  2
6:  2.4        6:  2          6:  2
5:  2.5        5:  2          5:  3
4:  2.6        4:  2          4:  3
3:  -2.        3:  -2         3:  -2
2:  -2.4       2:  -3         2:  -2
1:  -2.6       1:  -3         1:  -3
    .              .              .

                  M-7 F        U M-7 R
@end smallexample
@end group

Since dividing-and-flooring (i.e., ``integer quotient'') is such a
common operation, Calc provides a special command for that purpose, the
backslash @kbd{\}.  Another common arithmetic operator is @kbd{%}, which
computes the remainder that would arise from a @kbd{\} operation, i.e.,
the ``modulo'' of two numbers.  For example,

@group
@smallexample
2:  1234       1:  12         2:  1234       1:  34
1:  100            .          1:  100            .
    .                             .

1234 RET 100       \              U              %
@end smallexample
@end group

These commands actually work for any real numbers, not just integers.

@group
@smallexample
2:  3.1415     1:  3          2:  3.1415     1:  0.1415
1:  1              .          1:  1              .
    .                             .

3.1415 RET 1       \              U              %
@end smallexample
@end group

(@bullet{}) @strong{Exercise 1.}  The @kbd{\} command would appear to be a
frill, since you could always do the same thing with @kbd{/ F}.  Think
of a situation where this is not true---@kbd{/ F} would be inadequate.
Now think of a way you could get around the problem if Calc didn't
provide a @kbd{\} command.  @xref{Arithmetic Answer 1, 1}. (@bullet{})

We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
commands.  Other commands along those lines are @kbd{C} (cosine),
@kbd{T} (tangent), @kbd{E} (@cite{e^x}) and @kbd{L} (natural
logarithm).  These can be modified by the @kbd{I} (inverse) and
@kbd{H} (hyperbolic) prefix keys.

Let's compute the sine and cosine of an angle, and verify the
identity @c{$\sin^2x + \cos^2x = 1$}
@cite{sin(x)^2 + cos(x)^2 = 1}.  We'll
arbitrarily pick @i{-64} degrees as a good value for @cite{x}.  With
the angular mode set to degrees (type @w{@kbd{m d}}), do:

@group
@smallexample
2:  -64        2:  -64        2:  -0.89879   2:  -0.89879   1:  1.
1:  -64        1:  -0.89879   1:  -64        1:  0.43837        .
    .              .              .              .

 64 n RET RET      S              TAB            C              f h
@end smallexample
@end group

@noindent
(For brevity, we're showing only five digits of the results here.
You can of course do these calculations to any precision you like.)

Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
of squares, command.

Another identity is @c{$\displaystyle\tan x = {\sin x \over \cos x}$}
@cite{tan(x) = sin(x) / cos(x)}.
@group
@smallexample

2:  -0.89879   1:  -2.0503    1:  -64.
1:  0.43837        .              .
    .

    U              /              I T
@end smallexample
@end group

A physical interpretation of this calculation is that if you move
@cite{0.89879} units downward and @cite{0.43837} units to the right,
your direction of motion is @i{-64} degrees from horizontal.  Suppose
we move in the opposite direction, up and to the left:

@group
@smallexample
2:  -0.89879   2:  0.89879    1:  -2.0503    1:  -64.
1:  0.43837    1:  -0.43837       .              .
    .              .

    U U            M-2 n          /              I T
@end smallexample
@end group

@noindent
How can the angle be the same?  The answer is that the @kbd{/} operation
loses information about the signs of its inputs.  Because the quotient
is negative, we know exactly one of the inputs was negative, but we
can't tell which one.  There is an @kbd{f T} [@code{arctan2}] function which
computes the inverse tangent of the quotient of a pair of numbers.
Since you feed it the two original numbers, it has enough information
to give you a full 360-degree answer.

@group
@smallexample
2:  0.89879    1:  116.       3:  116.       2:  116.       1:  180.
1:  -0.43837       .          2:  -0.89879   1:  -64.           .
    .                         1:  0.43837        .
                                  .

    U U            f T         M-RET M-2 n       f T            -
@end smallexample
@end group

@noindent
The resulting angles differ by 180 degrees; in other words, they
point in opposite directions, just as we would expect.

The @key{META}-@key{RET} we used in the third step is the
``last-arguments'' command.  It is sort of like Undo, except that it
restores the arguments of the last command to the stack without removing
the command's result.  It is useful in situations like this one,
where we need to do several operations on the same inputs.  We could
have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
the top two stack elements right after the @kbd{U U}, then a pair of
@kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.

A similar identity is supposed to hold for hyperbolic sines and cosines,
except that it is the @emph{difference}
@c{$\cosh^2x - \sinh^2x$}
@cite{cosh(x)^2 - sinh(x)^2} that always equals one.
Let's try to verify this identity.@refill

@group
@smallexample
2:  -64        2:  -64        2:  -64        2:  9.7192e54  2:  9.7192e54
1:  -64        1:  -3.1175e27 1:  9.7192e54  1:  -64        1:  9.7192e54
    .              .              .              .              .

 64 n RET RET      H C            2 ^            TAB            H S 2 ^
@end smallexample
@end group

@noindent
@cindex Roundoff errors, examples
Something's obviously wrong, because when we subtract these numbers
the answer will clearly be zero!  But if you think about it, if these
numbers @emph{did} differ by one, it would be in the 55th decimal
place.  The difference we seek has been lost entirely to roundoff
error.

We could verify this hypothesis by doing the actual calculation with,
say, 60 decimal places of precision.  This will be slow, but not
enormously so.  Try it if you wish; sure enough, the answer is
0.99999, reasonably close to 1.

Of course, a more reasonable way to verify the identity is to use
a more reasonable value for @cite{x}!

@cindex Common logarithm
Some Calculator commands use the Hyperbolic prefix for other purposes.
The logarithm and exponential functions, for example, work to the base
@cite{e} normally but use base-10 instead if you use the Hyperbolic
prefix.

@group
@smallexample
1:  1000       1:  6.9077     1:  1000       1:  3
    .              .              .              .

    1000           L              U              H L
@end smallexample
@end group

@noindent
First, we mistakenly compute a natural logarithm.  Then we undo
and compute a common logarithm instead.

The @kbd{B} key computes a general base-@var{b} logarithm for any
value of @var{b}.

@group
@smallexample
2:  1000       1:  3          1:  1000.      2:  1000.      1:  6.9077
1:  10             .              .          1:  2.71828        .
    .                                            .

 1000 RET 10       B              H E            H P            B
@end smallexample
@end group

@noindent
Here we first use @kbd{B} to compute the base-10 logarithm, then use
the ``hyperbolic'' exponential as a cheap hack to recover the number
1000, then use @kbd{B} again to compute the natural logarithm.  Note
that @kbd{P} with the hyperbolic prefix pushes the constant @cite{e}
onto the stack.

You may have noticed that both times we took the base-10 logarithm
of 1000, we got an exact integer result.  Calc always tries to give
an exact rational result for calculations involving rational numbers
where possible.  But when we used @kbd{H E}, the result was a
floating-point number for no apparent reason.  In fact, if we had
computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
exact integer 1000.  But the @kbd{H E} command is rigged to generate
a floating-point result all of the time so that @kbd{1000 H E} will
not waste time computing a thousand-digit integer when all you
probably wanted was @samp{1e1000}.

(@bullet{}) @strong{Exercise 2.}  Find a pair of integer inputs to
the @kbd{B} command for which Calc could find an exact rational
result but doesn't.  @xref{Arithmetic Answer 2, 2}. (@bullet{})

The Calculator also has a set of functions relating to combinatorics
and statistics.  You may be familiar with the @dfn{factorial} function,
which computes the product of all the integers up to a given number.

@group
@smallexample
1:  100        1:  93326215443...    1:  100.       1:  9.3326e157
    .              .                     .              .

    100            !                     U c f          !
@end smallexample
@end group

@noindent
Recall, the @kbd{c f} command converts the integer or fraction at the
top of the stack to floating-point format.  If you take the factorial
of a floating-point number, you get a floating-point result
accurate to the current precision.  But if you give @kbd{!} an
exact integer, you get an exact integer result (158 digits long
in this case).

If you take the factorial of a non-integer, Calc uses a generalized
factorial function defined in terms of Euler's Gamma function
@c{$\Gamma(n)$}
@cite{gamma(n)}
(which is itself available as the @kbd{f g} command).

@group
@smallexample
3:  4.         3:  24.               1:  5.5        1:  52.342777847
2:  4.5        2:  52.3427777847         .              .
1:  5.         1:  120.
    .              .

                   M-3 !              M-0 DEL 5.5       f g
@end smallexample
@end group

@noindent
Here we verify the identity @c{$n! = \Gamma(n+1)$}
@cite{@var{n}!@: = gamma(@var{n}+1)}.

The binomial coefficient @var{n}-choose-@var{m}@c{ or $\displaystyle {n \choose m}$}
@asis{} is defined by
@c{$\displaystyle {n! \over m! \, (n-m)!}$}
@cite{n!@: / m!@: (n-m)!} for all reals @cite{n} and
@cite{m}.  The intermediate results in this formula can become quite
large even if the final result is small; the @kbd{k c} command computes
a binomial coefficient in a way that avoids large intermediate
values.

The @kbd{k} prefix key defines several common functions out of
combinatorics and number theory.  Here we compute the binomial
coefficient 30-choose-20, then determine its prime factorization.

@group
@smallexample
2:  30         1:  30045015   1:  [3, 3, 5, 7, 11, 13, 23, 29]
1:  20             .              .
    .

 30 RET 20         k c            k f
@end smallexample
@end group

@noindent
You can verify these prime factors by using @kbd{v u} to ``unpack''
this vector into 8 separate stack entries, then @kbd{M-8 *} to
multiply them back together.  The result is the original number,
30045015.

@cindex Hash tables
Suppose a program you are writing needs a hash table with at least
10000 entries.  It's best to use a prime number as the actual size
of a hash table.  Calc can compute the next prime number after 10000:

@group
@smallexample
1:  10000      1:  10007      1:  9973
    .              .              .

    10000          k n            I k n
@end smallexample
@end group

@noindent
Just for kicks we've also computed the next prime @emph{less} than
10000.

@c [fix-ref Financial Functions]
@xref{Financial Functions}, for a description of the Calculator
commands that deal with business and financial calculations (functions
like @code{pv}, @code{rate}, and @code{sln}).

@c [fix-ref Binary Number Functions]
@xref{Binary Functions}, to read about the commands for operating
on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).

@node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
@section Vector/Matrix Tutorial

@noindent
A @dfn{vector} is a list of numbers or other Calc data objects.
Calc provides a large set of commands that operate on vectors.  Some
are familiar operations from vector analysis.  Others simply treat
a vector as a list of objects.

@menu
* Vector Analysis Tutorial::
* Matrix Tutorial::
* List Tutorial::
@end menu

@node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
@subsection Vector Analysis

@noindent
If you add two vectors, the result is a vector of the sums of the
elements, taken pairwise.

@group
@smallexample
1:  [1, 2, 3]     2:  [1, 2, 3]     1:  [8, 8, 3]
    .             1:  [7, 6, 0]         .
                      .

    [1,2,3]  s 1      [7 6 0]  s 2      +
@end smallexample
@end group

@noindent
Note that we can separate the vector elements with either commas or
spaces.  This is true whether we are using incomplete vectors or
algebraic entry.  The @kbd{s 1} and @kbd{s 2} commands save these
vectors so we can easily reuse them later.

If you multiply two vectors, the result is the sum of the products
of the elements taken pairwise.  This is called the @dfn{dot product}
of the vectors.

@group
@smallexample
2:  [1, 2, 3]     1:  19
1:  [7, 6, 0]         .
    .

    r 1 r 2           *
@end smallexample
@end group

@cindex Dot product
The dot product of two vectors is equal to the product of their
lengths times the cosine of the angle between them.  (Here the vector
is interpreted as a line from the origin @cite{(0,0,0)} to the
specified point in three-dimensional space.)  The @kbd{A}
(absolute value) command can be used to compute the length of a
vector.

@group
@smallexample
3:  19            3:  19          1:  0.550782    1:  56.579
2:  [1, 2, 3]     2:  3.741657        .               .
1:  [7, 6, 0]     1:  9.219544
    .                 .

    M-RET             M-2 A          * /             I C
@end smallexample
@end group

@noindent
First we recall the arguments to the dot product command, then
we compute the absolute values of the top two stack entries to
obtain the lengths of the vectors, then we divide the dot product
by the product of the lengths to get the cosine of the angle.
The inverse cosine finds that the angle between the vectors
is about 56 degrees.

@cindex Cross product
@cindex Perpendicular vectors
The @dfn{cross product} of two vectors is a vector whose length
is the product of the lengths of the inputs times the sine of the
angle between them, and whose direction is perpendicular to both
input vectors.  Unlike the dot product, the cross product is
defined only for three-dimensional vectors.  Let's double-check
our computation of the angle using the cross product.

@group
@smallexample
2:  [1, 2, 3]  3:  [-18, 21, -8]  1:  [-0.52, 0.61, -0.23]  1:  56.579
1:  [7, 6, 0]  2:  [1, 2, 3]          .                         .
    .          1:  [7, 6, 0]
                   .

    r 1 r 2        V C  s 3  M-RET    M-2 A * /                 A I S
@end smallexample
@end group

@noindent
First we recall the original vectors and compute their cross product,
which we also store for later reference.  Now we divide the vector
by the product of the lengths of the original vectors.  The length of
this vector should be the sine of the angle; sure enough, it is!

@c [fix-ref General Mode Commands]
Vector-related commands generally begin with the @kbd{v} prefix key.
Some are uppercase letters and some are lowercase.  To make it easier
to type these commands, the shift-@kbd{V} prefix key acts the same as
the @kbd{v} key.  (@xref{General Mode Commands}, for a way to make all
prefix keys have this property.)

If we take the dot product of two perpendicular vectors we expect
to get zero, since the cosine of 90 degrees is zero.  Let's check
that the cross product is indeed perpendicular to both inputs:

@group
@smallexample
2:  [1, 2, 3]      1:  0          2:  [7, 6, 0]      1:  0
1:  [-18, 21, -8]      .          1:  [-18, 21, -8]      .
    .                                 .

    r 1 r 3            *          DEL r 2 r 3            *
@end smallexample
@end group

@cindex Normalizing a vector
@cindex Unit vectors
(@bullet{}) @strong{Exercise 1.}  Given a vector on the top of the
stack, what keystrokes would you use to @dfn{normalize} the
vector, i.e., to reduce its length to one without changing its
direction?  @xref{Vector Answer 1, 1}. (@bullet{})

(@bullet{}) @strong{Exercise 2.}  Suppose a certain particle can be
at any of several positions along a ruler.  You have a list of
those positions in the form of a vector, and another list of the
probabilities for the particle to be at the corresponding positions.
Find the average position of the particle.
@xref{Vector Answer 2, 2}. (@bullet{})

@node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
@subsection Matrices

@noindent
A @dfn{matrix} is just a vector of vectors, all the same length.
This means you can enter a matrix using nested brackets.  You can
also use the semicolon character to enter a matrix.  We'll show
both methods here:

@group
@smallexample
1:  [ [ 1, 2, 3 ]             1:  [ [ 1, 2, 3 ]
      [ 4, 5, 6 ] ]                 [ 4, 5, 6 ] ]
    .                             .

  [[1 2 3] [4 5 6]]             ' [1 2 3; 4 5 6] RET
@end smallexample
@end group

@noindent
We'll be using this matrix again, so type @kbd{s 4} to save it now.

Note that semicolons work with incomplete vectors, but they work
better in algebraic entry.  That's why we use the apostrophe in
the second example.

When two matrices are multiplied, the lefthand matrix must have
the same number of columns as the righthand matrix has rows.
Row @cite{i}, column @cite{j} of the result is effectively the
dot product of row @cite{i} of the left matrix by column @cite{j}
of the right matrix.

If we try to duplicate this matrix and multiply it by itself,
the dimensions are wrong and the multiplication cannot take place:

@group
@smallexample
1:  [ [ 1, 2, 3 ]   * [ [ 1, 2, 3 ]
      [ 4, 5, 6 ] ]     [ 4, 5, 6 ] ]
    .

    RET *
@end smallexample
@end group

@noindent
Though rather hard to read, this is a formula which shows the product
of two matrices.  The @samp{*} function, having invalid arguments, has
been left in symbolic form.

We can multiply the matrices if we @dfn{transpose} one of them first.

@group
@smallexample
2:  [ [ 1, 2, 3 ]       1:  [ [ 14, 32 ]      1:  [ [ 17, 22, 27 ]
      [ 4, 5, 6 ] ]           [ 32, 77 ] ]          [ 22, 29, 36 ]
1:  [ [ 1, 4 ]              .                       [ 27, 36, 45 ] ]
      [ 2, 5 ]                                    .
      [ 3, 6 ] ]
    .

    U v t                   *                     U TAB *
@end smallexample
@end group

Matrix multiplication is not commutative; indeed, switching the
order of the operands can even change the dimensions of the result
matrix, as happened here!

If you multiply a plain vector by a matrix, it is treated as a
single row or column depending on which side of the matrix it is
on.  The result is a plain vector which should also be interpreted
as a row or column as appropriate.

@group
@smallexample
2:  [ [ 1, 2, 3 ]      1:  [14, 32]
      [ 4, 5, 6 ] ]        .
1:  [1, 2, 3]
    .

    r 4 r 1                *
@end smallexample
@end group

Multiplying in the other order wouldn't work because the number of
rows in the matrix is different from the number of elements in the
vector.

(@bullet{}) @strong{Exercise 1.}  Use @samp{*} to sum along the rows
of the above @c{$2\times3$}
@asis{2x3} matrix to get @cite{[6, 15]}.  Now use @samp{*} to
sum along the columns to get @cite{[5, 7, 9]}.
@xref{Matrix Answer 1, 1}. (@bullet{})

@cindex Identity matrix
An @dfn{identity matrix} is a square matrix with ones along the
diagonal and zeros elsewhere.  It has the property that multiplication
by an identity matrix, on the left or on the right, always produces
the original matrix.

@group
@smallexample
1:  [ [ 1, 2, 3 ]      2:  [ [ 1, 2, 3 ]      1:  [ [ 1, 2, 3 ]
      [ 4, 5, 6 ] ]          [ 4, 5, 6 ] ]          [ 4, 5, 6 ] ]
    .                  1:  [ [ 1, 0, 0 ]          .
                             [ 0, 1, 0 ]
                             [ 0, 0, 1 ] ]
                           .

    r 4                    v i 3 RET              *
@end smallexample
@end group

If a matrix is square, it is often possible to find its @dfn{inverse},
that is, a matrix which, when multiplied by the original matrix, yields
an identity matrix.  The @kbd{&} (reciprocal) key also computes the
inverse of a matrix.

@group
@smallexample
1:  [ [ 1, 2, 3 ]      1:  [ [   -2.4,     1.2,   -0.2 ]
      [ 4, 5, 6 ]            [    2.8,    -1.4,    0.4 ]
      [ 7, 6, 0 ] ]          [ -0.73333, 0.53333, -0.2 ] ]
    .                      .

    r 4 r 2 |  s 5         &
@end smallexample
@end group

@noindent
The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
matrices together.  Here we have used it to add a new row onto
our matrix to make it square.

We can multiply these two matrices in either order to get an identity.

@group
@smallexample
1:  [ [ 1., 0., 0. ]      1:  [ [ 1., 0., 0. ]
      [ 0., 1., 0. ]            [ 0., 1., 0. ]
      [ 0., 0., 1. ] ]          [ 0., 0., 1. ] ]
    .                         .

    M-RET  *                  U TAB *
@end smallexample
@end group

@cindex Systems of linear equations
@cindex Linear equations, systems of
Matrix inverses are related to systems of linear equations in algebra.
Suppose we had the following set of equations:

@ifnottex
@group
@example
    a + 2b + 3c = 6
   4a + 5b + 6c = 2
   7a + 6b      = 3
@end example
@end group
@end ifnottex
@tex
\turnoffactive
\beforedisplayh
$$ \openup1\jot \tabskip=0pt plus1fil
\halign to\displaywidth{\tabskip=0pt
   $\hfil#$&$\hfil{}#{}$&
   $\hfil#$&$\hfil{}#{}$&
   $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
  a&+&2b&+&3c&=6 \cr
 4a&+&5b&+&6c&=2 \cr
 7a&+&6b& &  &=3 \cr}
$$
\afterdisplayh
@end tex

@noindent
This can be cast into the matrix equation,

@ifnottex
@group
@example
   [ [ 1, 2, 3 ]     [ [ a ]     [ [ 6 ]
     [ 4, 5, 6 ]   *   [ b ]   =   [ 2 ]
     [ 7, 6, 0 ] ]     [ c ] ]     [ 3 ] ]
@end example
@end group
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
   \times
   \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
$$
\afterdisplay
@end tex

We can solve this system of equations by multiplying both sides by the
inverse of the matrix.  Calc can do this all in one step:

@group
@smallexample
2:  [6, 2, 3]          1:  [-12.6, 15.2, -3.93333]
1:  [ [ 1, 2, 3 ]          .
      [ 4, 5, 6 ]
      [ 7, 6, 0 ] ]
    .

    [6,2,3] r 5            /
@end smallexample
@end group

@noindent
The result is the @cite{[a, b, c]} vector that solves the equations.
(Dividing by a square matrix is equivalent to multiplying by its
inverse.)

Let's verify this solution:

@group
@smallexample
2:  [ [ 1, 2, 3 ]                1:  [6., 2., 3.]
      [ 4, 5, 6 ]                    .
      [ 7, 6, 0 ] ]
1:  [-12.6, 15.2, -3.93333]
    .

    r 5  TAB                         *
@end smallexample
@end group

@noindent
Note that we had to be careful about the order in which we multiplied
the matrix and vector.  If we multiplied in the other order, Calc would
assume the vector was a row vector in order to make the dimensions
come out right, and the answer would be incorrect.  If you
don't feel safe letting Calc take either interpretation of your
vectors, use explicit @c{$N\times1$}
@asis{Nx1} or @c{$1\times N$}
@asis{1xN} matrices instead.
In this case, you would enter the original column vector as
@samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.

(@bullet{}) @strong{Exercise 2.}  Algebraic entry allows you to make
vectors and matrices that include variables.  Solve the following
system of equations to get expressions for @cite{x} and @cite{y}
in terms of @cite{a} and @cite{b}.

@ifnottex
@group
@example
   x + a y = 6
   x + b y = 10
@end example
@end group
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ \eqalign{ x &+ a y = 6 \cr
             x &+ b y = 10}
$$
\afterdisplay
@end tex

@noindent
@xref{Matrix Answer 2, 2}. (@bullet{})

@cindex Least-squares for over-determined systems
@cindex Over-determined systems of equations
(@bullet{}) @strong{Exercise 3.}  A system of equations is ``over-determined''
if it has more equations than variables.  It is often the case that
there are no values for the variables that will satisfy all the
equations at once, but it is still useful to find a set of values
which ``nearly'' satisfy all the equations.  In terms of matrix equations,
you can't solve @cite{A X = B} directly because the matrix @cite{A}
is not square for an over-determined system.  Matrix inversion works
only for square matrices.  One common trick is to multiply both sides
on the left by the transpose of @cite{A}:
@ifnottex
@samp{trn(A)*A*X = trn(A)*B}.
@end ifnottex
@tex
\turnoffactive
$A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
@end tex
Now @c{$A^T A$}
@cite{trn(A)*A} is a square matrix so a solution is possible.  It
turns out that the @cite{X} vector you compute in this way will be a
``least-squares'' solution, which can be regarded as the ``closest''
solution to the set of equations.  Use Calc to solve the following
over-determined system:@refill

@ifnottex
@group
@example
    a + 2b + 3c = 6
   4a + 5b + 6c = 2
   7a + 6b      = 3
   2a + 4b + 6c = 11
@end example
@end group
@end ifnottex
@tex
\turnoffactive
\beforedisplayh
$$ \openup1\jot \tabskip=0pt plus1fil
\halign to\displaywidth{\tabskip=0pt
   $\hfil#$&$\hfil{}#{}$&
   $\hfil#$&$\hfil{}#{}$&
   $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
  a&+&2b&+&3c&=6 \cr
 4a&+&5b&+&6c&=2 \cr
 7a&+&6b& &  &=3 \cr
 2a&+&4b&+&6c&=11 \cr}
$$
\afterdisplayh
@end tex

@noindent
@xref{Matrix Answer 3, 3}. (@bullet{})

@node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
@subsection Vectors as Lists

@noindent
@cindex Lists
Although Calc has a number of features for manipulating vectors and
matrices as mathematical objects, you can also treat vectors as
simple lists of values.  For example, we saw that the @kbd{k f}
command returns a vector which is a list of the prime factors of a
number.

You can pack and unpack stack entries into vectors:

@group
@smallexample
3:  10         1:  [10, 20, 30]     3:  10
2:  20             .                2:  20
1:  30                              1:  30
    .                                   .

                   M-3 v p              v u
@end smallexample
@end group

You can also build vectors out of consecutive integers, or out
of many copies of a given value:

@group
@smallexample
1:  [1, 2, 3, 4]    2:  [1, 2, 3, 4]    2:  [1, 2, 3, 4]
    .               1:  17              1:  [17, 17, 17, 17]
                        .                   .

    v x 4 RET           17                  v b 4 RET
@end smallexample
@end group

You can apply an operator to every element of a vector using the
@dfn{map} command.

@group
@smallexample
1:  [17, 34, 51, 68]   1:  [289, 1156, 2601, 4624]  1:  [17, 34, 51, 68]
    .                      .                            .

    V M *                  2 V M ^                      V M Q
@end smallexample
@end group

@noindent
In the first step, we multiply the vector of integers by the vector
of 17's elementwise.  In the second step, we raise each element to
the power two.  (The general rule is that both operands must be
vectors of the same length, or else one must be a vector and the
other a plain number.)  In the final step, we take the square root
of each element.

(@bullet{}) @strong{Exercise 1.}  Compute a vector of powers of two
from @c{$2^{-4}$}
@cite{2^-4} to @cite{2^4}.  @xref{List Answer 1, 1}. (@bullet{})

You can also @dfn{reduce} a binary operator across a vector.
For example, reducing @samp{*} computes the product of all the
elements in the vector:

@group
@smallexample
1:  123123     1:  [3, 7, 11, 13, 41]      1:  123123
    .              .                           .

    123123         k f                         V R *
@end smallexample
@end group

@noindent
In this example, we decompose 123123 into its prime factors, then
multiply those factors together again to yield the original number.

We could compute a dot product ``by hand'' using mapping and
reduction:

@group
@smallexample
2:  [1, 2, 3]     1:  [7, 12, 0]     1:  19
1:  [7, 6, 0]         .                  .
    .

    r 1 r 2           V M *              V R +
@end smallexample
@end group

@noindent
Recalling two vectors from the previous section, we compute the
sum of pairwise products of the elements to get the same answer
for the dot product as before.

A slight variant of vector reduction is the @dfn{accumulate} operation,
@kbd{V U}.  This produces a vector of the intermediate results from
a corresponding reduction.  Here we compute a table of factorials:

@group
@smallexample
1:  [1, 2, 3, 4, 5, 6]    1:  [1, 2, 6, 24, 120, 720]
    .                         .

    v x 6 RET                 V U *
@end smallexample
@end group

Calc allows vectors to grow as large as you like, although it gets
rather slow if vectors have more than about a hundred elements.
Actually, most of the time is spent formatting these large vectors
for display, not calculating on them.  Try the following experiment
(if your computer is very fast you may need to substitute a larger
vector size).

@group
@smallexample
1:  [1, 2, 3, 4, ...      1:  [2, 3, 4, 5, ...
    .                         .

    v x 500 RET               1 V M +
@end smallexample
@end group

Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
experiment again.  In @kbd{v .} mode, long vectors are displayed
``abbreviated'' like this:

@group
@smallexample
1:  [1, 2, 3, ..., 500]   1:  [2, 3, 4, ..., 501]
    .                         .

    v x 500 RET               1 V M +
@end smallexample
@end group

@noindent
(where now the @samp{...} is actually part of the Calc display).
You will find both operations are now much faster.  But notice that
even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
experiment one more time.  Operations on long vectors are now quite
fast!  (But of course if you use @kbd{t .} you will lose the ability
to get old vectors back using the @kbd{t y} command.)

An easy way to view a full vector when @kbd{v .} mode is active is
to press @kbd{`} (back-quote) to edit the vector; editing always works
with the full, unabbreviated value.

@cindex Least-squares for fitting a straight line
@cindex Fitting data to a line
@cindex Line, fitting data to
@cindex Data, extracting from buffers
@cindex Columns of data, extracting
As a larger example, let's try to fit a straight line to some data,
using the method of least squares.  (Calc has a built-in command for
least-squares curve fitting, but we'll do it by hand here just to
practice working with vectors.)  Suppose we have the following list
of values in a file we have loaded into Emacs:

@smallexample
  x        y
 ---      ---
 1.34    0.234
 1.41    0.298
 1.49    0.402
 1.56    0.412
 1.64    0.466
 1.73    0.473
 1.82    0.601
 1.91    0.519
 2.01    0.603
 2.11    0.637
 2.22    0.645
 2.33    0.705
 2.45    0.917
 2.58    1.009
 2.71    0.971
 2.85    1.062
 3.00    1.148
 3.15    1.157
 3.32    1.354
@end smallexample

@noindent
If you are reading this tutorial in printed form, you will find it
easiest to press @kbd{M-# i} to enter the on-line Info version of
the manual and find this table there.  (Press @kbd{g}, then type
@kbd{List Tutorial}, to jump straight to this section.)

Position the cursor at the upper-left corner of this table, just
to the left of the @cite{1.34}.  Press @kbd{C-@@} to set the mark.
(On your system this may be @kbd{C-2}, @kbd{C-SPC}, or @kbd{NUL}.)
Now position the cursor to the lower-right, just after the @cite{1.354}.
You have now defined this region as an Emacs ``rectangle.''  Still
in the Info buffer, type @kbd{M-# r}.  This command
(@code{calc-grab-rectangle}) will pop you back into the Calculator, with
the contents of the rectangle you specified in the form of a matrix.@refill

@group
@smallexample
1:  [ [ 1.34, 0.234 ]
      [ 1.41, 0.298 ]
      @dots{}
@end smallexample
@end group

@noindent
(You may wish to use @kbd{v .} mode to abbreviate the display of this
large matrix.)

We want to treat this as a pair of lists.  The first step is to
transpose this matrix into a pair of rows.  Remember, a matrix is
just a vector of vectors.  So we can unpack the matrix into a pair
of row vectors on the stack.

@group
@smallexample
1:  [ [ 1.34,  1.41,  1.49,  ... ]     2:  [1.34, 1.41, 1.49, ... ]
      [ 0.234, 0.298, 0.402, ... ] ]   1:  [0.234, 0.298, 0.402, ... ]
    .                                      .

    v t                                    v u
@end smallexample
@end group

@noindent
Let's store these in quick variables 1 and 2, respectively.

@group
@smallexample
1:  [1.34, 1.41, 1.49, ... ]        .
    .

    t 2                             t 1
@end smallexample
@end group

@noindent
(Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
stored value from the stack.)

In a least squares fit, the slope @cite{m} is given by the formula

@ifnottex
@example
m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ m = {N \sum x y - \sum x \sum y  \over
        N \sum x^2 - \left( \sum x \right)^2} $$
\afterdisplay
@end tex

@noindent
where @c{$\sum x$}
@cite{sum(x)} represents the sum of all the values of @cite{x}.
While there is an actual @code{sum} function in Calc, it's easier to
sum a vector using a simple reduction.  First, let's compute the four
different sums that this formula uses.

@group
@smallexample
1:  41.63                 1:  98.0003
    .                         .

 r 1 V R +   t 3           r 1 2 V M ^ V R +   t 4

@end smallexample
@end group
@noindent
@group
@smallexample
1:  13.613                1:  33.36554
    .                         .

 r 2 V R +   t 5           r 1 r 2 V M * V R +   t 6
@end smallexample
@end group

@ifnottex
@noindent
These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
respectively.  (We could have used @kbd{*} to compute @samp{sum(x^2)} and
@samp{sum(x y)}.)
@end ifnottex
@tex
\turnoffactive
These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
respectively.  (We could have used \kbd{*} to compute $\sum x^2$ and
$\sum x y$.)
@end tex

Finally, we also need @cite{N}, the number of data points.  This is just
the length of either of our lists.

@group
@smallexample
1:  19
    .

 r 1 v l   t 7
@end smallexample
@end group

@noindent
(That's @kbd{v} followed by a lower-case @kbd{l}.)

Now we grind through the formula:

@group
@smallexample
1:  633.94526  2:  633.94526  1:  67.23607
    .          1:  566.70919      .
                   .

 r 7 r 6 *      r 3 r 5 *         -

@end smallexample
@end group
@noindent
@group
@smallexample
2:  67.23607   3:  67.23607   2:  67.23607   1:  0.52141679
1:  1862.0057  2:  1862.0057  1:  128.9488       .
    .          1:  1733.0569      .
                   .

 r 7 r 4 *      r 3 2 ^           -              /   t 8
@end smallexample
@end group

That gives us the slope @cite{m}.  The y-intercept @cite{b} can now
be found with the simple formula,

@ifnottex
@example
b = (sum(y) - m sum(x)) / N
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ b = {\sum y - m \sum x \over N} $$
\afterdisplay
\vskip10pt
@end tex

@group
@smallexample
1:  13.613     2:  13.613     1:  -8.09358   1:  -0.425978
    .          1:  21.70658       .              .
                   .

   r 5            r 8 r 3 *       -              r 7 /   t 9
@end smallexample
@end group

Let's ``plot'' this straight line approximation, @c{$y \approx m x + b$}
@cite{m x + b}, and compare it with the original data.@refill

@group
@smallexample
1:  [0.699, 0.735, ... ]    1:  [0.273, 0.309, ... ]
    .                           .

    r 1 r 8 *                   r 9 +    s 0
@end smallexample
@end group

@noindent
Notice that multiplying a vector by a constant, and adding a constant
to a vector, can be done without mapping commands since these are
common operations from vector algebra.  As far as Calc is concerned,
we've just been doing geometry in 19-dimensional space!

We can subtract this vector from our original @cite{y} vector to get
a feel for the error of our fit.  Let's find the maximum error:

@group
@smallexample
1:  [0.0387, 0.0112, ... ]   1:  [0.0387, 0.0112, ... ]   1:  0.0897
    .                            .                            .

    r 2 -                        V M A                        V R X
@end smallexample
@end group

@noindent
First we compute a vector of differences, then we take the absolute
values of these differences, then we reduce the @code{max} function
across the vector.  (The @code{max} function is on the two-key sequence
@kbd{f x}; because it is so common to use @code{max} in a vector
operation, the letters @kbd{X} and @kbd{N} are also accepted for
@code{max} and @code{min} in this context.  In general, you answer
the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
invokes the function you want.  You could have typed @kbd{V R f x} or
even @kbd{V R x max @key{RET}} if you had preferred.)

If your system has the GNUPLOT program, you can see graphs of your
data and your straight line to see how well they match.  (If you have
GNUPLOT 3.0, the following instructions will work regardless of the
kind of display you have.  Some GNUPLOT 2.0, non-X-windows systems
may require additional steps to view the graphs.)

Let's start by plotting the original data.  Recall the ``@i{x}'' and ``@i{y}''
vectors onto the stack and press @kbd{g f}.  This ``fast'' graphing
command does everything you need to do for simple, straightforward
plotting of data.

@group
@smallexample
2:  [1.34, 1.41, 1.49, ... ]
1:  [0.234, 0.298, 0.402, ... ]
    .

    r 1 r 2    g f
@end smallexample
@end group

If all goes well, you will shortly get a new window containing a graph
of the data.  (If not, contact your GNUPLOT or Calc installer to find
out what went wrong.)  In the X window system, this will be a separate
graphics window.  For other kinds of displays, the default is to
display the graph in Emacs itself using rough character graphics.
Press @kbd{q} when you are done viewing the character graphics.

Next, let's add the line we got from our least-squares fit:

@group
@smallexample
2:  [1.34, 1.41, 1.49, ... ]
1:  [0.273, 0.309, 0.351, ... ]
    .

    DEL r 0    g a  g p
@end smallexample
@end group

It's not very useful to get symbols to mark the data points on this
second curve; you can type @kbd{g S g p} to remove them.  Type @kbd{g q}
when you are done to remove the X graphics window and terminate GNUPLOT.

(@bullet{}) @strong{Exercise 2.}  An earlier exercise showed how to do
least squares fitting to a general system of equations.  Our 19 data
points are really 19 equations of the form @cite{y_i = m x_i + b} for
different pairs of @cite{(x_i,y_i)}.  Use the matrix-transpose method
to solve for @cite{m} and @cite{b}, duplicating the above result.
@xref{List Answer 2, 2}. (@bullet{})

@cindex Geometric mean
(@bullet{}) @strong{Exercise 3.}  If the input data do not form a
rectangle, you can use @w{@kbd{M-# g}} (@code{calc-grab-region})
to grab the data the way Emacs normally works with regions---it reads
left-to-right, top-to-bottom, treating line breaks the same as spaces.
Use this command to find the geometric mean of the following numbers.
(The geometric mean is the @var{n}th root of the product of @var{n} numbers.)

@example
2.3  6  22  15.1  7
  15  14  7.5
  2.5
@end example

@noindent
The @kbd{M-# g} command accepts numbers separated by spaces or commas,
with or without surrounding vector brackets.
@xref{List Answer 3, 3}. (@bullet{})

@ifnottex
As another example, a theorem about binomial coefficients tells
us that the alternating sum of binomial coefficients
@var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
on up to @var{n}-choose-@var{n},
always comes out to zero.  Let's verify this
for @cite{n=6}.@refill
@end ifnottex
@tex
As another example, a theorem about binomial coefficients tells
us that the alternating sum of binomial coefficients
${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
always comes out to zero.  Let's verify this
for \cite{n=6}.
@end tex

@group
@smallexample
1:  [1, 2, 3, 4, 5, 6, 7]     1:  [0, 1, 2, 3, 4, 5, 6]
    .                             .

    v x 7 RET                     1 -

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [1, -6, 15, -20, 15, -6, 1]          1:  0
    .                                        .

    V M ' (-1)^$ choose(6,$) RET             V R +
@end smallexample
@end group

The @kbd{V M '} command prompts you to enter any algebraic expression
to define the function to map over the vector.  The symbol @samp{$}
inside this expression represents the argument to the function.
The Calculator applies this formula to each element of the vector,
substituting each element's value for the @samp{$} sign(s) in turn.

To define a two-argument function, use @samp{$$} for the first
argument and @samp{$} for the second:  @kbd{V M ' $$-$ RET} is
equivalent to @kbd{V M -}.  This is analogous to regular algebraic
entry, where @samp{$$} would refer to the next-to-top stack entry
and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ RET}
would act exactly like @kbd{-}.

Notice that the @kbd{V M '} command has recorded two things in the
trail:  The result, as usual, and also a funny-looking thing marked
@samp{oper} that represents the operator function you typed in.
The function is enclosed in @samp{< >} brackets, and the argument is
denoted by a @samp{#} sign.  If there were several arguments, they
would be shown as @samp{#1}, @samp{#2}, and so on.  (For example,
@kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
trail.)  This object is a ``nameless function''; you can use nameless
@w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
Nameless function notation has the interesting, occasionally useful
property that a nameless function is not actually evaluated until
it is used.  For example, @kbd{V M ' $+random(2.0)} evaluates
@samp{random(2.0)} once and adds that random number to all elements
of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
@samp{random(2.0)} separately for each vector element.

Another group of operators that are often useful with @kbd{V M} are
the relational operators:  @kbd{a =}, for example, compares two numbers
and gives the result 1 if they are equal, or 0 if not.  Similarly,
@w{@kbd{a <}} checks for one number being less than another.

Other useful vector operations include @kbd{v v}, to reverse a
vector end-for-end; @kbd{V S}, to sort the elements of a vector
into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
one row or column of a matrix, or (in both cases) to extract one
element of a plain vector.  With a negative argument, @kbd{v r}
and @kbd{v c} instead delete one row, column, or vector element.

@cindex Divisor functions
(@bullet{}) @strong{Exercise 4.}  The @cite{k}th @dfn{divisor function}
@tex
$\sigma_k(n)$
@end tex
is the sum of the @cite{k}th powers of all the divisors of an
integer @cite{n}.  Figure out a method for computing the divisor
function for reasonably small values of @cite{n}.  As a test,
the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
@xref{List Answer 4, 4}. (@bullet{})

@cindex Square-free numbers
@cindex Duplicate values in a list
(@bullet{}) @strong{Exercise 5.}  The @kbd{k f} command produces a
list of prime factors for a number.  Sometimes it is important to
know that a number is @dfn{square-free}, i.e., that no prime occurs
more than once in its list of prime factors.  Find a sequence of
keystrokes to tell if a number is square-free; your method should
leave 1 on the stack if it is, or 0 if it isn't.
@xref{List Answer 5, 5}. (@bullet{})

@cindex Triangular lists
(@bullet{}) @strong{Exercise 6.}  Build a list of lists that looks
like the following diagram.  (You may wish to use the @kbd{v /}
command to enable multi-line display of vectors.)

@group
@smallexample
1:  [ [1],
      [1, 2],
      [1, 2, 3],
      [1, 2, 3, 4],
      [1, 2, 3, 4, 5],
      [1, 2, 3, 4, 5, 6] ]
@end smallexample
@end group

@noindent
@xref{List Answer 6, 6}. (@bullet{})

(@bullet{}) @strong{Exercise 7.}  Build the following list of lists.

@group
@smallexample
1:  [ [0],
      [1, 2],
      [3, 4, 5],
      [6, 7, 8, 9],
      [10, 11, 12, 13, 14],
      [15, 16, 17, 18, 19, 20] ]
@end smallexample
@end group

@noindent
@xref{List Answer 7, 7}. (@bullet{})

@cindex Maximizing a function over a list of values
@c [fix-ref Numerical Solutions]
(@bullet{}) @strong{Exercise 8.}  Compute a list of values of Bessel's
@c{$J_1(x)$}
@cite{J1} function @samp{besJ(1,x)} for @cite{x} from 0 to 5
in steps of 0.25.
Find the value of @cite{x} (from among the above set of values) for
which @samp{besJ(1,x)} is a maximum.  Use an ``automatic'' method,
i.e., just reading along the list by hand to find the largest value
is not allowed!  (There is an @kbd{a X} command which does this kind
of thing automatically; @pxref{Numerical Solutions}.)
@xref{List Answer 8, 8}. (@bullet{})@refill

@cindex Digits, vectors of
(@bullet{}) @strong{Exercise 9.}  You are given an integer in the range
@c{$0 \le N < 10^m$}
@cite{0 <= N < 10^m} for @cite{m=12} (i.e., an integer of less than
twelve digits).  Convert this integer into a vector of @cite{m}
digits, each in the range from 0 to 9.  In vector-of-digits notation,
add one to this integer to produce a vector of @cite{m+1} digits
(since there could be a carry out of the most significant digit).
Convert this vector back into a regular integer.  A good integer
to try is 25129925999.  @xref{List Answer 9, 9}. (@bullet{})

(@bullet{}) @strong{Exercise 10.}  Your friend Joe tried to use
@kbd{V R a =} to test if all numbers in a list were equal.  What
happened?  How would you do this test?  @xref{List Answer 10, 10}. (@bullet{})

(@bullet{}) @strong{Exercise 11.}  The area of a circle of radius one
is @c{$\pi$}
@cite{pi}.  The area of the @c{$2\times2$}
@asis{2x2} square that encloses that
circle is 4.  So if we throw @i{N} darts at random points in the square,
about @c{$\pi/4$}
@cite{pi/4} of them will land inside the circle.  This gives us
an entertaining way to estimate the value of @c{$\pi$}
@cite{pi}.  The @w{@kbd{k r}}
command picks a random number between zero and the value on the stack.
We could get a random floating-point number between @i{-1} and 1 by typing
@w{@kbd{2.0 k r 1 -}}.  Build a vector of 100 random @cite{(x,y)} points in
this square, then use vector mapping and reduction to count how many
points lie inside the unit circle.  Hint:  Use the @kbd{v b} command.
@xref{List Answer 11, 11}. (@bullet{})

@cindex Matchstick problem
(@bullet{}) @strong{Exercise 12.}  The @dfn{matchstick problem} provides
another way to calculate @c{$\pi$}
@cite{pi}.  Say you have an infinite field
of vertical lines with a spacing of one inch.  Toss a one-inch matchstick
onto the field.  The probability that the matchstick will land crossing
a line turns out to be @c{$2/\pi$}
@cite{2/pi}.  Toss 100 matchsticks to estimate
@c{$\pi$}
@cite{pi}.  (If you want still more fun, the probability that the GCD
(@w{@kbd{k g}}) of two large integers is one turns out to be @c{$6/\pi^2$}
@cite{6/pi^2}.
That provides yet another way to estimate @c{$\pi$}
@cite{pi}.)
@xref{List Answer 12, 12}. (@bullet{})

(@bullet{}) @strong{Exercise 13.}  An algebraic entry of a string in
double-quote marks, @samp{"hello"}, creates a vector of the numerical
(ASCII) codes of the characters (here, @cite{[104, 101, 108, 108, 111]}).
Sometimes it is convenient to compute a @dfn{hash code} of a string,
which is just an integer that represents the value of that string.
Two equal strings have the same hash code; two different strings
@dfn{probably} have different hash codes.  (For example, Calc has
over 400 function names, but Emacs can quickly find the definition for
any given name because it has sorted the functions into ``buckets'' by
their hash codes.  Sometimes a few names will hash into the same bucket,
but it is easier to search among a few names than among all the names.)
One popular hash function is computed as follows:  First set @cite{h = 0}.
Then, for each character from the string in turn, set @cite{h = 3h + c_i}
where @cite{c_i} is the character's ASCII code.  If we have 511 buckets,
we then take the hash code modulo 511 to get the bucket number.  Develop a
simple command or commands for converting string vectors into hash codes.
The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
511 is 121.  @xref{List Answer 13, 13}. (@bullet{})

(@bullet{}) @strong{Exercise 14.}  The @kbd{H V R} and @kbd{H V U}
commands do nested function evaluations.  @kbd{H V U} takes a starting
value and a number of steps @var{n} from the stack; it then applies the
function you give to the starting value 0, 1, 2, up to @var{n} times
and returns a vector of the results.  Use this command to create a
``random walk'' of 50 steps.  Start with the two-dimensional point
@cite{(0,0)}; then take one step a random distance between @i{-1} and 1
in both @cite{x} and @cite{y}; then take another step, and so on.  Use the
@kbd{g f} command to display this random walk.  Now modify your random
walk to walk a unit distance, but in a random direction, at each step.
(Hint:  The @code{sincos} function returns a vector of the cosine and
sine of an angle.)  @xref{List Answer 14, 14}. (@bullet{})

@node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
@section Types Tutorial

@noindent
Calc understands a variety of data types as well as simple numbers.
In this section, we'll experiment with each of these types in turn.

The numbers we've been using so far have mainly been either @dfn{integers}
or @dfn{floats}.  We saw that floats are usually a good approximation to
the mathematical concept of real numbers, but they are only approximations
and are susceptible to roundoff error.  Calc also supports @dfn{fractions},
which can exactly represent any rational number.

@group
@smallexample
1:  3628800    2:  3628800    1:  518400:7   1:  518414:7   1:  7:518414
    .          1:  49             .              .              .
                   .

    10 !           49 RET         :              2 +            &
@end smallexample
@end group

@noindent
The @kbd{:} command divides two integers to get a fraction; @kbd{/}
would normally divide integers to get a floating-point result.
Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
since the @kbd{:} would otherwise be interpreted as part of a
fraction beginning with 49.

You can convert between floating-point and fractional format using
@kbd{c f} and @kbd{c F}:

@group
@smallexample
1:  1.35027217629e-5    1:  7:518414
    .                       .

    c f                     c F
@end smallexample
@end group

The @kbd{c F} command replaces a floating-point number with the
``simplest'' fraction whose floating-point representation is the
same, to within the current precision.

@group
@smallexample
1:  3.14159265359   1:  1146408:364913   1:  3.1416   1:  355:113
    .                   .                    .            .

    P                   c F      DEL       p 5 RET P      c F
@end smallexample
@end group

(@bullet{}) @strong{Exercise 1.}  A calculation has produced the
result 1.26508260337.  You suspect it is the square root of the
product of @c{$\pi$}
@cite{pi} and some rational number.  Is it?  (Be sure
to allow for roundoff error!)  @xref{Types Answer 1, 1}. (@bullet{})

@dfn{Complex numbers} can be stored in both rectangular and polar form.

@group
@smallexample
1:  -9     1:  (0, 3)    1:  (3; 90.)   1:  (6; 90.)   1:  (2.4495; 45.)
    .          .             .              .              .

    9 n        Q             c p            2 *            Q
@end smallexample
@end group

@noindent
The square root of @i{-9} is by default rendered in rectangular form
(@w{@cite{0 + 3i}}), but we can convert it to polar form (3 with a
phase angle of 90 degrees).  All the usual arithmetic and scientific
operations are defined on both types of complex numbers.

Another generalized kind of number is @dfn{infinity}.  Infinity
isn't really a number, but it can sometimes be treated like one.
Calc uses the symbol @code{inf} to represent positive infinity,
i.e., a value greater than any real number.  Naturally, you can
also write @samp{-inf} for minus infinity, a value less than any
real number.  The word @code{inf} can only be input using
algebraic entry.

@group
@smallexample
2:  inf        2:  -inf       2:  -inf       2:  -inf       1:  nan
1:  -17        1:  -inf       1:  -inf       1:  inf            .
    .              .              .              .

' inf RET 17 n     *  RET         72 +           A              +
@end smallexample
@end group

@noindent
Since infinity is infinitely large, multiplying it by any finite
number (like @i{-17}) has no effect, except that since @i{-17}
is negative, it changes a plus infinity to a minus infinity.
(``A huge positive number, multiplied by @i{-17}, yields a huge
negative number.'')  Adding any finite number to infinity also
leaves it unchanged.  Taking an absolute value gives us plus
infinity again.  Finally, we add this plus infinity to the minus
infinity we had earlier.  If you work it out, you might expect
the answer to be @i{-72} for this.  But the 72 has been completely
lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
the finite difference between them, if any, is indetectable.
So we say the result is @dfn{indeterminate}, which Calc writes
with the symbol @code{nan} (for Not A Number).

Dividing by zero is normally treated as an error, but you can get
Calc to write an answer in terms of infinity by pressing @kbd{m i}
to turn on ``infinite mode.''

@group
@smallexample
3:  nan        2:  nan        2:  nan        2:  nan        1:  nan
2:  1          1:  1 / 0      1:  uinf       1:  uinf           .
1:  0              .              .              .
    .

  1 RET 0          /       m i    U /            17 n *         +
@end smallexample
@end group

@noindent
Dividing by zero normally is left unevaluated, but after @kbd{m i}
it instead gives an infinite result.  The answer is actually
@code{uinf}, ``undirected infinity.''  If you look at a graph of
@cite{1 / x} around @w{@cite{x = 0}}, you'll see that it goes toward
plus infinity as you approach zero from above, but toward minus
infinity as you approach from below.  Since we said only @cite{1 / 0},
Calc knows that the answer is infinite but not in which direction.
That's what @code{uinf} means.  Notice that multiplying @code{uinf}
by a negative number still leaves plain @code{uinf}; there's no
point in saying @samp{-uinf} because the sign of @code{uinf} is
unknown anyway.  Finally, we add @code{uinf} to our @code{nan},
yielding @code{nan} again.  It's easy to see that, because
@code{nan} means ``totally unknown'' while @code{uinf} means
``unknown sign but known to be infinite,'' the more mysterious
@code{nan} wins out when it is combined with @code{uinf}, or, for
that matter, with anything else.

(@bullet{}) @strong{Exercise 2.}  Predict what Calc will answer
for each of these formulas:  @samp{inf / inf}, @samp{exp(inf)},
@samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
@samp{abs(uinf)}, @samp{ln(0)}.
@xref{Types Answer 2, 2}. (@bullet{})

(@bullet{}) @strong{Exercise 3.}  We saw that @samp{inf - inf = nan},
which stands for an unknown value.  Can @code{nan} stand for
a complex number?  Can it stand for infinity?
@xref{Types Answer 3, 3}. (@bullet{})

@dfn{HMS forms} represent a value in terms of hours, minutes, and
seconds.

@group
@smallexample
1:  2@@ 30' 0"     1:  3@@ 30' 0"     2:  3@@ 30' 0"     1:  2.
    .                 .             1:  1@@ 45' 0."        .
                                        .

  2@@ 30' RET          1 +               RET 2 /           /
@end smallexample
@end group

HMS forms can also be used to hold angles in degrees, minutes, and
seconds.

@group
@smallexample
1:  0.5        1:  26.56505   1:  26@@ 33' 54.18"    1:  0.44721
    .              .              .                     .

    0.5            I T            c h                   S
@end smallexample
@end group

@noindent
First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
form, then we take the sine of that angle.  Note that the trigonometric
functions will accept HMS forms directly as input.

@cindex Beatles
(@bullet{}) @strong{Exercise 4.}  The Beatles' @emph{Abbey Road} is
47 minutes and 26 seconds long, and contains 17 songs.  What is the
average length of a song on @emph{Abbey Road}?  If the Extended Disco
Version of @emph{Abbey Road} added 20 seconds to the length of each
song, how long would the album be?  @xref{Types Answer 4, 4}. (@bullet{})

A @dfn{date form} represents a date, or a date and time.  Dates must
be entered using algebraic entry.  Date forms are surrounded by
@samp{< >} symbols; most standard formats for dates are recognized.

@group
@smallexample
2:  <Sun Jan 13, 1991>                    1:  2.25
1:  <6:00pm Thu Jan 10, 1991>                 .
    .

' <13 Jan 1991>, <1/10/91, 6pm> RET           -
@end smallexample
@end group

@noindent
In this example, we enter two dates, then subtract to find the
number of days between them.  It is also possible to add an
HMS form or a number (of days) to a date form to get another
date form.

@group
@smallexample
1:  <4:45:59pm Mon Jan 14, 1991>     1:  <2:50:59am Thu Jan 17, 1991>
    .                                    .

    t N                                  2 + 10@@ 5' +
@end smallexample
@end group

@c [fix-ref Date Arithmetic]
@noindent
The @kbd{t N} (``now'') command pushes the current date and time on the
stack; then we add two days, ten hours and five minutes to the date and
time.  Other date-and-time related commands include @kbd{t J}, which
does Julian day conversions, @kbd{t W}, which finds the beginning of
the week in which a date form lies, and @kbd{t I}, which increments a
date by one or several months.  @xref{Date Arithmetic}, for more.

(@bullet{}) @strong{Exercise 5.}  How many days until the next
Friday the 13th?  @xref{Types Answer 5, 5}. (@bullet{})

(@bullet{}) @strong{Exercise 6.}  How many leap years will there be
between now and the year 10001 A.D.?  @xref{Types Answer 6, 6}. (@bullet{})

@cindex Slope and angle of a line
@cindex Angle and slope of a line
An @dfn{error form} represents a mean value with an attached standard
deviation, or error estimate.  Suppose our measurements indicate that
a certain telephone pole is about 30 meters away, with an estimated
error of 1 meter, and 8 meters tall, with an estimated error of 0.2
meters.  What is the slope of a line from here to the top of the
pole, and what is the equivalent angle in degrees?

@group
@smallexample
1:  8 +/- 0.2    2:  8 +/- 0.2   1:  0.266 +/- 0.011   1:  14.93 +/- 0.594
    .            1:  30 +/- 1        .                     .
                     .

    8 p .2 RET       30 p 1          /                     I T
@end smallexample
@end group

@noindent
This means that the angle is about 15 degrees, and, assuming our
original error estimates were valid standard deviations, there is about
a 60% chance that the result is correct within 0.59 degrees.

@cindex Torus, volume of
(@bullet{}) @strong{Exercise 7.}  The volume of a torus (a donut shape) is
@c{$2 \pi^2 R r^2$}
@w{@cite{2 pi^2 R r^2}} where @cite{R} is the radius of the circle that
defines the center of the tube and @cite{r} is the radius of the tube
itself.  Suppose @cite{R} is 20 cm and @cite{r} is 4 cm, each known to
within 5 percent.  What is the volume and the relative uncertainty of
the volume?  @xref{Types Answer 7, 7}. (@bullet{})

An @dfn{interval form} represents a range of values.  While an
error form is best for making statistical estimates, intervals give
you exact bounds on an answer.  Suppose we additionally know that
our telephone pole is definitely between 28 and 31 meters away,
and that it is between 7.7 and 8.1 meters tall.

@group
@smallexample
1:  [7.7 .. 8.1]  2:  [7.7 .. 8.1]  1:  [0.24 .. 0.28]  1:  [13.9 .. 16.1]
    .             1:  [28 .. 31]        .                   .
                      .

  [ 7.7 .. 8.1 ]    [ 28 .. 31 ]        /                   I T
@end smallexample
@end group

@noindent
If our bounds were correct, then the angle to the top of the pole
is sure to lie in the range shown.

The square brackets around these intervals indicate that the endpoints
themselves are allowable values.  In other words, the distance to the
telephone pole is between 28 and 31, @emph{inclusive}.  You can also
make an interval that is exclusive of its endpoints by writing
parentheses instead of square brackets.  You can even make an interval
which is inclusive (``closed'') on one end and exclusive (``open'') on
the other.

@group
@smallexample
1:  [1 .. 10)    1:  (0.1 .. 1]   2:  (0.1 .. 1]   1:  (0.2 .. 3)
    .                .            1:  [2 .. 3)         .
                                      .

  [ 1 .. 10 )        &              [ 2 .. 3 )         *
@end smallexample
@end group

@noindent
The Calculator automatically keeps track of which end values should
be open and which should be closed.  You can also make infinite or
semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
or both endpoints.

(@bullet{}) @strong{Exercise 8.}  What answer would you expect from
@samp{@w{1 /} @w{(0 .. 10)}}?  What about @samp{@w{1 /} @w{(-10 .. 0)}}?  What
about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
zero)?  What about @samp{@w{1 /} @w{(-10 .. 10)}}?
@xref{Types Answer 8, 8}. (@bullet{})

(@bullet{}) @strong{Exercise 9.}  Two easy ways of squaring a number
are @kbd{RET *} and @w{@kbd{2 ^}}.  Normally these produce the same
answer.  Would you expect this still to hold true for interval forms?
If not, which of these will result in a larger interval?
@xref{Types Answer 9, 9}. (@bullet{})

A @dfn{modulo form} is used for performing arithmetic modulo @i{M}.
For example, arithmetic involving time is generally done modulo 12
or 24 hours.

@group
@smallexample
1:  17 mod 24    1:  3 mod 24     1:  21 mod 24    1:  9 mod 24
    .                .                .                .

    17 M 24 RET      10 +             n                5 /
@end smallexample
@end group

@noindent
In this last step, Calc has found a new number which, when multiplied
by 5 modulo 24, produces the original number, 21.  If @i{M} is prime
it is always possible to find such a number.  For non-prime @i{M}
like 24, it is only sometimes possible.

@group
@smallexample
1:  10 mod 24    1:  16 mod 24    1:  1000000...   1:  16
    .                .                .                .

    10 M 24 RET      100 ^            10 RET 100 ^     24 %
@end smallexample
@end group

@noindent
These two calculations get the same answer, but the first one is
much more efficient because it avoids the huge intermediate value
that arises in the second one.

@cindex Fermat, primality test of
(@bullet{}) @strong{Exercise 10.}  A theorem of Pierre de Fermat
says that @c{\w{$x^{n-1} \bmod n = 1$}}
@cite{x^(n-1) mod n = 1} if @cite{n} is a prime number
and @cite{x} is an integer less than @cite{n}.  If @cite{n} is
@emph{not} a prime number, this will @emph{not} be true for most
values of @cite{x}.  Thus we can test informally if a number is
prime by trying this formula for several values of @cite{x}.
Use this test to tell whether the following numbers are prime:
811749613, 15485863.  @xref{Types Answer 10, 10}. (@bullet{})

It is possible to use HMS forms as parts of error forms, intervals,
modulo forms, or as the phase part of a polar complex number.
For example, the @code{calc-time} command pushes the current time
of day on the stack as an HMS/modulo form.

@group
@smallexample
1:  17@@ 34' 45" mod 24@@ 0' 0"     1:  6@@ 22' 15" mod 24@@ 0' 0"
    .                                 .

    x time RET                        n
@end smallexample
@end group

@noindent
This calculation tells me it is six hours and 22 minutes until midnight.

(@bullet{}) @strong{Exercise 11.}  A rule of thumb is that one year
is about @c{$\pi \times 10^7$}
@w{@cite{pi * 10^7}} seconds.  What time will it be that
many seconds from right now?  @xref{Types Answer 11, 11}. (@bullet{})

(@bullet{}) @strong{Exercise 12.}  You are preparing to order packaging
for the CD release of the Extended Disco Version of @emph{Abbey Road}.
You are told that the songs will actually be anywhere from 20 to 60
seconds longer than the originals.  One CD can hold about 75 minutes
of music.  Should you order single or double packages?
@xref{Types Answer 12, 12}. (@bullet{})

Another kind of data the Calculator can manipulate is numbers with
@dfn{units}.  This isn't strictly a new data type; it's simply an
application of algebraic expressions, where we use variables with
suggestive names like @samp{cm} and @samp{in} to represent units
like centimeters and inches.

@group
@smallexample
1:  2 in        1:  5.08 cm      1:  0.027778 fath   1:  0.0508 m
    .               .                .                   .

    ' 2in RET       u c cm RET       u c fath RET        u b
@end smallexample
@end group

@noindent
We enter the quantity ``2 inches'' (actually an algebraic expression
which means two times the variable @samp{in}), then we convert it
first to centimeters, then to fathoms, then finally to ``base'' units,
which in this case means meters.

@group
@smallexample
1:  9 acre     1:  3 sqrt(acre)   1:  190.84 m   1:  190.84 m + 30 cm
    .              .                  .              .

 ' 9 acre RET      Q                  u s            ' $+30 cm RET

@end smallexample
@end group
@noindent
@group
@smallexample
1:  191.14 m     1:  36536.3046 m^2    1:  365363046 cm^2
    .                .                     .

    u s              2 ^                   u c cgs
@end smallexample
@end group

@noindent
Since units expressions are really just formulas, taking the square
root of @samp{acre} is undefined.  After all, @code{acre} might be an
algebraic variable that you will someday assign a value.  We use the
``units-simplify'' command to simplify the expression with variables
being interpreted as unit names.

In the final step, we have converted not to a particular unit, but to a
units system.  The ``cgs'' system uses centimeters instead of meters
as its standard unit of length.

There is a wide variety of units defined in the Calculator.

@group
@smallexample
1:  55 mph     1:  88.5139 kph   1:   88.5139 km / hr   1:  8.201407e-8 c
    .              .                  .                     .

 ' 55 mph RET      u c kph RET        u c km/hr RET         u c c RET
@end smallexample
@end group

@noindent
We express a speed first in miles per hour, then in kilometers per
hour, then again using a slightly more explicit notation, then
finally in terms of fractions of the speed of light.

Temperature conversions are a bit more tricky.  There are two ways to
interpret ``20 degrees Fahrenheit''---it could mean an actual
temperature, or it could mean a change in temperature.  For normal
units there is no difference, but temperature units have an offset
as well as a scale factor and so there must be two explicit commands
for them.

@group
@smallexample
1:  20 degF       1:  11.1111 degC     1:  -20:3 degC    1:  -6.666 degC
    .                 .                    .                 .

  ' 20 degF RET       u c degC RET         U u t degC RET    c f
@end smallexample
@end group

@noindent
First we convert a change of 20 degrees Fahrenheit into an equivalent
change in degrees Celsius (or Centigrade).  Then, we convert the
absolute temperature 20 degrees Fahrenheit into Celsius.  Since
this comes out as an exact fraction, we then convert to floating-point
for easier comparison with the other result.

For simple unit conversions, you can put a plain number on the stack.
Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
When you use this method, you're responsible for remembering which
numbers are in which units:

@group
@smallexample
1:  55         1:  88.5139              1:  8.201407e-8
    .              .                        .

    55             u c mph RET kph RET      u c km/hr RET c RET
@end smallexample
@end group

To see a complete list of built-in units, type @kbd{u v}.  Press
@w{@kbd{M-# c}} again to re-enter the Calculator when you're done looking
at the units table.

(@bullet{}) @strong{Exercise 13.}  How many seconds are there really
in a year?  @xref{Types Answer 13, 13}. (@bullet{})

@cindex Speed of light
(@bullet{}) @strong{Exercise 14.}  Supercomputer designs are limited by
the speed of light (and of electricity, which is nearly as fast).
Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
cabinet is one meter across.  Is speed of light going to be a
significant factor in its design?  @xref{Types Answer 14, 14}. (@bullet{})

(@bullet{}) @strong{Exercise 15.}  Sam the Slug normally travels about
five yards in an hour.  He has obtained a supply of Power Pills; each
Power Pill he eats doubles his speed.  How many Power Pills can he
swallow and still travel legally on most US highways?
@xref{Types Answer 15, 15}. (@bullet{})

@node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
@section Algebra and Calculus Tutorial

@noindent
This section shows how to use Calc's algebra facilities to solve
equations, do simple calculus problems, and manipulate algebraic
formulas.

@menu
* Basic Algebra Tutorial::
* Rewrites Tutorial::
@end menu

@node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
@subsection Basic Algebra

@noindent
If you enter a formula in algebraic mode that refers to variables,
the formula itself is pushed onto the stack.  You can manipulate
formulas as regular data objects.

@group
@smallexample
1:  2 x^2 - 6       1:  6 - 2 x^2       1:  (6 - 2 x^2) (3 x^2 + y)
    .                   .                   .

    ' 2x^2-6 RET        n                   ' 3x^2+y RET *
@end smallexample
@end group

(@bullet{}) @strong{Exercise 1.}  Do @kbd{' x RET Q 2 ^} and
@kbd{' x RET 2 ^ Q} both wind up with the same result (@samp{x})?
Why or why not?  @xref{Algebra Answer 1, 1}. (@bullet{})

There are also commands for doing common algebraic operations on
formulas.  Continuing with the formula from the last example,

@group
@smallexample
1:  18 x^2 + 6 y - 6 x^4 - 2 x^2 y    1:  (18 - 2 y) x^2 - 6 x^4 + 6 y
    .                                     .

    a x                                   a c x RET
@end smallexample
@end group

@noindent
First we ``expand'' using the distributive law, then we ``collect''
terms involving like powers of @cite{x}.

Let's find the value of this expression when @cite{x} is 2 and @cite{y}
is one-half.

@group
@smallexample
1:  17 x^2 - 6 x^4 + 3      1:  -25
    .                           .

    1:2 s l y RET               2 s l x RET
@end smallexample
@end group

@noindent
The @kbd{s l} command means ``let''; it takes a number from the top of
the stack and temporarily assigns it as the value of the variable
you specify.  It then evaluates (as if by the @kbd{=} key) the
next expression on the stack.  After this command, the variable goes
back to its original value, if any.

(An earlier exercise in this tutorial involved storing a value in the
variable @code{x}; if this value is still there, you will have to
unstore it with @kbd{s u x RET} before the above example will work
properly.)

@cindex Maximum of a function using Calculus
Let's find the maximum value of our original expression when @cite{y}
is one-half and @cite{x} ranges over all possible values.  We can
do this by taking the derivative with respect to @cite{x} and examining
values of @cite{x} for which the derivative is zero.  If the second
derivative of the function at that value of @cite{x} is negative,
the function has a local maximum there.

@group
@smallexample
1:  17 x^2 - 6 x^4 + 3      1:  34 x - 24 x^3
    .                           .

    U DEL  s 1                  a d x RET   s 2
@end smallexample
@end group

@noindent
Well, the derivative is clearly zero when @cite{x} is zero.  To find
the other root(s), let's divide through by @cite{x} and then solve:

@group
@smallexample
1:  (34 x - 24 x^3) / x    1:  34 x / x - 24 x^3 / x    1:  34 - 24 x^2
    .                          .                            .

    ' x RET /                  a x                          a s

@end smallexample
@end group
@noindent
@group
@smallexample
1:  34 - 24 x^2 = 0        1:  x = 1.19023
    .                          .

    0 a =  s 3                 a S x RET
@end smallexample
@end group

@noindent
Notice the use of @kbd{a s} to ``simplify'' the formula.  When the
default algebraic simplifications don't do enough, you can use
@kbd{a s} to tell Calc to spend more time on the job.

Now we compute the second derivative and plug in our values of @cite{x}:

@group
@smallexample
1:  1.19023        2:  1.19023         2:  1.19023
    .              1:  34 x - 24 x^3   1:  34 - 72 x^2
                       .                   .

    a .                r 2                 a d x RET s 4
@end smallexample
@end group

@noindent
(The @kbd{a .} command extracts just the righthand side of an equation.
Another method would have been to use @kbd{v u} to unpack the equation
@w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 DEL}
to delete the @samp{x}.)

@group
@smallexample
2:  34 - 72 x^2   1:  -68.         2:  34 - 72 x^2     1:  34
1:  1.19023           .            1:  0                   .
    .                                  .

    TAB               s l x RET        U DEL 0             s l x RET
@end smallexample
@end group

@noindent
The first of these second derivatives is negative, so we know the function
has a maximum value at @cite{x = 1.19023}.  (The function also has a
local @emph{minimum} at @cite{x = 0}.)

When we solved for @cite{x}, we got only one value even though
@cite{34 - 24 x^2 = 0} is a quadratic equation that ought to have
two solutions.  The reason is that @w{@kbd{a S}} normally returns a
single ``principal'' solution.  If it needs to come up with an
arbitrary sign (as occurs in the quadratic formula) it picks @cite{+}.
If it needs an arbitrary integer, it picks zero.  We can get a full
solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.

@group
@smallexample
1:  34 - 24 x^2 = 0    1:  x = 1.19023 s1      1:  x = -1.19023
    .                      .                       .

    r 3                    H a S x RET  s 5        1 n  s l s1 RET
@end smallexample
@end group

@noindent
Calc has invented the variable @samp{s1} to represent an unknown sign;
it is supposed to be either @i{+1} or @i{-1}.  Here we have used
the ``let'' command to evaluate the expression when the sign is negative.
If we plugged this into our second derivative we would get the same,
negative, answer, so @cite{x = -1.19023} is also a maximum.

To find the actual maximum value, we must plug our two values of @cite{x}
into the original formula.

@group
@smallexample
2:  17 x^2 - 6 x^4 + 3    1:  24.08333 s1^2 - 12.04166 s1^4 + 3
1:  x = 1.19023 s1            .
    .

    r 1 r 5                   s l RET
@end smallexample
@end group

@noindent
(Here we see another way to use @kbd{s l}; if its input is an equation
with a variable on the lefthand side, then @kbd{s l} treats the equation
like an assignment to that variable if you don't give a variable name.)

It's clear that this will have the same value for either sign of
@code{s1}, but let's work it out anyway, just for the exercise:

@group
@smallexample
2:  [-1, 1]              1:  [15.04166, 15.04166]
1:  24.08333 s1^2 ...        .
    .

  [ 1 n , 1 ] TAB            V M $ RET
@end smallexample
@end group

@noindent
Here we have used a vector mapping operation to evaluate the function
at several values of @samp{s1} at once.  @kbd{V M $} is like @kbd{V M '}
except that it takes the formula from the top of the stack.  The
formula is interpreted as a function to apply across the vector at the
next-to-top stack level.  Since a formula on the stack can't contain
@samp{$} signs, Calc assumes the variables in the formula stand for
different arguments.  It prompts you for an @dfn{argument list}, giving
the list of all variables in the formula in alphabetical order as the
default list.  In this case the default is @samp{(s1)}, which is just
what we want so we simply press @key{RET} at the prompt.

If there had been several different values, we could have used
@w{@kbd{V R X}} to find the global maximum.

Calc has a built-in @kbd{a P} command that solves an equation using
@w{@kbd{H a S}} and returns a vector of all the solutions.  It simply
automates the job we just did by hand.  Applied to our original
cubic polynomial, it would produce the vector of solutions
@cite{[1.19023, -1.19023, 0]}.  (There is also an @kbd{a X} command
which finds a local maximum of a function.  It uses a numerical search
method rather than examining the derivatives, and thus requires you
to provide some kind of initial guess to show it where to look.)

(@bullet{}) @strong{Exercise 2.}  Given a vector of the roots of a
polynomial (such as the output of an @kbd{a P} command), what
sequence of commands would you use to reconstruct the original
polynomial?  (The answer will be unique to within a constant
multiple; choose the solution where the leading coefficient is one.)
@xref{Algebra Answer 2, 2}. (@bullet{})

The @kbd{m s} command enables ``symbolic mode,'' in which formulas
like @samp{sqrt(5)} that can't be evaluated exactly are left in
symbolic form rather than giving a floating-point approximate answer.
Fraction mode (@kbd{m f}) is also useful when doing algebra.

@group
@smallexample
2:  34 x - 24 x^3        2:  34 x - 24 x^3
1:  34 x - 24 x^3        1:  [sqrt(51) / 6, sqrt(51) / -6, 0]
    .                        .

    r 2  RET     m s  m f    a P x RET
@end smallexample
@end group

One more mode that makes reading formulas easier is ``Big mode.''

@group
@smallexample
               3
2:  34 x - 24 x

      ____   ____
     V 51   V 51
1:  [-----, -----, 0]
       6     -6

    .

    d B
@end smallexample
@end group

Here things like powers, square roots, and quotients and fractions
are displayed in a two-dimensional pictorial form.  Calc has other
language modes as well, such as C mode, FORTRAN mode, and @TeX{} mode.

@group
@smallexample
2:  34*x - 24*pow(x, 3)               2:  34*x - 24*x**3
1:  @{sqrt(51) / 6, sqrt(51) / -6, 0@}  1:  /sqrt(51) / 6, sqrt(51) / -6, 0/
    .                                     .

    d C                                   d F

@end smallexample
@end group
@noindent
@group
@smallexample
3:  34 x - 24 x^3
2:  [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
1:  @{2 \over 3@} \sqrt@{5@}
    .

    d T   ' 2 \sqrt@{5@} \over 3 RET
@end smallexample
@end group

@noindent
As you can see, language modes affect both entry and display of
formulas.  They affect such things as the names used for built-in
functions, the set of arithmetic operators and their precedences,
and notations for vectors and matrices.

Notice that @samp{sqrt(51)} may cause problems with older
implementations of C and FORTRAN, which would require something more
like @samp{sqrt(51.0)}.  It is always wise to check over the formulas
produced by the various language modes to make sure they are fully
correct.

Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes.  (You
may prefer to remain in Big mode, but all the examples in the tutorial
are shown in normal mode.)

@cindex Area under a curve
What is the area under the portion of this curve from @cite{x = 1} to @cite{2}?
This is simply the integral of the function:

@group
@smallexample
1:  17 x^2 - 6 x^4 + 3     1:  5.6666 x^3 - 1.2 x^5 + 3 x
    .                          .

    r 1                        a i x
@end smallexample
@end group

@noindent
We want to evaluate this at our two values for @cite{x} and subtract.
One way to do it is again with vector mapping and reduction:

@group
@smallexample
2:  [2, 1]            1:  [12.93333, 7.46666]    1:  5.46666
1:  5.6666 x^3 ...        .                          .

   [ 2 , 1 ] TAB          V M $ RET                  V R -
@end smallexample
@end group

(@bullet{}) @strong{Exercise 3.}  Find the integral from 1 to @cite{y}
of @c{$x \sin \pi x$}
@w{@cite{x sin(pi x)}} (where the sine is calculated in radians).
Find the values of the integral for integers @cite{y} from 1 to 5.
@xref{Algebra Answer 3, 3}. (@bullet{})

Calc's integrator can do many simple integrals symbolically, but many
others are beyond its capabilities.  Suppose we wish to find the area
under the curve @c{$\sin x \ln x$}
@cite{sin(x) ln(x)} over the same range of @cite{x}.  If
you entered this formula and typed @kbd{a i x RET} (don't bother to try
this), Calc would work for a long time but would be unable to find a
solution.  In fact, there is no closed-form solution to this integral.
Now what do we do?

@cindex Integration, numerical
@cindex Numerical integration
One approach would be to do the integral numerically.  It is not hard
to do this by hand using vector mapping and reduction.  It is rather
slow, though, since the sine and logarithm functions take a long time.
We can save some time by reducing the working precision.

@group
@smallexample
3:  10                  1:  [1, 1.1, 1.2,  ...  , 1.8, 1.9]
2:  1                       .
1:  0.1
    .

 10 RET 1 RET .1 RET        C-u v x
@end smallexample
@end group

@noindent
(Note that we have used the extended version of @kbd{v x}; we could
also have used plain @kbd{v x} as follows:  @kbd{v x 10 RET 9 + .1 *}.)

@group
@smallexample
2:  [1, 1.1, ... ]              1:  [0., 0.084941, 0.16993, ... ]
1:  sin(x) ln(x)                    .
    .

    ' sin(x) ln(x) RET  s 1    m r  p 5 RET   V M $ RET

@end smallexample
@end group
@noindent
@group
@smallexample
1:  3.4195     0.34195
    .          .

    V R +      0.1 *
@end smallexample
@end group

@noindent
(If you got wildly different results, did you remember to switch
to radians mode?)

Here we have divided the curve into ten segments of equal width;
approximating these segments as rectangular boxes (i.e., assuming
the curve is nearly flat at that resolution), we compute the areas
of the boxes (height times width), then sum the areas.  (It is
faster to sum first, then multiply by the width, since the width
is the same for every box.)

The true value of this integral turns out to be about 0.374, so
we're not doing too well.  Let's try another approach.

@group
@smallexample
1:  sin(x) ln(x)    1:  0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
    .                   .

    r 1                 a t x=1 RET 4 RET
@end smallexample
@end group

@noindent
Here we have computed the Taylor series expansion of the function
about the point @cite{x=1}.  We can now integrate this polynomial
approximation, since polynomials are easy to integrate.

@group
@smallexample
1:  0.42074 x^2 + ...    1:  [-0.0446, -0.42073]      1:  0.3761
    .                        .                            .

    a i x RET            [ 2 , 1 ] TAB  V M $ RET         V R -
@end smallexample
@end group

@noindent
Better!  By increasing the precision and/or asking for more terms
in the Taylor series, we can get a result as accurate as we like.
(Taylor series converge better away from singularities in the
function such as the one at @code{ln(0)}, so it would also help to
expand the series about the points @cite{x=2} or @cite{x=1.5} instead
of @cite{x=1}.)

@cindex Simpson's rule
@cindex Integration by Simpson's rule
(@bullet{}) @strong{Exercise 4.}  Our first method approximated the
curve by stairsteps of width 0.1; the total area was then the sum
of the areas of the rectangles under these stairsteps.  Our second
method approximated the function by a polynomial, which turned out
to be a better approximation than stairsteps.  A third method is
@dfn{Simpson's rule}, which is like the stairstep method except
that the steps are not required to be flat.  Simpson's rule boils
down to the formula,

@ifnottex
@example
(h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
              + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ \displaylines{
      \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
   \hfill \cr \hfill    {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
} $$
\afterdisplay
@end tex

@noindent
where @cite{n} (which must be even) is the number of slices and @cite{h}
is the width of each slice.  These are 10 and 0.1 in our example.
For reference, here is the corresponding formula for the stairstep
method:

@ifnottex
@example
h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
          + f(a+(n-2)*h) + f(a+(n-1)*h))
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
           + f(a+(n-2)h) + f(a+(n-1)h)) $$
\afterdisplay
@end tex

Compute the integral from 1 to 2 of @c{$\sin x \ln x$}
@cite{sin(x) ln(x)} using
Simpson's rule with 10 slices.  @xref{Algebra Answer 4, 4}. (@bullet{})

Calc has a built-in @kbd{a I} command for doing numerical integration.
It uses @dfn{Romberg's method}, which is a more sophisticated cousin
of Simpson's rule.  In particular, it knows how to keep refining the
result until the current precision is satisfied.

@c [fix-ref Selecting Sub-Formulas]
Aside from the commands we've seen so far, Calc also provides a
large set of commands for operating on parts of formulas.  You
indicate the desired sub-formula by placing the cursor on any part
of the formula before giving a @dfn{selection} command.  Selections won't
be covered in the tutorial; @pxref{Selecting Subformulas}, for
details and examples.

@c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
@c                to 2^((n-1)*(r-1)).

@node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
@subsection Rewrite Rules

@noindent
No matter how many built-in commands Calc provided for doing algebra,
there would always be something you wanted to do that Calc didn't have
in its repertoire.  So Calc also provides a @dfn{rewrite rule} system
that you can use to define your own algebraic manipulations.

Suppose we want to simplify this trigonometric formula:

@group
@smallexample
1:  1 / cos(x) - sin(x) tan(x)
    .

    ' 1/cos(x) - sin(x) tan(x) RET   s 1
@end smallexample
@end group

@noindent
If we were simplifying this by hand, we'd probably replace the
@samp{tan} with a @samp{sin/cos} first, then combine over a common
denominator.  There is no Calc command to do the former; the @kbd{a n}
algebra command will do the latter but we'll do both with rewrite
rules just for practice.

Rewrite rules are written with the @samp{:=} symbol.

@group
@smallexample
1:  1 / cos(x) - sin(x)^2 / cos(x)
    .

    a r tan(a) := sin(a)/cos(a) RET
@end smallexample
@end group

@noindent
(The ``assignment operator'' @samp{:=} has several uses in Calc.  All
by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
but when it is given to the @kbd{a r} command, that command interprets
it as a rewrite rule.)

The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
rewrite rule.  Calc searches the formula on the stack for parts that
match the pattern.  Variables in a rewrite pattern are called
@dfn{meta-variables}, and when matching the pattern each meta-variable
can match any sub-formula.  Here, the meta-variable @samp{a} matched
the actual variable @samp{x}.

When the pattern part of a rewrite rule matches a part of the formula,
that part is replaced by the righthand side with all the meta-variables
substituted with the things they matched.  So the result is
@samp{sin(x) / cos(x)}.  Calc's normal algebraic simplifications then
mix this in with the rest of the original formula.

To merge over a common denominator, we can use another simple rule:

@group
@smallexample
1:  (1 - sin(x)^2) / cos(x)
    .

    a r a/x + b/x := (a+b)/x RET
@end smallexample
@end group

This rule points out several interesting features of rewrite patterns.
First, if a meta-variable appears several times in a pattern, it must
match the same thing everywhere.  This rule detects common denominators
because the same meta-variable @samp{x} is used in both of the
denominators.

Second, meta-variable names are independent from variables in the
target formula.  Notice that the meta-variable @samp{x} here matches
the subformula @samp{cos(x)}; Calc never confuses the two meanings of
@samp{x}.

And third, rewrite patterns know a little bit about the algebraic
properties of formulas.  The pattern called for a sum of two quotients;
Calc was able to match a difference of two quotients by matching
@samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}.

@c [fix-ref Algebraic Properties of Rewrite Rules]
We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
the rule.  It would have worked just the same in all cases.  (If we
really wanted the rule to apply only to @samp{+} or only to @samp{-},
we could have used the @code{plain} symbol.  @xref{Algebraic Properties
of Rewrite Rules}, for some examples of this.)

One more rewrite will complete the job.  We want to use the identity
@samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
the identity in a way that matches our formula.  The obvious rule
would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows
that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work.  The
latter rule has a more general pattern so it will work in many other
situations, too.

@group
@smallexample
1:  (1 + cos(x)^2 - 1) / cos(x)           1:  cos(x)
    .                                         .

    a r sin(x)^2 := 1 - cos(x)^2 RET          a s
@end smallexample
@end group

You may ask, what's the point of using the most general rule if you
have to type it in every time anyway?  The answer is that Calc allows
you to store a rewrite rule in a variable, then give the variable
name in the @kbd{a r} command.  In fact, this is the preferred way to
use rewrites.  For one, if you need a rule once you'll most likely
need it again later.  Also, if the rule doesn't work quite right you
can simply Undo, edit the variable, and run the rule again without
having to retype it.

@group
@smallexample
' tan(x) := sin(x)/cos(x) RET      s t tsc RET
' a/x + b/x := (a+b)/x RET         s t merge RET
' sin(x)^2 := 1 - cos(x)^2 RET     s t sinsqr RET

1:  1 / cos(x) - sin(x) tan(x)     1:  cos(x)
    .                                  .

    r 1                a r tsc RET  a r merge RET  a r sinsqr RET  a s
@end smallexample
@end group

To edit a variable, type @kbd{s e} and the variable name, use regular
Emacs editing commands as necessary, then type @kbd{M-# M-#} or
@kbd{C-c C-c} to store the edited value back into the variable.
You can also use @w{@kbd{s e}} to create a new variable if you wish.

Notice that the first time you use each rule, Calc puts up a ``compiling''
message briefly.  The pattern matcher converts rules into a special
optimized pattern-matching language rather than using them directly.
This allows @kbd{a r} to apply even rather complicated rules very
efficiently.  If the rule is stored in a variable, Calc compiles it
only once and stores the compiled form along with the variable.  That's
another good reason to store your rules in variables rather than
entering them on the fly.

(@bullet{}) @strong{Exercise 1.}  Type @kbd{m s} to get symbolic
mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
Using a rewrite rule, simplify this formula by multiplying both
sides by the conjugate @w{@samp{1 - sqrt(2)}}.  The result will have
to be expanded by the distributive law; do this with another
rewrite.  @xref{Rewrites Answer 1, 1}. (@bullet{})

The @kbd{a r} command can also accept a vector of rewrite rules, or
a variable containing a vector of rules.

@group
@smallexample
1:  [tsc, merge, sinsqr]          1:  [tan(x) := sin(x) / cos(x), ... ]
    .                                 .

    ' [tsc,merge,sinsqr] RET          =

@end smallexample
@end group
@noindent
@group
@smallexample
1:  1 / cos(x) - sin(x) tan(x)    1:  cos(x)
    .                                 .

    s t trig RET  r 1                 a r trig RET  a s
@end smallexample
@end group

@c [fix-ref Nested Formulas with Rewrite Rules]
Calc tries all the rules you give against all parts of the formula,
repeating until no further change is possible.  (The exact order in
which things are tried is rather complex, but for simple rules like
the ones we've used here the order doesn't really matter.
@xref{Nested Formulas with Rewrite Rules}.)

Calc actually repeats only up to 100 times, just in case your rule set
has gotten into an infinite loop.  You can give a numeric prefix argument
to @kbd{a r} to specify any limit.  In particular, @kbd{M-1 a r} does
only one rewrite at a time.

@group
@smallexample
1:  1 / cos(x) - sin(x)^2 / cos(x)    1:  (1 - sin(x)^2) / cos(x)
    .                                     .

    r 1  M-1 a r trig RET                 M-1 a r trig RET
@end smallexample
@end group

You can type @kbd{M-0 a r} if you want no limit at all on the number
of rewrites that occur.

Rewrite rules can also be @dfn{conditional}.  Simply follow the rule
with a @samp{::} symbol and the desired condition.  For example,

@group
@smallexample
1:  exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
    .

    ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) RET

@end smallexample
@end group
@noindent
@group
@smallexample
1:  1 + exp(3 pi i) + 1
    .

    a r exp(k pi i) := 1 :: k % 2 = 0 RET
@end smallexample
@end group

@noindent
(Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
which will be zero only when @samp{k} is an even integer.)

An interesting point is that the variables @samp{pi} and @samp{i}
were matched literally rather than acting as meta-variables.
This is because they are special-constant variables.  The special
constants @samp{e}, @samp{phi}, and so on also match literally.
A common error with rewrite
rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
to match any @samp{f} with five arguments but in fact matching
only when the fifth argument is literally @samp{e}!@refill

@cindex Fibonacci numbers
@c @starindex
@tindex fib
Rewrite rules provide an interesting way to define your own functions.
Suppose we want to define @samp{fib(n)} to produce the @var{n}th
Fibonacci number.  The first two Fibonacci numbers are each 1;
later numbers are formed by summing the two preceding numbers in
the sequence.  This is easy to express in a set of three rules:

@group
@smallexample
' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] RET  s t fib

1:  fib(7)               1:  13
    .                        .

    ' fib(7) RET             a r fib RET
@end smallexample
@end group

One thing that is guaranteed about the order that rewrites are tried
is that, for any given subformula, earlier rules in the rule set will
be tried for that subformula before later ones.  So even though the
first and third rules both match @samp{fib(1)}, we know the first will
be used preferentially.

This rule set has one dangerous bug:  Suppose we apply it to the
formula @samp{fib(x)}?  (Don't actually try this.)  The third rule
will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
fib(x-4)}, and so on, expanding forever.  What we really want is to apply
the third rule only when @samp{n} is an integer greater than two.  Type
@w{@kbd{s e fib RET}}, then edit the third rule to:

@smallexample
fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
@end smallexample

@noindent
Now:

@group
@smallexample
1:  fib(6) + fib(x) + fib(0)      1:  8 + fib(x) + fib(0)
    .                                 .

    ' fib(6)+fib(x)+fib(0) RET        a r fib RET
@end smallexample
@end group

@noindent
We've created a new function, @code{fib}, and a new command,
@w{@kbd{a r fib RET}}, which means ``evaluate all @code{fib} calls in
this formula.''  To make things easier still, we can tell Calc to
apply these rules automatically by storing them in the special
variable @code{EvalRules}.

@group
@smallexample
1:  [fib(1) := ...]    .                1:  [8, 13]
    .                                       .

    s r fib RET        s t EvalRules RET    ' [fib(6), fib(7)] RET
@end smallexample
@end group

It turns out that this rule set has the problem that it does far
more work than it needs to when @samp{n} is large.  Consider the
first few steps of the computation of @samp{fib(6)}:

@group
@smallexample
fib(6) =
fib(5)              +               fib(4) =
fib(4)     +      fib(3)     +      fib(3)     +      fib(2) =
fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
@end smallexample
@end group

@noindent
Note that @samp{fib(3)} appears three times here.  Unless Calc's
algebraic simplifier notices the multiple @samp{fib(3)}s and combines
them (and, as it happens, it doesn't), this rule set does lots of
needless recomputation.  To cure the problem, type @code{s e EvalRules}
to edit the rules (or just @kbd{s E}, a shorthand command for editing
@code{EvalRules}) and add another condition:

@smallexample
fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
@end smallexample

@noindent
If a @samp{:: remember} condition appears anywhere in a rule, then if
that rule succeeds Calc will add another rule that describes that match
to the front of the rule set.  (Remembering works in any rule set, but
for technical reasons it is most effective in @code{EvalRules}.)  For
example, if the rule rewrites @samp{fib(7)} to something that evaluates
to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.

Type @kbd{' fib(8) RET} to compute the eighth Fibonacci number, then
type @kbd{s E} again to see what has happened to the rule set.

With the @code{remember} feature, our rule set can now compute
@samp{fib(@var{n})} in just @var{n} steps.  In the process it builds
up a table of all Fibonacci numbers up to @var{n}.  After we have
computed the result for a particular @var{n}, we can get it back
(and the results for all smaller @var{n}) later in just one step.

All Calc operations will run somewhat slower whenever @code{EvalRules}
contains any rules.  You should type @kbd{s u EvalRules RET} now to
un-store the variable.

(@bullet{}) @strong{Exercise 2.}  Sometimes it is possible to reformulate
a problem to reduce the amount of recursion necessary to solve it.
Create a rule that, in about @var{n} simple steps and without recourse
to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
@samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
@var{n}th and @var{n+1}st Fibonacci numbers, respectively.  This rule is
rather clunky to use, so add a couple more rules to make the ``user
interface'' the same as for our first version: enter @samp{fib(@var{n})},
get back a plain number.  @xref{Rewrites Answer 2, 2}. (@bullet{})

There are many more things that rewrites can do.  For example, there
are @samp{&&&} and @samp{|||} pattern operators that create ``and''
and ``or'' combinations of rules.  As one really simple example, we
could combine our first two Fibonacci rules thusly:

@example
[fib(1 ||| 2) := 1, fib(n) := ... ]
@end example

@noindent
That means ``@code{fib} of something matching either 1 or 2 rewrites
to 1.''

You can also make meta-variables optional by enclosing them in @code{opt}.
For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
@samp{2 + x} or @samp{3 x} or @samp{x}.  The pattern @samp{opt(a) + opt(b) x}
matches all of these forms, filling in a default of zero for @samp{a}
and one for @samp{b}.

(@bullet{}) @strong{Exercise 3.}  Your friend Joe had @samp{2 + 3 x}
on the stack and tried to use the rule
@samp{opt(a) + opt(b) x := f(a, b, x)}.  What happened?
@xref{Rewrites Answer 3, 3}. (@bullet{})

(@bullet{}) @strong{Exercise 4.}  Starting with a positive integer @cite{a},
divide @cite{a} by two if it is even, otherwise compute @cite{3 a + 1}.
Now repeat this step over and over.  A famous unproved conjecture
is that for any starting @cite{a}, the sequence always eventually
reaches 1.  Given the formula @samp{seq(@var{a}, 0)}, write a set of
rules that convert this into @samp{seq(1, @var{n})} where @var{n}
is the number of steps it took the sequence to reach the value 1.
Now enhance the rules to accept @samp{seq(@var{a})} as a starting
configuration, and to stop with just the number @var{n} by itself.
Now make the result be a vector of values in the sequence, from @var{a}
to 1.  (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
and @var{y}.)  For example, rewriting @samp{seq(6)} should yield the
vector @cite{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
@xref{Rewrites Answer 4, 4}. (@bullet{})

(@bullet{}) @strong{Exercise 5.}  Define, using rewrite rules, a function
@samp{nterms(@var{x})} that returns the number of terms in the sum
@var{x}, or 1 if @var{x} is not a sum.  (A @dfn{sum} for our purposes
is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
so that @cite{2 - 3 (x + y) + x y} is a sum of three terms.)
@xref{Rewrites Answer 5, 5}. (@bullet{})

(@bullet{}) @strong{Exercise 6.}  Calc considers the form @cite{0^0}
to be ``indeterminate,'' and leaves it unevaluated (assuming infinite
mode is not enabled).  Some people prefer to define @cite{0^0 = 1},
so that the identity @cite{x^0 = 1} can safely be used for all @cite{x}.
Find a way to make Calc follow this convention.  What happens if you
now type @kbd{m i} to turn on infinite mode?
@xref{Rewrites Answer 6, 6}. (@bullet{})

(@bullet{}) @strong{Exercise 7.}  A Taylor series for a function is an
infinite series that exactly equals the value of that function at
values of @cite{x} near zero.

@ifnottex
@example
cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
@end example
@end ifnottex
@tex
\turnoffactive \let\rm\goodrm
\beforedisplay
$$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
\afterdisplay
@end tex

The @kbd{a t} command produces a @dfn{truncated Taylor series} which
is obtained by dropping all the terms higher than, say, @cite{x^2}.
Calc represents the truncated Taylor series as a polynomial in @cite{x}.
Mathematicians often write a truncated series using a ``big-O'' notation
that records what was the lowest term that was truncated.

@ifnottex
@example
cos(x) = 1 - x^2 / 2! + O(x^3)
@end example
@end ifnottex
@tex
\turnoffactive \let\rm\goodrm
\beforedisplay
$$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
\afterdisplay
@end tex

@noindent
The meaning of @cite{O(x^3)} is ``a quantity which is negligibly small
if @cite{x^3} is considered negligibly small as @cite{x} goes to zero.''

The exercise is to create rewrite rules that simplify sums and products of
power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
on the stack, we want to be able to type @kbd{*} and get the result
@samp{x - 2:3 x^3 + O(x^4)}.  Don't worry if the terms of the sum are
rearranged or if @kbd{a s} needs to be typed after rewriting.  (This one
is rather tricky; the solution at the end of this chapter uses 6 rewrite
rules.  Hint:  The @samp{constant(x)} condition tests whether @samp{x} is
a number.)  @xref{Rewrites Answer 7, 7}. (@bullet{})

@c [fix-ref Rewrite Rules]
@xref{Rewrite Rules}, for the whole story on rewrite rules.

@node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
@section Programming Tutorial

@noindent
The Calculator is written entirely in Emacs Lisp, a highly extensible
language.  If you know Lisp, you can program the Calculator to do
anything you like.  Rewrite rules also work as a powerful programming
system.  But Lisp and rewrite rules take a while to master, and often
all you want to do is define a new function or repeat a command a few
times.  Calc has features that allow you to do these things easily.

(Note that the programming commands relating to user-defined keys
are not yet supported under Lucid Emacs 19.)

One very limited form of programming is defining your own functions.
Calc's @kbd{Z F} command allows you to define a function name and
key sequence to correspond to any formula.  Programming commands use
the shift-@kbd{Z} prefix; the user commands they create use the lower
case @kbd{z} prefix.

@group
@smallexample
1:  1 + x + x^2 / 2 + x^3 / 6         1:  1 + x + x^2 / 2 + x^3 / 6
    .                                     .

    ' 1 + x + x^2/2! + x^3/3! RET         Z F e myexp RET RET RET y
@end smallexample
@end group

This polynomial is a Taylor series approximation to @samp{exp(x)}.
The @kbd{Z F} command asks a number of questions.  The above answers
say that the key sequence for our function should be @kbd{z e}; the
@kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
function in algebraic formulas should also be @code{myexp}; the
default argument list @samp{(x)} is acceptable; and finally @kbd{y}
answers the question ``leave it in symbolic form for non-constant
arguments?''

@group
@smallexample
1:  1.3495     2:  1.3495     3:  1.3495
    .          1:  1.34986    2:  1.34986
                   .          1:  myexp(a + 1)
                                  .

    .3 z e         .3 E           ' a+1 RET z e
@end smallexample
@end group

@noindent
First we call our new @code{exp} approximation with 0.3 as an
argument, and compare it with the true @code{exp} function.  Then
we note that, as requested, if we try to give @kbd{z e} an
argument that isn't a plain number, it leaves the @code{myexp}
function call in symbolic form.  If we had answered @kbd{n} to the
final question, @samp{myexp(a + 1)} would have evaluated by plugging
in @samp{a + 1} for @samp{x} in the defining formula.

@cindex Sine integral Si(x)
@c @starindex
@tindex Si
(@bullet{}) @strong{Exercise 1.}  The ``sine integral'' function
@c{${\rm Si}(x)$}
@cite{Si(x)} is defined as the integral of @samp{sin(t)/t} for
@cite{t = 0} to @cite{x} in radians.  (It was invented because this
integral has no solution in terms of basic functions; if you give it
to Calc's @kbd{a i} command, it will ponder it for a long time and then
give up.)  We can use the numerical integration command, however,
which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
with any integrand @samp{f(t)}.  Define a @kbd{z s} command and
@code{Si} function that implement this.  You will need to edit the
default argument list a bit.  As a test, @samp{Si(1)} should return
0.946083.  (Hint:  @code{ninteg} will run a lot faster if you reduce
the precision to, say, six digits beforehand.)
@xref{Programming Answer 1, 1}. (@bullet{})

The simplest way to do real ``programming'' of Emacs is to define a
@dfn{keyboard macro}.  A keyboard macro is simply a sequence of
keystrokes which Emacs has stored away and can play back on demand.
For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
you may wish to program a keyboard macro to type this for you.

@group
@smallexample
1:  y = sqrt(x)          1:  x = y^2
    .                        .

    ' y=sqrt(x) RET       C-x ( H a S x RET C-x )

1:  y = cos(x)           1:  x = s1 arccos(y) + 2 pi n1
    .                        .

    ' y=cos(x) RET           X
@end smallexample
@end group

@noindent
When you type @kbd{C-x (}, Emacs begins recording.  But it is also
still ready to execute your keystrokes, so you're really ``training''
Emacs by walking it through the procedure once.  When you type
@w{@kbd{C-x )}}, the macro is recorded.  You can now type @kbd{X} to
re-execute the same keystrokes.

You can give a name to your macro by typing @kbd{Z K}.

@group
@smallexample
1:  .              1:  y = x^4         1:  x = s2 sqrt(s1 sqrt(y))
                       .                   .

  Z K x RET            ' y=x^4 RET         z x
@end smallexample
@end group

@noindent
Notice that we use shift-@kbd{Z} to define the command, and lower-case
@kbd{z} to call it up.

Keyboard macros can call other macros.

@group
@smallexample
1:  abs(x)        1:  x = s1 y                1:  2 / x    1:  x = 2 / y
    .                 .                           .            .

 ' abs(x) RET   C-x ( ' y RET a = z x C-x )    ' 2/x RET       X
@end smallexample
@end group

(@bullet{}) @strong{Exercise 2.}  Define a keyboard macro to negate
the item in level 3 of the stack, without disturbing the rest of
the stack.  @xref{Programming Answer 2, 2}. (@bullet{})

(@bullet{}) @strong{Exercise 3.}  Define keyboard macros to compute
the following functions:

@enumerate
@item
Compute @c{$\displaystyle{\sin x \over x}$}
@cite{sin(x) / x}, where @cite{x} is the number on the
top of the stack.

@item
Compute the base-@cite{b} logarithm, just like the @kbd{B} key except
the arguments are taken in the opposite order.

@item
Produce a vector of integers from 1 to the integer on the top of
the stack.
@end enumerate
@noindent
@xref{Programming Answer 3, 3}. (@bullet{})

(@bullet{}) @strong{Exercise 4.}  Define a keyboard macro to compute
the average (mean) value of a list of numbers.
@xref{Programming Answer 4, 4}. (@bullet{})

In many programs, some of the steps must execute several times.
Calc has @dfn{looping} commands that allow this.  Loops are useful
inside keyboard macros, but actually work at any time.

@group
@smallexample
1:  x^6          2:  x^6        1: 360 x^2
    .            1:  4             .
                     .

  ' x^6 RET          4         Z < a d x RET Z >
@end smallexample
@end group

@noindent
Here we have computed the fourth derivative of @cite{x^6} by
enclosing a derivative command in a ``repeat loop'' structure.
This structure pops a repeat count from the stack, then
executes the body of the loop that many times.

If you make a mistake while entering the body of the loop,
type @w{@kbd{Z C-g}} to cancel the loop command.

@cindex Fibonacci numbers
Here's another example:

@group
@smallexample
3:  1               2:  10946
2:  1               1:  17711
1:  20                  .
    .

1 RET RET 20       Z < TAB C-j + Z >
@end smallexample
@end group

@noindent
The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
numbers, respectively.  (To see what's going on, try a few repetitions
of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
key if you have one, makes a copy of the number in level 2.)

@cindex Golden ratio
@cindex Phi, golden ratio
A fascinating property of the Fibonacci numbers is that the @cite{n}th
Fibonacci number can be found directly by computing @c{$\phi^n / \sqrt{5}$}
@cite{phi^n / sqrt(5)}
and then rounding to the nearest integer, where @c{$\phi$ (``phi'')}
@cite{phi}, the
``golden ratio,'' is @c{$(1 + \sqrt{5}) / 2$}
@cite{(1 + sqrt(5)) / 2}.  (For convenience, this constant is available
from the @code{phi} variable, or the @kbd{I H P} command.)

@group
@smallexample
1:  1.61803         1:  24476.0000409    1:  10945.9999817    1:  10946
    .                   .                    .                    .

    I H P               21 ^                 5 Q /                R
@end smallexample
@end group

@cindex Continued fractions
(@bullet{}) @strong{Exercise 5.}  The @dfn{continued fraction}
representation of @c{$\phi$}
@cite{phi} is @c{$1 + 1/(1 + 1/(1 + 1/( \ldots )))$}
@cite{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
We can compute an approximate value by carrying this however far
and then replacing the innermost @c{$1/( \ldots )$}
@cite{1/( ...@: )} by 1.  Approximate
@c{$\phi$}
@cite{phi} using a twenty-term continued fraction.
@xref{Programming Answer 5, 5}. (@bullet{})

(@bullet{}) @strong{Exercise 6.}  Linear recurrences like the one for
Fibonacci numbers can be expressed in terms of matrices.  Given a
vector @w{@cite{[a, b]}} determine a matrix which, when multiplied by this
vector, produces the vector @cite{[b, c]}, where @cite{a}, @cite{b} and
@cite{c} are three successive Fibonacci numbers.  Now write a program
that, given an integer @cite{n}, computes the @cite{n}th Fibonacci number
using matrix arithmetic.  @xref{Programming Answer 6, 6}. (@bullet{})

@cindex Harmonic numbers
A more sophisticated kind of loop is the @dfn{for} loop.  Suppose
we wish to compute the 20th ``harmonic'' number, which is equal to
the sum of the reciprocals of the integers from 1 to 20.

@group
@smallexample
3:  0               1:  3.597739
2:  1                   .
1:  20
    .

0 RET 1 RET 20         Z ( & + 1 Z )
@end smallexample
@end group

@noindent
The ``for'' loop pops two numbers, the lower and upper limits, then
repeats the body of the loop as an internal counter increases from
the lower limit to the upper one.  Just before executing the loop
body, it pushes the current loop counter.  When the loop body
finishes, it pops the ``step,'' i.e., the amount by which to
increment the loop counter.  As you can see, our loop always
uses a step of one.

This harmonic number function uses the stack to hold the running
total as well as for the various loop housekeeping functions.  If
you find this disorienting, you can sum in a variable instead:

@group
@smallexample
1:  0         2:  1                  .            1:  3.597739
    .         1:  20                                  .
                  .

    0 t 7       1 RET 20      Z ( & s + 7 1 Z )       r 7
@end smallexample
@end group

@noindent
The @kbd{s +} command adds the top-of-stack into the value in a
variable (and removes that value from the stack).

It's worth noting that many jobs that call for a ``for'' loop can
also be done more easily by Calc's high-level operations.  Two
other ways to compute harmonic numbers are to use vector mapping
and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
or to use the summation command @kbd{a +}.  Both of these are
probably easier than using loops.  However, there are some
situations where loops really are the way to go:

(@bullet{}) @strong{Exercise 7.}  Use a ``for'' loop to find the first
harmonic number which is greater than 4.0.
@xref{Programming Answer 7, 7}. (@bullet{})

Of course, if we're going to be using variables in our programs,
we have to worry about the programs clobbering values that the
caller was keeping in those same variables.  This is easy to
fix, though:

@group
@smallexample
    .        1:  0.6667       1:  0.6667     3:  0.6667
                 .                .          2:  3.597739
                                             1:  0.6667
                                                 .

   Z `    p 4 RET 2 RET 3 /   s 7 s s a RET    Z '  r 7 s r a RET
@end smallexample
@end group

@noindent
When we type @kbd{Z `} (that's a back-quote character), Calc saves
its mode settings and the contents of the ten ``quick variables''
for later reference.  When we type @kbd{Z '} (that's an apostrophe
now), Calc restores those saved values.  Thus the @kbd{p 4} and
@kbd{s 7} commands have no effect outside this sequence.  Wrapping
this around the body of a keyboard macro ensures that it doesn't
interfere with what the user of the macro was doing.  Notice that
the contents of the stack, and the values of named variables,
survive past the @kbd{Z '} command.

@cindex Bernoulli numbers, approximate
The @dfn{Bernoulli numbers} are a sequence with the interesting
property that all of the odd Bernoulli numbers are zero, and the
even ones, while difficult to compute, can be roughly approximated
by the formula @c{$\displaystyle{2 n! \over (2 \pi)^n}$}
@cite{2 n!@: / (2 pi)^n}.  Let's write a keyboard
macro to compute (approximate) Bernoulli numbers.  (Calc has a
command, @kbd{k b}, to compute exact Bernoulli numbers, but
this command is very slow for large @cite{n} since the higher
Bernoulli numbers are very large fractions.)

@group
@smallexample
1:  10               1:  0.0756823
    .                    .

    10     C-x ( RET 2 % Z [ DEL 0 Z : ' 2 $! / (2 pi)^$ RET = Z ] C-x )
@end smallexample
@end group

@noindent
You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
@kbd{Z ]} as ``end-if.''  There is no need for an explicit ``if''
command.  For the purposes of @w{@kbd{Z [}}, the condition is ``true''
if the value it pops from the stack is a nonzero number, or ``false''
if it pops zero or something that is not a number (like a formula).
Here we take our integer argument modulo 2; this will be nonzero
if we're asking for an odd Bernoulli number.

The actual tenth Bernoulli number is @cite{5/66}.

@group
@smallexample
3:  0.0756823    1:  0          1:  0.25305    1:  0          1:  1.16659
2:  5:66             .              .              .              .
1:  0.0757575
    .

10 k b RET c f   M-0 DEL 11 X   DEL 12 X       DEL 13 X       DEL 14 X
@end smallexample
@end group

Just to exercise loops a bit more, let's compute a table of even
Bernoulli numbers.

@group
@smallexample
3:  []             1:  [0.10132, 0.03079, 0.02340, 0.033197, ...]
2:  2                  .
1:  30
    .

 [ ] 2 RET 30          Z ( X | 2 Z )
@end smallexample
@end group

@noindent
The vertical-bar @kbd{|} is the vector-concatenation command.  When
we execute it, the list we are building will be in stack level 2
(initially this is an empty list), and the next Bernoulli number
will be in level 1.  The effect is to append the Bernoulli number
onto the end of the list.  (To create a table of exact fractional
Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
sequence of keystrokes.)

With loops and conditionals, you can program essentially anything
in Calc.  One other command that makes looping easier is @kbd{Z /},
which takes a condition from the stack and breaks out of the enclosing
loop if the condition is true (non-zero).  You can use this to make
``while'' and ``until'' style loops.

If you make a mistake when entering a keyboard macro, you can edit
it using @kbd{Z E}.  First, you must attach it to a key with @kbd{Z K}.
One technique is to enter a throwaway dummy definition for the macro,
then enter the real one in the edit command.

@group
@smallexample
1:  3                   1:  3           Keyboard Macro Editor.
    .                       .           Original keys: 1 RET 2 +

                                        type "1\r"
                                        type "2"
                                        calc-plus

C-x ( 1 RET 2 + C-x )    Z K h RET      Z E h
@end smallexample
@end group

@noindent
This shows the screen display assuming you have the @file{macedit}
keyboard macro editing package installed, which is usually the case
since a copy of @file{macedit} comes bundled with Calc.

A keyboard macro is stored as a pure keystroke sequence.  The
@file{macedit} package (invoked by @kbd{Z E}) scans along the
macro and tries to decode it back into human-readable steps.
If a key or keys are simply shorthand for some command with a
@kbd{M-x} name, that name is shown.  Anything that doesn't correspond
to a @kbd{M-x} command is written as a @samp{type} command.

Let's edit in a new definition, for computing harmonic numbers.
First, erase the three lines of the old definition.  Then, type
in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
to copy it from this page of the Info file; you can skip typing
the comments that begin with @samp{#}).

@smallexample
calc-kbd-push         # Save local values (Z `)
type "0"              # Push a zero
calc-store-into       # Store it in variable 1
type "1"
type "1"              # Initial value for loop
calc-roll-down        # This is the TAB key; swap initial & final
calc-kbd-for          # Begin "for" loop...
calc-inv              #   Take reciprocal
calc-store-plus       #   Add to accumulator
type "1"
type "1"              #   Loop step is 1
calc-kbd-end-for      # End "for" loop
calc-recall           # Now recall final accumulated value
type "1"
calc-kbd-pop          # Restore values (Z ')
@end smallexample

@noindent
Press @kbd{M-# M-#} to finish editing and return to the Calculator.

@group
@smallexample
1:  20         1:  3.597739
    .              .

    20             z h
@end smallexample
@end group

If you don't know how to write a particular command in @file{macedit}
format, you can always write it as keystrokes in a @code{type} command.
There is also a @code{keys} command which interprets the rest of the
line as standard Emacs keystroke names.  In fact, @file{macedit} defines
a handy @code{read-kbd-macro} command which reads the current region
of the current buffer as a sequence of keystroke names, and defines that
sequence on the @kbd{X} (and @kbd{C-x e}) key.  Because this is so
useful, Calc puts this command on the @kbd{M-# m} key.  Try reading in
this macro in the following form:  Press @kbd{C-@@} (or @kbd{C-SPC}) at
one end of the text below, then type @kbd{M-# m} at the other.

@group
@example
Z ` 0 t 1
    1 TAB
    Z (  & s + 1  1 Z )
    r 1
Z '
@end example
@end group

(@bullet{}) @strong{Exercise 8.}  A general algorithm for solving
equations numerically is @dfn{Newton's Method}.  Given the equation
@cite{f(x) = 0} for any function @cite{f}, and an initial guess
@cite{x_0} which is reasonably close to the desired solution, apply
this formula over and over:

@ifnottex
@example
new_x = x - f(x)/f'(x)
@end example
@end ifnottex
@tex
\beforedisplay
$$ x_{\goodrm new} = x - {f(x) \over f'(x)} $$
\afterdisplay
@end tex

@noindent
where @cite{f'(x)} is the derivative of @cite{f}.  The @cite{x}
values will quickly converge to a solution, i.e., eventually
@c{$x_{\rm new}$}
@cite{new_x} and @cite{x} will be equal to within the limits
of the current precision.  Write a program which takes a formula
involving the variable @cite{x}, and an initial guess @cite{x_0},
on the stack, and produces a value of @cite{x} for which the formula
is zero.  Use it to find a solution of @c{$\sin(\cos x) = 0.5$}
@cite{sin(cos(x)) = 0.5}
near @cite{x = 4.5}.  (Use angles measured in radians.)  Note that
the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
method when it is able.  @xref{Programming Answer 8, 8}. (@bullet{})

@cindex Digamma function
@cindex Gamma constant, Euler's
@cindex Euler's gamma constant
(@bullet{}) @strong{Exercise 9.}  The @dfn{digamma} function @c{$\psi(z)$ (``psi'')}
@cite{psi(z)}
is defined as the derivative of @c{$\ln \Gamma(z)$}
@cite{ln(gamma(z))}.  For large
values of @cite{z}, it can be approximated by the infinite sum

@ifnottex
@example
psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
@end example
@end ifnottex
@tex
\let\rm\goodrm
\beforedisplay
$$ \psi(z) \approx \ln z - {1\over2z} -
   \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
$$
\afterdisplay
@end tex

@noindent
where @c{$\sum$}
@cite{sum} represents the sum over @cite{n} from 1 to infinity
(or to some limit high enough to give the desired accuracy), and
the @code{bern} function produces (exact) Bernoulli numbers.
While this sum is not guaranteed to converge, in practice it is safe.
An interesting mathematical constant is Euler's gamma, which is equal
to about 0.5772.  One way to compute it is by the formula,
@c{$\gamma = -\psi(1)$}
@cite{gamma = -psi(1)}.  Unfortunately, 1 isn't a large enough argument
for the above formula to work (5 is a much safer value for @cite{z}).
Fortunately, we can compute @c{$\psi(1)$}
@cite{psi(1)} from @c{$\psi(5)$}
@cite{psi(5)} using
the recurrence @c{$\psi(z+1) = \psi(z) + {1 \over z}$}
@cite{psi(z+1) = psi(z) + 1/z}.  Your task:  Develop
a program to compute @c{$\psi(z)$}
@cite{psi(z)}; it should ``pump up'' @cite{z}
if necessary to be greater than 5, then use the above summation
formula.  Use looping commands to compute the sum.  Use your function
to compute @c{$\gamma$}
@cite{gamma} to twelve decimal places.  (Calc has a built-in command
for Euler's constant, @kbd{I P}, which you can use to check your answer.)
@xref{Programming Answer 9, 9}. (@bullet{})

@cindex Polynomial, list of coefficients
(@bullet{}) @strong{Exercise 10.}  Given a polynomial in @cite{x} and
a number @cite{m} on the stack, where the polynomial is of degree
@cite{m} or less (i.e., does not have any terms higher than @cite{x^m}),
write a program to convert the polynomial into a list-of-coefficients
notation.  For example, @cite{5 x^4 + (x + 1)^2} with @cite{m = 6}
should produce the list @cite{[1, 2, 1, 0, 5, 0, 0]}.  Also develop
a way to convert from this form back to the standard algebraic form.
@xref{Programming Answer 10, 10}. (@bullet{})

@cindex Recursion
(@bullet{}) @strong{Exercise 11.}  The @dfn{Stirling numbers of the
first kind} are defined by the recurrences,

@ifnottex
@example
s(n,n) = 1   for n >= 0,
s(n,0) = 0   for n > 0,
s(n+1,m) = s(n,m-1) - n s(n,m)   for n >= m >= 1.
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ \eqalign{ s(n,n)   &= 1 \qquad \hbox{for } n \ge 0,  \cr
             s(n,0)   &= 0 \qquad \hbox{for } n > 0, \cr
             s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
                          \hbox{for } n \ge m \ge 1.}
$$
\afterdisplay
\vskip5pt
(These numbers are also sometimes written $\displaystyle{n \brack m}$.)
@end tex

This can be implemented using a @dfn{recursive} program in Calc; the
program must invoke itself in order to calculate the two righthand
terms in the general formula.  Since it always invokes itself with
``simpler'' arguments, it's easy to see that it must eventually finish
the computation.  Recursion is a little difficult with Emacs keyboard
macros since the macro is executed before its definition is complete.
So here's the recommended strategy:  Create a ``dummy macro'' and assign
it to a key with, e.g., @kbd{Z K s}.  Now enter the true definition,
using the @kbd{z s} command to call itself recursively, then assign it
to the same key with @kbd{Z K s}.  Now the @kbd{z s} command will run
the complete recursive program.  (Another way is to use @w{@kbd{Z E}}
or @kbd{M-# m} (@code{read-kbd-macro}) to read the whole macro at once,
thus avoiding the ``training'' phase.)  The task:  Write a program
that computes Stirling numbers of the first kind, given @cite{n} and
@cite{m} on the stack.  Test it with @emph{small} inputs like
@cite{s(4,2)}.  (There is a built-in command for Stirling numbers,
@kbd{k s}, which you can use to check your answers.)
@xref{Programming Answer 11, 11}. (@bullet{})

The programming commands we've seen in this part of the tutorial
are low-level, general-purpose operations.  Often you will find
that a higher-level function, such as vector mapping or rewrite
rules, will do the job much more easily than a detailed, step-by-step
program can:

(@bullet{}) @strong{Exercise 12.}  Write another program for
computing Stirling numbers of the first kind, this time using
rewrite rules.  Once again, @cite{n} and @cite{m} should be taken
from the stack.  @xref{Programming Answer 12, 12}. (@bullet{})

@example

@end example
This ends the tutorial section of the Calc manual.  Now you know enough
about Calc to use it effectively for many kinds of calculations.  But
Calc has many features that were not even touched upon in this tutorial.
@c [not-split]
The rest of this manual tells the whole story.
@c [when-split]
@c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.

@page
@node Answers to Exercises, , Programming Tutorial, Tutorial
@section Answers to Exercises

@noindent
This section includes answers to all the exercises in the Calc tutorial.

@menu
* RPN Answer 1::           1 RET 2 RET 3 RET 4 + * -
* RPN Answer 2::           2*4 + 7*9.5 + 5/4
* RPN Answer 3::           Operating on levels 2 and 3
* RPN Answer 4::           Joe's complex problems
* Algebraic Answer 1::     Simulating Q command
* Algebraic Answer 2::     Joe's algebraic woes
* Algebraic Answer 3::     1 / 0
* Modes Answer 1::         3#0.1 = 3#0.0222222?
* Modes Answer 2::         16#f.e8fe15
* Modes Answer 3::         Joe's rounding bug
* Modes Answer 4::         Why floating point?
* Arithmetic Answer 1::    Why the \ command?
* Arithmetic Answer 2::    Tripping up the B command
* Vector Answer 1::        Normalizing a vector
* Vector Answer 2::        Average position
* Matrix Answer 1::        Row and column sums
* Matrix Answer 2::        Symbolic system of equations
* Matrix Answer 3::        Over-determined system
* List Answer 1::          Powers of two
* List Answer 2::          Least-squares fit with matrices
* List Answer 3::          Geometric mean
* List Answer 4::          Divisor function
* List Answer 5::          Duplicate factors
* List Answer 6::          Triangular list
* List Answer 7::          Another triangular list
* List Answer 8::          Maximum of Bessel function
* List Answer 9::          Integers the hard way
* List Answer 10::         All elements equal
* List Answer 11::         Estimating pi with darts
* List Answer 12::         Estimating pi with matchsticks
* List Answer 13::         Hash codes
* List Answer 14::         Random walk
* Types Answer 1::         Square root of pi times rational
* Types Answer 2::         Infinities
* Types Answer 3::         What can "nan" be?
* Types Answer 4::         Abbey Road
* Types Answer 5::         Friday the 13th
* Types Answer 6::         Leap years
* Types Answer 7::         Erroneous donut
* Types Answer 8::         Dividing intervals
* Types Answer 9::         Squaring intervals
* Types Answer 10::        Fermat's primality test
* Types Answer 11::        pi * 10^7 seconds
* Types Answer 12::        Abbey Road on CD
* Types Answer 13::        Not quite pi * 10^7 seconds
* Types Answer 14::        Supercomputers and c
* Types Answer 15::        Sam the Slug
* Algebra Answer 1::       Squares and square roots
* Algebra Answer 2::       Building polynomial from roots
* Algebra Answer 3::       Integral of x sin(pi x)
* Algebra Answer 4::       Simpson's rule
* Rewrites Answer 1::      Multiplying by conjugate
* Rewrites Answer 2::      Alternative fib rule
* Rewrites Answer 3::      Rewriting opt(a) + opt(b) x
* Rewrites Answer 4::      Sequence of integers
* Rewrites Answer 5::      Number of terms in sum
* Rewrites Answer 6::      Defining 0^0 = 1
* Rewrites Answer 7::      Truncated Taylor series
* Programming Answer 1::   Fresnel's C(x)
* Programming Answer 2::   Negate third stack element
* Programming Answer 3::   Compute sin(x) / x, etc.
* Programming Answer 4::   Average value of a list
* Programming Answer 5::   Continued fraction phi
* Programming Answer 6::   Matrix Fibonacci numbers
* Programming Answer 7::   Harmonic number greater than 4
* Programming Answer 8::   Newton's method
* Programming Answer 9::   Digamma function
* Programming Answer 10::  Unpacking a polynomial
* Programming Answer 11::  Recursive Stirling numbers
* Programming Answer 12::  Stirling numbers with rewrites
@end menu

@c The following kludgery prevents the individual answers from
@c being entered on the table of contents.
@tex
\global\let\oldwrite=\write
\gdef\skipwrite#1#2{\let\write=\oldwrite}
\global\let\oldchapternofonts=\chapternofonts
\gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
@end tex

@node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
@subsection RPN Tutorial Exercise 1

@noindent
@kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}

The result is @c{$1 - (2 \times (3 + 4)) = -13$}
@cite{1 - (2 * (3 + 4)) = -13}.

@node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
@subsection RPN Tutorial Exercise 2

@noindent
@c{$2\times4 + 7\times9.5 + {5\over4} = 75.75$}
@cite{2*4 + 7*9.5 + 5/4 = 75.75}

After computing the intermediate term @c{$2\times4 = 8$}
@cite{2*4 = 8}, you can leave
that result on the stack while you compute the second term.  With
both of these results waiting on the stack you can then compute the
final term, then press @kbd{+ +} to add everything up.

@group
@smallexample
2:  2          1:  8          3:  8          2:  8
1:  4              .          2:  7          1:  66.5
    .                         1:  9.5            .
                                  .

  2 RET 4          *          7 RET 9.5          *

@end smallexample
@end group
@noindent
@group
@smallexample
4:  8          3:  8          2:  8          1:  75.75
3:  66.5       2:  66.5       1:  67.75          .
2:  5          1:  1.25           .
1:  4              .
    .

  5 RET 4          /              +              +
@end smallexample
@end group

Alternatively, you could add the first two terms before going on
with the third term.

@group
@smallexample
2:  8          1:  74.5       3:  74.5       2:  74.5       1:  75.75
1:  66.5           .          2:  5          1:  1.25           .
    .                         1:  4              .
                                  .

   ...             +            5 RET 4          /              +
@end smallexample
@end group

On an old-style RPN calculator this second method would have the
advantage of using only three stack levels.  But since Calc's stack
can grow arbitrarily large this isn't really an issue.  Which method
you choose is purely a matter of taste.

@node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
@subsection RPN Tutorial Exercise 3

@noindent
The @key{TAB} key provides a way to operate on the number in level 2.

@group
@smallexample
3:  10         3:  10         4:  10         3:  10         3:  10
2:  20         2:  30         3:  30         2:  30         2:  21
1:  30         1:  20         2:  20         1:  21         1:  30
    .              .          1:  1              .              .
                                  .

                  TAB             1              +             TAB
@end smallexample
@end group

Similarly, @key{M-TAB} gives you access to the number in level 3.

@group
@smallexample
3:  10         3:  21         3:  21         3:  30         3:  11
2:  21         2:  30         2:  30         2:  11         2:  21
1:  30         1:  10         1:  11         1:  21         1:  30
    .              .              .              .              .

                  M-TAB           1 +           M-TAB          M-TAB
@end smallexample
@end group

@node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
@subsection RPN Tutorial Exercise 4

@noindent
Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
but using both the comma and the space at once yields:

@group
@smallexample
1:  ( ...      2:  ( ...      1:  (2, ...    2:  (2, ...    2:  (2, ...
    .          1:  2              .          1:  (2, ...    1:  (2, 3)
                   .                             .              .

    (              2              ,             SPC            3 )
@end smallexample
@end group

Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
extra incomplete object to the top of the stack and delete it.
But a feature of Calc is that @key{DEL} on an incomplete object
deletes just one component out of that object, so he had to press
@key{DEL} twice to finish the job.

@group
@smallexample
2:  (2, ...    2:  (2, 3)     2:  (2, 3)     1:  (2, 3)
1:  (2, 3)     1:  (2, ...    1:  ( ...          .
    .              .              .

                  TAB            DEL            DEL
@end smallexample
@end group

(As it turns out, deleting the second-to-top stack entry happens often
enough that Calc provides a special key, @kbd{M-DEL}, to do just that.
@kbd{M-DEL} is just like @kbd{TAB DEL}, except that it doesn't exhibit
the ``feature'' that tripped poor Joe.)

@node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
@subsection Algebraic Entry Tutorial Exercise 1

@noindent
Type @kbd{' sqrt($) @key{RET}}.

If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
Or, RPN style, @kbd{0.5 ^}.

(Actually, @samp{$^1:2}, using the fraction one-half as the power, is
a closer equivalent, since @samp{9^0.5} yields @cite{3.0} whereas
@samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @cite{3}.)

@node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
@subsection Algebraic Entry Tutorial Exercise 2

@noindent
In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
name with @samp{1+y} as its argument.  Assigning a value to a variable
has no relation to a function by the same name.  Joe needed to use an
explicit @samp{*} symbol here:  @samp{2 x*(1+y)}.

@node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
@subsection Algebraic Entry Tutorial Exercise 3

@noindent
The result from @kbd{1 @key{RET} 0 /} will be the formula @cite{1 / 0}.
The ``function'' @samp{/} cannot be evaluated when its second argument
is zero, so it is left in symbolic form.  When you now type @kbd{0 *},
the result will be zero because Calc uses the general rule that ``zero
times anything is zero.''

@c [fix-ref Infinities]
The @kbd{m i} command enables an @dfn{infinite mode} in which @cite{1 / 0}
results in a special symbol that represents ``infinity.''  If you
multiply infinity by zero, Calc uses another special new symbol to
show that the answer is ``indeterminate.''  @xref{Infinities}, for
further discussion of infinite and indeterminate values.

@node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
@subsection Modes Tutorial Exercise 1

@noindent
Calc always stores its numbers in decimal, so even though one-third has
an exact base-3 representation (@samp{3#0.1}), it is still stored as
0.3333333 (chopped off after 12 or however many decimal digits) inside
the calculator's memory.  When this inexact number is converted back
to base 3 for display, it may still be slightly inexact.  When we
multiply this number by 3, we get 0.999999, also an inexact value.

When Calc displays a number in base 3, it has to decide how many digits
to show.  If the current precision is 12 (decimal) digits, that corresponds
to @samp{12 / log10(3) = 25.15} base-3 digits.  Because 25.15 is not an
exact integer, Calc shows only 25 digits, with the result that stored
numbers carry a little bit of extra information that may not show up on
the screen.  When Joe entered @samp{3#0.2}, the stored number 0.666666
happened to round to a pleasing value when it lost that last 0.15 of a
digit, but it was still inexact in Calc's memory.  When he divided by 2,
he still got the dreaded inexact value 0.333333.  (Actually, he divided
0.666667 by 2 to get 0.333334, which is why he got something a little
higher than @code{3#0.1} instead of a little lower.)

If Joe didn't want to be bothered with all this, he could have typed
@kbd{M-24 d n} to display with one less digit than the default.  (If
you give @kbd{d n} a negative argument, it uses default-minus-that,
so @kbd{M-- d n} would be an easier way to get the same effect.)  Those
inexact results would still be lurking there, but they would now be
rounded to nice, natural-looking values for display purposes.  (Remember,
@samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
off one digit will round the number up to @samp{0.1}.)  Depending on the
nature of your work, this hiding of the inexactness may be a benefit or
a danger.  With the @kbd{d n} command, Calc gives you the choice.

Incidentally, another consequence of all this is that if you type
@kbd{M-30 d n} to display more digits than are ``really there,''
you'll see garbage digits at the end of the number.  (In decimal
display mode, with decimally-stored numbers, these garbage digits are
always zero so they vanish and you don't notice them.)  Because Calc
rounds off that 0.15 digit, there is the danger that two numbers could
be slightly different internally but still look the same.  If you feel
uneasy about this, set the @kbd{d n} precision to be a little higher
than normal; you'll get ugly garbage digits, but you'll always be able
to tell two distinct numbers apart.

An interesting side note is that most computers store their
floating-point numbers in binary, and convert to decimal for display.
Thus everyday programs have the same problem:  Decimal 0.1 cannot be
represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
comes out as an inexact approximation to 1 on some machines (though
they generally arrange to hide it from you by rounding off one digit as
we did above).  Because Calc works in decimal instead of binary, you can
be sure that numbers that look exact @emph{are} exact as long as you stay
in decimal display mode.

It's not hard to show that any number that can be represented exactly
in binary, octal, or hexadecimal is also exact in decimal, so the kinds
of problems we saw in this exercise are likely to be severe only when
you use a relatively unusual radix like 3.

@node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
@subsection Modes Tutorial Exercise 2

If the radix is 15 or higher, we can't use the letter @samp{e} to mark
the exponent because @samp{e} is interpreted as a digit.  When Calc
needs to display scientific notation in a high radix, it writes
@samp{16#F.E8F*16.^15}.  You can enter a number like this as an
algebraic entry.  Also, pressing @kbd{e} without any digits before it
normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
puts you in algebraic entry:  @kbd{16#f.e8f RET e 15 RET *} is another
way to enter this number.

The reason Calc puts a decimal point in the @samp{16.^} is to prevent
huge integers from being generated if the exponent is large (consider
@samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
exact integer and then throw away most of the digits when we multiply
it by the floating-point @samp{16#1.23}).  While this wouldn't normally
matter for display purposes, it could give you a nasty surprise if you
copied that number into a file and later moved it back into Calc.

@node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
@subsection Modes Tutorial Exercise 3

@noindent
The answer he got was @cite{0.5000000000006399}.

The problem is not that the square operation is inexact, but that the
sine of 45 that was already on the stack was accurate to only 12 places.
Arbitrary-precision calculations still only give answers as good as
their inputs.

The real problem is that there is no 12-digit number which, when
squared, comes out to 0.5 exactly.  The @kbd{f [} and @kbd{f ]}
commands decrease or increase a number by one unit in the last
place (according to the current precision).  They are useful for
determining facts like this.

@group
@smallexample
1:  0.707106781187      1:  0.500000000001
    .                       .

    45 S                    2 ^

@end smallexample
@end group
@noindent
@group
@smallexample
1:  0.707106781187      1:  0.707106781186      1:  0.499999999999
    .                       .                       .

    U  DEL                  f [                     2 ^
@end smallexample
@end group

A high-precision calculation must be carried out in high precision
all the way.  The only number in the original problem which was known
exactly was the quantity 45 degrees, so the precision must be raised
before anything is done after the number 45 has been entered in order
for the higher precision to be meaningful.

@node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
@subsection Modes Tutorial Exercise 4

@noindent
Many calculations involve real-world quantities, like the width and
height of a piece of wood or the volume of a jar.  Such quantities
can't be measured exactly anyway, and if the data that is input to
a calculation is inexact, doing exact arithmetic on it is a waste
of time.

Fractions become unwieldy after too many calculations have been
done with them.  For example, the sum of the reciprocals of the
integers from 1 to 10 is 7381:2520.  The sum from 1 to 30 is
9304682830147:2329089562800.  After a point it will take a long
time to add even one more term to this sum, but a floating-point
calculation of the sum will not have this problem.

Also, rational numbers cannot express the results of all calculations.
There is no fractional form for the square root of two, so if you type
@w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.

@node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
@subsection Arithmetic Tutorial Exercise 1

@noindent
Dividing two integers that are larger than the current precision may
give a floating-point result that is inaccurate even when rounded
down to an integer.  Consider @cite{123456789 / 2} when the current
precision is 6 digits.  The true answer is @cite{61728394.5}, but
with a precision of 6 this will be rounded to @c{$12345700.0/2.0 = 61728500.0$}
@cite{12345700.@: / 2.@: = 61728500.}.
The result, when converted to an integer, will be off by 106.

Here are two solutions:  Raise the precision enough that the
floating-point round-off error is strictly to the right of the
decimal point.  Or, convert to fraction mode so that @cite{123456789 / 2}
produces the exact fraction @cite{123456789:2}, which can be rounded
down by the @kbd{F} command without ever switching to floating-point
format.

@node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
@subsection Arithmetic Tutorial Exercise 2

@noindent
@kbd{27 @key{RET} 9 B} could give the exact result @cite{3:2}, but it
does a floating-point calculation instead and produces @cite{1.5}.

Calc will find an exact result for a logarithm if the result is an integer
or the reciprocal of an integer.  But there is no efficient way to search
the space of all possible rational numbers for an exact answer, so Calc
doesn't try.

@node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
@subsection Vector Tutorial Exercise 1

@noindent
Duplicate the vector, compute its length, then divide the vector
by its length:  @kbd{@key{RET} A /}.

@group
@smallexample
1:  [1, 2, 3]  2:  [1, 2, 3]      1:  [0.27, 0.53, 0.80]  1:  1.
    .          1:  3.74165738677      .                       .
                   .

    r 1            RET A              /                       A
@end smallexample
@end group

The final @kbd{A} command shows that the normalized vector does
indeed have unit length.

@node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
@subsection Vector Tutorial Exercise 2

@noindent
The average position is equal to the sum of the products of the
positions times their corresponding probabilities.  This is the
definition of the dot product operation.  So all you need to do
is to put the two vectors on the stack and press @kbd{*}.

@node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
@subsection Matrix Tutorial Exercise 1

@noindent
The trick is to multiply by a vector of ones.  Use @kbd{r 4 [1 1 1] *} to
get the row sum.  Similarly, use @kbd{[1 1] r 4 *} to get the column sum.

@node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
@subsection Matrix Tutorial Exercise 2

@ifnottex
@group
@example
   x + a y = 6
   x + b y = 10
@end example
@end group
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ \eqalign{ x &+ a y = 6 \cr
             x &+ b y = 10}
$$
\afterdisplay
@end tex

Just enter the righthand side vector, then divide by the lefthand side
matrix as usual.

@group
@smallexample
1:  [6, 10]    2:  [6, 10]         1:  [6 - 4 a / (b - a), 4 / (b - a) ]
    .          1:  [ [ 1, a ]          .
                     [ 1, b ] ]
                   .

' [6 10] RET     ' [1 a; 1 b] RET      /
@end smallexample
@end group

This can be made more readable using @kbd{d B} to enable ``big'' display
mode:

@group
@smallexample
          4 a     4
1:  [6 - -----, -----]
         b - a  b - a
@end smallexample
@end group

Type @kbd{d N} to return to ``normal'' display mode afterwards.

@node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
@subsection Matrix Tutorial Exercise 3

@noindent
To solve @c{$A^T A \, X = A^T B$}
@cite{trn(A) * A * X = trn(A) * B}, first we compute
@c{$A' = A^T A$}
@cite{A2 = trn(A) * A} and @c{$B' = A^T B$}
@cite{B2 = trn(A) * B}; now, we have a
system @c{$A' X = B'$}
@cite{A2 * X = B2} which we can solve using Calc's @samp{/}
command.

@ifnottex
@group
@example
    a + 2b + 3c = 6
   4a + 5b + 6c = 2
   7a + 6b      = 3
   2a + 4b + 6c = 11
@end example
@end group
@end ifnottex
@tex
\turnoffactive
\beforedisplayh
$$ \openup1\jot \tabskip=0pt plus1fil
\halign to\displaywidth{\tabskip=0pt
   $\hfil#$&$\hfil{}#{}$&
   $\hfil#$&$\hfil{}#{}$&
   $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
  a&+&2b&+&3c&=6 \cr
 4a&+&5b&+&6c&=2 \cr
 7a&+&6b& &  &=3 \cr
 2a&+&4b&+&6c&=11 \cr}
$$
\afterdisplayh
@end tex

The first step is to enter the coefficient matrix.  We'll store it in
quick variable number 7 for later reference.  Next, we compute the
@c{$B'$}
@cite{B2} vector.

@group
@smallexample
1:  [ [ 1, 2, 3 ]             2:  [ [ 1, 4, 7, 2 ]     1:  [57, 84, 96]
      [ 4, 5, 6 ]                   [ 2, 5, 6, 4 ]         .
      [ 7, 6, 0 ]                   [ 3, 6, 0, 6 ] ]
      [ 2, 4, 6 ] ]           1:  [6, 2, 3, 11]
    .                             .

' [1 2 3; 4 5 6; 7 6 0; 2 4 6] RET  s 7  v t  [6 2 3 11]   *
@end smallexample
@end group

@noindent
Now we compute the matrix @c{$A'$}
@cite{A2} and divide.

@group
@smallexample
2:  [57, 84, 96]          1:  [-11.64, 14.08, -3.64]
1:  [ [ 70, 72, 39 ]          .
      [ 72, 81, 60 ]
      [ 39, 60, 81 ] ]
    .

    r 7 v t r 7 *             /
@end smallexample
@end group

@noindent
(The actual computed answer will be slightly inexact due to
round-off error.)

Notice that the answers are similar to those for the @c{$3\times3$}
@asis{3x3} system
solved in the text.  That's because the fourth equation that was
added to the system is almost identical to the first one multiplied
by two.  (If it were identical, we would have gotten the exact same
answer since the @c{$4\times3$}
@asis{4x3} system would be equivalent to the original @c{$3\times3$}
@asis{3x3}
system.)

Since the first and fourth equations aren't quite equivalent, they
can't both be satisfied at once.  Let's plug our answers back into
the original system of equations to see how well they match.

@group
@smallexample
2:  [-11.64, 14.08, -3.64]     1:  [5.6, 2., 3., 11.2]
1:  [ [ 1, 2, 3 ]                  .
      [ 4, 5, 6 ]
      [ 7, 6, 0 ]
      [ 2, 4, 6 ] ]
    .

    r 7                            TAB *
@end smallexample
@end group

@noindent
This is reasonably close to our original @cite{B} vector,
@cite{[6, 2, 3, 11]}.

@node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
@subsection List Tutorial Exercise 1

@noindent
We can use @kbd{v x} to build a vector of integers.  This needs to be
adjusted to get the range of integers we desire.  Mapping @samp{-}
across the vector will accomplish this, although it turns out the
plain @samp{-} key will work just as well.

@group
@smallexample
2:  2                              2:  2
1:  [1, 2, 3, 4, 5, 6, 7, 8, 9]    1:  [-4, -3, -2, -1, 0, 1, 2, 3, 4]
    .                                  .

    2  v x 9 RET                       5 V M -   or   5 -
@end smallexample
@end group

@noindent
Now we use @kbd{V M ^} to map the exponentiation operator across the
vector.

@group
@smallexample
1:  [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
    .

    V M ^
@end smallexample
@end group

@node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
@subsection List Tutorial Exercise 2

@noindent
Given @cite{x} and @cite{y} vectors in quick variables 1 and 2 as before,
the first job is to form the matrix that describes the problem.

@ifnottex
@example
   m*x + b*1 = y
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ m \times x + b \times 1 = y $$
\afterdisplay
@end tex

Thus we want a @c{$19\times2$}
@asis{19x2} matrix with our @cite{x} vector as one column and
ones as the other column.  So, first we build the column of ones, then
we combine the two columns to form our @cite{A} matrix.

@group
@smallexample
2:  [1.34, 1.41, 1.49, ... ]    1:  [ [ 1.34, 1 ]
1:  [1, 1, 1, ...]                    [ 1.41, 1 ]
    .                                 [ 1.49, 1 ]
                                      @dots{}

    r 1 1 v b 19 RET                M-2 v p v t   s 3
@end smallexample
@end group

@noindent
Now we compute @c{$A^T y$}
@cite{trn(A) * y} and @c{$A^T A$}
@cite{trn(A) * A} and divide.

@group
@smallexample
1:  [33.36554, 13.613]    2:  [33.36554, 13.613]
    .                     1:  [ [ 98.0003, 41.63 ]
                                [  41.63,   19   ] ]
                              .

 v t r 2 *                    r 3 v t r 3 *
@end smallexample
@end group

@noindent
(Hey, those numbers look familiar!)

@group
@smallexample
1:  [0.52141679, -0.425978]
    .

    /
@end smallexample
@end group

Since we were solving equations of the form @c{$m \times x + b \times 1 = y$}
@cite{m*x + b*1 = y}, these
numbers should be @cite{m} and @cite{b}, respectively.  Sure enough, they
agree exactly with the result computed using @kbd{V M} and @kbd{V R}!

The moral of this story:  @kbd{V M} and @kbd{V R} will probably solve
your problem, but there is often an easier way using the higher-level
arithmetic functions!

@c [fix-ref Curve Fitting]
In fact, there is a built-in @kbd{a F} command that does least-squares
fits.  @xref{Curve Fitting}.

@node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
@subsection List Tutorial Exercise 3

@noindent
Move to one end of the list and press @kbd{C-@@} (or @kbd{C-SPC} or
whatever) to set the mark, then move to the other end of the list
and type @w{@kbd{M-# g}}.

@group
@smallexample
1:  [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
    .
@end smallexample
@end group

To make things interesting, let's assume we don't know at a glance
how many numbers are in this list.  Then we could type:

@group
@smallexample
2:  [2.3, 6, 22, ... ]     2:  [2.3, 6, 22, ... ]
1:  [2.3, 6, 22, ... ]     1:  126356422.5
    .                          .

    RET                        V R *

@end smallexample
@end group
@noindent
@group
@smallexample
2:  126356422.5            2:  126356422.5     1:  7.94652913734
1:  [2.3, 6, 22, ... ]     1:  9                   .
    .                          .

    TAB                        v l                 I ^
@end smallexample
@end group

@noindent
(The @kbd{I ^} command computes the @var{n}th root of a number.
You could also type @kbd{& ^} to take the reciprocal of 9 and
then raise the number to that power.)

@node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
@subsection List Tutorial Exercise 4

@noindent
A number @cite{j} is a divisor of @cite{n} if @c{$n \mathbin{\hbox{\code{\%}}} j = 0$}
@samp{n % j = 0}.  The first
step is to get a vector that identifies the divisors.

@group
@smallexample
2:  30                  2:  [0, 0, 0, 2, ...]    1:  [1, 1, 1, 0, ...]
1:  [1, 2, 3, 4, ...]   1:  0                        .
    .                       .

 30 RET v x 30 RET   s 1    V M %  0                 V M a =  s 2
@end smallexample
@end group

@noindent
This vector has 1's marking divisors of 30 and 0's marking non-divisors.

The zeroth divisor function is just the total number of divisors.
The first divisor function is the sum of the divisors.

@group
@smallexample
1:  8      3:  8                    2:  8                    2:  8
           2:  [1, 2, 3, 4, ...]    1:  [1, 2, 3, 0, ...]    1:  72
           1:  [1, 1, 1, 0, ...]        .                        .
               .

   V R +       r 1 r 2                  V M *                  V R +
@end smallexample
@end group

@noindent
Once again, the last two steps just compute a dot product for which
a simple @kbd{*} would have worked equally well.

@node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
@subsection List Tutorial Exercise 5

@noindent
The obvious first step is to obtain the list of factors with @kbd{k f}.
This list will always be in sorted order, so if there are duplicates
they will be right next to each other.  A suitable method is to compare
the list with a copy of itself shifted over by one.

@group
@smallexample
1:  [3, 7, 7, 7, 19]   2:  [3, 7, 7, 7, 19]     2:  [3, 7, 7, 7, 19, 0]
    .                  1:  [3, 7, 7, 7, 19, 0]  1:  [0, 3, 7, 7, 7, 19]
                           .                        .

    19551 k f              RET 0 |                  TAB 0 TAB |

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [0, 0, 1, 1, 0, 0]   1:  2          1:  0
    .                        .              .

    V M a =                  V R +          0 a =
@end smallexample
@end group

@noindent
Note that we have to arrange for both vectors to have the same length
so that the mapping operation works; no prime factor will ever be
zero, so adding zeros on the left and right is safe.  From then on
the job is pretty straightforward.

Incidentally, Calc provides the @c{\dfn{M\"obius} $\mu$}
@dfn{Moebius mu} function which is
zero if and only if its argument is square-free.  It would be a much
more convenient way to do the above test in practice.

@node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
@subsection List Tutorial Exercise 6

@noindent
First use @kbd{v x 6 RET} to get a list of integers, then @kbd{V M v x}
to get a list of lists of integers!

@node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
@subsection List Tutorial Exercise 7

@noindent
Here's one solution.  First, compute the triangular list from the previous
exercise and type @kbd{1 -} to subtract one from all the elements.

@group
@smallexample
1:  [ [0],
      [0, 1],
      [0, 1, 2],
      @dots{}

    1 -
@end smallexample
@end group

The numbers down the lefthand edge of the list we desire are called
the ``triangular numbers'' (now you know why!).  The @cite{n}th
triangular number is the sum of the integers from 1 to @cite{n}, and
can be computed directly by the formula @c{$n (n+1) \over 2$}
@cite{n * (n+1) / 2}.

@group
@smallexample
2:  [ [0], [0, 1], ... ]    2:  [ [0], [0, 1], ... ]
1:  [0, 1, 2, 3, 4, 5]      1:  [0, 1, 3, 6, 10, 15]
    .                           .

    v x 6 RET 1 -               V M ' $ ($+1)/2 RET
@end smallexample
@end group

@noindent
Adding this list to the above list of lists produces the desired
result:

@group
@smallexample
1:  [ [0],
      [1, 2],
      [3, 4, 5],
      [6, 7, 8, 9],
      [10, 11, 12, 13, 14],
      [15, 16, 17, 18, 19, 20] ]
      .

      V M +
@end smallexample
@end group

If we did not know the formula for triangular numbers, we could have
computed them using a @kbd{V U +} command.  We could also have
gotten them the hard way by mapping a reduction across the original
triangular list.

@group
@smallexample
2:  [ [0], [0, 1], ... ]    2:  [ [0], [0, 1], ... ]
1:  [ [0], [0, 1], ... ]    1:  [0, 1, 3, 6, 10, 15]
    .                           .

    RET                         V M V R +
@end smallexample
@end group

@noindent
(This means ``map a @kbd{V R +} command across the vector,'' and
since each element of the main vector is itself a small vector,
@kbd{V R +} computes the sum of its elements.)

@node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
@subsection List Tutorial Exercise 8

@noindent
The first step is to build a list of values of @cite{x}.

@group
@smallexample
1:  [1, 2, 3, ..., 21]  1:  [0, 1, 2, ..., 20]  1:  [0, 0.25, 0.5, ..., 5]
    .                       .                       .

    v x 21 RET              1 -                     4 /  s 1
@end smallexample
@end group

Next, we compute the Bessel function values.

@group
@smallexample
1:  [0., 0.124, 0.242, ..., -0.328]
    .

    V M ' besJ(1,$) RET
@end smallexample
@end group

@noindent
(Another way to do this would be @kbd{1 TAB V M f j}.)

A way to isolate the maximum value is to compute the maximum using
@kbd{V R X}, then compare all the Bessel values with that maximum.

@group
@smallexample
2:  [0., 0.124, 0.242, ... ]   1:  [0, 0, 0, ... ]    2:  [0, 0, 0, ... ]
1:  0.5801562                      .                  1:  1
    .                                                     .

    RET V R X                      V M a =                RET V R +    DEL
@end smallexample
@end group

@noindent
It's a good idea to verify, as in the last step above, that only
one value is equal to the maximum.  (After all, a plot of @c{$\sin x$}
@cite{sin(x)}
might have many points all equal to the maximum value, 1.)

The vector we have now has a single 1 in the position that indicates
the maximum value of @cite{x}.  Now it is a simple matter to convert
this back into the corresponding value itself.

@group
@smallexample
2:  [0, 0, 0, ... ]         1:  [0, 0., 0., ... ]    1:  1.75
1:  [0, 0.25, 0.5, ... ]        .                        .
    .

    r 1                         V M *                    V R +
@end smallexample
@end group

If @kbd{a =} had produced more than one @cite{1} value, this method
would have given the sum of all maximum @cite{x} values; not very
useful!  In this case we could have used @kbd{v m} (@code{calc-mask-vector})
instead.  This command deletes all elements of a ``data'' vector that
correspond to zeros in a ``mask'' vector, leaving us with, in this
example, a vector of maximum @cite{x} values.

The built-in @kbd{a X} command maximizes a function using more
efficient methods.  Just for illustration, let's use @kbd{a X}
to maximize @samp{besJ(1,x)} over this same interval.

@group
@smallexample
2:  besJ(1, x)                 1:  [1.84115, 0.581865]
1:  [0 .. 5]                       .
    .

' besJ(1,x), [0..5] RET            a X x RET
@end smallexample
@end group

@noindent
The output from @kbd{a X} is a vector containing the value of @cite{x}
that maximizes the function, and the function's value at that maximum.
As you can see, our simple search got quite close to the right answer.

@node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
@subsection List Tutorial Exercise 9

@noindent
Step one is to convert our integer into vector notation.

@group
@smallexample
1:  25129925999           3:  25129925999
    .                     2:  10
                          1:  [11, 10, 9, ..., 1, 0]
                              .

    25129925999 RET           10 RET 12 RET v x 12 RET -

@end smallexample
@end group
@noindent
@group
@smallexample
1:  25129925999              1:  [0, 2, 25, 251, 2512, ... ]
2:  [100000000000, ... ]         .
    .

    V M ^   s 1                  V M \
@end smallexample
@end group

@noindent
(Recall, the @kbd{\} command computes an integer quotient.)

@group
@smallexample
1:  [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
    .

    10 V M %   s 2
@end smallexample
@end group

Next we must increment this number.  This involves adding one to
the last digit, plus handling carries.  There is a carry to the
left out of a digit if that digit is a nine and all the digits to
the right of it are nines.

@group
@smallexample
1:  [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1]   1:  [1, 1, 1, 0, 0, 1, ... ]
    .                                          .

    9 V M a =                                  v v

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [1, 1, 1, 0, 0, 0, ... ]   1:  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
    .                              .

    V U *                          v v 1 |
@end smallexample
@end group

@noindent
Accumulating @kbd{*} across a vector of ones and zeros will preserve
only the initial run of ones.  These are the carries into all digits
except the rightmost digit.  Concatenating a one on the right takes
care of aligning the carries properly, and also adding one to the
rightmost digit.

@group
@smallexample
2:  [0, 0, 0, 0, ... ]     1:  [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
1:  [0, 0, 2, 5, ... ]         .
    .

    0 r 2 |                    V M +  10 V M %
@end smallexample
@end group

@noindent
Here we have concatenated 0 to the @emph{left} of the original number;
this takes care of shifting the carries by one with respect to the
digits that generated them.

Finally, we must convert this list back into an integer.

@group
@smallexample
3:  [0, 0, 2, 5, ... ]        2:  [0, 0, 2, 5, ... ]
2:  1000000000000             1:  [1000000000000, 100000000000, ... ]
1:  [100000000000, ... ]          .
    .

    10 RET 12 ^  r 1              |

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [0, 0, 20000000000, 5000000000, ... ]    1:  25129926000
    .                                            .

    V M *                                        V R +
@end smallexample
@end group

@noindent
Another way to do this final step would be to reduce the formula
@w{@samp{10 $$ + $}} across the vector of digits.

@group
@smallexample
1:  [0, 0, 2, 5, ... ]        1:  25129926000
    .                             .

                                  V R ' 10 $$ + $ RET
@end smallexample
@end group

@node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
@subsection List Tutorial Exercise 10

@noindent
For the list @cite{[a, b, c, d]}, the result is @cite{((a = b) = c) = d},
which will compare @cite{a} and @cite{b} to produce a 1 or 0, which is
then compared with @cite{c} to produce another 1 or 0, which is then
compared with @cite{d}.  This is not at all what Joe wanted.

Here's a more correct method:

@group
@smallexample
1:  [7, 7, 7, 8, 7]      2:  [7, 7, 7, 8, 7]
    .                    1:  7
                             .

  ' [7,7,7,8,7] RET          RET v r 1 RET

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [1, 1, 1, 0, 1]      1:  0
    .                        .

    V M a =                  V R *
@end smallexample
@end group

@node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
@subsection List Tutorial Exercise 11

@noindent
The circle of unit radius consists of those points @cite{(x,y)} for which
@cite{x^2 + y^2 < 1}.  We start by generating a vector of @cite{x^2}
and a vector of @cite{y^2}.

We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
commands.

@group
@smallexample
2:  [2., 2., ..., 2.]          2:  [2., 2., ..., 2.]
1:  [2., 2., ..., 2.]          1:  [1.16, 1.98, ..., 0.81]
    .                              .

 v . t .  2. v b 100 RET RET       V M k r

@end smallexample
@end group
@noindent
@group
@smallexample
2:  [2., 2., ..., 2.]          1:  [0.026, 0.96, ..., 0.036]
1:  [0.026, 0.96, ..., 0.036]  2:  [0.53, 0.81, ..., 0.094]
    .                              .

    1 -  2 V M ^                   TAB  V M k r  1 -  2 V M ^
@end smallexample
@end group

Now we sum the @cite{x^2} and @cite{y^2} values, compare with 1 to
get a vector of 1/0 truth values, then sum the truth values.

@group
@smallexample
1:  [0.56, 1.78, ..., 0.13]    1:  [1, 0, ..., 1]    1:  84
    .                              .                     .

    +                              1 V M a <             V R +
@end smallexample
@end group

@noindent
The ratio @cite{84/100} should approximate the ratio @c{$\pi/4$}
@cite{pi/4}.

@group
@smallexample
1:  0.84       1:  3.36       2:  3.36       1:  1.0695
    .              .          1:  3.14159        .

    100 /          4 *            P              /
@end smallexample
@end group

@noindent
Our estimate, 3.36, is off by about 7%.  We could get a better estimate
by taking more points (say, 1000), but it's clear that this method is
not very efficient!

(Naturally, since this example uses random numbers your own answer
will be slightly different from the one shown here!)

If you typed @kbd{v .} and @kbd{t .} before, type them again to
return to full-sized display of vectors.

@node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
@subsection List Tutorial Exercise 12

@noindent
This problem can be made a lot easier by taking advantage of some
symmetries.  First of all, after some thought it's clear that the
@cite{y} axis can be ignored altogether.  Just pick a random @cite{x}
component for one end of the match, pick a random direction @c{$\theta$}
@cite{theta},
and see if @cite{x} and @c{$x + \cos \theta$}
@cite{x + cos(theta)} (which is the @cite{x}
coordinate of the other endpoint) cross a line.  The lines are at
integer coordinates, so this happens when the two numbers surround
an integer.

Since the two endpoints are equivalent, we may as well choose the leftmost
of the two endpoints as @cite{x}.  Then @cite{theta} is an angle pointing
to the right, in the range -90 to 90 degrees.  (We could use radians, but
it would feel like cheating to refer to @c{$\pi/2$}
@cite{pi/2} radians while trying
to estimate @c{$\pi$}
@cite{pi}!)

In fact, since the field of lines is infinite we can choose the
coordinates 0 and 1 for the lines on either side of the leftmost
endpoint.  The rightmost endpoint will be between 0 and 1 if the
match does not cross a line, or between 1 and 2 if it does.  So:
Pick random @cite{x} and @c{$\theta$}
@cite{theta}, compute @c{$x + \cos \theta$}
@cite{x + cos(theta)},
and count how many of the results are greater than one.  Simple!

We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
commands.

@group
@smallexample
1:  [0.52, 0.71, ..., 0.72]    2:  [0.52, 0.71, ..., 0.72]
    .                          1:  [78.4, 64.5, ..., -42.9]
                                   .

v . t . 1. v b 100 RET  V M k r    180. v b 100 RET  V M k r  90 -
@end smallexample
@end group

@noindent
(The next step may be slow, depending on the speed of your computer.)

@group
@smallexample
2:  [0.52, 0.71, ..., 0.72]    1:  [0.72, 1.14, ..., 1.45]
1:  [0.20, 0.43, ..., 0.73]        .
    .

    m d  V M C                     +

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [0, 1, ..., 1]       1:  0.64            1:  3.125
    .                        .                   .

    1 V M a >                V R + 100 /         2 TAB /
@end smallexample
@end group

Let's try the third method, too.  We'll use random integers up to
one million.  The @kbd{k r} command with an integer argument picks
a random integer.

@group
@smallexample
2:  [1000000, 1000000, ..., 1000000]   2:  [78489, 527587, ..., 814975]
1:  [1000000, 1000000, ..., 1000000]   1:  [324014, 358783, ..., 955450]
    .                                      .

    1000000 v b 100 RET RET                V M k r  TAB  V M k r

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [1, 1, ..., 25]      1:  [1, 1, ..., 0]     1:  0.56
    .                        .                      .

    V M k g                  1 V M a =              V R + 100 /

@end smallexample
@end group
@noindent
@group
@smallexample
1:  10.714        1:  3.273
    .                 .

    6 TAB /           Q
@end smallexample
@end group

For a proof of this property of the GCD function, see section 4.5.2,
exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.

If you typed @kbd{v .} and @kbd{t .} before, type them again to
return to full-sized display of vectors.

@node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
@subsection List Tutorial Exercise 13

@noindent
First, we put the string on the stack as a vector of ASCII codes.

@group
@smallexample
1:  [84, 101, 115, ..., 51]
    .

    "Testing, 1, 2, 3 RET
@end smallexample
@end group

@noindent
Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
there was no need to type an apostrophe.  Also, Calc didn't mind that
we omitted the closing @kbd{"}.  (The same goes for all closing delimiters
like @kbd{)} and @kbd{]} at the end of a formula.

We'll show two different approaches here.  In the first, we note that
if the input vector is @cite{[a, b, c, d]}, then the hash code is
@cite{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}.  In other words,
it's a sum of descending powers of three times the ASCII codes.

@group
@smallexample
2:  [84, 101, 115, ..., 51]    2:  [84, 101, 115, ..., 51]
1:  16                         1:  [15, 14, 13, ..., 0]
    .                              .

    RET v l                        v x 16 RET -

@end smallexample
@end group
@noindent
@group
@smallexample
2:  [84, 101, 115, ..., 51]    1:  1960915098    1:  121
1:  [14348907, ..., 1]             .                 .
    .

    3 TAB V M ^                    *                 511 %
@end smallexample
@end group

@noindent
Once again, @kbd{*} elegantly summarizes most of the computation.
But there's an even more elegant approach:  Reduce the formula
@kbd{3 $$ + $} across the vector.  Recall that this represents a
function of two arguments that computes its first argument times three
plus its second argument.

@group
@smallexample
1:  [84, 101, 115, ..., 51]    1:  1960915098
    .                              .

    "Testing, 1, 2, 3 RET          V R ' 3$$+$ RET
@end smallexample
@end group

@noindent
If you did the decimal arithmetic exercise, this will be familiar.
Basically, we're turning a base-3 vector of digits into an integer,
except that our ``digits'' are much larger than real digits.

Instead of typing @kbd{511 %} again to reduce the result, we can be
cleverer still and notice that rather than computing a huge integer
and taking the modulo at the end, we can take the modulo at each step
without affecting the result.  While this means there are more
arithmetic operations, the numbers we operate on remain small so
the operations are faster.

@group
@smallexample
1:  [84, 101, 115, ..., 51]    1:  121
    .                              .

    "Testing, 1, 2, 3 RET          V R ' (3$$+$)%511 RET
@end smallexample
@end group

Why does this work?  Think about a two-step computation:
@w{@cite{3 (3a + b) + c}}.  Taking a result modulo 511 basically means
subtracting off enough 511's to put the result in the desired range.
So the result when we take the modulo after every step is,

@ifnottex
@example
3 (3 a + b - 511 m) + c - 511 n
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ 3 (3 a + b - 511 m) + c - 511 n $$
\afterdisplay
@end tex

@noindent
for some suitable integers @cite{m} and @cite{n}.  Expanding out by
the distributive law yields

@ifnottex
@example
9 a + 3 b + c - 511*3 m - 511 n
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ 9 a + 3 b + c - 511\times3 m - 511 n $$
\afterdisplay
@end tex

@noindent
The @cite{m} term in the latter formula is redundant because any
contribution it makes could just as easily be made by the @cite{n}
term.  So we can take it out to get an equivalent formula with
@cite{n' = 3m + n},

@ifnottex
@example
9 a + 3 b + c - 511 n'
@end example
@end ifnottex
@tex
\turnoffactive
\beforedisplay
$$ 9 a + 3 b + c - 511 n' $$
\afterdisplay
@end tex

@noindent
which is just the formula for taking the modulo only at the end of
the calculation.  Therefore the two methods are essentially the same.

Later in the tutorial we will encounter @dfn{modulo forms}, which
basically automate the idea of reducing every intermediate result
modulo some value @i{M}.

@node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
@subsection List Tutorial Exercise 14

We want to use @kbd{H V U} to nest a function which adds a random
step to an @cite{(x,y)} coordinate.  The function is a bit long, but
otherwise the problem is quite straightforward.

@group
@smallexample
2:  [0, 0]     1:  [ [    0,       0    ]
1:  50               [  0.4288, -0.1695 ]
    .                [ -0.4787, -0.9027 ]
                     ...

    [0,0] 50       H V U ' <# + [random(2.0)-1, random(2.0)-1]> RET
@end smallexample
@end group

Just as the text recommended, we used @samp{< >} nameless function
notation to keep the two @code{random} calls from being evaluated
before nesting even begins.

We now have a vector of @cite{[x, y]} sub-vectors, which by Calc's
rules acts like a matrix.  We can transpose this matrix and unpack
to get a pair of vectors, @cite{x} and @cite{y}, suitable for graphing.

@group
@smallexample
2:  [ 0, 0.4288, -0.4787, ... ]
1:  [ 0, -0.1696, -0.9027, ... ]
    .

    v t  v u  g f
@end smallexample
@end group

Incidentally, because the @cite{x} and @cite{y} are completely
independent in this case, we could have done two separate commands
to create our @cite{x} and @cite{y} vectors of numbers directly.

To make a random walk of unit steps, we note that @code{sincos} of
a random direction exactly gives us an @cite{[x, y]} step of unit
length; in fact, the new nesting function is even briefer, though
we might want to lower the precision a bit for it.

@group
@smallexample
2:  [0, 0]     1:  [ [    0,      0    ]
1:  50               [  0.1318, 0.9912 ]
    .                [ -0.5965, 0.3061 ]
                     ...

    [0,0] 50   m d  p 6 RET   H V U ' <# + sincos(random(360.0))> RET
@end smallexample
@end group

Another @kbd{v t v u g f} sequence will graph this new random walk.

An interesting twist on these random walk functions would be to use
complex numbers instead of 2-vectors to represent points on the plane.
In the first example, we'd use something like @samp{random + random*(0,1)},
and in the second we could use polar complex numbers with random phase
angles.  (This exercise was first suggested in this form by Randal
Schwartz.)

@node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
@subsection Types Tutorial Exercise 1

@noindent
If the number is the square root of @c{$\pi$}
@cite{pi} times a rational number,
then its square, divided by @c{$\pi$}
@cite{pi}, should be a rational number.

@group
@smallexample
1:  1.26508260337    1:  0.509433962268   1:  2486645810:4881193627
    .                    .                    .

                         2 ^ P /              c F
@end smallexample
@end group

@noindent
Technically speaking this is a rational number, but not one that is
likely to have arisen in the original problem.  More likely, it just
happens to be the fraction which most closely represents some
irrational number to within 12 digits.

But perhaps our result was not quite exact.  Let's reduce the
precision slightly and try again:

@group
@smallexample
1:  0.509433962268     1:  27:53
    .                      .

    U p 10 RET             c F
@end smallexample
@end group

@noindent
Aha!  It's unlikely that an irrational number would equal a fraction
this simple to within ten digits, so our original number was probably
@c{$\sqrt{27 \pi / 53}$}
@cite{sqrt(27 pi / 53)}.

Notice that we didn't need to re-round the number when we reduced the
precision.  Remember, arithmetic operations always round their inputs
to the current precision before they begin.

@node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
@subsection Types Tutorial Exercise 2

@noindent
@samp{inf / inf = nan}.  Perhaps @samp{1} is the ``obvious'' answer.
But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.

@samp{exp(inf) = inf}.  It's tempting to say that the exponential
of infinity must be ``bigger'' than ``regular'' infinity, but as
far as Calc is concerned all infinities are as just as big.
In other words, as @cite{x} goes to infinity, @cite{e^x} also goes
to infinity, but the fact the @cite{e^x} grows much faster than
@cite{x} is not relevant here.

@samp{exp(-inf) = 0}.  Here we have a finite answer even though
the input is infinite.

@samp{sqrt(-inf) = (0, 1) inf}.  Remember that @cite{(0, 1)}
represents the imaginary number @cite{i}.  Here's a derivation:
@samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
The first part is, by definition, @cite{i}; the second is @code{inf}
because, once again, all infinities are the same size.

@samp{sqrt(uinf) = uinf}.  In fact, we do know something about the
direction because @code{sqrt} is defined to return a value in the
right half of the complex plane.  But Calc has no notation for this,
so it settles for the conservative answer @code{uinf}.

@samp{abs(uinf) = inf}.  No matter which direction @cite{x} points,
@samp{abs(x)} always points along the positive real axis.

@samp{ln(0) = -inf}.  Here we have an infinite answer to a finite
input.  As in the @cite{1 / 0} case, Calc will only use infinities
here if you have turned on ``infinite'' mode.  Otherwise, it will
treat @samp{ln(0)} as an error.

@node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
@subsection Types Tutorial Exercise 3

@noindent
We can make @samp{inf - inf} be any real number we like, say,
@cite{a}, just by claiming that we added @cite{a} to the first
infinity but not to the second.  This is just as true for complex
values of @cite{a}, so @code{nan} can stand for a complex number.
(And, similarly, @code{uinf} can stand for an infinity that points
in any direction in the complex plane, such as @samp{(0, 1) inf}).

In fact, we can multiply the first @code{inf} by two.  Surely
@w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
So @code{nan} can even stand for infinity.  Obviously it's just
as easy to make it stand for minus infinity as for plus infinity.

The moral of this story is that ``infinity'' is a slippery fish
indeed, and Calc tries to handle it by having a very simple model
for infinities (only the direction counts, not the ``size''); but
Calc is careful to write @code{nan} any time this simple model is
unable to tell what the true answer is.

@node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
@subsection Types Tutorial Exercise 4

@group
@smallexample
2:  0@@ 47' 26"              1:  0@@ 2' 47.411765"
1:  17                          .
    .

    0@@ 47' 26" RET 17           /
@end smallexample
@end group

@noindent
The average song length is two minutes and 47.4 seconds.

@group
@smallexample
2:  0@@ 2' 47.411765"     1:  0@@ 3' 7.411765"    1:  0@@ 53' 6.000005"
1:  0@@ 0' 20"                .                      .
    .

    20"                      +                      17 *
@end smallexample
@end group

@noindent
The album would be 53 minutes and 6 seconds long.

@node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
@subsection Types Tutorial Exercise 5

@noindent
Let's suppose it's January 14, 1991.  The easiest thing to do is
to keep trying 13ths of months until Calc reports a Friday.
We can do this by manually entering dates, or by using @kbd{t I}:

@group
@smallexample
1:  <Wed Feb 13, 1991>    1:  <Wed Mar 13, 1991>   1:  <Sat Apr 13, 1991>
    .                         .                        .

    ' <2/13> RET       DEL    ' <3/13> RET             t I
@end smallexample
@end group

@noindent
(Calc assumes the current year if you don't say otherwise.)

This is getting tedious---we can keep advancing the date by typing
@kbd{t I} over and over again, but let's automate the job by using
vector mapping.  The @kbd{t I} command actually takes a second
``how-many-months'' argument, which defaults to one.  This
argument is exactly what we want to map over:

@group
@smallexample
2:  <Sat Apr 13, 1991>     1:  [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
1:  [1, 2, 3, 4, 5, 6]          <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
    .                           <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
                               .

    v x 6 RET                  V M t I
@end smallexample
@end group

@ifnottex
@noindent
Et voila, September 13, 1991 is a Friday.
@end ifnottex
@tex
\noindent
{\it Et voil{\accent"12 a}}, September 13, 1991 is a Friday.
@end tex

@group
@smallexample
1:  242
    .

' <sep 13> - <jan 14> RET
@end smallexample
@end group

@noindent
And the answer to our original question:  242 days to go.

@node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
@subsection Types Tutorial Exercise 6

@noindent
The full rule for leap years is that they occur in every year divisible
by four, except that they don't occur in years divisible by 100, except
that they @emph{do} in years divisible by 400.  We could work out the
answer by carefully counting the years divisible by four and the
exceptions, but there is a much simpler way that works even if we
don't know the leap year rule.

Let's assume the present year is 1991.  Years have 365 days, except
that leap years (whenever they occur) have 366 days.  So let's count
the number of days between now and then, and compare that to the
number of years times 365.  The number of extra days we find must be
equal to the number of leap years there were.

@group
@smallexample
1:  <Mon Jan 1, 10001>     2:  <Mon Jan 1, 10001>     1:  2925593
    .                      1:  <Tue Jan 1, 1991>          .
                               .

  ' <jan 1 10001> RET         ' <jan 1 1991> RET          -

@end smallexample
@end group
@noindent
@group
@smallexample
3:  2925593       2:  2925593     2:  2925593     1:  1943
2:  10001         1:  8010        1:  2923650         .
1:  1991              .               .
    .

  10001 RET 1991      -               365 *           -
@end smallexample
@end group

@c [fix-ref Date Forms]
@noindent
There will be 1943 leap years before the year 10001.  (Assuming,
of course, that the algorithm for computing leap years remains
unchanged for that long.  @xref{Date Forms}, for some interesting
background information in that regard.)

@node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
@subsection Types Tutorial Exercise 7

@noindent
The relative errors must be converted to absolute errors so that
@samp{+/-} notation may be used.

@group
@smallexample
1:  1.              2:  1.
    .               1:  0.2
                        .

    20 RET .05 *        4 RET .05 *
@end smallexample
@end group

Now we simply chug through the formula.

@group
@smallexample
1:  19.7392088022    1:  394.78 +/- 19.739    1:  6316.5 +/- 706.21
    .                    .                        .

    2 P 2 ^ *            20 p 1 *                 4 p .2 RET 2 ^ *
@end smallexample
@end group

It turns out the @kbd{v u} command will unpack an error form as
well as a vector.  This saves us some retyping of numbers.

@group
@smallexample
3:  6316.5 +/- 706.21     2:  6316.5 +/- 706.21
2:  6316.5                1:  0.1118
1:  706.21                    .
    .

    RET v u                   TAB /
@end smallexample
@end group

@noindent
Thus the volume is 6316 cubic centimeters, within about 11 percent.

@node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
@subsection Types Tutorial Exercise 8

@noindent
The first answer is pretty simple:  @samp{1 / (0 .. 10) = (0.1 .. inf)}.
Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
close to zero, its reciprocal can get arbitrarily large, so the answer
is an interval that effectively means, ``any number greater than 0.1''
but with no upper bound.

The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.

Calc normally treats division by zero as an error, so that the formula
@w{@samp{1 / 0}} is left unsimplified.  Our third problem,
@w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
is now a member of the interval.  So Calc leaves this one unevaluated, too.

If you turn on ``infinite'' mode by pressing @kbd{m i}, you will
instead get the answer @samp{[0.1 .. inf]}, which includes infinity
as a possible value.

The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
Zero is buried inside the interval, but it's still a possible value.
It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
will be either greater than @i{0.1}, or less than @i{-0.1}.  Thus
the interval goes from minus infinity to plus infinity, with a ``hole''
in it from @i{-0.1} to @i{0.1}.  Calc doesn't have any way to
represent this, so it just reports @samp{[-inf .. inf]} as the answer.
It may be disappointing to hear ``the answer lies somewhere between
minus infinity and plus infinity, inclusive,'' but that's the best
that interval arithmetic can do in this case.

@node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
@subsection Types Tutorial Exercise 9

@group
@smallexample
1:  [-3 .. 3]       2:  [-3 .. 3]     2:  [0 .. 9]
    .               1:  [0 .. 9]      1:  [-9 .. 9]
                        .                 .

    [ 3 n .. 3 ]        RET 2 ^           TAB RET *
@end smallexample
@end group

@noindent
In the first case the result says, ``if a number is between @i{-3} and
3, its square is between 0 and 9.''  The second case says, ``the product
of two numbers each between @i{-3} and 3 is between @i{-9} and 9.''

An interval form is not a number; it is a symbol that can stand for
many different numbers.  Two identical-looking interval forms can stand
for different numbers.

The same issue arises when you try to square an error form.

@node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
@subsection Types Tutorial Exercise 10

@noindent
Testing the first number, we might arbitrarily choose 17 for @cite{x}.

@group
@smallexample
1:  17 mod 811749613   2:  17 mod 811749613   1:  533694123 mod 811749613
    .                      811749612              .
                           .

    17 M 811749613 RET     811749612              ^
@end smallexample
@end group

@noindent
Since 533694123 is (considerably) different from 1, the number 811749613
must not be prime.

It's awkward to type the number in twice as we did above.  There are
various ways to avoid this, and algebraic entry is one.  In fact, using
a vector mapping operation we can perform several tests at once.  Let's
use this method to test the second number.

@group
@smallexample
2:  [17, 42, 100000]               1:  [1 mod 15485863, 1 mod ... ]
1:  15485863                           .
    .

 [17 42 100000] 15485863 RET           V M ' ($$ mod $)^($-1) RET
@end smallexample
@end group

@noindent
The result is three ones (modulo @cite{n}), so it's very probable that
15485863 is prime.  (In fact, this number is the millionth prime.)

Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
would have been hopelessly inefficient, since they would have calculated
the power using full integer arithmetic.

Calc has a @kbd{k p} command that does primality testing.  For small
numbers it does an exact test; for large numbers it uses a variant
of the Fermat test we used here.  You can use @kbd{k p} repeatedly
to prove that a large integer is prime with any desired probability.

@node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
@subsection Types Tutorial Exercise 11

@noindent
There are several ways to insert a calculated number into an HMS form.
One way to convert a number of seconds to an HMS form is simply to
multiply the number by an HMS form representing one second:

@group
@smallexample
1:  31415926.5359     2:  31415926.5359     1:  8726@@ 38' 46.5359"
    .                 1:  0@@ 0' 1"              .
                          .

    P 1e7 *               0@@ 0' 1"              *

@end smallexample
@end group
@noindent
@group
@smallexample
2:  8726@@ 38' 46.5359"             1:  6@@ 6' 2.5359" mod 24@@ 0' 0"
1:  15@@ 27' 16" mod 24@@ 0' 0"          .
    .

    x time RET                         +
@end smallexample
@end group

@noindent
It will be just after six in the morning.

The algebraic @code{hms} function can also be used to build an
HMS form:

@group
@smallexample
1:  hms(0, 0, 10000000. pi)       1:  8726@@ 38' 46.5359"
    .                                 .

  ' hms(0, 0, 1e7 pi) RET             =
@end smallexample
@end group

@noindent
The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
the actual number 3.14159...

@node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
@subsection Types Tutorial Exercise 12

@noindent
As we recall, there are 17 songs of about 2 minutes and 47 seconds
each.

@group
@smallexample
2:  0@@ 2' 47"                    1:  [0@@ 3' 7" .. 0@@ 3' 47"]
1:  [0@@ 0' 20" .. 0@@ 1' 0"]          .
    .

    [ 0@@ 20" .. 0@@ 1' ]              +

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [0@@ 52' 59." .. 1@@ 4' 19."]
    .

    17 *
@end smallexample
@end group

@noindent
No matter how long it is, the album will fit nicely on one CD.

@node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
@subsection Types Tutorial Exercise 13

@noindent
Type @kbd{' 1 yr RET u c s RET}.  The answer is 31557600 seconds.

@node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
@subsection Types Tutorial Exercise 14

@noindent
How long will it take for a signal to get from one end of the computer
to the other?

@group
@smallexample
1:  m / c         1:  3.3356 ns
    .                 .

 ' 1 m / c RET        u c ns RET
@end smallexample
@end group

@noindent
(Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)

@group
@smallexample
1:  3.3356 ns     1:  0.81356 ns / ns     1:  0.81356
2:  4.1 ns            .                       .
    .

  ' 4.1 ns RET        /                       u s
@end smallexample
@end group

@noindent
Thus a signal could take up to 81 percent of a clock cycle just to
go from one place to another inside the computer, assuming the signal
could actually attain the full speed of light.  Pretty tight!

@node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
@subsection Types Tutorial Exercise 15

@noindent
The speed limit is 55 miles per hour on most highways.  We want to
find the ratio of Sam's speed to the US speed limit.

@group
@smallexample
1:  55 mph         2:  55 mph           3:  11 hr mph / yd
    .              1:  5 yd / hr            .
                       .

  ' 55 mph RET       ' 5 yd/hr RET          /
@end smallexample
@end group

The @kbd{u s} command cancels out these units to get a plain
number.  Now we take the logarithm base two to find the final
answer, assuming that each successive pill doubles his speed.

@group
@smallexample
1:  19360.       2:  19360.       1:  14.24
    .            1:  2                .
                     .

    u s              2                B
@end smallexample
@end group

@noindent
Thus Sam can take up to 14 pills without a worry.

@node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
@subsection Algebra Tutorial Exercise 1

@noindent
@c [fix-ref Declarations]
The result @samp{sqrt(x)^2} is simplified back to @cite{x} by the
Calculator, but @samp{sqrt(x^2)} is not.  (Consider what happens
if @w{@cite{x = -4}}.)  If @cite{x} is real, this formula could be
simplified to @samp{abs(x)}, but for general complex arguments even
that is not safe.  (@xref{Declarations}, for a way to tell Calc
that @cite{x} is known to be real.)

@node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
@subsection Algebra Tutorial Exercise 2

@noindent
Suppose our roots are @cite{[a, b, c]}.  We want a polynomial which
is zero when @cite{x} is any of these values.  The trivial polynomial
@cite{x-a} is zero when @cite{x=a}, so the product @cite{(x-a)(x-b)(x-c)}
will do the job.  We can use @kbd{a c x} to write this in a more
familiar form.

@group
@smallexample
1:  34 x - 24 x^3          1:  [1.19023, -1.19023, 0]
    .                          .

    r 2                        a P x RET

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [x - 1.19023, x + 1.19023, x]     1:  (x - 1.19023) (x + 1.19023) x
    .                                     .

    V M ' x-$ RET                         V R *

@end smallexample
@end group
@noindent
@group
@smallexample
1:  x^3 - 1.41666 x        1:  34 x - 24 x^3
    .                          .

    a c x RET                  24 n *  a x
@end smallexample
@end group

@noindent
Sure enough, our answer (multiplied by a suitable constant) is the
same as the original polynomial.

@node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
@subsection Algebra Tutorial Exercise 3

@group
@smallexample
1:  x sin(pi x)         1:  (sin(pi x) - pi x cos(pi x)) / pi^2
    .                       .

  ' x sin(pi x) RET   m r   a i x RET

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [y, 1]
2:  (sin(pi x) - pi x cos(pi x)) / pi^2
    .

  ' [y,1] RET TAB

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
    .

    V M $ RET

@end smallexample
@end group
@noindent
@group
@smallexample
1:  (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
    .

    V R -

@end smallexample
@end group
@noindent
@group
@smallexample
1:  (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
    .

    =

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [0., -0.95493, 0.63662, -1.5915, 1.2732]
    .

    v x 5 RET  TAB  V M $ RET
@end smallexample
@end group

@node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
@subsection Algebra Tutorial Exercise 4

@noindent
The hard part is that @kbd{V R +} is no longer sufficient to add up all
the contributions from the slices, since the slices have varying
coefficients.  So first we must come up with a vector of these
coefficients.  Here's one way:

@group
@smallexample
2:  -1                 2:  3                    1:  [4, 2, ..., 4]
1:  [1, 2, ..., 9]     1:  [-1, 1, ..., -1]         .
    .                      .

    1 n v x 9 RET          V M ^  3 TAB             -

@end smallexample
@end group
@noindent
@group
@smallexample
1:  [4, 2, ..., 4, 1]      1:  [1, 4, 2, ..., 4, 1]
    .                          .

    1 |                        1 TAB |
@end smallexample
@end group

@noindent
Now we compute the function values.  Note that for this method we need
eleven values, including both endpoints of the desired interval.

@group
@smallexample
2:  [1, 4, 2, ..., 4, 1]
1:  [1, 1.1, 1.2,  ...  , 1.8, 1.9, 2.]
    .

 11 RET 1 RET .1 RET  C-u v x

@end smallexample
@end group
@noindent
@group
@smallexample
2:  [1, 4, 2, ..., 4, 1]
1:  [0., 0.084941, 0.16993, ... ]
    .

    ' sin(x) ln(x) RET   m r  p 5 RET   V M $ RET
@end smallexample
@end group

@noindent
Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
same thing.

@group
@smallexample
1:  11.22      1:  1.122      1:  0.374
    .              .              .

    *              .1 *           3 /
@end smallexample
@end group

@noindent
Wow!  That's even better than the result from the Taylor series method.

@node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
@subsection Rewrites Tutorial Exercise 1

@noindent
We'll use Big mode to make the formulas more readable.

@group
@smallexample
                                               ___
                                          2 + V 2
1:  (2 + sqrt(2)) / (1 + sqrt(2))     1:  --------
    .                                          ___
                                          1 + V 2

                                          .

  ' (2+sqrt(2)) / (1+sqrt(2)) RET         d B
@end smallexample
@end group

@noindent
Multiplying by the conjugate helps because @cite{(a+b) (a-b) = a^2 - b^2}.

@group
@smallexample
          ___    ___
1:  (2 + V 2 ) (V 2  - 1)
    .

  a r a/(b+c) := a*(b-c) / (b^2-c^2) RET

@end smallexample
@end group
@noindent
@group
@smallexample
         ___                         ___
1:  2 + V 2  - 2                1:  V 2
    .                               .

  a r a*(b+c) := a*b + a*c          a s
@end smallexample
@end group

@noindent
(We could have used @kbd{a x} instead of a rewrite rule for the
second step.)

The multiply-by-conjugate rule turns out to be useful in many
different circumstances, such as when the denominator involves
sines and cosines or the imaginary constant @code{i}.

@node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
@subsection Rewrites Tutorial Exercise 2

@noindent
Here is the rule set:

@group
@smallexample
[ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
  fib(1, x, y) := x,
  fib(n, x, y) := fib(n-1, y, x+y) ]
@end smallexample
@end group

@noindent
The first rule turns a one-argument @code{fib} that people like to write
into a three-argument @code{fib} that makes computation easier.  The
second rule converts back from three-argument form once the computation
is done.  The third rule does the computation itself.  It basically
says that if @cite{x} and @cite{y} are two consecutive Fibonacci numbers,
then @cite{y} and @cite{x+y} are the next (overlapping) pair of Fibonacci
numbers.

Notice that because the number @cite{n} was ``validated'' by the
conditions on the first rule, there is no need to put conditions on
the other rules because the rule set would never get that far unless
the input were valid.  That further speeds computation, since no
extra conditions need to be checked at every step.

Actually, a user with a nasty sense of humor could enter a bad
three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
which would get the rules into an infinite loop.  One thing that would
help keep this from happening by accident would be to use something like
@samp{ZzFib} instead of @code{fib} as the name of the three-argument
function.

@node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
@subsection Rewrites Tutorial Exercise 3

@noindent
He got an infinite loop.  First, Calc did as expected and rewrote
@w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}.  Then it looked for ways to
apply the rule again, and found that @samp{f(2, 3, x)} looks like
@samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
@samp{f(0, 1, f(2, 3, x))}.  It then wrapped another @samp{f(0, 1, ...)}
around that, and so on, ad infinitum.  Joe should have used @kbd{M-1 a r}
to make sure the rule applied only once.

(Actually, even the first step didn't work as he expected.  What Calc
really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
to it.  While this may seem odd, it's just as valid a solution as the
``obvious'' one.  One way to fix this would be to add the condition
@samp{:: variable(x)} to the rule, to make sure the thing that matches
@samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
on the lefthand side, so that the rule matches the actual variable
@samp{x} rather than letting @samp{x} stand for something else.)

@node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
@subsection Rewrites Tutorial Exercise 4

@noindent
@c @starindex
@tindex seq
Here is a suitable set of rules to solve the first part of the problem:

@group
@smallexample
[ seq(n, c) := seq(n/2,  c+1) :: n%2 = 0,
  seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
@end smallexample
@end group

Given the initial formula @samp{seq(6, 0)}, application of these
rules produces the following sequence of formulas:

@example
seq( 3, 1)
seq(10, 2)
seq( 5, 3)
seq(16, 4)
seq( 8, 5)
seq( 4, 6)
seq( 2, 7)
seq( 1, 8)
@end example

@noindent
whereupon neither of the rules match, and rewriting stops.

We can pretty this up a bit with a couple more rules:

@group
@smallexample
[ seq(n) := seq(n, 0),
  seq(1, c) := c,
  ... ]
@end smallexample
@end group

@noindent
Now, given @samp{seq(6)} as the starting configuration, we get 8
as the result.

The change to return a vector is quite simple:

@group
@smallexample
[ seq(n) := seq(n, []) :: integer(n) :: n > 0,
  seq(1, v) := v | 1,
  seq(n, v) := seq(n/2,  v | n) :: n%2 = 0,
  seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
@end smallexample
@end group

@noindent
Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.

Notice that the @cite{n > 1} guard is no longer necessary on the last
rule since the @cite{n = 1} case is now detected by another rule.
But a guard has been added to the initial rule to make sure the
initial value is suitable before the computation begins.

While still a good idea, this guard is not as vitally important as it
was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
will not get into an infinite loop.  Calc will not be able to prove
the symbol @samp{x} is either even or odd, so none of the rules will
apply and the rewrites will stop right away.

@node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
@subsection Rewrites Tutorial Exercise 5

@noindent
@c @starindex
@tindex nterms
If @cite{x} is the sum @cite{a + b}, then `@t{nterms(}@i{x}@t{)}' must
be `@t{nterms(}@i{a}@t{)}' plus `@t{nterms(}@i{b}@t{)}'.  If @cite{x}
is not a sum, then `@t{nterms(}@i{x}@t{)}' = 1.

@group
@smallexample
[ nterms(a + b) := nterms(a) + nterms(b),
  nterms(x)     := 1 ]
@end smallexample
@end group

@noindent
Here we have taken advantage of the fact that earlier rules always
match before later rules; @samp{nterms(x)} will only be tried if we
already know that @samp{x} is not a sum.

@node Rewrites Answer 6, Rewrites Answer 7, Rewrites Answer 5, Answers to Exercises
@subsection Rewrites Tutorial Exercise 6

Just put the rule @samp{0^0 := 1} into @code{EvalRules}.  For example,
before making this definition we have:

@group
@smallexample
2:  [-2, -1, 0, 1, 2]                1:  [1, 1, 0^0, 1, 1]
1:  0                                    .
    .

    v x 5 RET  3 -  0                    V M ^
@end smallexample
@end group

@noindent
But then:

@group
@smallexample
2:  [-2, -1, 0, 1, 2]                1:  [1, 1, 1, 1, 1]
1:  0                                    .
    .

    U  ' 0^0:=1 RET s t EvalRules RET    V M ^
@end smallexample
@end group

Perhaps more surprisingly, this rule still works with infinite mode
turned on.  Calc tries @code{EvalRules} before any built-in rules for
a function.  This allows you to override the default behavior of any
Calc feature:  Even though Calc now wants to evaluate @cite{0^0} to
@code{nan}, your rule gets there first and evaluates it to 1 instead.

Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
What happens?  (Be sure to remove this rule afterward, or you might get
a nasty surprise when you use Calc to balance your checkbook!)

@node Rewrites Answer 7, Programming Answer 1, Rewrites Answer 6, Answers to Exercises
@subsection Rewrites Tutorial Exercise 7

@noindent
Here is a rule set that will do the job:

@group
@smallexample
[ a*(b + c) := a*b + a*c,
  opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
     :: constant(a) :: constant(b),
  opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
     :: constant(a) :: constant(b),
  a O(x^n) := O(x^n) :: constant(a),
  x^opt(m) O(x^n) := O(x^(n+m)),
  O(x^n) O(x^m) := O(x^(n+m)) ]
@end smallexample
@end group

If we really want the @kbd{+} and @kbd{*} keys to operate naturally
on power series, we should put these rules in @code{EvalRules}.  For
testing purposes, it is better to put them in a different variable,
say, @code{O}, first.

The first rule just expands products of sums so that the rest of the
rules can assume they have an expanded-out polynomial to work with.
Note that this rule does not mention @samp{O} at all, so it will
apply to any product-of-sum it encounters---this rule may surprise
you if you put it into @code{EvalRules}!

In the second rule, the sum of two O's is changed to the smaller O.
The optional constant coefficients are there mostly so that
@samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
as well as @samp{O(x^2) + O(x^3)}.

The third rule absorbs higher powers of @samp{x} into O's.

The fourth rule says that a constant times a negligible quantity
is still negligible.  (This rule will also match @samp{O(x^3) / 4},
with @samp{a = 1/4}.)

The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
(It is easy to see that if one of these forms is negligible, the other
is, too.)  Notice the @samp{x^opt(m)} to pick up terms like
@w{@samp{x O(x^3)}}.  Optional powers will match @samp{x} as @samp{x^1}
but not 1 as @samp{x^0}.  This turns out to be exactly what we want here.

The sixth rule is the corresponding rule for products of two O's.

Another way to solve this problem would be to create a new ``data type''
that represents truncated power series.  We might represent these as
function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
a vector of coefficients for @cite{x^0}, @cite{x^1}, @cite{x^2}, and so
on.  Rules would exist for sums and products of such @code{series}
objects, and as an optional convenience could also know how to combine a
@code{series} object with a normal polynomial.  (With this, and with a
rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
you could still enter power series in exactly the same notation as
before.)  Operations on such objects would probably be more efficient,
although the objects would be a bit harder to read.

@c [fix-ref Compositions]
Some other symbolic math programs provide a power series data type
similar to this.  Mathematica, for example, has an object that looks
like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
@var{nmax}, @var{den}]}, where @var{x0} is the point about which the
power series is taken (we've been assuming this was always zero),
and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
with fractional or negative powers.  Also, the @code{PowerSeries}
objects have a special display format that makes them look like
@samp{2 x^2 + O(x^4)} when they are printed out.  (@xref{Compositions},
for a way to do this in Calc, although for something as involved as
this it would probably be better to write the formatting routine
in Lisp.)

@node Programming Answer 1, Programming Answer 2, Rewrites Answer 7, Answers to Exercises
@subsection Programming Tutorial Exercise 1

@noindent
Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
@kbd{Z F}, and answer the questions.  Since this formula contains two
variables, the default argument list will be @samp{(t x)}.  We want to
change this to @samp{(x)} since @cite{t} is really a dummy variable
to be used within @code{ninteg}.

The exact keystrokes are @kbd{Z F s Si RET RET C-b C-b DEL DEL RET y}.
(The @kbd{C-b C-b DEL DEL} are what fix the argument list.)

@node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
@subsection Programming Tutorial Exercise 2

@noindent
One way is to move the number to the top of the stack, operate on
it, then move it back:  @kbd{C-x ( M-TAB n M-TAB M-TAB C-x )}.

Another way is to negate the top three stack entries, then negate
again the top two stack entries:  @kbd{C-x ( M-3 n M-2 n C-x )}.

Finally, it turns out that a negative prefix argument causes a
command like @kbd{n} to operate on the specified stack entry only,
which is just what we want:  @kbd{C-x ( M-- 3 n C-x )}.

Just for kicks, let's also do it algebraically:
@w{@kbd{C-x ( ' -$$$, $$, $ RET C-x )}}.

@node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
@subsection Programming Tutorial Exercise 3

@noindent
Each of these functions can be computed using the stack, or using
algebraic entry, whichever way you prefer:

@noindent
Computing @c{$\displaystyle{\sin x \over x}$}
@cite{sin(x) / x}:

Using the stack:  @kbd{C-x (  RET S TAB /  C-x )}.

Using algebraic entry:  @kbd{C-x (  ' sin($)/$ RET  C-x )}.

@noindent
Computing the logarithm:

Using the stack:  @kbd{C-x (  TAB B  C-x )}

Using algebraic entry:  @kbd{C-x (  ' log($,$$) RET  C-x )}.

@noindent
Computing the vector of integers:

Using the stack:  @kbd{C-x (  1 RET 1  C-u v x  C-x )}.  (Recall that
@kbd{C-u v x} takes the vector size, starting value, and increment
from the stack.)

Alternatively:  @kbd{C-x (  ~ v x  C-x )}.  (The @kbd{~} key pops a
number from the stack and uses it as the prefix argument for the
next command.)

Using algebraic entry:  @kbd{C-x (  ' index($) RET  C-x )}.

@node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
@subsection Programming Tutorial Exercise 4

@noindent
Here's one way:  @kbd{C-x ( RET V R + TAB v l / C-x )}.

@node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
@subsection Programming Tutorial Exercise 5

@group
@smallexample
2:  1              1:  1.61803398502         2:  1.61803398502
1:  20                 .                     1:  1.61803398875
    .                                            .

   1 RET 20         Z < & 1 + Z >                I H P
@end smallexample
@end group

@noindent
This answer is quite accurate.

@node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
@subsection Programming Tutorial Exercise 6

@noindent
Here is the matrix:

@example
[ [ 0, 1 ]   * [a, b] = [b, a + b]
  [ 1, 1 ] ]
@end example

@noindent
Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @cite{n+1}
and @cite{n+2}.  Here's one program that does the job:

@example
C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] RET v u DEL C-x )
@end example

@noindent
This program is quite efficient because Calc knows how to raise a
matrix (or other value) to the power @cite{n} in only @c{$\log_2 n$}
@cite{log(n,2)}
steps.  For example, this program can compute the 1000th Fibonacci
number (a 209-digit integer!) in about 10 steps; even though the
@kbd{Z < ... Z >} solution had much simpler steps, it would have
required so many steps that it would not have been practical.

@node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
@subsection Programming Tutorial Exercise 7

@noindent
The trick here is to compute the harmonic numbers differently, so that
the loop counter itself accumulates the sum of reciprocals.  We use
a separate variable to hold the integer counter.

@group
@smallexample
1:  1          2:  1       1:  .
    .          1:  4
                   .

    1 t 1       1 RET 4      Z ( t 2 r 1 1 + s 1 & Z )
@end smallexample
@end group

@noindent
The body of the loop goes as follows:  First save the harmonic sum
so far in variable 2.  Then delete it from the stack; the for loop
itself will take care of remembering it for us.  Next, recall the
count from variable 1, add one to it, and feed its reciprocal to
the for loop to use as the step value.  The for loop will increase
the ``loop counter'' by that amount and keep going until the
loop counter exceeds 4.

@group
@smallexample
2:  31                  3:  31
1:  3.99498713092       2:  3.99498713092
    .                   1:  4.02724519544
                            .

    r 1 r 2                 RET 31 & +
@end smallexample
@end group

Thus we find that the 30th harmonic number is 3.99, and the 31st
harmonic number is 4.02.

@node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
@subsection Programming Tutorial Exercise 8

@noindent
The first step is to compute the derivative @cite{f'(x)} and thus
the formula @c{$\displaystyle{x - {f(x) \over f'(x)}}$}
@cite{x - f(x)/f'(x)}.

(Because this definition is long, it will be repeated in concise form
below.  You can use @w{@kbd{M-# m}} to load it from there.  While you are
entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
keystrokes without executing them.  In the following diagrams we'll
pretend Calc actually executed the keystrokes as you typed them,
just for purposes of illustration.)

@group
@smallexample
2:  sin(cos(x)) - 0.5            3:  4.5
1:  4.5                          2:  sin(cos(x)) - 0.5
    .                            1:  -(sin(x) cos(cos(x)))
                                     .

' sin(cos(x))-0.5 RET 4.5  m r  C-x ( Z `  TAB RET a d x RET

@end smallexample
@end group
@noindent
@group
@smallexample
2:  4.5
1:  x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
    .

    /  ' x RET TAB -   t 1
@end smallexample
@end group

Now, we enter the loop.  We'll use a repeat loop with a 20-repetition
limit just in case the method fails to converge for some reason.
(Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
repetitions are done.)

@group
@smallexample
1:  4.5         3:  4.5                     2:  4.5
    .           2:  x + (sin(cos(x)) ...    1:  5.24196456928
                1:  4.5                         .
                    .

  20 Z <          RET r 1 TAB                 s l x RET
@end smallexample
@end group

This is the new guess for @cite{x}.  Now we compare it with the
old one to see if we've converged.

@group
@smallexample
3:  5.24196     2:  5.24196     1:  5.24196     1:  5.26345856348
2:  5.24196     1:  0               .               .
1:  4.5             .
    .

  RET M-TAB         a =             Z /             Z > Z ' C-x )
@end smallexample
@end group

The loop converges in just a few steps to this value.  To check
the result, we can simply substitute it back into the equation.

@group
@smallexample
2:  5.26345856348
1:  0.499999999997
    .

 RET ' sin(cos($)) RET
@end smallexample
@end group

Let's test the new definition again:

@group
@smallexample
2:  x^2 - 9           1:  3.
1:  1                     .
    .

  ' x^2-9 RET 1           X
@end smallexample
@end group

Once again, here's the full Newton's Method definition:

@group
@example
C-x ( Z `  TAB RET a d x RET  /  ' x RET TAB -  t 1
           20 Z <  RET r 1 TAB  s l x RET
                   RET M-TAB  a =  Z /
              Z >
      Z '
C-x )
@end example
@end group

@c [fix-ref Nesting and Fixed Points]
It turns out that Calc has a built-in command for applying a formula
repeatedly until it converges to a number.  @xref{Nesting and Fixed Points},
to see how to use it.

@c [fix-ref Root Finding]
Also, of course, @kbd{a R} is a built-in command that uses Newton's
method (among others) to look for numerical solutions to any equation.
@xref{Root Finding}.

@node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
@subsection Programming Tutorial Exercise 9

@noindent
The first step is to adjust @cite{z} to be greater than 5.  A simple
``for'' loop will do the job here.  If @cite{z} is less than 5, we
reduce the problem using @c{$\psi(z) = \psi(z+1) - 1/z$}
@cite{psi(z) = psi(z+1) - 1/z}.  We go
on to compute @c{$\psi(z+1)$}
@cite{psi(z+1)}, and remember to add back a factor of
@cite{-1/z} when we're done.  This step is repeated until @cite{z > 5}.

(Because this definition is long, it will be repeated in concise form
below.  You can use @w{@kbd{M-# m}} to load it from there.  While you are
entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
keystrokes without executing them.  In the following diagrams we'll
pretend Calc actually executed the keystrokes as you typed them,
just for purposes of illustration.)

@group
@smallexample
1:  1.             1:  1.
    .                  .

 1.0 RET       C-x ( Z `  s 1  0 t 2
@end smallexample
@end group

Here, variable 1 holds @cite{z} and variable 2 holds the adjustment
factor.  If @cite{z < 5}, we use a loop to increase it.

(By the way, we started with @samp{1.0} instead of the integer 1 because
otherwise the calculation below will try to do exact fractional arithmetic,
and will never converge because fractions compare equal only if they
are exactly equal, not just equal to within the current precision.)

@group
@smallexample
3:  1.      2:  1.       1:  6.
2:  1.      1:  1            .
1:  5           .
    .

  RET 5        a <    Z [  5 Z (  & s + 2  1 s + 1  1 Z ) r 1  Z ]
@end smallexample
@end group

Now we compute the initial part of the sum:  @c{$\ln z - {1 \over 2z}$}
@cite{ln(z) - 1/2z}
minus the adjustment factor.

@group
@smallexample
2:  1.79175946923      2:  1.7084261359      1:  -0.57490719743
1:  0.0833333333333    1:  2.28333333333         .
    .                      .

    L  r 1 2 * &           -  r 2                -
@end smallexample
@end group

Now we evaluate the series.  We'll use another ``for'' loop counting
up the value of @cite{2 n}.  (Calc does have a summation command,
@kbd{a +}, but we'll use loops just to get more practice with them.)

@group
@smallexample
3:  -0.5749       3:  -0.5749        4:  -0.5749      2:  -0.5749
2:  2             2:  1:6            3:  1:6          1:  2.3148e-3
1:  40            1:  2              2:  2                .
    .                 .              1:  36.
                                         .

   2 RET 40        Z ( RET k b TAB     RET r 1 TAB ^      * /

@end smallexample
@end group
@noindent
@group
@smallexample
3:  -0.5749       3:  -0.5772      2:  -0.5772     1:  -0.577215664892
2:  -0.5749       2:  -0.5772      1:  0               .
1:  2.3148e-3     1:  -0.5749          .
    .                 .

  TAB RET M-TAB       - RET M-TAB      a =     Z /    2  Z )  Z ' C-x )
@end smallexample
@end group

This is the value of @c{$-\gamma$}
@cite{- gamma}, with a slight bit of roundoff error.
To get a full 12 digits, let's use a higher precision:

@group
@smallexample
2:  -0.577215664892      2:  -0.577215664892
1:  1.                   1:  -0.577215664901532

    1. RET                   p 16 RET X
@end smallexample
@end group

Here's the complete sequence of keystrokes:

@group
@example
C-x ( Z `  s 1  0 t 2
           RET 5 a <  Z [  5 Z (  & s + 2  1 s + 1  1 Z ) r 1  Z ]
           L r 1 2 * & - r 2 -
           2 RET 40  Z (  RET k b TAB RET r 1 TAB ^ * /
                          TAB RET M-TAB - RET M-TAB a = Z /
                  2  Z )
      Z '
C-x )
@end example
@end group

@node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
@subsection Programming Tutorial Exercise 10

@noindent
Taking the derivative of a term of the form @cite{x^n} will produce
a term like @c{$n x^{n-1}$}
@cite{n x^(n-1)}.  Taking the derivative of a constant
produces zero.  From this it is easy to see that the @cite{n}th
derivative of a polynomial, evaluated at @cite{x = 0}, will equal the
coefficient on the @cite{x^n} term times @cite{n!}.

(Because this definition is long, it will be repeated in concise form
below.  You can use @w{@kbd{M-# m}} to load it from there.  While you are
entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
keystrokes without executing them.  In the following diagrams we'll
pretend Calc actually executed the keystrokes as you typed them,
just for purposes of illustration.)

@group
@smallexample
2:  5 x^4 + (x + 1)^2          3:  5 x^4 + (x + 1)^2
1:  6                          2:  0
    .                          1:  6
                                   .

  ' 5 x^4 + (x+1)^2 RET 6        C-x ( Z `  [ ] t 1  0 TAB
@end smallexample
@end group

@noindent
Variable 1 will accumulate the vector of coefficients.

@group
@smallexample
2:  0              3:  0                  2:  5 x^4 + ...
1:  5 x^4 + ...    2:  5 x^4 + ...        1:  1
    .              1:  1                      .
                       .

   Z ( TAB         RET 0 s l x RET            M-TAB ! /  s | 1
@end smallexample
@end group

@noindent
Note that @kbd{s | 1} appends the top-of-stack value to the vector
in a variable; it is completely analogous to @kbd{s + 1}.  We could
have written instead, @kbd{r 1 TAB | t 1}.

@group
@smallexample
1:  20 x^3 + 2 x + 2      1:  0         1:  [1, 2, 1, 0, 5, 0, 0]
    .                         .             .

    a d x RET                 1 Z )         DEL r 1  Z ' C-x )
@end smallexample
@end group

To convert back, a simple method is just to map the coefficients
against a table of powers of @cite{x}.

@group
@smallexample
2:  [1, 2, 1, 0, 5, 0, 0]    2:  [1, 2, 1, 0, 5, 0, 0]
1:  6                        1:  [0, 1, 2, 3, 4, 5, 6]
    .                            .

    6 RET                        1 + 0 RET 1 C-u v x

@end smallexample
@end group
@noindent
@group
@smallexample
2:  [1, 2, 1, 0, 5, 0, 0]    2:  1 + 2 x + x^2 + 5 x^4
1:  [1, x, x^2, x^3, ... ]       .
    .

    ' x RET TAB V M ^            *
@end smallexample
@end group

Once again, here are the whole polynomial to/from vector programs:

@group
@example
C-x ( Z `  [ ] t 1  0 TAB
           Z (  TAB RET 0 s l x RET M-TAB ! /  s | 1
                a d x RET
         1 Z ) r 1
      Z '
C-x )

C-x (  1 + 0 RET 1 C-u v x ' x RET TAB V M ^ *  C-x )
@end example
@end group

@node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
@subsection Programming Tutorial Exercise 11

@noindent
First we define a dummy program to go on the @kbd{z s} key.  The true
@w{@kbd{z s}} key is supposed to take two numbers from the stack and
return one number, so @kbd{DEL} as a dummy definition will make
sure the stack comes out right.

@group
@smallexample
2:  4          1:  4                         2:  4
1:  2              .                         1:  2
    .                                            .

  4 RET 2       C-x ( DEL C-x )  Z K s RET       2
@end smallexample
@end group

The last step replaces the 2 that was eaten during the creation
of the dummy @kbd{z s} command.  Now we move on to the real
definition.  The recurrence needs to be rewritten slightly,
to the form @cite{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.

(Because this definition is long, it will be repeated in concise form
below.  You can use @kbd{M-# m} to load it from there.)

@group
@smallexample
2:  4        4:  4       3:  4       2:  4
1:  2        3:  2       2:  2       1:  2
    .        2:  4       1:  0           .
             1:  2           .
                 .

  C-x (       M-2 RET        a =         Z [  DEL DEL 1  Z :

@end smallexample
@end group
@noindent
@group
@smallexample
4:  4       2:  4                     2:  3      4:  3    4:  3    3:  3
3:  2       1:  2                     1:  2      3:  2    3:  2    2:  2
2:  2           .                         .      2:  3    2:  3    1:  3
1:  0                                            1:  2    1:  1        .
    .                                                .        .

  RET 0   a = Z [  DEL DEL 0  Z :  TAB 1 - TAB   M-2 RET     1 -      z s
@end smallexample
@end group

@noindent
(Note that the value 3 that our dummy @kbd{z s} produces is not correct;
it is merely a placeholder that will do just as well for now.)

@group
@smallexample
3:  3               4:  3           3:  3       2:  3      1:  -6
2:  3               3:  3           2:  3       1:  9          .
1:  2               2:  3           1:  3           .
    .               1:  2               .
                        .

 M-TAB M-TAB     TAB RET M-TAB         z s          *          -

@end smallexample
@end group
@noindent
@group
@smallexample
1:  -6                          2:  4          1:  11      2:  11
    .                           1:  2              .       1:  11
                                    .                          .

  Z ] Z ] C-x )   Z K s RET      DEL 4 RET 2       z s      M-RET k s
@end smallexample
@end group

Even though the result that we got during the definition was highly
bogus, once the definition is complete the @kbd{z s} command gets
the right answers.

Here's the full program once again:

@group
@example
C-x (  M-2 RET a =
       Z [  DEL DEL 1
       Z :  RET 0 a =
            Z [  DEL DEL 0
            Z :  TAB 1 - TAB M-2 RET 1 - z s
                 M-TAB M-TAB TAB RET M-TAB z s * -
            Z ]
       Z ]
C-x )
@end example
@end group

You can read this definition using @kbd{M-# m} (@code{read-kbd-macro})
followed by @kbd{Z K s}, without having to make a dummy definition
first, because @code{read-kbd-macro} doesn't need to execute the
definition as it reads it in.  For this reason, @code{M-# m} is often
the easiest way to create recursive programs in Calc.

@node Programming Answer 12, , Programming Answer 11, Answers to Exercises
@subsection Programming Tutorial Exercise 12

@noindent
This turns out to be a much easier way to solve the problem.  Let's
denote Stirling numbers as calls of the function @samp{s}.

First, we store the rewrite rules corresponding to the definition of
Stirling numbers in a convenient variable:

@smallexample
s e StirlingRules RET
[ s(n,n) := 1  :: n >= 0,
  s(n,0) := 0  :: n > 0,
  s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
C-c C-c
@end smallexample

Now, it's just a matter of applying the rules:

@group
@smallexample
2:  4          1:  s(4, 2)              1:  11
1:  2              .                        .
    .

  4 RET 2       C-x (  ' s($$,$) RET     a r StirlingRules RET  C-x )
@end smallexample
@end group

As in the case of the @code{fib} rules, it would be useful to put these
rules in @code{EvalRules} and to add a @samp{:: remember} condition to
the last rule.

@c This ends the table-of-contents kludge from above:
@tex
\global\let\chapternofonts=\oldchapternofonts
@end tex

@c [reference]

@node Introduction, Data Types, Tutorial, Top
@chapter Introduction

@noindent
This chapter is the beginning of the Calc reference manual.
It covers basic concepts such as the stack, algebraic and
numeric entry, undo, numeric prefix arguments, etc.

@c [when-split]
@c (Chapter 2, the Tutorial, has been printed in a separate volume.)

@menu
* Basic Commands::
* Help Commands::
* Stack Basics::
* Numeric Entry::
* Algebraic Entry::
* Quick Calculator::
* Keypad Mode::
* Prefix Arguments::
* Undo::
* Error Messages::
* Multiple Calculators::
* Troubleshooting Commands::
@end menu

@node Basic Commands, Help Commands, Introduction, Introduction
@section Basic Commands

@noindent
@pindex calc
@pindex calc-mode
@cindex Starting the Calculator
@cindex Running the Calculator
To start the Calculator in its standard interface, type @kbd{M-x calc}.
By default this creates a pair of small windows, @samp{*Calculator*}
and @samp{*Calc Trail*}.  The former displays the contents of the
Calculator stack and is manipulated exclusively through Calc commands.
It is possible (though not usually necessary) to create several Calc
Mode buffers each of which has an independent stack, undo list, and
mode settings.  There is exactly one Calc Trail buffer; it records a
list of the results of all calculations that have been done.  The
Calc Trail buffer uses a variant of Calc Mode, so Calculator commands
still work when the trail buffer's window is selected.  It is possible
to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
still exists and is updated silently.  @xref{Trail Commands}.@refill

@kindex M-# c
@kindex M-# M-#
@c @mindex @null
@kindex M-# #
In most installations, the @kbd{M-# c} key sequence is a more
convenient way to start the Calculator.  Also, @kbd{M-# M-#} and
@kbd{M-# #} are synonyms for @kbd{M-# c} unless you last used Calc
in its ``keypad'' mode.

@kindex x
@kindex M-x
@pindex calc-execute-extended-command
Most Calc commands use one or two keystrokes.  Lower- and upper-case
letters are distinct.  Commands may also be entered in full @kbd{M-x} form;
for some commands this is the only form.  As a convenience, the @kbd{x}
key (@code{calc-execute-extended-command})
is like @kbd{M-x} except that it enters the initial string @samp{calc-}
for you.  For example, the following key sequences are equivalent:
@kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.@refill

@cindex Extensions module
@cindex @file{calc-ext} module
The Calculator exists in many parts.  When you type @kbd{M-# c}, the
Emacs ``auto-load'' mechanism will bring in only the first part, which
contains the basic arithmetic functions.  The other parts will be
auto-loaded the first time you use the more advanced commands like trig
functions or matrix operations.  This is done to improve the response time
of the Calculator in the common case when all you need to do is a
little arithmetic.  If for some reason the Calculator fails to load an
extension module automatically, you can force it to load all the
extensions by using the @kbd{M-# L} (@code{calc-load-everything})
command.  @xref{Mode Settings}.@refill

If you type @kbd{M-x calc} or @kbd{M-# c} with any numeric prefix argument,
the Calculator is loaded if necessary, but it is not actually started.
If the argument is positive, the @file{calc-ext} extensions are also
loaded if necessary.  User-written Lisp code that wishes to make use
of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
to auto-load the Calculator.@refill

@kindex M-# b
@pindex full-calc
If you type @kbd{M-# b}, then next time you use @kbd{M-# c} you
will get a Calculator that uses the full height of the Emacs screen.
When full-screen mode is on, @kbd{M-# c} runs the @code{full-calc}
command instead of @code{calc}.  From the Unix shell you can type
@samp{emacs -f full-calc} to start a new Emacs specifically for use
as a calculator.  When Calc is started from the Emacs command line
like this, Calc's normal ``quit'' commands actually quit Emacs itself.

@kindex M-# o
@pindex calc-other-window
The @kbd{M-# o} command is like @kbd{M-# c} except that the Calc
window is not actually selected.  If you are already in the Calc
window, @kbd{M-# o} switches you out of it.  (The regular Emacs
@kbd{C-x o} command would also work for this, but it has a
tendency to drop you into the Calc Trail window instead, which
@kbd{M-# o} takes care not to do.)

@c @mindex M-# q
For one quick calculation, you can type @kbd{M-# q} (@code{quick-calc})
which prompts you for a formula (like @samp{2+3/4}).  The result is
displayed at the bottom of the Emacs screen without ever creating
any special Calculator windows.  @xref{Quick Calculator}.

@c @mindex M-# k
Finally, if you are using the X window system you may want to try
@kbd{M-# k} (@code{calc-keypad}) which runs Calc with a
``calculator keypad'' picture as well as a stack display.  Click on
the keys with the mouse to operate the calculator.  @xref{Keypad Mode}.

@kindex q
@pindex calc-quit
@cindex Quitting the Calculator
@cindex Exiting the Calculator
The @kbd{q} key (@code{calc-quit}) exits Calc Mode and closes the
Calculator's window(s).  It does not delete the Calculator buffers.
If you type @kbd{M-x calc} again, the Calculator will reappear with the
contents of the stack intact.  Typing @kbd{M-# c} or @kbd{M-# M-#}
again from inside the Calculator buffer is equivalent to executing
@code{calc-quit}; you can think of @kbd{M-# M-#} as toggling the
Calculator on and off.@refill

@kindex M-# x
The @kbd{M-# x} command also turns the Calculator off, no matter which
user interface (standard, Keypad, or Embedded) is currently active.
It also cancels @code{calc-edit} mode if used from there.

@kindex d SPC
@pindex calc-refresh
@cindex Refreshing a garbled display
@cindex Garbled displays, refreshing
The @kbd{d SPC} key sequence (@code{calc-refresh}) redraws the contents
of the Calculator buffer from memory.  Use this if the contents of the
buffer have been damaged somehow.

@c @mindex o
The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
``home'' position at the bottom of the Calculator buffer.

@kindex <
@kindex >
@pindex calc-scroll-left
@pindex calc-scroll-right
@cindex Horizontal scrolling
@cindex Scrolling
@cindex Wide text, scrolling
The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
@code{calc-scroll-right}.  These are just like the normal horizontal
scrolling commands except that they scroll one half-screen at a time by
default.  (Calc formats its output to fit within the bounds of the
window whenever it can.)@refill

@kindex @{
@kindex @}
@pindex calc-scroll-down
@pindex calc-scroll-up
@cindex Vertical scrolling
The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
and @code{calc-scroll-up}.  They scroll up or down by one-half the
height of the Calc window.@refill

@kindex M-# 0
@pindex calc-reset
The @kbd{M-# 0} command (@code{calc-reset}; that's @kbd{M-#} followed
by a zero) resets the Calculator to its default state.  This clears
the stack, resets all the modes, clears the caches (@pxref{Caches}),
and so on.  (It does @emph{not} erase the values of any variables.)
With a numeric prefix argument, @kbd{M-# 0} preserves the contents
of the stack but resets everything else.

@pindex calc-version
The @kbd{M-x calc-version} command displays the current version number
of Calc and the name of the person who installed it on your system.
(This information is also present in the @samp{*Calc Trail*} buffer,
and in the output of the @kbd{h h} command.)

@node Help Commands, Stack Basics, Basic Commands, Introduction
@section Help Commands

@noindent
@cindex Help commands
@kindex ?
@pindex calc-help
The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
@key{ESC} and @kbd{C-x} prefixes.  You can type
@kbd{?} after a prefix to see a list of commands beginning with that
prefix.  (If the message includes @samp{[MORE]}, press @kbd{?} again
to see additional commands for that prefix.)

@kindex h h
@pindex calc-full-help
The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
responses at once.  When printed, this makes a nice, compact (three pages)
summary of Calc keystrokes.

In general, the @kbd{h} key prefix introduces various commands that
provide help within Calc.  Many of the @kbd{h} key functions are
Calc-specific analogues to the @kbd{C-h} functions for Emacs help.

@kindex h i
@kindex M-# i
@kindex i
@pindex calc-info
The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
to read this manual on-line.  This is basically the same as typing
@kbd{C-h i} (the regular way to run the Info system), then, if Info
is not already in the Calc manual, selecting the beginning of the
manual.  The @kbd{M-# i} command is another way to read the Calc
manual; it is different from @kbd{h i} in that it works any time,
not just inside Calc.  The plain @kbd{i} key is also equivalent to
@kbd{h i}, though this key is obsolete and may be replaced with a
different command in a future version of Calc.

@kindex h t
@kindex M-# t
@pindex calc-tutorial
The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
the Tutorial section of the Calc manual.  It is like @kbd{h i},
except that it selects the starting node of the tutorial rather
than the beginning of the whole manual.  (It actually selects the
node ``Interactive Tutorial'' which tells a few things about
using the Info system before going on to the actual tutorial.)
The @kbd{M-# t} key is equivalent to @kbd{h t} (but it works at
all times).

@kindex h s
@kindex M-# s
@pindex calc-info-summary
The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
on the Summary node of the Calc manual.  @xref{Summary}.  The @kbd{M-# s}
key is equivalent to @kbd{h s}.

@kindex h k
@pindex calc-describe-key
The @kbd{h k} (@code{calc-describe-key}) command looks up a key
sequence in the Calc manual.  For example, @kbd{h k H a S} looks
up the documentation on the @kbd{H a S} (@code{calc-solve-for})
command.  This works by looking up the textual description of
the key(s) in the Key Index of the manual, then jumping to the
node indicated by the index.

Most Calc commands do not have traditional Emacs documentation
strings, since the @kbd{h k} command is both more convenient and
more instructive.  This means the regular Emacs @kbd{C-h k}
(@code{describe-key}) command will not be useful for Calc keystrokes.

@kindex h c
@pindex calc-describe-key-briefly
The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
key sequence and displays a brief one-line description of it at
the bottom of the screen.  It looks for the key sequence in the
Summary node of the Calc manual; if it doesn't find the sequence
there, it acts just like its regular Emacs counterpart @kbd{C-h c}
(@code{describe-key-briefly}).  For example, @kbd{h c H a S}
gives the description:

@smallexample
H a S runs calc-solve-for:  a `H a S' v  => fsolve(a,v)  (?=notes)
@end smallexample

@noindent
which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
takes a value @cite{a} from the stack, prompts for a value @cite{v},
then applies the algebraic function @code{fsolve} to these values.
The @samp{?=notes} message means you can now type @kbd{?} to see
additional notes from the summary that apply to this command.

@kindex h f
@pindex calc-describe-function
The @kbd{h f} (@code{calc-describe-function}) command looks up an
algebraic function or a command name in the Calc manual.  The
prompt initially contains @samp{calcFunc-}; follow this with an
algebraic function name to look up that function in the Function
Index.  Or, backspace and enter a command name beginning with
@samp{calc-} to look it up in the Command Index.  This command
will also look up operator symbols that can appear in algebraic
formulas, like @samp{%} and @samp{=>}.

@kindex h v
@pindex calc-describe-variable
The @kbd{h v} (@code{calc-describe-variable}) command looks up a
variable in the Calc manual.  The prompt initially contains the
@samp{var-} prefix; just add a variable name like @code{pi} or
@code{PlotRejects}.

@kindex h b
@pindex describe-bindings
The @kbd{h b} (@code{calc-describe-bindings}) command is just like
@kbd{C-h b}, except that only local (Calc-related) key bindings are
listed.

@kindex h n
The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
the ``news'' or change history of Calc.  This is kept in the file
@file{README}, which Calc looks for in the same directory as the Calc
source files.

@kindex h C-c
@kindex h C-d
@kindex h C-w
The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
distribution, and warranty information about Calc.  These work by
pulling up the appropriate parts of the ``Copying'' or ``Reporting
Bugs'' sections of the manual.

@node Stack Basics, Numeric Entry, Help Commands, Introduction
@section Stack Basics

@noindent
@cindex Stack basics
@c [fix-tut RPN Calculations and the Stack]
Calc uses RPN notation.  If you are not familar with RPN, @pxref{RPN
Tutorial}.

To add the numbers 1 and 2 in Calc you would type the keys:
@kbd{1 @key{RET} 2 +}.
(@key{RET} corresponds to the @key{ENTER} key on most calculators.)
The first three keystrokes ``push'' the numbers 1 and 2 onto the stack.  The
@kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
and pushes the result (3) back onto the stack.  This number is ready for
further calculations:  @kbd{5 -} pushes 5 onto the stack, then pops the
3 and 5, subtracts them, and pushes the result (@i{-2}).@refill

Note that the ``top'' of the stack actually appears at the @emph{bottom}
of the buffer.  A line containing a single @samp{.} character signifies
the end of the buffer; Calculator commands operate on the number(s)
directly above this line.  The @kbd{d t} (@code{calc-truncate-stack})
command allows you to move the @samp{.} marker up and down in the stack;
@pxref{Truncating the Stack}.

@kindex d l
@pindex calc-line-numbering
Stack elements are numbered consecutively, with number 1 being the top of
the stack.  These line numbers are ordinarily displayed on the lefthand side
of the window.  The @kbd{d l} (@code{calc-line-numbering}) command controls
whether these numbers appear.  (Line numbers may be turned off since they
slow the Calculator down a bit and also clutter the display.)

@kindex o
@pindex calc-realign
The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
the cursor to its top-of-stack ``home'' position.  It also undoes any
horizontal scrolling in the window.  If you give it a numeric prefix
argument, it instead moves the cursor to the specified stack element.

The @key{RET} (or equivalent @key{SPC}) key is only required to separate
two consecutive numbers.
(After all, if you typed @kbd{1 2} by themselves the Calculator
would enter the number 12.)  If you press @kbd{RET} or @kbd{SPC} @emph{not}
right after typing a number, the key duplicates the number on the top of
the stack.  @kbd{@key{RET} *} is thus a handy way to square a number.@refill

The @key{DEL} key pops and throws away the top number on the stack.
The @key{TAB} key swaps the top two objects on the stack.
@xref{Stack and Trail}, for descriptions of these and other stack-related
commands.@refill

@node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
@section Numeric Entry

@noindent
@kindex 0-9
@kindex .
@kindex e
@cindex Numeric entry
@cindex Entering numbers
Pressing a digit or other numeric key begins numeric entry using the
minibuffer.  The number is pushed on the stack when you press the @key{RET}
or @key{SPC} keys.  If you press any other non-numeric key, the number is
pushed onto the stack and the appropriate operation is performed.  If
you press a numeric key which is not valid, the key is ignored.

@cindex Minus signs
@cindex Negative numbers, entering
@kindex _
There are three different concepts corresponding to the word ``minus,''
typified by @cite{a-b} (subtraction), @cite{-x}
(change-sign), and @cite{-5} (negative number).  Calc uses three
different keys for these operations, respectively:
@kbd{-}, @kbd{n}, and @kbd{_} (the underscore).  The @kbd{-} key subtracts
the two numbers on the top of the stack.  The @kbd{n} key changes the sign
of the number on the top of the stack or the number currently being entered.
The @kbd{_} key begins entry of a negative number or changes the sign of
the number currently being entered.  The following sequences all enter the
number @i{-5} onto the stack:  @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
@kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.@refill

Some other keys are active during numeric entry, such as @kbd{#} for
non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
These notations are described later in this manual with the corresponding
data types.  @xref{Data Types}.

During numeric entry, the only editing key available is @kbd{DEL}.

@node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
@section Algebraic Entry

@noindent
@kindex '
@pindex calc-algebraic-entry
@cindex Algebraic notation
@cindex Formulas, entering
Calculations can also be entered in algebraic form.  This is accomplished
by typing the apostrophe key, @kbd{'}, followed by the expression in
standard format:  @kbd{@key{'} 2+3*4 @key{RET}} computes
@c{$2+(3\times4) = 14$}
@cite{2+(3*4) = 14} and pushes that on the stack.  If you wish you can
ignore the RPN aspect of Calc altogether and simply enter algebraic
expressions in this way.  You may want to use @key{DEL} every so often to
clear previous results off the stack.@refill

You can press the apostrophe key during normal numeric entry to switch
the half-entered number into algebraic entry mode.  One reason to do this
would be to use the full Emacs cursor motion and editing keys, which are
available during algebraic entry but not during numeric entry.

In the same vein, during either numeric or algebraic entry you can
press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
you complete your half-finished entry in a separate buffer.
@xref{Editing Stack Entries}.

@kindex m a
@pindex calc-algebraic-mode
@cindex Algebraic mode
If you prefer algebraic entry, you can use the command @kbd{m a}
(@code{calc-algebraic-mode}) to set Algebraic mode.  In this mode,
digits and other keys that would normally start numeric entry instead
start full algebraic entry; as long as your formula begins with a digit
you can omit the apostrophe.  Open parentheses and square brackets also
begin algebraic entry.  You can still do RPN calculations in this mode,
but you will have to press @key{RET} to terminate every number:
@kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
thing as @kbd{2*3+4 @key{RET}}.@refill

@cindex Incomplete algebraic mode
If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
command, it enables Incomplete Algebraic mode; this is like regular
Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
only.  Numeric keys still begin a numeric entry in this mode.

@kindex m t
@pindex calc-total-algebraic-mode
@cindex Total algebraic mode
The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
stronger algebraic-entry mode, in which @emph{all} regular letter and
punctuation keys begin algebraic entry.  Use this if you prefer typing
@w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
@kbd{a f}, and so on.  To type regular Calc commands when you are in
``total'' algebraic mode, hold down the @key{META} key.  Thus @kbd{M-q}
is the command to quit Calc, @kbd{M-p} sets the precision, and
@kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns total algebraic
mode back off again.  Meta keys also terminate algebraic entry, so
that @kbd{2+3 M-S} is equivalent to @kbd{2+3 RET M-S}.  The symbol
@samp{Alg*} will appear in the mode line whenever you are in this mode.

Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
algebraic formula.  You can then use the normal Emacs editing keys to
modify this formula to your liking before pressing @key{RET}.

@kindex $
@cindex Formulas, referring to stack
Within a formula entered from the keyboard, the symbol @kbd{$}
represents the number on the top of the stack.  If an entered formula
contains any @kbd{$} characters, the Calculator replaces the top of
stack with that formula rather than simply pushing the formula onto the
stack.  Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
@key{RET}} replaces it with 6.  Note that the @kbd{$} key always
initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
first character in the new formula.@refill

Higher stack elements can be accessed from an entered formula with the
symbols @kbd{$$}, @kbd{$$$}, and so on.  The number of stack elements
removed (to be replaced by the entered values) equals the number of dollar
signs in the longest such symbol in the formula.  For example, @samp{$$+$$$}
adds the second and third stack elements, replacing the top three elements
with the answer.  (All information about the top stack element is thus lost
since no single @samp{$} appears in this formula.)@refill

A slightly different way to refer to stack elements is with a dollar
sign followed by a number:  @samp{$1}, @samp{$2}, and so on are much
like @samp{$}, @samp{$$}, etc., except that stack entries referred
to numerically are not replaced by the algebraic entry.  That is, while
@samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
on the stack and pushes an additional 6.

If a sequence of formulas are entered separated by commas, each formula
is pushed onto the stack in turn.  For example, @samp{1,2,3} pushes
those three numbers onto the stack (leaving the 3 at the top), and
@samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6.  Also,
@samp{$,$$} exchanges the top two elements of the stack, just like the
@key{TAB} key.

You can finish an algebraic entry with @kbd{M-=} or @kbd{M-RET} instead
of @key{RET}.  This uses @kbd{=} to evaluate the variables in each
formula that goes onto the stack.  (Thus @kbd{' pi @key{RET}} pushes
the variable @samp{pi}, but @kbd{' pi M-RET} pushes 3.1415.)

If you finish your algebraic entry by pressing @kbd{LFD} (or @kbd{C-j})
instead of @key{RET}, Calc disables the default simplifications
(as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
is being pushed on the stack.  Thus @kbd{' 1+2 @key{RET}} pushes 3
on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @cite{1+2};
you might then press @kbd{=} when it is time to evaluate this formula.

@node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
@section ``Quick Calculator'' Mode

@noindent
@kindex M-# q
@pindex quick-calc
@cindex Quick Calculator
There is another way to invoke the Calculator if all you need to do
is make one or two quick calculations.  Type @kbd{M-# q} (or
@kbd{M-x quick-calc}), then type any formula as an algebraic entry.
The Calculator will compute the result and display it in the echo
area, without ever actually putting up a Calc window.

You can use the @kbd{$} character in a Quick Calculator formula to
refer to the previous Quick Calculator result.  Older results are
not retained; the Quick Calculator has no effect on the full
Calculator's stack or trail.  If you compute a result and then
forget what it was, just run @code{M-# q} again and enter
@samp{$} as the formula.

If this is the first time you have used the Calculator in this Emacs
session, the @kbd{M-# q} command will create the @code{*Calculator*}
buffer and perform all the usual initializations; it simply will
refrain from putting that buffer up in a new window.  The Quick
Calculator refers to the @code{*Calculator*} buffer for all mode
settings.  Thus, for example, to set the precision that the Quick
Calculator uses, simply run the full Calculator momentarily and use
the regular @kbd{p} command.

If you use @code{M-# q} from inside the Calculator buffer, the
effect is the same as pressing the apostrophe key (algebraic entry).

The result of a Quick calculation is placed in the Emacs ``kill ring''
as well as being displayed.  A subsequent @kbd{C-y} command will
yank the result into the editing buffer.  You can also use this
to yank the result into the next @kbd{M-# q} input line as a more
explicit alternative to @kbd{$} notation, or to yank the result
into the Calculator stack after typing @kbd{M-# c}.

If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
of @key{RET}, the result is inserted immediately into the current
buffer rather than going into the kill ring.

Quick Calculator results are actually evaluated as if by the @kbd{=}
key (which replaces variable names by their stored values, if any).
If the formula you enter is an assignment to a variable using the
@samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
then the result of the evaluation is stored in that Calc variable.
@xref{Store and Recall}.

If the result is an integer and the current display radix is decimal,
the number will also be displayed in hex and octal formats.  If the
integer is in the range from 1 to 126, it will also be displayed as
an ASCII character.

For example, the quoted character @samp{"x"} produces the vector
result @samp{[120]} (because 120 is the ASCII code of the lower-case
`x'; @pxref{Strings}).  Since this is a vector, not an integer, it
is displayed only according to the current mode settings.  But
running Quick Calc again and entering @samp{120} will produce the
result @samp{120 (16#78, 8#170, x)} which shows the number in its
decimal, hexadecimal, octal, and ASCII forms.

Please note that the Quick Calculator is not any faster at loading
or computing the answer than the full Calculator; the name ``quick''
merely refers to the fact that it's much less hassle to use for
small calculations.

@node Prefix Arguments, Undo, Quick Calculator, Introduction
@section Numeric Prefix Arguments

@noindent
Many Calculator commands use numeric prefix arguments.  Some, such as
@kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
the prefix argument or use a default if you don't use a prefix.
Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
and prompt for a number if you don't give one as a prefix.@refill

As a rule, stack-manipulation commands accept a numeric prefix argument
which is interpreted as an index into the stack.  A positive argument
operates on the top @var{n} stack entries; a negative argument operates
on the @var{n}th stack entry in isolation; and a zero argument operates
on the entire stack.

Most commands that perform computations (such as the arithmetic and
scientific functions) accept a numeric prefix argument that allows the
operation to be applied across many stack elements.  For unary operations
(that is, functions of one argument like absolute value or complex
conjugate), a positive prefix argument applies that function to the top
@var{n} stack entries simultaneously, and a negative argument applies it
to the @var{n}th stack entry only.  For binary operations (functions of
two arguments like addition, GCD, and vector concatenation), a positive
prefix argument ``reduces'' the function across the top @var{n}
stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
@pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
@var{n} stack elements with the top stack element as a second argument
(for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
This feature is not available for operations which use the numeric prefix
argument for some other purpose.

Numeric prefixes are specified the same way as always in Emacs:  Press
a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
or press @kbd{C-u} followed by digits.  Some commands treat plain
@kbd{C-u} (without any actual digits) specially.@refill

@kindex ~
@pindex calc-num-prefix
You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
top of the stack and enter it as the numeric prefix for the next command.
For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
(silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
to the fourth power and set the precision to that value.@refill

Conversely, if you have typed a numeric prefix argument the @kbd{~} key
pushes it onto the stack in the form of an integer.

@node Undo, Error Messages, Prefix Arguments, Introduction
@section Undoing Mistakes

@noindent
@kindex U
@kindex C-_
@pindex calc-undo
@cindex Mistakes, undoing
@cindex Undoing mistakes
@cindex Errors, undoing
The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
If that operation added or dropped objects from the stack, those objects
are removed or restored.  If it was a ``store'' operation, you are
queried whether or not to restore the variable to its original value.
The @kbd{U} key may be pressed any number of times to undo successively
farther back in time; with a numeric prefix argument it undoes a
specified number of operations.  The undo history is cleared only by the
@kbd{q} (@code{calc-quit}) command.  (Recall that @kbd{M-# c} is
synonymous with @code{calc-quit} while inside the Calculator; this
also clears the undo history.)

Currently the mode-setting commands (like @code{calc-precision}) are not
undoable.  You can undo past a point where you changed a mode, but you
will need to reset the mode yourself.

@kindex D
@pindex calc-redo
@cindex Redoing after an Undo
The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
mistakenly undone.  Pressing @kbd{U} with a negative prefix argument is
equivalent to executing @code{calc-redo}.  You can redo any number of
times, up to the number of recent consecutive undo commands.  Redo
information is cleared whenever you give any command that adds new undo
information, i.e., if you undo, then enter a number on the stack or make
any other change, then it will be too late to redo.

@kindex M-RET
@pindex calc-last-args
@cindex Last-arguments feature
@cindex Arguments, restoring
The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
it restores the arguments of the most recent command onto the stack;
however, it does not remove the result of that command.  Given a numeric
prefix argument, this command applies to the @cite{n}th most recent
command which removed items from the stack; it pushes those items back
onto the stack.

The @kbd{K} (@code{calc-keep-args}) command provides a related function
to @kbd{M-@key{RET}}.  @xref{Stack and Trail}.

It is also possible to recall previous results or inputs using the trail.
@xref{Trail Commands}.

The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.

@node Error Messages, Multiple Calculators, Undo, Introduction
@section Error Messages

@noindent
@kindex w
@pindex calc-why
@cindex Errors, messages
@cindex Why did an error occur?
Many situations that would produce an error message in other calculators
simply create unsimplified formulas in the Emacs Calculator.  For example,
@kbd{1 @key{RET} 0 /} pushes the formula @cite{1 / 0}; @w{@kbd{0 L}} pushes
the formula @samp{ln(0)}.  Floating-point overflow and underflow are also
reasons for this to happen.

When a function call must be left in symbolic form, Calc usually
produces a message explaining why.  Messages that are probably
surprising or indicative of user errors are displayed automatically.
Other messages are simply kept in Calc's memory and are displayed only
if you type @kbd{w} (@code{calc-why}).  You can also press @kbd{w} if
the same computation results in several messages.  (The first message
will end with @samp{[w=more]} in this case.)

@kindex d w
@pindex calc-auto-why
The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
are displayed automatically.  (Calc effectively presses @kbd{w} for you
after your computation finishes.)  By default, this occurs only for
``important'' messages.  The other possible modes are to report
@emph{all} messages automatically, or to report none automatically (so
that you must always press @kbd{w} yourself to see the messages).

@node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
@section Multiple Calculators

@noindent
@pindex another-calc
It is possible to have any number of Calc Mode buffers at once.
Usually this is done by executing @kbd{M-x another-calc}, which
is similar to @kbd{M-# c} except that if a @samp{*Calculator*}
buffer already exists, a new, independent one with a name of the
form @samp{*Calculator*<@var{n}>} is created.  You can also use the
command @code{calc-mode} to put any buffer into Calculator mode, but
this would ordinarily never be done.

The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
it only closes its window.  Use @kbd{M-x kill-buffer} to destroy a
Calculator buffer.

Each Calculator buffer keeps its own stack, undo list, and mode settings
such as precision, angular mode, and display formats.  In Emacs terms,
variables such as @code{calc-stack} are buffer-local variables.  The
global default values of these variables are used only when a new
Calculator buffer is created.  The @code{calc-quit} command saves
the stack and mode settings of the buffer being quit as the new defaults.

There is only one trail buffer, @samp{*Calc Trail*}, used by all
Calculator buffers.

@node Troubleshooting Commands, , Multiple Calculators, Introduction
@section Troubleshooting Commands

@noindent
This section describes commands you can use in case a computation
incorrectly fails or gives the wrong answer.

@xref{Reporting Bugs}, if you find a problem that appears to be due
to a bug or deficiency in Calc.

@menu
* Autoloading Problems::
* Recursion Depth::
* Caches::
* Debugging Calc::
@end menu

@node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
@subsection Autoloading Problems

@noindent
The Calc program is split into many component files; components are
loaded automatically as you use various commands that require them.
Occasionally Calc may lose track of when a certain component is
necessary; typically this means you will type a command and it won't
work because some function you've never heard of was undefined.

@kindex M-# L
@pindex calc-load-everything
If this happens, the easiest workaround is to type @kbd{M-# L}
(@code{calc-load-everything}) to force all the parts of Calc to be
loaded right away.  This will cause Emacs to take up a lot more
memory than it would otherwise, but it's guaranteed to fix the problem.

If you seem to run into this problem no matter what you do, or if
even the @kbd{M-# L} command crashes, Calc may have been improperly
installed.  @xref{Installation}, for details of the installation
process.

@node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
@subsection Recursion Depth

@noindent
@kindex M
@kindex I M
@pindex calc-more-recursion-depth
@pindex calc-less-recursion-depth
@cindex Recursion depth
@cindex ``Computation got stuck'' message
@cindex @code{max-lisp-eval-depth}
@cindex @code{max-specpdl-size}
Calc uses recursion in many of its calculations.  Emacs Lisp keeps a
variable @code{max-lisp-eval-depth} which limits the amount of recursion
possible in an attempt to recover from program bugs.  If a calculation
ever halts incorrectly with the message ``Computation got stuck or
ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
to increase this limit.  (Of course, this will not help if the
calculation really did get stuck due to some problem inside Calc.)@refill

The limit is always increased (multiplied) by a factor of two.  There
is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
decreases this limit by a factor of two, down to a minimum value of 200.
The default value is 1000.

These commands also double or halve @code{max-specpdl-size}, another
internal Lisp recursion limit.  The minimum value for this limit is 600.

@node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
@subsection Caches

@noindent
@cindex Caches
@cindex Flushing caches
Calc saves certain values after they have been computed once.  For
example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
constant @c{$\pi$}
@cite{pi} to about 20 decimal places; if the current precision
is greater than this, it will recompute @c{$\pi$}
@cite{pi} using a series
approximation.  This value will not need to be recomputed ever again
unless you raise the precision still further.  Many operations such as
logarithms and sines make use of similarly cached values such as
@c{$\pi \over 4$}
@cite{pi/4} and @c{$\ln 2$}
@cite{ln(2)}.  The visible effect of caching is that
high-precision computations may seem to do extra work the first time.
Other things cached include powers of two (for the binary arithmetic
functions), matrix inverses and determinants, symbolic integrals, and
data points computed by the graphing commands.

@pindex calc-flush-caches
If you suspect a Calculator cache has become corrupt, you can use the
@code{calc-flush-caches} command to reset all caches to the empty state.
(This should only be necessary in the event of bugs in the Calculator.)
The @kbd{M-# 0} (with the zero key) command also resets caches along
with all other aspects of the Calculator's state.

@node Debugging Calc, , Caches, Troubleshooting Commands
@subsection Debugging Calc

@noindent
A few commands exist to help in the debugging of Calc commands.
@xref{Programming}, to see the various ways that you can write
your own Calc commands.

@kindex Z T
@pindex calc-timing
The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
in which the timing of slow commands is reported in the Trail.
Any Calc command that takes two seconds or longer writes a line
to the Trail showing how many seconds it took.  This value is
accurate only to within one second.

All steps of executing a command are included; in particular, time
taken to format the result for display in the stack and trail is
counted.  Some prompts also count time taken waiting for them to
be answered, while others do not; this depends on the exact
implementation of the command.  For best results, if you are timing
a sequence that includes prompts or multiple commands, define a
keyboard macro to run the whole sequence at once.  Calc's @kbd{X}
command (@pxref{Keyboard Macros}) will then report the time taken
to execute the whole macro.

Another advantage of the @kbd{X} command is that while it is
executing, the stack and trail are not updated from step to step.
So if you expect the output of your test sequence to leave a result
that may take a long time to format and you don't wish to count
this formatting time, end your sequence with a @key{DEL} keystroke
to clear the result from the stack.  When you run the sequence with
@kbd{X}, Calc will never bother to format the large result.

Another thing @kbd{Z T} does is to increase the Emacs variable
@code{gc-cons-threshold} to a much higher value (two million; the
usual default in Calc is 250,000) for the duration of each command.
This generally prevents garbage collection during the timing of
the command, though it may cause your Emacs process to grow
abnormally large.  (Garbage collection time is a major unpredictable
factor in the timing of Emacs operations.)

Another command that is useful when debugging your own Lisp
extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
the error handler that changes the ``@code{max-lisp-eval-depth}
exceeded'' message to the much more friendly ``Computation got
stuck or ran too long.''  This handler interferes with the Emacs
Lisp debugger's @code{debug-on-error} mode.  Errors are reported
in the handler itself rather than at the true location of the
error.  After you have executed @code{calc-pass-errors}, Lisp
errors will be reported correctly but the user-friendly message
will be lost.

@node Data Types, Stack and Trail, Introduction, Top
@chapter Data Types

@noindent
This chapter discusses the various types of objects that can be placed
on the Calculator stack, how they are displayed, and how they are
entered.  (@xref{Data Type Formats}, for information on how these data
types are represented as underlying Lisp objects.)@refill

Integers, fractions, and floats are various ways of describing real
numbers.  HMS forms also for many purposes act as real numbers.  These
types can be combined to form complex numbers, modulo forms, error forms,
or interval forms.  (But these last four types cannot be combined
arbitrarily:@: error forms may not contain modulo forms, for example.)
Finally, all these types of numbers may be combined into vectors,
matrices, or algebraic formulas.

@menu
* Integers::                The most basic data type.
* Fractions::               This and above are called @dfn{rationals}.
* Floats::                  This and above are called @dfn{reals}.
* Complex Numbers::         This and above are called @dfn{numbers}.
* Infinities::
* Vectors and Matrices::
* Strings::
* HMS Forms::
* Date Forms::
* Modulo Forms::
* Error Forms::
* Interval Forms::
* Incomplete Objects::
* Variables::
* Formulas::
@end menu

@node Integers, Fractions, Data Types, Data Types
@section Integers

@noindent
@cindex Integers
The Calculator stores integers to arbitrary precision.  Addition,
subtraction, and multiplication of integers always yields an exact
integer result.  (If the result of a division or exponentiation of
integers is not an integer, it is expressed in fractional or
floating-point form according to the current Fraction Mode.
@xref{Fraction Mode}.)

A decimal integer is represented as an optional sign followed by a
sequence of digits.  Grouping (@pxref{Grouping Digits}) can be used to
insert a comma at every third digit for display purposes, but you
must not type commas during the entry of numbers.@refill

@kindex #
A non-decimal integer is represented as an optional sign, a radix
between 2 and 36, a @samp{#} symbol, and one or more digits.  For radix 11
and above, the letters A through Z (upper- or lower-case) count as
digits and do not terminate numeric entry mode.  @xref{Radix Modes}, for how
to set the default radix for display of integers.  Numbers of any radix
may be entered at any time.  If you press @kbd{#} at the beginning of a
number, the current display radix is used.@refill

@node Fractions, Floats, Integers, Data Types
@section Fractions

@noindent
@cindex Fractions
A @dfn{fraction} is a ratio of two integers.  Fractions are traditionally
written ``2/3'' but Calc uses the notation @samp{2:3}.  (The @kbd{/} key
performs RPN division; the following two sequences push the number
@samp{2:3} on the stack:  @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
assuming Fraction Mode has been enabled.)
When the Calculator produces a fractional result it always reduces it to
simplest form, which may in fact be an integer.@refill

Fractions may also be entered in a three-part form, where @samp{2:3:4}
represents two-and-three-quarters.  @xref{Fraction Formats}, for fraction
display formats.@refill

Non-decimal fractions are entered and displayed as
@samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
form).  The numerator and denominator always use the same radix.@refill

@node Floats, Complex Numbers, Fractions, Data Types
@section Floats

@noindent
@cindex Floating-point numbers
A floating-point number or @dfn{float} is a number stored in scientific
notation.  The number of significant digits in the fractional part is
governed by the current floating precision (@pxref{Precision}).  The
range of acceptable values is from @c{$10^{-3999999}$}
@cite{10^-3999999} (inclusive)
to @c{$10^{4000000}$}
@cite{10^4000000}
(exclusive), plus the corresponding negative
values and zero.

Calculations that would exceed the allowable range of values (such
as @samp{exp(exp(20))}) are left in symbolic form by Calc.  The
messages ``floating-point overflow'' or ``floating-point underflow''
indicate that during the calculation a number would have been produced
that was too large or too close to zero, respectively, to be represented
by Calc.  This does not necessarily mean the final result would have
overflowed, just that an overflow occurred while computing the result.
(In fact, it could report an underflow even though the final result
would have overflowed!)

If a rational number and a float are mixed in a calculation, the result
will in general be expressed as a float.  Commands that require an integer
value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
floats, i.e., floating-point numbers with nothing after the decimal point.

Floats are identified by the presence of a decimal point and/or an
exponent.  In general a float consists of an optional sign, digits
including an optional decimal point, and an optional exponent consisting
of an @samp{e}, an optional sign, and up to seven exponent digits.
For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
or 0.235.

Floating-point numbers are normally displayed in decimal notation with
all significant figures shown.  Exceedingly large or small numbers are
displayed in scientific notation.  Various other display options are
available.  @xref{Float Formats}.

@cindex Accuracy of calculations
Floating-point numbers are stored in decimal, not binary.  The result
of each operation is rounded to the nearest value representable in the
number of significant digits specified by the current precision,
rounding away from zero in the case of a tie.  Thus (in the default
display mode) what you see is exactly what you get.  Some operations such
as square roots and transcendental functions are performed with several
digits of extra precision and then rounded down, in an effort to make the
final result accurate to the full requested precision.  However,
accuracy is not rigorously guaranteed.  If you suspect the validity of a
result, try doing the same calculation in a higher precision.  The
Calculator's arithmetic is not intended to be IEEE-conformant in any
way.@refill

While floats are always @emph{stored} in decimal, they can be entered
and displayed in any radix just like integers and fractions.  The
notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point
number whose digits are in the specified radix.  Note that the @samp{.}
is more aptly referred to as a ``radix point'' than as a decimal
point in this case.  The number @samp{8#123.4567} is defined as
@samp{8#1234567 * 8^-4}.  If the radix is 14 or less, you can use
@samp{e} notation to write a non-decimal number in scientific notation.
The exponent is written in decimal, and is considered to be a power
of the radix: @samp{8#1234567e-4}.  If the radix is 15 or above, the
letter @samp{e} is a digit, so scientific notation must be written
out, e.g., @samp{16#123.4567*16^2}.  The first two exercises of the
Modes Tutorial explore some of the properties of non-decimal floats.

@node Complex Numbers, Infinities, Floats, Data Types
@section Complex Numbers

@noindent
@cindex Complex numbers
There are two supported formats for complex numbers: rectangular and
polar.  The default format is rectangular, displayed in the form
@samp{(@var{real},@var{imag})} where @var{real} is the real part and
@var{imag} is the imaginary part, each of which may be any real number.
Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
notation; @pxref{Complex Formats}.@refill

Polar complex numbers are displayed in the form `@t{(}@var{r}@t{;}@c{$\theta$}
@var{theta}@t{)}'
where @var{r} is the nonnegative magnitude and @c{$\theta$}
@var{theta} is the argument
or phase angle.  The range of @c{$\theta$}
@var{theta} depends on the current angular
mode (@pxref{Angular Modes}); it is generally between @i{-180} and
@i{+180} degrees or the equivalent range in radians.@refill

Complex numbers are entered in stages using incomplete objects.
@xref{Incomplete Objects}.

Operations on rectangular complex numbers yield rectangular complex
results, and similarly for polar complex numbers.  Where the two types
are mixed, or where new complex numbers arise (as for the square root of
a negative real), the current @dfn{Polar Mode} is used to determine the
type.  @xref{Polar Mode}.

A complex result in which the imaginary part is zero (or the phase angle
is 0 or 180 degrees or @c{$\pi$}
@cite{pi} radians) is automatically converted to a real
number.

@node Infinities, Vectors and Matrices, Complex Numbers, Data Types
@section Infinities

@noindent
@cindex Infinity
@cindex @code{inf} variable
@cindex @code{uinf} variable
@cindex @code{nan} variable
@vindex inf
@vindex uinf
@vindex nan
The word @code{inf} represents the mathematical concept of @dfn{infinity}.
Calc actually has three slightly different infinity-like values:
@code{inf}, @code{uinf}, and @code{nan}.  These are just regular
variable names (@pxref{Variables}); you should avoid using these
names for your own variables because Calc gives them special
treatment.  Infinities, like all variable names, are normally
entered using algebraic entry.

Mathematically speaking, it is not rigorously correct to treat
``infinity'' as if it were a number, but mathematicians often do
so informally.  When they say that @samp{1 / inf = 0}, what they
really mean is that @cite{1 / x}, as @cite{x} becomes larger and
larger, becomes arbitrarily close to zero.  So you can imagine
that if @cite{x} got ``all the way to infinity,'' then @cite{1 / x}
would go all the way to zero.  Similarly, when they say that
@samp{exp(inf) = inf}, they mean that @c{$e^x$}
@cite{exp(x)} grows without
bound as @cite{x} grows.  The symbol @samp{-inf} likewise stands
for an infinitely negative real value; for example, we say that
@samp{exp(-inf) = 0}.  You can have an infinity pointing in any
direction on the complex plane:  @samp{sqrt(-inf) = i inf}.

The same concept of limits can be used to define @cite{1 / 0}.  We
really want the value that @cite{1 / x} approaches as @cite{x}
approaches zero.  But if all we have is @cite{1 / 0}, we can't
tell which direction @cite{x} was coming from.  If @cite{x} was
positive and decreasing toward zero, then we should say that
@samp{1 / 0 = inf}.  But if @cite{x} was negative and increasing
toward zero, the answer is @samp{1 / 0 = -inf}.  In fact, @cite{x}
could be an imaginary number, giving the answer @samp{i inf} or
@samp{-i inf}.  Calc uses the special symbol @samp{uinf} to mean
@dfn{undirected infinity}, i.e., a value which is infinitely
large but with an unknown sign (or direction on the complex plane).

Calc actually has three modes that say how infinities are handled.
Normally, infinities never arise from calculations that didn't
already have them.  Thus, @cite{1 / 0} is treated simply as an
error and left unevaluated.  The @kbd{m i} (@code{calc-infinite-mode})
command (@pxref{Infinite Mode}) enables a mode in which
@cite{1 / 0} evaluates to @code{uinf} instead.  There is also
an alternative type of infinite mode which says to treat zeros
as if they were positive, so that @samp{1 / 0 = inf}.  While this
is less mathematically correct, it may be the answer you want in
some cases.

Since all infinities are ``as large'' as all others, Calc simplifies,
e.g., @samp{5 inf} to @samp{inf}.  Another example is
@samp{5 - inf = -inf}, where the @samp{-inf} is so large that
adding a finite number like five to it does not affect it.
Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
that variables like @code{a} always stand for finite quantities.
Just to show that infinities really are all the same size,
note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
notation.

It's not so easy to define certain formulas like @samp{0 * inf} and
@samp{inf / inf}.  Depending on where these zeros and infinities
came from, the answer could be literally anything.  The latter
formula could be the limit of @cite{x / x} (giving a result of one),
or @cite{2 x / x} (giving two), or @cite{x^2 / x} (giving @code{inf}),
or @cite{x / x^2} (giving zero).  Calc uses the symbol @code{nan}
to represent such an @dfn{indeterminate} value.  (The name ``nan''
comes from analogy with the ``NAN'' concept of IEEE standard
arithmetic; it stands for ``Not A Number.''  This is somewhat of a
misnomer, since @code{nan} @emph{does} stand for some number or
infinity, it's just that @emph{which} number it stands for
cannot be determined.)  In Calc's notation, @samp{0 * inf = nan}
and @samp{inf / inf = nan}.  A few other common indeterminate
expressions are @samp{inf - inf} and @samp{inf ^ 0}.  Also,
@samp{0 / 0 = nan} if you have turned on ``infinite mode''
(as described above).

Infinities are especially useful as parts of @dfn{intervals}.
@xref{Interval Forms}.

@node Vectors and Matrices, Strings, Infinities, Data Types
@section Vectors and Matrices

@noindent
@cindex Vectors
@cindex Plain vectors
@cindex Matrices
The @dfn{vector} data type is flexible and general.  A vector is simply a
list of zero or more data objects.  When these objects are numbers, the
whole is a vector in the mathematical sense.  When these objects are
themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
A vector which is not a matrix is referred to here as a @dfn{plain vector}.

A vector is displayed as a list of values separated by commas and enclosed
in square brackets:  @samp{[1, 2, 3]}.  Thus the following is a 2 row by
3 column matrix:  @samp{[[1, 2, 3], [4, 5, 6]]}.  Vectors, like complex
numbers, are entered as incomplete objects.  @xref{Incomplete Objects}.
During algebraic entry, vectors are entered all at once in the usual
brackets-and-commas form.  Matrices may be entered algebraically as nested
vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
with rows separated by semicolons.  The commas may usually be omitted
when entering vectors:  @samp{[1 2 3]}.  Curly braces may be used in
place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
this case.

Traditional vector and matrix arithmetic is also supported;
@pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
Many other operations are applied to vectors element-wise.  For example,
the complex conjugate of a vector is a vector of the complex conjugates
of its elements.@refill

@c @starindex
@tindex vec
Algebraic functions for building vectors include @samp{vec(a, b, c)}
to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an @c{$n\times m$}
@asis{@var{n}x@var{m}}
matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
from 1 to @samp{n}.

@node Strings, HMS Forms, Vectors and Matrices, Data Types
@section Strings

@noindent
@kindex "
@cindex Strings
@cindex Character strings
Character strings are not a special data type in the Calculator.
Rather, a string is represented simply as a vector all of whose
elements are integers in the range 0 to 255 (ASCII codes).  You can
enter a string at any time by pressing the @kbd{"} key.  Quotation
marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
inside strings.  Other notations introduced by backslashes are:

@group
@example
\a     7          \^@@    0
\b     8          \^a-z  1-26
\e     27         \^[    27
\f     12         \^\\   28
\n     10         \^]    29
\r     13         \^^    30
\t     9          \^_    31
                  \^?    127
@end example
@end group

@noindent
Finally, a backslash followed by three octal digits produces any
character from its ASCII code.

@kindex d "
@pindex calc-display-strings
Strings are normally displayed in vector-of-integers form.  The
@w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
which any vectors of small integers are displayed as quoted strings
instead.

The backslash notations shown above are also used for displaying
strings.  Characters 128 and above are not translated by Calc; unless
you have an Emacs modified for 8-bit fonts, these will show up in
backslash-octal-digits notation.  For characters below 32, and
for character 127, Calc uses the backslash-letter combination if
there is one, or otherwise uses a @samp{\^} sequence.

The only Calc feature that uses strings is @dfn{compositions};
@pxref{Compositions}.  Strings also provide a convenient
way to do conversions between ASCII characters and integers.

@c @starindex
@tindex string
There is a @code{string} function which provides a different display
format for strings.  Basically, @samp{string(@var{s})}, where @var{s}
is a vector of integers in the proper range, is displayed as the
corresponding string of characters with no surrounding quotation
marks or other modifications.  Thus @samp{string("ABC")} (or
@samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
This happens regardless of whether @w{@kbd{d "}} has been used.  The
only way to turn it off is to use @kbd{d U} (unformatted language
mode) which will display @samp{string("ABC")} instead.

Control characters are displayed somewhat differently by @code{string}.
Characters below 32, and character 127, are shown using @samp{^} notation
(same as shown above, but without the backslash).  The quote and
backslash characters are left alone, as are characters 128 and above.

@c @starindex
@tindex bstring
The @code{bstring} function is just like @code{string} except that
the resulting string is breakable across multiple lines if it doesn't
fit all on one line.  Potential break points occur at every space
character in the string.

@node HMS Forms, Date Forms, Strings, Data Types
@section HMS Forms

@noindent
@cindex Hours-minutes-seconds forms
@cindex Degrees-minutes-seconds forms
@dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
argument, the interpretation is Degrees-Minutes-Seconds.  All functions
that operate on angles accept HMS forms.  These are interpreted as
degrees regardless of the current angular mode.  It is also possible to
use HMS as the angular mode so that calculated angles are expressed in
degrees, minutes, and seconds.

@kindex @@
@c @mindex @null
@kindex ' (HMS forms)
@c @mindex @null
@kindex " (HMS forms)
@c @mindex @null
@kindex h (HMS forms)
@c @mindex @null
@kindex o (HMS forms)
@c @mindex @null
@kindex m (HMS forms)
@c @mindex @null
@kindex s (HMS forms)
The default format for HMS values is
@samp{@var{hours}@@ @var{mins}' @var{secs}"}.  During entry, the letters
@samp{h} (for ``hours'') or
@samp{o} (approximating the ``degrees'' symbol) are accepted as well as
@samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
accepted in place of @samp{"}.
The @var{hours} value is an integer (or integer-valued float).
The @var{mins} value is an integer or integer-valued float between 0 and 59.
The @var{secs} value is a real number between 0 (inclusive) and 60
(exclusive).  A positive HMS form is interpreted as @var{hours} +
@var{mins}/60 + @var{secs}/3600.  A negative HMS form is interpreted
as @i{- @var{hours}} @i{-} @var{mins}/60 @i{-} @var{secs}/3600.
Display format for HMS forms is quite flexible.  @xref{HMS Formats}.@refill

HMS forms can be added and subtracted.  When they are added to numbers,
the numbers are interpreted according to the current angular mode.  HMS
forms can also be multiplied and divided by real numbers.  Dividing
two HMS forms produces a real-valued ratio of the two angles.

@pindex calc-time
@cindex Time of day
Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
the stack as an HMS form.

@node Date Forms, Modulo Forms, HMS Forms, Data Types
@section Date Forms

@noindent
@cindex Date forms
A @dfn{date form} represents a date and possibly an associated time.
Simple date arithmetic is supported:  Adding a number to a date
produces a new date shifted by that many days; adding an HMS form to
a date shifts it by that many hours.  Subtracting two date forms
computes the number of days between them (represented as a simple
number).  Many other operations, such as multiplying two date forms,
are nonsensical and are not allowed by Calc.

Date forms are entered and displayed enclosed in @samp{< >} brackets.
The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
Input is flexible; date forms can be entered in any of the usual
notations for dates and times.  @xref{Date Formats}.

Date forms are stored internally as numbers, specifically the number
of days since midnight on the morning of January 1 of the year 1 AD.
If the internal number is an integer, the form represents a date only;
if the internal number is a fraction or float, the form represents
a date and time.  For example, @samp{<6:00am Wed Jan 9, 1991>}
is represented by the number 726842.25.  The standard precision of
12 decimal digits is enough to ensure that a (reasonable) date and
time can be stored without roundoff error.

If the current precision is greater than 12, date forms will keep
additional digits in the seconds position.  For example, if the
precision is 15, the seconds will keep three digits after the
decimal point.  Decreasing the precision below 12 may cause the
time part of a date form to become inaccurate.  This can also happen
if astronomically high years are used, though this will not be an
issue in everyday (or even everymillenium) use.  Note that date
forms without times are stored as exact integers, so roundoff is
never an issue for them.

You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
(@code{calc-unpack}) commands to get at the numerical representation
of a date form.  @xref{Packing and Unpacking}.

Date forms can go arbitrarily far into the future or past.  Negative
year numbers represent years BC.  Calc uses a combination of the
Gregorian and Julian calendars, following the history of Great
Britain and the British colonies.  This is the same calendar that
is used by the @code{cal} program in most Unix implementations.

@cindex Julian calendar
@cindex Gregorian calendar
Some historical background:  The Julian calendar was created by
Julius Caesar in the year 46 BC as an attempt to fix the gradual
drift caused by the lack of leap years in the calendar used
until that time.  The Julian calendar introduced an extra day in
all years divisible by four.  After some initial confusion, the
calendar was adopted around the year we call 8 AD.  Some centuries
later it became apparent that the Julian year of 365.25 days was
itself not quite right.  In 1582 Pope Gregory XIII introduced the
Gregorian calendar, which added the new rule that years divisible
by 100, but not by 400, were not to be considered leap years
despite being divisible by four.  Many countries delayed adoption
of the Gregorian calendar because of religious differences;
in Britain it was put off until the year 1752, by which time
the Julian calendar had fallen eleven days behind the true
seasons.  So the switch to the Gregorian calendar in early
September 1752 introduced a discontinuity:  The day after
Sep 2, 1752 is Sep 14, 1752.  Calc follows this convention.
To take another example, Russia waited until 1918 before
adopting the new calendar, and thus needed to remove thirteen
days (between Feb 1, 1918 and Feb 14, 1918).  This means that
Calc's reckoning will be inconsistent with Russian history between
1752 and 1918, and similarly for various other countries.

Today's timekeepers introduce an occasional ``leap second'' as
well, but Calc does not take these minor effects into account.
(If it did, it would have to report a non-integer number of days
between, say, @samp{<12:00am Mon Jan 1, 1900>} and
@samp{<12:00am Sat Jan 1, 2000>}.)

Calc uses the Julian calendar for all dates before the year 1752,
including dates BC when the Julian calendar technically had not
yet been invented.  Thus the claim that day number @i{-10000} is
called ``August 16, 28 BC'' should be taken with a grain of salt.

Please note that there is no ``year 0''; the day before
@samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}.  These are
days 0 and @i{-1} respectively in Calc's internal numbering scheme.

@cindex Julian day counting
Another day counting system in common use is, confusingly, also
called ``Julian.''  It was invented in 1583 by Joseph Justus
Scaliger, who named it in honor of his father Julius Caesar
Scaliger.  For obscure reasons he chose to start his day
numbering on Jan 1, 4713 BC at noon, which in Calc's scheme
is @i{-1721423.5} (recall that Calc starts at midnight instead
of noon).  Thus to convert a Calc date code obtained by
unpacking a date form into a Julian day number, simply add
1721423.5.  The Julian code for @samp{6:00am Jan 9, 1991}
is 2448265.75.  The built-in @kbd{t J} command performs
this conversion for you.

@cindex Unix time format
The Unix operating system measures time as an integer number of
seconds since midnight, Jan 1, 1970.  To convert a Calc date
value into a Unix time stamp, first subtract 719164 (the code
for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
seconds in a day) and press @kbd{R} to round to the nearest
integer.  If you have a date form, you can simply subtract the
day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
719164.  Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
to convert from Unix time to a Calc date form.  (Note that
Unix normally maintains the time in the GMT time zone; you may
need to subtract five hours to get New York time, or eight hours
for California time.  The same is usually true of Julian day
counts.)  The built-in @kbd{t U} command performs these
conversions.

@node Modulo Forms, Error Forms, Date Forms, Data Types
@section Modulo Forms

@noindent
@cindex Modulo forms
A @dfn{modulo form} is a real number which is taken modulo (i.e., within
an integer multiple of) some value @cite{M}.  Arithmetic modulo @cite{M}
often arises in number theory.  Modulo forms are written
`@i{a} @t{mod} @i{M}',
where @cite{a} and @cite{M} are real numbers or HMS forms, and
@c{$0 \le a < M$}
@cite{0 <= a < @var{M}}.
In many applications @cite{a} and @cite{M} will be
integers but this is not required.@refill

Modulo forms are not to be confused with the modulo operator @samp{%}.
The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
the result 7.  Further computations treat this 7 as just a regular integer.
The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
further computations with this value are again reduced modulo 10 so that
the result always lies in the desired range.

When two modulo forms with identical @cite{M}'s are added or multiplied,
the Calculator simply adds or multiplies the values, then reduces modulo
@cite{M}.  If one argument is a modulo form and the other a plain number,
the plain number is treated like a compatible modulo form.  It is also
possible to raise modulo forms to powers; the result is the value raised
to the power, then reduced modulo @cite{M}.  (When all values involved
are integers, this calculation is done much more efficiently than
actually computing the power and then reducing.)

@cindex Modulo division
Two modulo forms `@i{a} @t{mod} @i{M}' and `@i{b} @t{mod} @i{M}'
can be divided if @cite{a}, @cite{b}, and @cite{M} are all
integers.  The result is the modulo form which, when multiplied by
`@i{b} @t{mod} @i{M}', produces `@i{a} @t{mod} @i{M}'.  If
there is no solution to this equation (which can happen only when
@cite{M} is non-prime), or if any of the arguments are non-integers, the
division is left in symbolic form.  Other operations, such as square
roots, are not yet supported for modulo forms.  (Note that, although
@w{`@t{(}@i{a} @t{mod} @i{M}@t{)^.5}'} will compute a ``modulo square root''
in the sense of reducing @c{$\sqrt a$}
@cite{sqrt(a)} modulo @cite{M}, this is not a
useful definition from the number-theoretical point of view.)@refill

@c @mindex M
@kindex M (modulo forms)
@c @mindex mod
@tindex mod (operator)
To create a modulo form during numeric entry, press the shift-@kbd{M}
key to enter the word @samp{mod}.  As a special convenience, pressing
shift-@kbd{M} a second time automatically enters the value of @cite{M}
that was most recently used before.  During algebraic entry, either
type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
Once again, pressing this a second time enters the current modulo.@refill

You can also use @kbd{v p} and @kbd{%} to modify modulo forms.
@xref{Building Vectors}.  @xref{Basic Arithmetic}.

It is possible to mix HMS forms and modulo forms.  For example, an
HMS form modulo 24 could be used to manipulate clock times; an HMS
form modulo 360 would be suitable for angles.  Making the modulo @cite{M}
also be an HMS form eliminates troubles that would arise if the angular
mode were inadvertently set to Radians, in which case
@w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
24 radians!

Modulo forms cannot have variables or formulas for components.  If you
enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
to each of the coefficients:  @samp{(1 mod 5) x + (2 mod 5)}.

@c @starindex
@tindex makemod
The algebraic function @samp{makemod(a, m)} builds the modulo form
@w{@samp{a mod m}}.

@node Error Forms, Interval Forms, Modulo Forms, Data Types
@section Error Forms

@noindent
@cindex Error forms
@cindex Standard deviations
An @dfn{error form} is a number with an associated standard
deviation, as in @samp{2.3 +/- 0.12}.  The notation
`@i{x} @t{+/-} @c{$\sigma$}
@asis{sigma}' stands for an uncertain value which follows a normal or
Gaussian distribution of mean @cite{x} and standard deviation or
``error'' @c{$\sigma$}
@cite{sigma}.  Both the mean and the error can be either numbers or
formulas.  Generally these are real numbers but the mean may also be
complex.  If the error is negative or complex, it is changed to its
absolute value.  An error form with zero error is converted to a
regular number by the Calculator.@refill

All arithmetic and transcendental functions accept error forms as input.
Operations on the mean-value part work just like operations on regular
numbers.  The error part for any function @cite{f(x)} (such as @c{$\sin x$}
@cite{sin(x)})
is defined by the error of @cite{x} times the derivative of @cite{f}
evaluated at the mean value of @cite{x}.  For a two-argument function
@cite{f(x,y)} (such as addition) the error is the square root of the sum
of the squares of the errors due to @cite{x} and @cite{y}.
@tex
$$ \eqalign{
  f(x \hbox{\code{ +/- }} \sigma)
    &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
  f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
    &= f(x,y) \hbox{\code{ +/- }}
        \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
                             \right| \right)^2
             +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
                             \right| \right)^2 } \cr
} $$
@end tex
Note that this
definition assumes the errors in @cite{x} and @cite{y} are uncorrelated.
A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
is not the same as @samp{(2 +/- 1)^2}; the former represents the product
of two independent values which happen to have the same probability
distributions, and the latter is the product of one random value with itself.
The former will produce an answer with less error, since on the average
the two independent errors can be expected to cancel out.@refill

Consult a good text on error analysis for a discussion of the proper use
of standard deviations.  Actual errors often are neither Gaussian-distributed
nor uncorrelated, and the above formulas are valid only when errors
are small.  As an example, the error arising from
`@t{sin(}@i{x} @t{+/-} @c{$\sigma$}
@i{sigma}@t{)}' is
`@c{$\sigma$\nobreak}
@i{sigma} @t{abs(cos(}@i{x}@t{))}'.  When @cite{x} is close to zero,
@c{$\cos x$}
@cite{cos(x)} is
close to one so the error in the sine is close to @c{$\sigma$}
@cite{sigma}; this makes sense, since @c{$\sin x$}
@cite{sin(x)} is approximately @cite{x} near zero, so a given
error in @cite{x} will produce about the same error in the sine.  Likewise,
near 90 degrees @c{$\cos x$}
@cite{cos(x)} is nearly zero and so the computed error is
small:  The sine curve is nearly flat in that region, so an error in @cite{x}
has relatively little effect on the value of @c{$\sin x$}
@cite{sin(x)}.  However, consider
@samp{sin(90 +/- 1000)}.  The cosine of 90 is zero, so Calc will report
zero error!  We get an obviously wrong result because we have violated
the small-error approximation underlying the error analysis.  If the error
in @cite{x} had been small, the error in @c{$\sin x$}
@cite{sin(x)} would indeed have been negligible.@refill

@c @mindex p
@kindex p (error forms)
@tindex +/-
To enter an error form during regular numeric entry, use the @kbd{p}
(``plus-or-minus'') key to type the @samp{+/-} symbol.  (If you try actually
typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
@kbd{+} command!)  Within an algebraic formula, you can press @kbd{M-p} to
type the @samp{+/-} symbol, or type it out by hand.

Error forms and complex numbers can be mixed; the formulas shown above
are used for complex numbers, too; note that if the error part evaluates
to a complex number its absolute value (or the square root of the sum of
the squares of the absolute values of the two error contributions) is
used.  Mathematically, this corresponds to a radially symmetric Gaussian
distribution of numbers on the complex plane.  However, note that Calc
considers an error form with real components to represent a real number,
not a complex distribution around a real mean.

Error forms may also be composed of HMS forms.  For best results, both
the mean and the error should be HMS forms if either one is.

@c @starindex
@tindex sdev
The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.

@node Interval Forms, Incomplete Objects, Error Forms, Data Types
@section Interval Forms

@noindent
@cindex Interval forms
An @dfn{interval} is a subset of consecutive real numbers.  For example,
the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
inclusive.  If you multiply it by the interval @samp{[0.5 ..@: 2]} you
obtain @samp{[1 ..@: 8]}.  This calculation represents the fact that if
you multiply some number in the range @samp{[2 ..@: 4]} by some other
number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
from 1 to 8.  Interval arithmetic is used to get a worst-case estimate
of the possible range of values a computation will produce, given the
set of possible values of the input.

@ifnottex
Calc supports several varieties of intervals, including @dfn{closed}
intervals of the type shown above, @dfn{open} intervals such as
@samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
@emph{exclusive}, and @dfn{semi-open} intervals in which one end
uses a round parenthesis and the other a square bracket.  In mathematical
terms,
@samp{[2 ..@: 4]} means @cite{2 <= x <= 4}, whereas
@samp{[2 ..@: 4)} represents @cite{2 <= x < 4},
@samp{(2 ..@: 4]} represents @cite{2 < x <= 4}, and
@samp{(2 ..@: 4)} represents @cite{2 < x < 4}.@refill
@end ifnottex
@tex
Calc supports several varieties of intervals, including \dfn{closed}
intervals of the type shown above, \dfn{open} intervals such as
\samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
\emph{exclusive}, and \dfn{semi-open} intervals in which one end
uses a round parenthesis and the other a square bracket.  In mathematical
terms,
$$ \eqalign{
   [2 \hbox{\cite{..}} 4]  &\quad\hbox{means}\quad  2 \le x \le 4  \cr
   [2 \hbox{\cite{..}} 4)  &\quad\hbox{means}\quad  2 \le x  <  4  \cr
   (2 \hbox{\cite{..}} 4]  &\quad\hbox{means}\quad  2  <  x \le 4  \cr
   (2 \hbox{\cite{..}} 4)  &\quad\hbox{means}\quad  2  <  x  <  4  \cr
} $$
@end tex

The lower and upper limits of an interval must be either real numbers
(or HMS or date forms), or symbolic expressions which are assumed to be
real-valued, or @samp{-inf} and @samp{inf}.  In general the lower limit
must be less than the upper limit.  A closed interval containing only
one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
automatically.  An interval containing no values at all (such as
@samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
guaranteed to behave well when used in arithmetic.  Note that the
interval @samp{[3 .. inf)} represents all real numbers greater than
or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
In fact, @samp{[-inf .. inf]} represents all real numbers including
the real infinities.

Intervals are entered in the notation shown here, either as algebraic
formulas, or using incomplete forms.  (@xref{Incomplete Objects}.)
In algebraic formulas, multiple periods in a row are collected from
left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
rather than @samp{1 ..@: 0.1e2}.  Add spaces or zeros if you want to
get the other interpretation.  If you omit the lower or upper limit,
a default of @samp{-inf} or @samp{inf} (respectively) is furnished.

``Infinite mode'' also affects operations on intervals
(@pxref{Infinities}).  Calc will always introduce an open infinity,
as in @samp{1 / (0 .. 2] = [0.5 .. inf)}.  But closed infinities,
@w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in infinite mode;
otherwise they are left unevaluated.  Note that the ``direction'' of
a zero is not an issue in this case since the zero is always assumed
to be continuous with the rest of the interval.  For intervals that
contain zero inside them Calc is forced to give the result,
@samp{1 / (-2 .. 2) = [-inf .. inf]}.

While it may seem that intervals and error forms are similar, they are
based on entirely different concepts of inexact quantities.  An error
form `@i{x} @t{+/-} @c{$\sigma$}
@i{sigma}' means a variable is random, and its value could
be anything but is ``probably'' within one @c{$\sigma$}
@i{sigma} of the mean value @cite{x}.
An interval `@t{[}@i{a} @t{..@:} @i{b}@t{]}' means a variable's value
is unknown, but guaranteed to lie in the specified range.  Error forms
are statistical or ``average case'' approximations; interval arithmetic
tends to produce ``worst case'' bounds on an answer.@refill

Intervals may not contain complex numbers, but they may contain
HMS forms or date forms.

@xref{Set Operations}, for commands that interpret interval forms
as subsets of the set of real numbers.

@c @starindex
@tindex intv
The algebraic function @samp{intv(n, a, b)} builds an interval form
from @samp{a} to @samp{b}; @samp{n} is an integer code which must
be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
3 for @samp{[..]}.

Please note that in fully rigorous interval arithmetic, care would be
taken to make sure that the computation of the lower bound rounds toward
minus infinity, while upper bound computations round toward plus
infinity.  Calc's arithmetic always uses a round-to-nearest mode,
which means that roundoff errors could creep into an interval
calculation to produce intervals slightly smaller than they ought to
be.  For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
should yield the interval @samp{[1..2]} again, but in fact it yields the
(slightly too small) interval @samp{[1..1.9999999]} due to roundoff
error.

@node Incomplete Objects, Variables, Interval Forms, Data Types
@section Incomplete Objects

@noindent
@c @mindex [ ]
@kindex [
@c @mindex ( )
@kindex (
@kindex ,
@c @mindex @null
@kindex ]
@c @mindex @null
@kindex )
@cindex Incomplete vectors
@cindex Incomplete complex numbers
@cindex Incomplete interval forms
When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
vector, respectively, the effect is to push an @dfn{incomplete} complex
number or vector onto the stack.  The @kbd{,} key adds the value(s) at
the top of the stack onto the current incomplete object.  The @kbd{)}
and @kbd{]} keys ``close'' the incomplete object after adding any values
on the top of the stack in front of the incomplete object.

As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
pushes the vector @samp{[2, 6, 9]} onto the stack.  Likewise, @kbd{( 1 , 2 Q )}
pushes the complex number @samp{(1, 1.414)} (approximately).

If several values lie on the stack in front of the incomplete object,
all are collected and appended to the object.  Thus the @kbd{,} key
is redundant:  @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}.  Some people
prefer the equivalent @key{SPC} key to @key{RET}.@refill

As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
@kbd{,} adds a zero or duplicates the preceding value in the list being
formed.  Typing @key{DEL} during incomplete entry removes the last item
from the list.

@kindex ;
The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
numbers:  @kbd{( 1 ; 2 )}.  When entering a vector, @kbd{;} is useful for
creating a matrix.  In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.

@kindex ..
@pindex calc-dots
Incomplete entry is also used to enter intervals.  For example,
@kbd{[ 2 ..@: 4 )} enters a semi-open interval.  Note that when you type
the first period, it will be interpreted as a decimal point, but when
you type a second period immediately afterward, it is re-interpreted as
part of the interval symbol.  Typing @kbd{..} corresponds to executing
the @code{calc-dots} command.

If you find incomplete entry distracting, you may wish to enter vectors
and complex numbers as algebraic formulas by pressing the apostrophe key.

@node Variables, Formulas, Incomplete Objects, Data Types
@section Variables

@noindent
@cindex Variables, in formulas
A @dfn{variable} is somewhere between a storage register on a conventional
calculator, and a variable in a programming language.  (In fact, a Calc
variable is really just an Emacs Lisp variable that contains a Calc number
or formula.)  A variable's name is normally composed of letters and digits.
Calc also allows apostrophes and @code{#} signs in variable names.
The Calc variable @code{foo} corresponds to the Emacs Lisp variable
@code{var-foo}.  Commands like @kbd{s s} (@code{calc-store}) that operate
on variables can be made to use any arbitrary Lisp variable simply by
backspacing over the @samp{var-} prefix in the minibuffer.@refill

In a command that takes a variable name, you can either type the full
name of a variable, or type a single digit to use one of the special
convenience variables @code{var-q0} through @code{var-q9}.  For example,
@kbd{3 s s 2} stores the number 3 in variable @code{var-q2}, and
@w{@kbd{3 s s foo @key{RET}}} stores that number in variable
@code{var-foo}.@refill

To push a variable itself (as opposed to the variable's value) on the
stack, enter its name as an algebraic expression using the apostrophe
(@key{'}) key.  Variable names in algebraic formulas implicitly have
@samp{var-} prefixed to their names.  The @samp{#} character in variable
names used in algebraic formulas corresponds to a dash @samp{-} in the
Lisp variable name.  If the name contains any dashes, the prefix @samp{var-}
is @emph{not} automatically added.  Thus the two formulas @samp{foo + 1}
and @samp{var#foo + 1} both refer to the same variable.

@kindex =
@pindex calc-evaluate
@cindex Evaluation of variables in a formula
@cindex Variables, evaluation
@cindex Formulas, evaluation
The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
replacing all variables in the formula which have been given values by a
@code{calc-store} or @code{calc-let} command by their stored values.
Other variables are left alone.  Thus a variable that has not been
stored acts like an abstract variable in algebra; a variable that has
been stored acts more like a register in a traditional calculator.
With a positive numeric prefix argument, @kbd{=} evaluates the top
@var{n} stack entries; with a negative argument, @kbd{=} evaluates
the @var{n}th stack entry.

@cindex @code{e} variable
@cindex @code{pi} variable
@cindex @code{i} variable
@cindex @code{phi} variable
@cindex @code{gamma} variable
@vindex e
@vindex pi
@vindex i
@vindex phi
@vindex gamma
A few variables are called @dfn{special constants}.  Their names are
@samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
(@xref{Scientific Functions}.)  When they are evaluated with @kbd{=},
their values are calculated if necessary according to the current precision
or complex polar mode.  If you wish to use these symbols for other purposes,
simply undefine or redefine them using @code{calc-store}.@refill

The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
infinite or indeterminate values.  It's best not to use them as
regular variables, since Calc uses special algebraic rules when
it manipulates them.  Calc displays a warning message if you store
a value into any of these special variables.

@xref{Store and Recall}, for a discussion of commands dealing with variables.

@node Formulas, , Variables, Data Types
@section Formulas

@noindent
@cindex Formulas
@cindex Expressions
@cindex Operators in formulas
@cindex Precedence of operators
When you press the apostrophe key you may enter any expression or formula
in algebraic form.  (Calc uses the terms ``expression'' and ``formula''
interchangeably.)  An expression is built up of numbers, variable names,
and function calls, combined with various arithmetic operators.
Parentheses may
be used to indicate grouping.  Spaces are ignored within formulas, except
that spaces are not permitted within variable names or numbers.
Arithmetic operators, in order from highest to lowest precedence, and
with their equivalent function names, are:

@samp{_} [@code{subscr}] (subscripts);

postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});

prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x})
and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});

@samp{+/-} [@code{sdev}] (the standard deviation symbol) and
@samp{mod} [@code{makemod}] (the symbol for modulo forms);

postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
and postfix @samp{!!} [@code{dfact}] (double factorial);

@samp{^} [@code{pow}] (raised-to-the-power-of);

@samp{*} [@code{mul}];

@samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
@samp{\} [@code{idiv}] (integer division);

infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});

@samp{|} [@code{vconcat}] (vector concatenation);

relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
@samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];

@samp{&&} [@code{land}] (logical ``and'');

@samp{||} [@code{lor}] (logical ``or'');

the C-style ``if'' operator @samp{a?b:c} [@code{if}];

@samp{!!!} [@code{pnot}] (rewrite pattern ``not'');

@samp{&&&} [@code{pand}] (rewrite pattern ``and'');

@samp{|||} [@code{por}] (rewrite pattern ``or'');

@samp{:=} [@code{assign}] (for assignments and rewrite rules);

@samp{::} [@code{condition}] (rewrite pattern condition);

@samp{=>} [@code{evalto}].

Note that, unlike in usual computer notation, multiplication binds more
strongly than division:  @samp{a*b/c*d} is equivalent to @c{$a b \over c d$}
@cite{(a*b)/(c*d)}.

@cindex Multiplication, implicit
@cindex Implicit multiplication
The multiplication sign @samp{*} may be omitted in many cases.  In particular,
if the righthand side is a number, variable name, or parenthesized
expression, the @samp{*} may be omitted.  Implicit multiplication has the
same precedence as the explicit @samp{*} operator.  The one exception to
the rule is that a variable name followed by a parenthesized expression,
as in @samp{f(x)},
is interpreted as a function call, not an implicit @samp{*}.  In many
cases you must use a space if you omit the @samp{*}:  @samp{2a} is the
same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
is a variable called @code{ab}, @emph{not} the product of @samp{a} and
@samp{b}!  Also note that @samp{f (x)} is still a function call.@refill

@cindex Implicit comma in vectors
The rules are slightly different for vectors written with square brackets.
In vectors, the space character is interpreted (like the comma) as a
separator of elements of the vector.  Thus @w{@samp{[ 2a b+c d ]}} is
equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
to @samp{2*a*b + c*d}.
Note that spaces around the brackets, and around explicit commas, are
ignored.  To force spaces to be interpreted as multiplication you can
enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
interpreted as @samp{[a*b, 2*c*d]}.  An implicit comma is also inserted
between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.@refill

Vectors that contain commas (not embedded within nested parentheses or
brackets) do not treat spaces specially:  @samp{[a b, 2 c d]} is a vector
of two elements.  Also, if it would be an error to treat spaces as
separators, but not otherwise, then Calc will ignore spaces:
@w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
a vector of two elements.  Finally, vectors entered with curly braces
instead of square brackets do not give spaces any special treatment.
When Calc displays a vector that does not contain any commas, it will
insert parentheses if necessary to make the meaning clear:
@w{@samp{[(a b)]}}.

The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
or five modulo minus-two?  Calc always interprets the leftmost symbol as
an infix operator preferentially (modulo, in this case), so you would
need to write @samp{(5%)-2} to get the former interpretation.

@cindex Function call notation
A function call is, e.g., @samp{sin(1+x)}.  Function names follow the same
rules as variable names except that the default prefix @samp{calcFunc-} is
used (instead of @samp{var-}) for the internal Lisp form.
Most mathematical Calculator commands like
@code{calc-sin} have function equivalents like @code{sin}.
If no Lisp function is defined for a function called by a formula, the
call is left as it is during algebraic manipulation: @samp{f(x+y)} is
left alone.  Beware that many innocent-looking short names like @code{in}
and @code{re} have predefined meanings which could surprise you; however,
single letters or single letters followed by digits are always safe to
use for your own function names.  @xref{Function Index}.@refill

In the documentation for particular commands, the notation @kbd{H S}
(@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
represent the same operation.@refill

Commands that interpret (``parse'') text as algebraic formulas include
algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
the contents of the editing buffer when you finish, the @kbd{M-# g}
and @w{@kbd{M-# r}} commands, the @kbd{C-y} command, the X window system
``paste'' mouse operation, and Embedded Mode.  All of these operations
use the same rules for parsing formulas; in particular, language modes
(@pxref{Language Modes}) affect them all in the same way.

When you read a large amount of text into the Calculator (say a vector
which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
you may wish to include comments in the text.  Calc's formula parser
ignores the symbol @samp{%%} and anything following it on a line:

@example
[ a + b,   %% the sum of "a" and "b"
  c + d,
  %% last line is coming up:
  e + f ]
@end example

@noindent
This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.

@xref{Syntax Tables}, for a way to create your own operators and other
input notations.  @xref{Compositions}, for a way to create new display
formats.

@xref{Algebra}, for commands for manipulating formulas symbolically.

@node Stack and Trail, Mode Settings, Data Types, Top
@chapter Stack and Trail Commands

@noindent
This chapter describes the Calc commands for manipulating objects on the
stack and in the trail buffer.  (These commands operate on objects of any
type, such as numbers, vectors, formulas, and incomplete objects.)

@menu
* Stack Manipulation::
* Editing Stack Entries::
* Trail Commands::
* Keep Arguments::
@end menu

@node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
@section Stack Manipulation Commands

@noindent
@kindex RET
@kindex SPC
@pindex calc-enter
@cindex Duplicating stack entries
To duplicate the top object on the stack, press @key{RET} or @key{SPC}
(two equivalent keys for the @code{calc-enter} command).
Given a positive numeric prefix argument, these commands duplicate
several elements at the top of the stack.
Given a negative argument,
these commands duplicate the specified element of the stack.
Given an argument of zero, they duplicate the entire stack.
For example, with @samp{10 20 30} on the stack,
@key{RET} creates @samp{10 20 30 30},
@kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
@kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
@kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.@refill

@kindex LFD
@pindex calc-over
The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
have it, else on @kbd{C-j}) is like @code{calc-enter}
except that the sign of the numeric prefix argument is interpreted
oppositely.  Also, with no prefix argument the default argument is 2.
Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
@samp{10 20 30 20}.@refill

@kindex DEL
@kindex C-d
@pindex calc-pop
@cindex Removing stack entries
@cindex Deleting stack entries
To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
The @kbd{C-d} key is a synonym for @key{DEL}.
(If the top element is an incomplete object with at least one element, the
last element is removed from it.)  Given a positive numeric prefix argument,
several elements are removed.  Given a negative argument, the specified
element of the stack is deleted.  Given an argument of zero, the entire
stack is emptied.
For example, with @samp{10 20 30} on the stack,
@key{DEL} leaves @samp{10 20},
@kbd{C-u 2 @key{DEL}} leaves @samp{10},
@kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
@kbd{C-u 0 @key{DEL}} leaves an empty stack.@refill

@kindex M-DEL
@pindex calc-pop-above
The @key{M-DEL} (@code{calc-pop-above}) command is to @key{DEL} what
@key{LFD} is to @key{RET}:  It interprets the sign of the numeric
prefix argument in the opposite way, and the default argument is 2.
Thus @key{M-DEL} by itself removes the second-from-top stack element,
leaving the first, third, fourth, and so on; @kbd{M-3 M-DEL} deletes
the third stack element.

@kindex TAB
@pindex calc-roll-down
To exchange the top two elements of the stack, press @key{TAB}
(@code{calc-roll-down}).  Given a positive numeric prefix argument, the
specified number of elements at the top of the stack are rotated downward.
Given a negative argument, the entire stack is rotated downward the specified
number of times.  Given an argument of zero, the entire stack is reversed
top-for-bottom.
For example, with @samp{10 20 30 40 50} on the stack,
@key{TAB} creates @samp{10 20 30 50 40},
@kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
@kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
@kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.@refill

@kindex M-TAB
@pindex calc-roll-up
The command @key{M-TAB} (@code{calc-roll-up}) is analogous to @key{TAB}
except that it rotates upward instead of downward.  Also, the default
with no prefix argument is to rotate the top 3 elements.
For example, with @samp{10 20 30 40 50} on the stack,
@key{M-TAB} creates @samp{10 20 40 50 30},
@kbd{C-u 4 @key{M-TAB}} creates @samp{10 30 40 50 20},
@kbd{C-u - 2 @key{M-TAB}} creates @samp{30 40 50 10 20}, and
@kbd{C-u 0 @key{M-TAB}} creates @samp{50 40 30 20 10}.@refill

A good way to view the operation of @key{TAB} and @key{M-TAB} is in
terms of moving a particular element to a new position in the stack.
With a positive argument @i{n}, @key{TAB} moves the top stack
element down to level @i{n}, making room for it by pulling all the
intervening stack elements toward the top.  @key{M-TAB} moves the
element at level @i{n} up to the top.  (Compare with @key{LFD},
which copies instead of moving the element in level @i{n}.)

With a negative argument @i{-n}, @key{TAB} rotates the stack
to move the object in level @i{n} to the deepest place in the
stack, and the object in level @i{n+1} to the top.  @key{M-TAB}
rotates the deepest stack element to be in level @i{n}, also
putting the top stack element in level @i{n+1}.

@xref{Selecting Subformulas}, for a way to apply these commands to
any portion of a vector or formula on the stack.

@node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
@section Editing Stack Entries

@noindent
@kindex `
@pindex calc-edit
@pindex calc-edit-finish
@cindex Editing the stack with Emacs
The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary
buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using
regular Emacs commands.  With a numeric prefix argument, it edits the
specified number of stack entries at once.  (An argument of zero edits
the entire stack; a negative argument edits one specific stack entry.)

When you are done editing, press @kbd{M-# M-#} to finish and return
to Calc.  The @key{RET} and @key{LFD} keys also work to finish most
sorts of editing, though in some cases Calc leaves @key{RET} with its
usual meaning (``insert a newline'') if it's a situation where you
might want to insert new lines into the editing buffer.  The traditional
Emacs ``finish'' key sequence, @kbd{C-c C-c}, also works to finish
editing and may be easier to type, depending on your keyboard.

When you finish editing, the Calculator parses the lines of text in
the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
original stack elements in the original buffer with these new values,
then kills the @samp{*Calc Edit*} buffer.  The original Calculator buffer
continues to exist during editing, but for best results you should be
careful not to change it until you have finished the edit.  You can
also cancel the edit by pressing @kbd{M-# x}.

The formula is normally reevaluated as it is put onto the stack.
For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
@kbd{M-# M-#} will push 5 on the stack.  If you use @key{LFD} to
finish, Calc will put the result on the stack without evaluating it.

If you give a prefix argument to @kbd{M-# M-#} (or @kbd{C-c C-c}),
Calc will not kill the @samp{*Calc Edit*} buffer.  You can switch
back to that buffer and continue editing if you wish.  However, you
should understand that if you initiated the edit with @kbd{`}, the
@kbd{M-# M-#} operation will be programmed to replace the top of the
stack with the new edited value, and it will do this even if you have
rearranged the stack in the meanwhile.  This is not so much of a problem
with other editing commands, though, such as @kbd{s e}
(@code{calc-edit-variable}; @pxref{Operations on Variables}).

If the @code{calc-edit} command involves more than one stack entry,
each line of the @samp{*Calc Edit*} buffer is interpreted as a
separate formula.  Otherwise, the entire buffer is interpreted as
one formula, with line breaks ignored.  (You can use @kbd{C-o} or
@kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)

The @kbd{`} key also works during numeric or algebraic entry.  The
text entered so far is moved to the @code{*Calc Edit*} buffer for
more extensive editing than is convenient in the minibuffer.

@node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
@section Trail Commands

@noindent
@cindex Trail buffer
The commands for manipulating the Calc Trail buffer are two-key sequences
beginning with the @kbd{t} prefix.

@kindex t d
@pindex calc-trail-display
The @kbd{t d} (@code{calc-trail-display}) command turns display of the
trail on and off.  Normally the trail display is toggled on if it was off,
off if it was on.  With a numeric prefix of zero, this command always
turns the trail off; with a prefix of one, it always turns the trail on.
The other trail-manipulation commands described here automatically turn
the trail on.  Note that when the trail is off values are still recorded
there; they are simply not displayed.  To set Emacs to turn the trail
off by default, type @kbd{t d} and then save the mode settings with
@kbd{m m} (@code{calc-save-modes}).

@kindex t i
@pindex calc-trail-in
@kindex t o
@pindex calc-trail-out
The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
(@code{calc-trail-out}) commands switch the cursor into and out of the
Calc Trail window.  In practice they are rarely used, since the commands
shown below are a more convenient way to move around in the
trail, and they work ``by remote control'' when the cursor is still
in the Calculator window.@refill

@cindex Trail pointer
There is a @dfn{trail pointer} which selects some entry of the trail at
any given time.  The trail pointer looks like a @samp{>} symbol right
before the selected number.  The following commands operate on the
trail pointer in various ways.

@kindex t y
@pindex calc-trail-yank
@cindex Retrieving previous results
The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
the trail and pushes it onto the Calculator stack.  It allows you to
re-use any previously computed value without retyping.  With a numeric
prefix argument @var{n}, it yanks the value @var{n} lines above the current
trail pointer.

@kindex t <
@pindex calc-trail-scroll-left
@kindex t >
@pindex calc-trail-scroll-right
The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
(@code{calc-trail-scroll-right}) commands horizontally scroll the trail
window left or right by one half of its width.@refill

@kindex t n
@pindex calc-trail-next
@kindex t p
@pindex calc-trail-previous
@kindex t f
@pindex calc-trail-forward
@kindex t b
@pindex calc-trail-backward
The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
(@code{calc-trail-previous)} commands move the trail pointer down or up
one line.  The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
(@code{calc-trail-backward}) commands move the trail pointer down or up
one screenful at a time.  All of these commands accept numeric prefix
arguments to move several lines or screenfuls at a time.@refill

@kindex t [
@pindex calc-trail-first
@kindex t ]
@pindex calc-trail-last
@kindex t h
@pindex calc-trail-here
The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
(@code{calc-trail-last}) commands move the trail pointer to the first or
last line of the trail.  The @kbd{t h} (@code{calc-trail-here}) command
moves the trail pointer to the cursor position; unlike the other trail
commands, @kbd{t h} works only when Calc Trail is the selected window.@refill

@kindex t s
@pindex calc-trail-isearch-forward
@kindex t r
@pindex calc-trail-isearch-backward
@ifnottex
The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
(@code{calc-trail-isearch-backward}) commands perform an incremental
search forward or backward through the trail.  You can press @key{RET}
to terminate the search; the trail pointer moves to the current line.
If you cancel the search with @kbd{C-g}, the trail pointer stays where
it was when the search began.@refill
@end ifnottex
@tex
The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
(@code{calc-trail-isearch-backward}) com\-mands perform an incremental
search forward or backward through the trail.  You can press @key{RET}
to terminate the search; the trail pointer moves to the current line.
If you cancel the search with @kbd{C-g}, the trail pointer stays where
it was when the search began.
@end tex

@kindex t m
@pindex calc-trail-marker
The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
line of text of your own choosing into the trail.  The text is inserted
after the line containing the trail pointer; this usually means it is
added to the end of the trail.  Trail markers are useful mainly as the
targets for later incremental searches in the trail.

@kindex t k
@pindex calc-trail-kill
The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
from the trail.  The line is saved in the Emacs kill ring suitable for
yanking into another buffer, but it is not easy to yank the text back
into the trail buffer.  With a numeric prefix argument, this command
kills the @var{n} lines below or above the selected one.

The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
elsewhere; @pxref{Vector and Matrix Formats}.

@node Keep Arguments, , Trail Commands, Stack and Trail
@section Keep Arguments

@noindent
@kindex K
@pindex calc-keep-args
The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
the following command.  It prevents that command from removing its
arguments from the stack.  For example, after @kbd{2 @key{RET} 3 +},
the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
the stack contains the arguments and the result: @samp{2 3 5}.

This works for all commands that take arguments off the stack.  As
another example, @kbd{K a s} simplifies a formula, pushing the
simplified version of the formula onto the stack after the original
formula (rather than replacing the original formula).

Note that you could get the same effect by typing @kbd{RET a s},
copying the formula and then simplifying the copy.  One difference
is that for a very large formula the time taken to format the
intermediate copy in @kbd{RET a s} could be noticeable; @kbd{K a s}
would avoid this extra work.

Even stack manipulation commands are affected.  @key{TAB} works by
popping two values and pushing them back in the opposite order,
so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.

A few Calc commands provide other ways of doing the same thing.
For example, @kbd{' sin($)} replaces the number on the stack with
its sine using algebraic entry; to push the sine and keep the
original argument you could use either @kbd{' sin($1)} or
@kbd{K ' sin($)}.  @xref{Algebraic Entry}.  Also, the @kbd{s s}
command is effectively the same as @kbd{K s t}.  @xref{Storing Variables}.

Keyboard macros may interact surprisingly with the @kbd{K} prefix.
If you have defined a keyboard macro to be, say, @samp{Q +} to add
one number to the square root of another, then typing @kbd{K X} will
execute @kbd{K Q +}, probably not what you expected.  The @kbd{K}
prefix will apply to just the first command in the macro rather than
the whole macro.

If you execute a command and then decide you really wanted to keep
the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
This command pushes the last arguments that were popped by any command
onto the stack.  Note that the order of things on the stack will be
different than with @kbd{K}:  @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
@samp{5 2 3} on the stack instead of @samp{2 3 5}.  @xref{Undo}.

@node Mode Settings, Arithmetic, Stack and Trail, Top
@chapter Mode Settings

@noindent
This chapter describes commands that set modes in the Calculator.
They do not affect the contents of the stack, although they may change
the @emph{appearance} or @emph{interpretation} of the stack's contents.

@menu
* General Mode Commands::
* Precision::
* Inverse and Hyperbolic::
* Calculation Modes::
* Simplification Modes::
* Declarations::
* Display Modes::
* Language Modes::
* Modes Variable::
* Calc Mode Line::
@end menu

@node General Mode Commands, Precision, Mode Settings, Mode Settings
@section General Mode Commands

@noindent
@kindex m m
@pindex calc-save-modes
@cindex Continuous memory
@cindex Saving mode settings
@cindex Permanent mode settings
@cindex @file{.emacs} file, mode settings
You can save all of the current mode settings in your @file{.emacs} file
with the @kbd{m m} (@code{calc-save-modes}) command.  This will cause
Emacs to reestablish these modes each time it starts up.  The modes saved
in the file include everything controlled by the @kbd{m} and @kbd{d}
prefix keys, the current precision and binary word size, whether or not
the trail is displayed, the current height of the Calc window, and more.
The current interface (used when you type @kbd{M-# M-#}) is also saved.
If there were already saved mode settings in the file, they are replaced.
Otherwise, the new mode information is appended to the end of the file.

@kindex m R
@pindex calc-mode-record-mode
The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
record the new mode settings (as if by pressing @kbd{m m}) every
time a mode setting changes.  If Embedded Mode is enabled, other
options are available; @pxref{Mode Settings in Embedded Mode}.

@kindex m F
@pindex calc-settings-file-name
The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
choose a different place than your @file{.emacs} file for @kbd{m m},
@kbd{Z P}, and similar commands to save permanent information.
You are prompted for a file name.  All Calc modes are then reset to
their default values, then settings from the file you named are loaded
if this file exists, and this file becomes the one that Calc will
use in the future for commands like @kbd{m m}.  The default settings
file name is @file{~/.emacs}.  You can see the current file name by
giving a blank response to the @kbd{m F} prompt.  See also the
discussion of the @code{calc-settings-file} variable; @pxref{Installation}.

If the file name you give contains the string @samp{.emacs} anywhere
inside it, @kbd{m F} will not automatically load the new file.  This
is because you are presumably switching to your @file{~/.emacs} file,
which may contain other things you don't want to reread.  You can give
a numeric prefix argument of 1 to @kbd{m F} to force it to read the
file no matter what its name.  Conversely, an argument of @i{-1} tells
@kbd{m F} @emph{not} to read the new file.  An argument of 2 or @i{-2}
tells @kbd{m F} not to reset the modes to their defaults beforehand,
which is useful if you intend your new file to have a variant of the
modes present in the file you were using before.

@kindex m x
@pindex calc-always-load-extensions
The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
in which the first use of Calc loads the entire program, including all
extensions modules.  Otherwise, the extensions modules will not be loaded
until the various advanced Calc features are used.  Since this mode only
has effect when Calc is first loaded, @kbd{m x} is usually followed by
@kbd{m m} to make the mode-setting permanent.  To load all of Calc just
once, rather than always in the future, you can press @kbd{M-# L}.

@kindex m S
@pindex calc-shift-prefix
The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
all of Calc's letter prefix keys may be typed shifted as well as unshifted.
If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
you might find it easier to turn this mode on so that you can type
@kbd{A S} instead.  When this mode is enabled, the commands that used to
be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
now be invoked by pressing the shifted letter twice: @kbd{A A}.  Note
that the @kbd{v} prefix key always works both shifted and unshifted, and
the @kbd{z} and @kbd{Z} prefix keys are always distinct.  Also, the @kbd{h}
prefix is not affected by this mode.  Press @kbd{m S} again to disable
shifted-prefix mode.

@node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
@section Precision

@noindent
@kindex p
@pindex calc-precision
@cindex Precision of calculations
The @kbd{p} (@code{calc-precision}) command controls the precision to
which floating-point calculations are carried.  The precision must be
at least 3 digits and may be arbitrarily high, within the limits of
memory and time.  This affects only floats:  Integer and rational
calculations are always carried out with as many digits as necessary.

The @kbd{p} key prompts for the current precision.  If you wish you
can instead give the precision as a numeric prefix argument.

Many internal calculations are carried to one or two digits higher
precision than normal.  Results are rounded down afterward to the
current precision.  Unless a special display mode has been selected,
floats are always displayed with their full stored precision, i.e.,
what you see is what you get.  Reducing the current precision does not
round values already on the stack, but those values will be rounded
down before being used in any calculation.  The @kbd{c 0} through
@kbd{c 9} commands (@pxref{Conversions}) can be used to round an
existing value to a new precision.@refill

@cindex Accuracy of calculations
It is important to distinguish the concepts of @dfn{precision} and
@dfn{accuracy}.  In the normal usage of these words, the number
123.4567 has a precision of 7 digits but an accuracy of 4 digits.
The precision is the total number of digits not counting leading
or trailing zeros (regardless of the position of the decimal point).
The accuracy is simply the number of digits after the decimal point
(again not counting trailing zeros).  In Calc you control the precision,
not the accuracy of computations.  If you were to set the accuracy
instead, then calculations like @samp{exp(100)} would generate many
more digits than you would typically need, while @samp{exp(-100)} would
probably round to zero!  In Calc, both these computations give you
exactly 12 (or the requested number of) significant digits.

The only Calc features that deal with accuracy instead of precision
are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
and the rounding functions like @code{floor} and @code{round}
(@pxref{Integer Truncation}).  Also, @kbd{c 0} through @kbd{c 9}
deal with both precision and accuracy depending on the magnitudes
of the numbers involved.

If you need to work with a particular fixed accuracy (say, dollars and
cents with two digits after the decimal point), one solution is to work
with integers and an ``implied'' decimal point.  For example, $8.99
divided by 6 would be entered @kbd{899 RET 6 /}, yielding 149.833
(actually $1.49833 with our implied decimal point); pressing @kbd{R}
would round this to 150 cents, i.e., $1.50.

@xref{Floats}, for still more on floating-point precision and related
issues.

@node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
@section Inverse and Hyperbolic Flags

@noindent
@kindex I
@pindex calc-inverse
There is no single-key equivalent to the @code{calc-arcsin} function.
Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
The @kbd{I} key actually toggles the Inverse Flag.  When this flag
is set, the word @samp{Inv} appears in the mode line.@refill

@kindex H
@pindex calc-hyperbolic
Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
If both of these flags are set at once, the effect will be
@code{calc-arcsinh}.  (The Hyperbolic flag is also used by some
non-trigonometric commands; for example @kbd{H L} computes a base-10,
instead of base-@i{e}, logarithm.)@refill

Command names like @code{calc-arcsin} are provided for completeness, and
may be executed with @kbd{x} or @kbd{M-x}.  Their effect is simply to
toggle the Inverse and/or Hyperbolic flags and then execute the
corresponding base command (@code{calc-sin} in this case).

The Inverse and Hyperbolic flags apply only to the next Calculator
command, after which they are automatically cleared.  (They are also
cleared if the next keystroke is not a Calc command.)  Digits you
type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix
arguments for the next command, not as numeric entries.  The same
is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to
subtract and keep arguments).

The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed
elsewhere.  @xref{Keep Arguments}.

@node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
@section Calculation Modes

@noindent
The commands in this section are two-key sequences beginning with
the @kbd{m} prefix.  (That's the letter @kbd{m}, not the @key{META} key.)
The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
(@pxref{Algebraic Entry}).

@menu
* Angular Modes::
* Polar Mode::
* Fraction Mode::
* Infinite Mode::
* Symbolic Mode::
* Matrix Mode::
* Automatic Recomputation::
* Working Message::
@end menu

@node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
@subsection Angular Modes

@noindent
@cindex Angular mode
The Calculator supports three notations for angles: radians, degrees,
and degrees-minutes-seconds.  When a number is presented to a function
like @code{sin} that requires an angle, the current angular mode is
used to interpret the number as either radians or degrees.  If an HMS
form is presented to @code{sin}, it is always interpreted as
degrees-minutes-seconds.

Functions that compute angles produce a number in radians, a number in
degrees, or an HMS form depending on the current angular mode.  If the
result is a complex number and the current mode is HMS, the number is
instead expressed in degrees.  (Complex-number calculations would
normally be done in radians mode, though.  Complex numbers are converted
to degrees by calculating the complex result in radians and then
multiplying by 180 over @c{$\pi$}
@cite{pi}.)

@kindex m r
@pindex calc-radians-mode
@kindex m d
@pindex calc-degrees-mode
@kindex m h
@pindex calc-hms-mode
The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
The current angular mode is displayed on the Emacs mode line.
The default angular mode is degrees.@refill

@node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
@subsection Polar Mode

@noindent
@cindex Polar mode
The Calculator normally ``prefers'' rectangular complex numbers in the
sense that rectangular form is used when the proper form can not be
decided from the input.  This might happen by multiplying a rectangular
number by a polar one, by taking the square root of a negative real
number, or by entering @kbd{( 2 @key{SPC} 3 )}.

@kindex m p
@pindex calc-polar-mode
The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
preference between rectangular and polar forms.  In polar mode, all
of the above example situations would produce polar complex numbers.

@node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
@subsection Fraction Mode

@noindent
@cindex Fraction mode
@cindex Division of integers
Division of two integers normally yields a floating-point number if the
result cannot be expressed as an integer.  In some cases you would
rather get an exact fractional answer.  One way to accomplish this is
to multiply fractions instead:  @kbd{6 @key{RET} 1:4 *} produces @cite{3:2}
even though @kbd{6 @key{RET} 4 /} produces @cite{1.5}.

@kindex m f
@pindex calc-frac-mode
To set the Calculator to produce fractional results for normal integer
divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
For example, @cite{8/4} produces @cite{2} in either mode,
but @cite{6/4} produces @cite{3:2} in Fraction Mode, @cite{1.5} in
Float Mode.@refill

At any time you can use @kbd{c f} (@code{calc-float}) to convert a
fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
float to a fraction.  @xref{Conversions}.

@node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
@subsection Infinite Mode

@noindent
@cindex Infinite mode
The Calculator normally treats results like @cite{1 / 0} as errors;
formulas like this are left in unsimplified form.  But Calc can be
put into a mode where such calculations instead produce ``infinite''
results.

@kindex m i
@pindex calc-infinite-mode
The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
on and off.  When the mode is off, infinities do not arise except
in calculations that already had infinities as inputs.  (One exception
is that infinite open intervals like @samp{[0 .. inf)} can be
generated; however, intervals closed at infinity (@samp{[0 .. inf]})
will not be generated when infinite mode is off.)

With infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
an undirected infinity.  @xref{Infinities}, for a discussion of the
difference between @code{inf} and @code{uinf}.  Also, @cite{0 / 0}
evaluates to @code{nan}, the ``indeterminate'' symbol.  Various other
functions can also return infinities in this mode; for example,
@samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}.  Once again,
note that @samp{exp(inf) = inf} regardless of infinite mode because
this calculation has infinity as an input.

@cindex Positive infinite mode
The @kbd{m i} command with a numeric prefix argument of zero,
i.e., @kbd{C-u 0 m i}, turns on a ``positive infinite mode'' in
which zero is treated as positive instead of being directionless.  
Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
Note that zero never actually has a sign in Calc; there are no
separate representations for @i{+0} and @i{-0}.  Positive
infinite mode merely changes the interpretation given to the
single symbol, @samp{0}.  One consequence of this is that, while
you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.

@node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
@subsection Symbolic Mode

@noindent
@cindex Symbolic mode
@cindex Inexact results
Calculations are normally performed numerically wherever possible.
For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
algebraic expression, produces a numeric answer if the argument is a
number or a symbolic expression if the argument is an expression:
@kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.

@kindex m s
@pindex calc-symbolic-mode
In @dfn{symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
command, functions which would produce inexact, irrational results are
left in symbolic form.  Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
@samp{sqrt(2)}.

@kindex N
@pindex calc-eval-num
The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
the expression at the top of the stack, by temporarily disabling
@code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
Given a numeric prefix argument, it also
sets the floating-point precision to the specified value for the duration
of the command.@refill

To evaluate a formula numerically without expanding the variables it
contains, you can use the key sequence @kbd{m s a v m s} (this uses
@code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
variables.)

@node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
@subsection Matrix and Scalar Modes

@noindent
@cindex Matrix mode
@cindex Scalar mode
Calc sometimes makes assumptions during algebraic manipulation that
are awkward or incorrect when vectors and matrices are involved.
Calc has two modes, @dfn{matrix mode} and @dfn{scalar mode}, which
modify its behavior around vectors in useful ways.

@kindex m v
@pindex calc-matrix-mode
Press @kbd{m v} (@code{calc-matrix-mode}) once to enter matrix mode.
In this mode, all objects are assumed to be matrices unless provably
otherwise.  One major effect is that Calc will no longer consider
multiplication to be commutative.  (Recall that in matrix arithmetic,
@samp{A*B} is not the same as @samp{B*A}.)  This assumption affects
rewrite rules and algebraic simplification.  Another effect of this
mode is that calculations that would normally produce constants like
0 and 1 (e.g., @cite{a - a} and @cite{a / a}, respectively) will now
produce function calls that represent ``generic'' zero or identity
matrices: @samp{idn(0)}, @samp{idn(1)}.  The @code{idn} function
@samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
identity matrix; if @var{n} is omitted, it doesn't know what
dimension to use and so the @code{idn} call remains in symbolic
form.  However, if this generic identity matrix is later combined
with a matrix whose size is known, it will be converted into
a true identity matrix of the appropriate size.  On the other hand,
if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
will assume it really was a scalar after all and produce, e.g., 3.

Press @kbd{m v} a second time to get scalar mode.  Here, objects are
assumed @emph{not} to be vectors or matrices unless provably so.
For example, normally adding a variable to a vector, as in
@samp{[x, y, z] + a}, will leave the sum in symbolic form because
as far as Calc knows, @samp{a} could represent either a number or
another 3-vector.  In scalar mode, @samp{a} is assumed to be a
non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.

Press @kbd{m v} a third time to return to the normal mode of operation.

If you press @kbd{m v} with a numeric prefix argument @var{n}, you
get a special ``dimensioned matrix mode'' in which matrices of
unknown size are assumed to be @var{n}x@var{n} square matrices.
Then, the function call @samp{idn(1)} will expand into an actual
matrix rather than representing a ``generic'' matrix.

@cindex Declaring scalar variables
Of course these modes are approximations to the true state of
affairs, which is probably that some quantities will be matrices
and others will be scalars.  One solution is to ``declare''
certain variables or functions to be scalar-valued.
@xref{Declarations}, to see how to make declarations in Calc.

There is nothing stopping you from declaring a variable to be
scalar and then storing a matrix in it; however, if you do, the
results you get from Calc may not be valid.  Suppose you let Calc
get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
@samp{[1, 2, 3]} in @samp{a}.  The result would not be the same as
for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
your earlier promise to Calc that @samp{a} would be scalar.

Another way to mix scalars and matrices is to use selections
(@pxref{Selecting Subformulas}).  Use matrix mode when operating on
your formula normally; then, to apply scalar mode to a certain part
of the formula without affecting the rest just select that part,
change into scalar mode and press @kbd{=} to resimplify the part
under this mode, then change back to matrix mode before deselecting.

@node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
@subsection Automatic Recomputation

@noindent
The @dfn{evaluates-to} operator, @samp{=>}, has the special
property that any @samp{=>} formulas on the stack are recomputed
whenever variable values or mode settings that might affect them
are changed.  @xref{Evaluates-To Operator}.

@kindex m C
@pindex calc-auto-recompute
The @kbd{m C} (@code{calc-auto-recompute}) command turns this
automatic recomputation on and off.  If you turn it off, Calc will
not update @samp{=>} operators on the stack (nor those in the
attached Embedded Mode buffer, if there is one).  They will not
be updated unless you explicitly do so by pressing @kbd{=} or until
you press @kbd{m C} to turn recomputation back on.  (While automatic
recomputation is off, you can think of @kbd{m C m C} as a command
to update all @samp{=>} operators while leaving recomputation off.)

To update @samp{=>} operators in an Embedded buffer while
automatic recomputation is off, use @w{@kbd{M-# u}}.
@xref{Embedded Mode}.

@node Working Message, , Automatic Recomputation, Calculation Modes
@subsection Working Messages

@noindent
@cindex Performance
@cindex Working messages
Since the Calculator is written entirely in Emacs Lisp, which is not
designed for heavy numerical work, many operations are quite slow.
The Calculator normally displays the message @samp{Working...} in the
echo area during any command that may be slow.  In addition, iterative
operations such as square roots and trigonometric functions display the
intermediate result at each step.  Both of these types of messages can
be disabled if you find them distracting.

@kindex m w
@pindex calc-working
Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
disable all ``working'' messages.  Use a numeric prefix of 1 to enable
only the plain @samp{Working...} message.  Use a numeric prefix of 2 to
see intermediate results as well.  With no numeric prefix this displays
the current mode.@refill

While it may seem that the ``working'' messages will slow Calc down
considerably, experiments have shown that their impact is actually
quite small.  But if your terminal is slow you may find that it helps
to turn the messages off.

@node Simplification Modes, Declarations, Calculation Modes, Mode Settings
@section Simplification Modes

@noindent
The current @dfn{simplification mode} controls how numbers and formulas
are ``normalized'' when being taken from or pushed onto the stack.
Some normalizations are unavoidable, such as rounding floating-point
results to the current precision, and reducing fractions to simplest
form.  Others, such as simplifying a formula like @cite{a+a} (or @cite{2+3}),
are done by default but can be turned off when necessary.

When you press a key like @kbd{+} when @cite{2} and @cite{3} are on the
stack, Calc pops these numbers, normalizes them, creates the formula
@cite{2+3}, normalizes it, and pushes the result.  Of course the standard
rules for normalizing @cite{2+3} will produce the result @cite{5}.

Simplification mode commands consist of the lower-case @kbd{m} prefix key
followed by a shifted letter.

@kindex m O
@pindex calc-no-simplify-mode
The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
simplifications.  These would leave a formula like @cite{2+3} alone.  In
fact, nothing except simple numbers are ever affected by normalization
in this mode.

@kindex m N
@pindex calc-num-simplify-mode
The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
of any formulas except those for which all arguments are constants.  For
example, @cite{1+2} is simplified to @cite{3}, and @cite{a+(2-2)} is
simplified to @cite{a+0} but no further, since one argument of the sum
is not a constant.  Unfortunately, @cite{(a+2)-2} is @emph{not} simplified
because the top-level @samp{-} operator's arguments are not both
constant numbers (one of them is the formula @cite{a+2}).
A constant is a number or other numeric object (such as a constant
error form or modulo form), or a vector all of whose
elements are constant.@refill

@kindex m D
@pindex calc-default-simplify-mode
The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
default simplifications for all formulas.  This includes many easy and
fast algebraic simplifications such as @cite{a+0} to @cite{a}, and
@cite{a + 2 a} to @cite{3 a}, as well as evaluating functions like
@cite{@t{deriv}(x^2, x)} to @cite{2 x}.

@kindex m B
@pindex calc-bin-simplify-mode
The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
simplifications to a result and then, if the result is an integer,
uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
to the current binary word size.  @xref{Binary Functions}.  Real numbers
are rounded to the nearest integer and then clipped; other kinds of
results (after the default simplifications) are left alone.

@kindex m A
@pindex calc-alg-simplify-mode
The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
simplification; it applies all the default simplifications, and also
the more powerful (and slower) simplifications made by @kbd{a s}
(@code{calc-simplify}).  @xref{Algebraic Simplifications}.

@kindex m E
@pindex calc-ext-simplify-mode
The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
command.  @xref{Unsafe Simplifications}.

@kindex m U
@pindex calc-units-simplify-mode
The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
simplification; it applies the command @kbd{u s}
(@code{calc-simplify-units}), which in turn
is a superset of @kbd{a s}.  In this mode, variable names which
are identifiable as unit names (like @samp{mm} for ``millimeters'')
are simplified with their unit definitions in mind.@refill

A common technique is to set the simplification mode down to the lowest
amount of simplification you will allow to be applied automatically, then
use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
perform higher types of simplifications on demand.  @xref{Algebraic
Definitions}, for another sample use of no-simplification mode.@refill

@node Declarations, Display Modes, Simplification Modes, Mode Settings
@section Declarations

@noindent
A @dfn{declaration} is a statement you make that promises you will
use a certain variable or function in a restricted way.  This may
give Calc the freedom to do things that it couldn't do if it had to
take the fully general situation into account.

@menu
* Declaration Basics::
* Kinds of Declarations::
* Functions for Declarations::
@end menu

@node Declaration Basics, Kinds of Declarations, Declarations, Declarations
@subsection Declaration Basics

@noindent
@kindex s d
@pindex calc-declare-variable
The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
way to make a declaration for a variable.  This command prompts for
the variable name, then prompts for the declaration.  The default
at the declaration prompt is the previous declaration, if any.
You can edit this declaration, or press @kbd{C-k} to erase it and
type a new declaration.  (Or, erase it and press @key{RET} to clear
the declaration, effectively ``undeclaring'' the variable.)

A declaration is in general a vector of @dfn{type symbols} and
@dfn{range} values.  If there is only one type symbol or range value,
you can write it directly rather than enclosing it in a vector.
For example, @kbd{s d foo RET real RET} declares @code{foo} to
be a real number, and @kbd{s d bar RET [int, const, [1..6]] RET}
declares @code{bar} to be a constant integer between 1 and 6.
(Actually, you can omit the outermost brackets and Calc will
provide them for you: @kbd{s d bar RET int, const, [1..6] RET}.)

@cindex @code{Decls} variable
@vindex Decls
Declarations in Calc are kept in a special variable called @code{Decls}.
This variable encodes the set of all outstanding declarations in
the form of a matrix.  Each row has two elements:  A variable or
vector of variables declared by that row, and the declaration
specifier as described above.  You can use the @kbd{s D} command to
edit this variable if you wish to see all the declarations at once.
@xref{Operations on Variables}, for a description of this command
and the @kbd{s p} command that allows you to save your declarations
permanently if you wish.

Items being declared can also be function calls.  The arguments in
the call are ignored; the effect is to say that this function returns
values of the declared type for any valid arguments.  The @kbd{s d}
command declares only variables, so if you wish to make a function
declaration you will have to edit the @code{Decls} matrix yourself.

For example, the declaration matrix

@group
@smallexample
[ [ foo,       real       ]
  [ [j, k, n], int        ]
  [ f(1,2,3),  [0 .. inf) ] ]
@end smallexample
@end group

@noindent
declares that @code{foo} represents a real number, @code{j}, @code{k}
and @code{n} represent integers, and the function @code{f} always
returns a real number in the interval shown.

@vindex All
If there is a declaration for the variable @code{All}, then that
declaration applies to all variables that are not otherwise declared.
It does not apply to function names.  For example, using the row
@samp{[All, real]} says that all your variables are real unless they
are explicitly declared without @code{real} in some other row.
The @kbd{s d} command declares @code{All} if you give a blank
response to the variable-name prompt.

@node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
@subsection Kinds of Declarations

@noindent
The type-specifier part of a declaration (that is, the second prompt
in the @kbd{s d} command) can be a type symbol, an interval, or a
vector consisting of zero or more type symbols followed by zero or
more intervals or numbers that represent the set of possible values
for the variable.

@group
@smallexample
[ [ a, [1, 2, 3, 4, 5] ]
  [ b, [1 .. 5]        ]
  [ c, [int, 1 .. 5]   ] ]
@end smallexample
@end group

Here @code{a} is declared to contain one of the five integers shown;
@code{b} is any number in the interval from 1 to 5 (any real number
since we haven't specified), and @code{c} is any integer in that
interval.  Thus the declarations for @code{a} and @code{c} are
nearly equivalent (see below).

The type-specifier can be the empty vector @samp{[]} to say that
nothing is known about a given variable's value.  This is the same
as not declaring the variable at all except that it overrides any
@code{All} declaration which would otherwise apply.

The initial value of @code{Decls} is the empty vector @samp{[]}.
If @code{Decls} has no stored value or if the value stored in it
is not valid, it is ignored and there are no declarations as far
as Calc is concerned.  (The @kbd{s d} command will replace such a
malformed value with a fresh empty matrix, @samp{[]}, before recording
the new declaration.)  Unrecognized type symbols are ignored.

The following type symbols describe what sorts of numbers will be
stored in a variable:

@table @code
@item int
Integers.
@item numint
Numerical integers.  (Integers or integer-valued floats.)
@item frac
Fractions.  (Rational numbers which are not integers.)
@item rat
Rational numbers.  (Either integers or fractions.)
@item float
Floating-point numbers.
@item real
Real numbers.  (Integers, fractions, or floats.  Actually,
intervals and error forms with real components also count as
reals here.)
@item pos
Positive real numbers.  (Strictly greater than zero.)
@item nonneg
Nonnegative real numbers.  (Greater than or equal to zero.)
@item number
Numbers.  (Real or complex.)
@end table

Calc uses this information to determine when certain simplifications
of formulas are safe.  For example, @samp{(x^y)^z} cannot be
simplified to @samp{x^(y z)} in general; for example,
@samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @i{-3}.
However, this simplification @emph{is} safe if @code{z} is known
to be an integer, or if @code{x} is known to be a nonnegative
real number.  If you have given declarations that allow Calc to
deduce either of these facts, Calc will perform this simplification
of the formula.

Calc can apply a certain amount of logic when using declarations.
For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
has been declared @code{int}; Calc knows that an integer times an
integer, plus an integer, must always be an integer.  (In fact,
Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
it is able to determine that @samp{2n+1} must be an odd integer.)

Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
because Calc knows that the @code{abs} function always returns a
nonnegative real.  If you had a @code{myabs} function that also had
this property, you could get Calc to recognize it by adding the row
@samp{[myabs(), nonneg]} to the @code{Decls} matrix.

One instance of this simplification is @samp{sqrt(x^2)} (since the
@code{sqrt} function is effectively a one-half power).  Normally
Calc leaves this formula alone.  After the command
@kbd{s d x RET real RET}, however, it can simplify the formula to
@samp{abs(x)}.  And after @kbd{s d x RET nonneg RET}, Calc can
simplify this formula all the way to @samp{x}.

If there are any intervals or real numbers in the type specifier,
they comprise the set of possible values that the variable or
function being declared can have.  In particular, the type symbol
@code{real} is effectively the same as the range @samp{[-inf .. inf]}
(note that infinity is included in the range of possible values);
@code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
the same as @samp{[0 .. inf]}.  Saying @samp{[real, [-5 .. 5]]} is
redundant because the fact that the variable is real can be
deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
@samp{[rat, [-5 .. 5]]} are useful combinations.

Note that the vector of intervals or numbers is in the same format
used by Calc's set-manipulation commands.  @xref{Set Operations}.

The type specifier @samp{[1, 2, 3]} is equivalent to
@samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
In other words, the range of possible values means only that
the variable's value must be numerically equal to a number in
that range, but not that it must be equal in type as well.
Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''

If you use a conflicting combination of type specifiers, the
results are unpredictable.  An example is @samp{[pos, [0 .. 5]]},
where the interval does not lie in the range described by the
type symbol.

``Real'' declarations mostly affect simplifications involving powers
like the one described above.  Another case where they are used
is in the @kbd{a P} command which returns a list of all roots of a
polynomial; if the variable has been declared real, only the real
roots (if any) will be included in the list.

``Integer'' declarations are used for simplifications which are valid
only when certain values are integers (such as @samp{(x^y)^z}
shown above).

Another command that makes use of declarations is @kbd{a s}, when
simplifying equations and inequalities.  It will cancel @code{x}
from both sides of @samp{a x = b x} only if it is sure @code{x}
is non-zero, say, because it has a @code{pos} declaration.
To declare specifically that @code{x} is real and non-zero,
use @samp{[[-inf .. 0), (0 .. inf]]}.  (There is no way in the
current notation to say that @code{x} is nonzero but not necessarily
real.)  The @kbd{a e} command does ``unsafe'' simplifications,
including cancelling @samp{x} from the equation when @samp{x} is
not known to be nonzero.

Another set of type symbols distinguish between scalars and vectors.

@table @code
@item scalar
The value is not a vector.
@item vector
The value is a vector.
@item matrix
The value is a matrix (a rectangular vector of vectors).
@end table

These type symbols can be combined with the other type symbols
described above; @samp{[int, matrix]} describes an object which
is a matrix of integers.

Scalar/vector declarations are used to determine whether certain
algebraic operations are safe.  For example, @samp{[a, b, c] + x}
is normally not simplified to @samp{[a + x, b + x, c + x]}, but
it will be if @code{x} has been declared @code{scalar}.  On the
other hand, multiplication is usually assumed to be commutative,
but the terms in @samp{x y} will never be exchanged if both @code{x}
and @code{y} are known to be vectors or matrices.  (Calc currently
never distinguishes between @code{vector} and @code{matrix}
declarations.)

@xref{Matrix Mode}, for a discussion of ``matrix mode'' and
``scalar mode,'' which are similar to declaring @samp{[All, matrix]}
or @samp{[All, scalar]} but much more convenient.

One more type symbol that is recognized is used with the @kbd{H a d}
command for taking total derivatives of a formula.  @xref{Calculus}.

@table @code
@item const
The value is a constant with respect to other variables.
@end table

Calc does not check the declarations for a variable when you store
a value in it.  However, storing @i{-3.5} in a variable that has
been declared @code{pos}, @code{int}, or @code{matrix} may have
unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @cite{3.5}
if it substitutes the value first, or to @cite{-3.5} if @code{x}
was declared @code{pos} and the formula @samp{sqrt(x^2)} is
simplified to @samp{x} before the value is substituted.  Before
using a variable for a new purpose, it is best to use @kbd{s d}
or @kbd{s D} to check to make sure you don't still have an old
declaration for the variable that will conflict with its new meaning.

@node Functions for Declarations, , Kinds of Declarations, Declarations
@subsection Functions for Declarations

@noindent
Calc has a set of functions for accessing the current declarations
in a convenient manner.  These functions return 1 if the argument
can be shown to have the specified property, or 0 if the argument
can be shown @emph{not} to have that property; otherwise they are
left unevaluated.  These functions are suitable for use with rewrite
rules (@pxref{Conditional Rewrite Rules}) or programming constructs
(@pxref{Conditionals in Macros}).  They can be entered only using
algebraic notation.  @xref{Logical Operations}, for functions
that perform other tests not related to declarations.

For example, @samp{dint(17)} returns 1 because 17 is an integer, as
do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
@code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
Calc consults knowledge of its own built-in functions as well as your
own declarations: @samp{dint(floor(x))} returns 1.

@c @starindex
@tindex dint
@c @starindex
@tindex dnumint
@c @starindex
@tindex dnatnum
The @code{dint} function checks if its argument is an integer.
The @code{dnatnum} function checks if its argument is a natural
number, i.e., a nonnegative integer.  The @code{dnumint} function
checks if its argument is numerically an integer, i.e., either an
integer or an integer-valued float.  Note that these and the other
data type functions also accept vectors or matrices composed of
suitable elements, and that real infinities @samp{inf} and @samp{-inf}
are considered to be integers for the purposes of these functions.

@c @starindex
@tindex drat
The @code{drat} function checks if its argument is rational, i.e.,
an integer or fraction.  Infinities count as rational, but intervals
and error forms do not.

@c @starindex
@tindex dreal
The @code{dreal} function checks if its argument is real.  This
includes integers, fractions, floats, real error forms, and intervals.

@c @starindex
@tindex dimag
The @code{dimag} function checks if its argument is imaginary,
i.e., is mathematically equal to a real number times @cite{i}.

@c @starindex
@tindex dpos
@c @starindex
@tindex dneg
@c @starindex
@tindex dnonneg
The @code{dpos} function checks for positive (but nonzero) reals.
The @code{dneg} function checks for negative reals.  The @code{dnonneg}
function checks for nonnegative reals, i.e., reals greater than or
equal to zero.  Note that the @kbd{a s} command can simplify an
expression like @cite{x > 0} to 1 or 0 using @code{dpos}, and that
@kbd{a s} is effectively applied to all conditions in rewrite rules,
so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
are rarely necessary.

@c @starindex
@tindex dnonzero
The @code{dnonzero} function checks that its argument is nonzero.
This includes all nonzero real or complex numbers, all intervals that
do not include zero, all nonzero modulo forms, vectors all of whose
elements are nonzero, and variables or formulas whose values can be
deduced to be nonzero.  It does not include error forms, since they
represent values which could be anything including zero.  (This is
also the set of objects considered ``true'' in conditional contexts.)

@c @starindex
@tindex deven
@c @starindex
@tindex dodd
The @code{deven} function returns 1 if its argument is known to be
an even integer (or integer-valued float); it returns 0 if its argument
is known not to be even (because it is known to be odd or a non-integer).
The @kbd{a s} command uses this to simplify a test of the form
@samp{x % 2 = 0}.  There is also an analogous @code{dodd} function.

@c @starindex
@tindex drange
The @code{drange} function returns a set (an interval or a vector
of intervals and/or numbers; @pxref{Set Operations}) that describes
the set of possible values of its argument.  If the argument is
a variable or a function with a declaration, the range is copied
from the declaration.  Otherwise, the possible signs of the
expression are determined using a method similar to @code{dpos},
etc., and a suitable set like @samp{[0 .. inf]} is returned.  If
the expression is not provably real, the @code{drange} function
remains unevaluated.

@c @starindex
@tindex dscalar
The @code{dscalar} function returns 1 if its argument is provably
scalar, or 0 if its argument is provably non-scalar.  It is left
unevaluated if this cannot be determined.  (If matrix mode or scalar
mode are in effect, this function returns 1 or 0, respectively,
if it has no other information.)  When Calc interprets a condition
(say, in a rewrite rule) it considers an unevaluated formula to be
``false.''  Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
is provably non-scalar; both are ``false'' if there is insufficient
information to tell.

@node Display Modes, Language Modes, Declarations, Mode Settings
@section Display Modes

@noindent
The commands in this section are two-key sequences beginning with the
@kbd{d} prefix.  The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
(@code{calc-line-breaking}) commands are described elsewhere;
@pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
Display formats for vectors and matrices are also covered elsewhere;
@pxref{Vector and Matrix Formats}.@refill

One thing all display modes have in common is their treatment of the
@kbd{H} prefix.  This prefix causes any mode command that would normally
refresh the stack to leave the stack display alone.  The word ``Dirty''
will appear in the mode line when Calc thinks the stack display may not
reflect the latest mode settings.

@kindex d RET
@pindex calc-refresh-top
The @kbd{d RET} (@code{calc-refresh-top}) command reformats the
top stack entry according to all the current modes.  Positive prefix
arguments reformat the top @var{n} entries; negative prefix arguments
reformat the specified entry, and a prefix of zero is equivalent to
@kbd{d SPC} (@code{calc-refresh}), which reformats the entire stack.
For example, @kbd{H d s M-2 d RET} changes to scientific notation
but reformats only the top two stack entries in the new mode.

The @kbd{I} prefix has another effect on the display modes.  The mode
is set only temporarily; the top stack entry is reformatted according
to that mode, then the original mode setting is restored.  In other
words, @kbd{I d s} is equivalent to @kbd{H d s d RET H d @var{(old mode)}}.

@menu
* Radix Modes::
* Grouping Digits::
* Float Formats::
* Complex Formats::
* Fraction Formats::
* HMS Formats::
* Date Formats::
* Truncating the Stack::
* Justification::
* Labels::
@end menu

@node Radix Modes, Grouping Digits, Display Modes, Display Modes
@subsection Radix Modes

@noindent
@cindex Radix display
@cindex Non-decimal numbers
@cindex Decimal and non-decimal numbers
Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
notation.  Calc can actually display in any radix from two (binary) to 36.
When the radix is above 10, the letters @code{A} to @code{Z} are used as
digits.  When entering such a number, letter keys are interpreted as
potential digits rather than terminating numeric entry mode.

@kindex d 2
@kindex d 8
@kindex d 6
@kindex d 0
@cindex Hexadecimal integers
@cindex Octal integers
The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
binary, octal, hexadecimal, and decimal as the current display radix,
respectively.  Numbers can always be entered in any radix, though the
current radix is used as a default if you press @kbd{#} without any initial
digits.  A number entered without a @kbd{#} is @emph{always} interpreted
as decimal.@refill

@kindex d r
@pindex calc-radix
To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
an integer from 2 to 36.  You can specify the radix as a numeric prefix
argument; otherwise you will be prompted for it.

@kindex d z
@pindex calc-leading-zeros
@cindex Leading zeros
Integers normally are displayed with however many digits are necessary to
represent the integer and no more.  The @kbd{d z} (@code{calc-leading-zeros})
command causes integers to be padded out with leading zeros according to the
current binary word size.  (@xref{Binary Functions}, for a discussion of
word size.)  If the absolute value of the word size is @cite{w}, all integers
are displayed with at least enough digits to represent @c{$2^w-1$}
@cite{(2^w)-1} in the
current radix.  (Larger integers will still be displayed in their entirety.)

@node Grouping Digits, Float Formats, Radix Modes, Display Modes
@subsection Grouping Digits

@noindent
@kindex d g
@pindex calc-group-digits
@cindex Grouping digits
@cindex Digit grouping
Long numbers can be hard to read if they have too many digits.  For
example, the factorial of 30 is 33 digits long!  Press @kbd{d g}
(@code{calc-group-digits}) to enable @dfn{grouping} mode, in which digits
are displayed in clumps of 3 or 4 (depending on the current radix)
separated by commas.

The @kbd{d g} command toggles grouping on and off.
With a numerix prefix of 0, this command displays the current state of
the grouping flag; with an argument of minus one it disables grouping;
with a positive argument @cite{N} it enables grouping on every @cite{N}
digits.  For floating-point numbers, grouping normally occurs only
before the decimal point.  A negative prefix argument @cite{-N} enables
grouping every @cite{N} digits both before and after the decimal point.@refill

@kindex d ,
@pindex calc-group-char
The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
character as the grouping separator.  The default is the comma character.
If you find it difficult to read vectors of large integers grouped with
commas, you may wish to use spaces or some other character instead.
This command takes the next character you type, whatever it is, and
uses it as the digit separator.  As a special case, @kbd{d , \} selects
@samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.

Please note that grouped numbers will not generally be parsed correctly
if re-read in textual form, say by the use of @kbd{M-# y} and @kbd{M-# g}.
(@xref{Kill and Yank}, for details on these commands.)  One exception is
the @samp{\,} separator, which doesn't interfere with parsing because it
is ignored by @TeX{} language mode.

@node Float Formats, Complex Formats, Grouping Digits, Display Modes
@subsection Float Formats

@noindent
Floating-point quantities are normally displayed in standard decimal
form, with scientific notation used if the exponent is especially high
or low.  All significant digits are normally displayed.  The commands
in this section allow you to choose among several alternative display
formats for floats.

@kindex d n
@pindex calc-normal-notation
The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
display format.  All significant figures in a number are displayed.
With a positive numeric prefix, numbers are rounded if necessary to
that number of significant digits.  With a negative numerix prefix,
the specified number of significant digits less than the current
precision is used.  (Thus @kbd{C-u -2 d n} displays 10 digits if the
current precision is 12.)

@kindex d f
@pindex calc-fix-notation
The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
notation.  The numeric argument is the number of digits after the
decimal point, zero or more.  This format will relax into scientific
notation if a nonzero number would otherwise have been rounded all the
way to zero.  Specifying a negative number of digits is the same as
for a positive number, except that small nonzero numbers will be rounded
to zero rather than switching to scientific notation.

@kindex d s
@pindex calc-sci-notation
@cindex Scientific notation, display of
The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
notation.  A positive argument sets the number of significant figures
displayed, of which one will be before and the rest after the decimal
point.  A negative argument works the same as for @kbd{d n} format.
The default is to display all significant digits.

@kindex d e
@pindex calc-eng-notation
@cindex Engineering notation, display of
The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
notation.  This is similar to scientific notation except that the
exponent is rounded down to a multiple of three, with from one to three
digits before the decimal point.  An optional numeric prefix sets the
number of significant digits to display, as for @kbd{d s}.

It is important to distinguish between the current @emph{precision} and
the current @emph{display format}.  After the commands @kbd{C-u 10 p}
and @kbd{C-u 6 d n} the Calculator computes all results to ten
significant figures but displays only six.  (In fact, intermediate
calculations are often carried to one or two more significant figures,
but values placed on the stack will be rounded down to ten figures.)
Numbers are never actually rounded to the display precision for storage,
except by commands like @kbd{C-k} and @kbd{M-# y} which operate on the
actual displayed text in the Calculator buffer.

@kindex d .
@pindex calc-point-char
The @kbd{d .} (@code{calc-point-char}) command selects the character used
as a decimal point.  Normally this is a period; users in some countries
may wish to change this to a comma.  Note that this is only a display
style; on entry, periods must always be used to denote floating-point
numbers, and commas to separate elements in a list.

@node Complex Formats, Fraction Formats, Float Formats, Display Modes
@subsection Complex Formats

@noindent
@kindex d c
@pindex calc-complex-notation
There are three supported notations for complex numbers in rectangular
form.  The default is as a pair of real numbers enclosed in parentheses
and separated by a comma: @samp{(a,b)}.  The @kbd{d c}
(@code{calc-complex-notation}) command selects this style.@refill

@kindex d i
@pindex calc-i-notation
@kindex d j
@pindex calc-j-notation
The other notations are @kbd{d i} (@code{calc-i-notation}), in which
numbers are displayed in @samp{a+bi} form, and @kbd{d j}
(@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
in some disciplines.@refill

@cindex @code{i} variable
@vindex i
Complex numbers are normally entered in @samp{(a,b)} format.
If you enter @samp{2+3i} as an algebraic formula, it will be stored as
the formula @samp{2 + 3 * i}.  However, if you use @kbd{=} to evaluate
this formula and you have not changed the variable @samp{i}, the @samp{i}
will be interpreted as @samp{(0,1)} and the formula will be simplified
to @samp{(2,3)}.  Other commands (like @code{calc-sin}) will @emph{not}
interpret the formula @samp{2 + 3 * i} as a complex number.
@xref{Variables}, under ``special constants.''@refill

@node Fraction Formats, HMS Formats, Complex Formats, Display Modes
@subsection Fraction Formats

@noindent
@kindex d o
@pindex calc-over-notation
Display of fractional numbers is controlled by the @kbd{d o}
(@code{calc-over-notation}) command.  By default, a number like
eight thirds is displayed in the form @samp{8:3}.  The @kbd{d o} command
prompts for a one- or two-character format.  If you give one character,
that character is used as the fraction separator.  Common separators are
@samp{:} and @samp{/}.  (During input of numbers, the @kbd{:} key must be
used regardless of the display format; in particular, the @kbd{/} is used
for RPN-style division, @emph{not} for entering fractions.)

If you give two characters, fractions use ``integer-plus-fractional-part''
notation.  For example, the format @samp{+/} would display eight thirds
as @samp{2+2/3}.  If two colons are present in a number being entered,
the number is interpreted in this form (so that the entries @kbd{2:2:3}
and @kbd{8:3} are equivalent).

It is also possible to follow the one- or two-character format with
a number.  For example:  @samp{:10} or @samp{+/3}.  In this case,
Calc adjusts all fractions that are displayed to have the specified
denominator, if possible.  Otherwise it adjusts the denominator to
be a multiple of the specified value.  For example, in @samp{:6} mode
the fraction @cite{1:6} will be unaffected, but @cite{2:3} will be
displayed as @cite{4:6}, @cite{1:2} will be displayed as @cite{3:6},
and @cite{1:8} will be displayed as @cite{3:24}.  Integers are also
affected by this mode:  3 is displayed as @cite{18:6}.  Note that the
format @samp{:1} writes fractions the same as @samp{:}, but it writes
integers as @cite{n:1}.

The fraction format does not affect the way fractions or integers are
stored, only the way they appear on the screen.  The fraction format
never affects floats.

@node HMS Formats, Date Formats, Fraction Formats, Display Modes
@subsection HMS Formats

@noindent
@kindex d h
@pindex calc-hms-notation
The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
HMS (hours-minutes-seconds) forms.  It prompts for a string which
consists basically of an ``hours'' marker, optional punctuation, a
``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
Punctuation is zero or more spaces, commas, or semicolons.  The hours
marker is one or more non-punctuation characters.  The minutes and
seconds markers must be single non-punctuation characters.

The default HMS format is @samp{@@ ' "}, producing HMS values of the form
@samp{23@@ 30' 15.75"}.  The format @samp{deg, ms} would display this same
value as @samp{23deg, 30m15.75s}.  During numeric entry, the @kbd{h} or @kbd{o}
keys are recognized as synonyms for @kbd{@@} regardless of display format.
The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
@kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
already been typed; otherwise, they have their usual meanings
(@kbd{m-} prefix and @kbd{s-} prefix).  Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
@kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
@kbd{o}) has already been pressed; otherwise it means to switch to algebraic
entry.

@node Date Formats, Truncating the Stack, HMS Formats, Display Modes
@subsection Date Formats

@noindent
@kindex d d
@pindex calc-date-notation
The @kbd{d d} (@code{calc-date-notation}) command controls the display
of date forms (@pxref{Date Forms}).  It prompts for a string which
contains letters that represent the various parts of a date and time.
To show which parts should be omitted when the form represents a pure
date with no time, parts of the string can be enclosed in @samp{< >}
marks.  If you don't include @samp{< >} markers in the format, Calc
guesses at which parts, if any, should be omitted when formatting
pure dates.

The default format is:  @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
If you enter a blank format string, this default format is
reestablished.

Calc uses @samp{< >} notation for nameless functions as well as for
dates.  @xref{Specifying Operators}.  To avoid confusion with nameless
functions, your date formats should avoid using the @samp{#} character.

@menu
* Date Formatting Codes::
* Free-Form Dates::
* Standard Date Formats::
@end menu

@node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
@subsubsection Date Formatting Codes

@noindent
When displaying a date, the current date format is used.  All
characters except for letters and @samp{<} and @samp{>} are
copied literally when dates are formatted.  The portion between
@samp{< >} markers is omitted for pure dates, or included for
date/time forms.  Letters are interpreted according to the table
below.

When dates are read in during algebraic entry, Calc first tries to
match the input string to the current format either with or without
the time part.  The punctuation characters (including spaces) must
match exactly; letter fields must correspond to suitable text in
the input.  If this doesn't work, Calc checks if the input is a
simple number; if so, the number is interpreted as a number of days
since Jan 1, 1 AD.  Otherwise, Calc tries a much more relaxed and
flexible algorithm which is described in the next section.

Weekday names are ignored during reading.

Two-digit year numbers are interpreted as lying in the range
from 1941 to 2039.  Years outside that range are always
entered and displayed in full.  Year numbers with a leading
@samp{+} sign are always interpreted exactly, allowing the
entry and display of the years 1 through 99 AD.

Here is a complete list of the formatting codes for dates:

@table @asis
@item Y
Year:  ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
@item YY
Year:  ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
@item BY
Year:  ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
@item YYY
Year:  ``1991'' for 1991, ``23'' for 23 AD.
@item YYYY
Year:  ``1991'' for 1991, ``+23'' for 23 AD.
@item aa
Year:  ``ad'' or blank.
@item AA
Year:  ``AD'' or blank.
@item aaa
Year:  ``ad '' or blank.  (Note trailing space.)
@item AAA
Year:  ``AD '' or blank.
@item aaaa
Year:  ``a.d.'' or blank.
@item AAAA
Year:  ``A.D.'' or blank.
@item bb
Year:  ``bc'' or blank.
@item BB
Year:  ``BC'' or blank.
@item bbb
Year:  `` bc'' or blank.  (Note leading space.)
@item BBB
Year:  `` BC'' or blank.
@item bbbb
Year:  ``b.c.'' or blank.
@item BBBB
Year:  ``B.C.'' or blank.
@item M
Month:  ``8'' for August.
@item MM
Month:  ``08'' for August.
@item BM
Month:  `` 8'' for August.
@item MMM
Month:  ``AUG'' for August.
@item Mmm
Month:  ``Aug'' for August.
@item mmm
Month:  ``aug'' for August.
@item MMMM
Month:  ``AUGUST'' for August.
@item Mmmm
Month:  ``August'' for August.
@item D
Day:  ``7'' for 7th day of month.
@item DD
Day:  ``07'' for 7th day of month.
@item BD
Day:  `` 7'' for 7th day of month.
@item W
Weekday:  ``0'' for Sunday, ``6'' for Saturday.
@item WWW
Weekday:  ``SUN'' for Sunday.
@item Www
Weekday:  ``Sun'' for Sunday.
@item www
Weekday:  ``sun'' for Sunday.
@item WWWW
Weekday:  ``SUNDAY'' for Sunday.
@item Wwww
Weekday:  ``Sunday'' for Sunday.
@item d
Day of year:  ``34'' for Feb. 3.
@item ddd
Day of year:  ``034'' for Feb. 3.
@item bdd
Day of year:  `` 34'' for Feb. 3.
@item h
Hour:  ``5'' for 5 AM; ``17'' for 5 PM.
@item hh
Hour:  ``05'' for 5 AM; ``17'' for 5 PM.
@item bh
Hour:  `` 5'' for 5 AM; ``17'' for 5 PM.
@item H
Hour:  ``5'' for 5 AM and 5 PM.
@item HH
Hour:  ``05'' for 5 AM and 5 PM.
@item BH
Hour:  `` 5'' for 5 AM and 5 PM.
@item p
AM/PM:  ``a'' or ``p''.
@item P
AM/PM:  ``A'' or ``P''.
@item pp
AM/PM:  ``am'' or ``pm''.
@item PP
AM/PM:  ``AM'' or ``PM''.
@item pppp
AM/PM:  ``a.m.'' or ``p.m.''.
@item PPPP
AM/PM:  ``A.M.'' or ``P.M.''.
@item m
Minutes:  ``7'' for 7.
@item mm
Minutes:  ``07'' for 7.
@item bm
Minutes:  `` 7'' for 7.
@item s
Seconds:  ``7'' for 7;  ``7.23'' for 7.23.
@item ss
Seconds:  ``07'' for 7;  ``07.23'' for 7.23.
@item bs
Seconds:  `` 7'' for 7;  `` 7.23'' for 7.23.
@item SS
Optional seconds:  ``07'' for 7;  blank for 0.
@item BS
Optional seconds:  `` 7'' for 7;  blank for 0.
@item N
Numeric date/time:  ``726842.25'' for 6:00am Wed Jan 9, 1991.
@item n
Numeric date:  ``726842'' for any time on Wed Jan 9, 1991.
@item J
Julian date/time:  ``2448265.75'' for 6:00am Wed Jan 9, 1991.
@item j
Julian date:  ``2448266'' for any time on Wed Jan 9, 1991.
@item U
Unix time:  ``663400800'' for 6:00am Wed Jan 9, 1991.
@item X
Brackets suppression.  An ``X'' at the front of the format
causes the surrounding @w{@samp{< >}} delimiters to be omitted
when formatting dates.  Note that the brackets are still
required for algebraic entry.
@end table

If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
colon is also omitted if the seconds part is zero.

If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
appear in the format, then negative year numbers are displayed
without a minus sign.  Note that ``aa'' and ``bb'' are mutually
exclusive.  Some typical usages would be @samp{YYYY AABB};
@samp{AAAYYYYBBB}; @samp{YYYYBBB}.

The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
reading unless several of these codes are strung together with no
punctuation in between, in which case the input must have exactly as
many digits as there are letters in the format.

The ``j,'' ``J,'' and ``U'' formats do not make any time zone
adjustment.  They effectively use @samp{julian(x,0)} and
@samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.

@node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
@subsubsection Free-Form Dates

@noindent
When reading a date form during algebraic entry, Calc falls back
on the algorithm described here if the input does not exactly
match the current date format.  This algorithm generally
``does the right thing'' and you don't have to worry about it,
but it is described here in full detail for the curious.

Calc does not distinguish between upper- and lower-case letters
while interpreting dates.

First, the time portion, if present, is located somewhere in the
text and then removed.  The remaining text is then interpreted as
the date.

A time is of the form @samp{hh:mm:ss}, possibly with the seconds
part omitted and possibly with an AM/PM indicator added to indicate
12-hour time.  If the AM/PM is present, the minutes may also be
omitted.  The AM/PM part may be any of the words @samp{am},
@samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
abbreviated to one letter, and the alternate forms @samp{a.m.},
@samp{p.m.}, and @samp{mid} are also understood.  Obviously
@samp{noon} and @samp{midnight} are allowed only on 12:00:00.
The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
recognized with no number attached.

If there is no AM/PM indicator, the time is interpreted in 24-hour
format.

To read the date portion, all words and numbers are isolated
from the string; other characters are ignored.  All words must
be either month names or day-of-week names (the latter of which
are ignored).  Names can be written in full or as three-letter
abbreviations.

Large numbers, or numbers with @samp{+} or @samp{-} signs,
are interpreted as years.  If one of the other numbers is
greater than 12, then that must be the day and the remaining
number in the input is therefore the month.  Otherwise, Calc
assumes the month, day and year are in the same order that they
appear in the current date format.  If the year is omitted, the
current year is taken from the system clock.

If there are too many or too few numbers, or any unrecognizable
words, then the input is rejected.

If there are any large numbers (of five digits or more) other than
the year, they are ignored on the assumption that they are something
like Julian dates that were included along with the traditional
date components when the date was formatted.

One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
may optionally be used; the latter two are equivalent to a
minus sign on the year value.

If you always enter a four-digit year, and use a name instead
of a number for the month, there is no danger of ambiguity.

@node Standard Date Formats, , Free-Form Dates, Date Formats
@subsubsection Standard Date Formats

@noindent
There are actually ten standard date formats, numbered 0 through 9.
Entering a blank line at the @kbd{d d} command's prompt gives
you format number 1, Calc's usual format.  You can enter any digit
to select the other formats.

To create your own standard date formats, give a numeric prefix
argument from 0 to 9 to the @w{@kbd{d d}} command.  The format you
enter will be recorded as the new standard format of that
number, as well as becoming the new current date format.
You can save your formats permanently with the @w{@kbd{m m}}
command (@pxref{Mode Settings}).

@table @asis
@item 0
@samp{N}  (Numerical format)
@item 1
@samp{<H:mm:SSpp >Www Mmm D, YYYY}  (American format)
@item 2
@samp{D Mmm YYYY<, h:mm:SS>}  (European format)
@item 3
@samp{Www Mmm BD< hh:mm:ss> YYYY}  (Unix written date format)
@item 4
@samp{M/D/Y< H:mm:SSpp>}  (American slashed format)
@item 5
@samp{D.M.Y< h:mm:SS>}  (European dotted format)
@item 6
@samp{M-D-Y< H:mm:SSpp>}  (American dashed format)
@item 7
@samp{D-M-Y< h:mm:SS>}  (European dashed format)
@item 8
@samp{j<, h:mm:ss>}  (Julian day plus time)
@item 9
@samp{YYddd< hh:mm:ss>}  (Year-day format)
@end table

@node Truncating the Stack, Justification, Date Formats, Display Modes
@subsection Truncating the Stack

@noindent
@kindex d t
@pindex calc-truncate-stack
@cindex Truncating the stack
@cindex Narrowing the stack
The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
line that marks the top-of-stack up or down in the Calculator buffer.
The number right above that line is considered to the be at the top of
the stack.  Any numbers below that line are ``hidden'' from all stack
operations.  This is similar to the Emacs ``narrowing'' feature, except
that the values below the @samp{.} are @emph{visible}, just temporarily
frozen.  This feature allows you to keep several independent calculations
running at once in different parts of the stack, or to apply a certain
command to an element buried deep in the stack.@refill

Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
is on.  Thus, this line and all those below it become hidden.  To un-hide
these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
With a positive numeric prefix argument @cite{n}, @kbd{d t} hides the
bottom @cite{n} values in the buffer.  With a negative argument, it hides
all but the top @cite{n} values.  With an argument of zero, it hides zero
values, i.e., moves the @samp{.} all the way down to the bottom.@refill

@kindex d [
@pindex calc-truncate-up
@kindex d ]
@pindex calc-truncate-down
The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
(@code{calc-truncate-down}) commands move the @samp{.} up or down one
line at a time (or several lines with a prefix argument).@refill

@node Justification, Labels, Truncating the Stack, Display Modes
@subsection Justification

@noindent
@kindex d <
@pindex calc-left-justify
@kindex d =
@pindex calc-center-justify
@kindex d >
@pindex calc-right-justify
Values on the stack are normally left-justified in the window.  You can
control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
@kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
(@code{calc-center-justify}).  For example, in right-justification mode,
stack entries are displayed flush-right against the right edge of the
window.@refill

If you change the width of the Calculator window you may have to type
@kbd{d SPC} (@code{calc-refresh}) to re-align right-justified or centered
text.

Right-justification is especially useful together with fixed-point
notation (see @code{d f}; @code{calc-fix-notation}).  With these modes
together, the decimal points on numbers will always line up.

With a numeric prefix argument, the justification commands give you
a little extra control over the display.  The argument specifies the
horizontal ``origin'' of a display line.  It is also possible to
specify a maximum line width using the @kbd{d b} command (@pxref{Normal
Language Modes}).  For reference, the precise rules for formatting and
breaking lines are given below.  Notice that the interaction between
origin and line width is slightly different in each justification
mode.

In left-justified mode, the line is indented by a number of spaces
given by the origin (default zero).  If the result is longer than the
maximum line width, if given, or too wide to fit in the Calc window
otherwise, then it is broken into lines which will fit; each broken
line is indented to the origin.

In right-justified mode, lines are shifted right so that the rightmost
character is just before the origin, or just before the current
window width if no origin was specified.  If the line is too long
for this, then it is broken; the current line width is used, if
specified, or else the origin is used as a width if that is
specified, or else the line is broken to fit in the window.

In centering mode, the origin is the column number of the center of
each stack entry.  If a line width is specified, lines will not be
allowed to go past that width; Calc will either indent less or
break the lines if necessary.  If no origin is specified, half the
line width or Calc window width is used.

Note that, in each case, if line numbering is enabled the display
is indented an additional four spaces to make room for the line
number.  The width of the line number is taken into account when
positioning according to the current Calc window width, but not
when positioning by explicit origins and widths.  In the latter
case, the display is formatted as specified, and then uniformly
shifted over four spaces to fit the line numbers.

@node Labels, , Justification, Display Modes
@subsection Labels

@noindent
@kindex d @{
@pindex calc-left-label
The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
then displays that string to the left of every stack entry.  If the
entries are left-justified (@pxref{Justification}), then they will
appear immediately after the label (unless you specified an origin
greater than the length of the label).  If the entries are centered
or right-justified, the label appears on the far left and does not
affect the horizontal position of the stack entry.

Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.

@kindex d @}
@pindex calc-right-label
The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
label on the righthand side.  It does not affect positioning of
the stack entries unless they are right-justified.  Also, if both
a line width and an origin are given in right-justified mode, the
stack entry is justified to the origin and the righthand label is
justified to the line width.

One application of labels would be to add equation numbers to
formulas you are manipulating in Calc and then copying into a
document (possibly using Embedded Mode).  The equations would
typically be centered, and the equation numbers would be on the
left or right as you prefer.

@node Language Modes, Modes Variable, Display Modes, Mode Settings
@section Language Modes

@noindent
The commands in this section change Calc to use a different notation for
entry and display of formulas, corresponding to the conventions of some
other common language such as Pascal or @TeX{}.  Objects displayed on the
stack or yanked from the Calculator to an editing buffer will be formatted
in the current language; objects entered in algebraic entry or yanked from
another buffer will be interpreted according to the current language.

The current language has no effect on things written to or read from the
trail buffer, nor does it affect numeric entry.  Only algebraic entry is
affected.  You can make even algebraic entry ignore the current language
and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.

For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
program; elsewhere in the program you need the derivatives of this formula
with respect to @samp{a[1]} and @samp{a[2]}.  First, type @kbd{d C}
to switch to C notation.  Now use @code{C-u M-# g} to grab the formula
into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
to the first variable, and @kbd{M-# y} to yank the formula for the derivative
back into your C program.  Press @kbd{U} to undo the differentiation and
repeat with @kbd{a d a[2] @key{RET}} for the other derivative.

Without being switched into C mode first, Calc would have misinterpreted
the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
@code{atan} was equivalent to Calc's built-in @code{arctan} function,
and would have written the formula back with notations (like implicit
multiplication) which would not have been legal for a C program.

As another example, suppose you are maintaining a C program and a @TeX{}
document, each of which needs a copy of the same formula.  You can grab the
formula from the program in C mode, switch to @TeX{} mode, and yank the
formula into the document in @TeX{} math-mode format.

Language modes are selected by typing the letter @kbd{d} followed by a
shifted letter key.

@menu
* Normal Language Modes::
* C FORTRAN Pascal::
* TeX Language Mode::
* Eqn Language Mode::
* Mathematica Language Mode::
* Maple Language Mode::
* Compositions::
* Syntax Tables::
@end menu

@node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
@subsection Normal Language Modes

@noindent
@kindex d N
@pindex calc-normal-language
The @kbd{d N} (@code{calc-normal-language}) command selects the usual
notation for Calc formulas, as described in the rest of this manual.
Matrices are displayed in a multi-line tabular format, but all other
objects are written in linear form, as they would be typed from the
keyboard.

@kindex d O
@pindex calc-flat-language
@cindex Matrix display
The @kbd{d O} (@code{calc-flat-language}) command selects a language
identical with the normal one, except that matrices are written in
one-line form along with everything else.  In some applications this
form may be more suitable for yanking data into other buffers.

@kindex d b
@pindex calc-line-breaking
@cindex Line breaking
@cindex Breaking up long lines
Even in one-line mode, long formulas or vectors will still be split
across multiple lines if they exceed the width of the Calculator window.
The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
feature on and off.  (It works independently of the current language.)
If you give a numeric prefix argument of five or greater to the @kbd{d b}
command, that argument will specify the line width used when breaking
long lines.

@kindex d B
@pindex calc-big-language
The @kbd{d B} (@code{calc-big-language}) command selects a language
which uses textual approximations to various mathematical notations,
such as powers, quotients, and square roots:

@example
  ____________
 | a + 1    2
 | ----- + c
\|   b
@end example

@noindent
in place of @samp{sqrt((a+1)/b + c^2)}.

Subscripts like @samp{a_i} are displayed as actual subscripts in ``big''
mode.  Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
are displayed as @samp{a} with subscripts separated by commas:
@samp{i, j}.  They must still be entered in the usual underscore
notation.

One slight ambiguity of Big notation is that

@example
  3
- -
  4
@end example

@noindent
can represent either the negative rational number @cite{-3:4}, or the
actual expression @samp{-(3/4)}; but the latter formula would normally
never be displayed because it would immediately be evaluated to
@cite{-3:4} or @cite{-0.75}, so this ambiguity is not a problem in
typical use.

Non-decimal numbers are displayed with subscripts.  Thus there is no
way to tell the difference between @samp{16#C2} and @samp{C2_16},
though generally you will know which interpretation is correct.
Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
in Big mode.

In Big mode, stack entries often take up several lines.  To aid
readability, stack entries are separated by a blank line in this mode.
You may find it useful to expand the Calc window's height using
@kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).

Long lines are currently not rearranged to fit the window width in
Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
to scroll across a wide formula.  For really big formulas, you may
even need to use @kbd{@{} and @kbd{@}} to scroll up and down.

@kindex d U
@pindex calc-unformatted-language
The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
the use of operator notation in formulas.  In this mode, the formula
shown above would be displayed:

@example
sqrt(add(div(add(a, 1), b), pow(c, 2)))
@end example

These four modes differ only in display format, not in the format
expected for algebraic entry.  The standard Calc operators work in
all four modes, and unformatted notation works in any language mode
(except that Mathematica mode expects square brackets instead of
parentheses).

@node C FORTRAN Pascal, TeX Language Mode, Normal Language Modes, Language Modes
@subsection C, FORTRAN, and Pascal Modes

@noindent
@kindex d C
@pindex calc-c-language
@cindex C language
The @kbd{d C} (@code{calc-c-language}) command selects the conventions
of the C language for display and entry of formulas.  This differs from
the normal language mode in a variety of (mostly minor) ways.  In
particular, C language operators and operator precedences are used in
place of Calc's usual ones.  For example, @samp{a^b} means @samp{xor(a,b)}
in C mode; a value raised to a power is written as a function call,
@samp{pow(a,b)}.

In C mode, vectors and matrices use curly braces instead of brackets.
Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
rather than using the @samp{#} symbol.  Array subscripting is
translated into @code{subscr} calls, so that @samp{a[i]} in C
mode is the same as @samp{a_i} in normal mode.  Assignments
turn into the @code{assign} function, which Calc normally displays
using the @samp{:=} symbol.

The variables @code{var-pi} and @code{var-e} would be displayed @samp{pi}
and @samp{e} in normal mode, but in C mode they are displayed as
@samp{M_PI} and @samp{M_E}, corresponding to the names of constants
typically provided in the @file{<math.h>} header.  Functions whose
names are different in C are translated automatically for entry and
display purposes.  For example, entering @samp{asin(x)} will push the
formula @samp{arcsin(x)} onto the stack; this formula will be displayed
as @samp{asin(x)} as long as C mode is in effect.

@kindex d P
@pindex calc-pascal-language
@cindex Pascal language
The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
conventions.  Like C mode, Pascal mode interprets array brackets and uses
a different table of operators.  Hexadecimal numbers are entered and
displayed with a preceding dollar sign.  (Thus the regular meaning of
@kbd{$2} during algebraic entry does not work in Pascal mode, though
@kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
always.)  No special provisions are made for other non-decimal numbers,
vectors, and so on, since there is no universally accepted standard way
of handling these in Pascal.

@kindex d F
@pindex calc-fortran-language
@cindex FORTRAN language
The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
conventions.  Various function names are transformed into FORTRAN
equivalents.  Vectors are written as @samp{/1, 2, 3/}, and may be
entered this way or using square brackets.  Since FORTRAN uses round
parentheses for both function calls and array subscripts, Calc displays
both in the same way; @samp{a(i)} is interpreted as a function call
upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
Also, if the variable @code{a} has been declared to have type
@code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
subscript.  (@xref{Declarations}.)  Usually it doesn't matter, though;
if you enter the subscript expression @samp{a(i)} and Calc interprets
it as a function call, you'll never know the difference unless you
switch to another language mode or replace @code{a} with an actual
vector (or unless @code{a} happens to be the name of a built-in
function!).

Underscores are allowed in variable and function names in all of these
language modes.  The underscore here is equivalent to the @samp{#} in
normal mode, or to hyphens in the underlying Emacs Lisp variable names.

FORTRAN and Pascal modes normally do not adjust the case of letters in
formulas.  Most built-in Calc names use lower-case letters.  If you use a
positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
modes will use upper-case letters exclusively for display, and will
convert to lower-case on input.  With a negative prefix, these modes
convert to lower-case for display and input.

@node TeX Language Mode, Eqn Language Mode, C FORTRAN Pascal, Language Modes
@subsection @TeX{} Language Mode

@noindent
@kindex d T
@pindex calc-tex-language
@cindex TeX language
The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
of ``math mode'' in the @TeX{} typesetting language, by Donald Knuth.
Formulas are entered
and displayed in @TeX{} notation, as in @samp{\sin\left( a \over b \right)}.
Math formulas are usually enclosed by @samp{$ $} signs in @TeX{}; these
should be omitted when interfacing with Calc.  To Calc, the @samp{$} sign
has the same meaning it always does in algebraic formulas (a reference to
an existing entry on the stack).@refill

Complex numbers are displayed as in @samp{3 + 4i}.  Fractions and
quotients are written using @code{\over};
binomial coefficients are written with @code{\choose}.
Interval forms are written with @code{\ldots}, and
error forms are written with @code{\pm}.
Absolute values are written as in @samp{|x + 1|}, and the floor and
ceiling functions are written with @code{\lfloor}, @code{\rfloor}, etc.
The words @code{\left} and @code{\right} are ignored when reading
formulas in @TeX{} mode.  Both @code{inf} and @code{uinf} are written
as @code{\infty}; when read, @code{\infty} always translates to
@code{inf}.@refill

Function calls are written the usual way, with the function name followed
by the arguments in parentheses.  However, functions for which @TeX{} has
special names (like @code{\sin}) will use curly braces instead of
parentheses for very simple arguments.  During input, curly braces and
parentheses work equally well for grouping, but when the document is
formatted the curly braces will be invisible.  Thus the printed result is
@c{$\sin{2 x}$}
@cite{sin 2x} but @c{$\sin(2 + x)$}
@cite{sin(2 + x)}.

Function and variable names not treated specially by @TeX{} are simply
written out as-is, which will cause them to come out in italic letters
in the printed document.  If you invoke @kbd{d T} with a positive numeric
prefix argument, names of more than one character will instead be written
@samp{\hbox@{@var{name}@}}.  The @samp{\hbox@{ @}} notation is ignored
during reading.  If you use a negative prefix argument, such function
names are written @samp{\@var{name}}, and function names that begin
with @code{\} during reading have the @code{\} removed.  (Note that
in this mode, long variable names are still written with @code{\hbox}.
However, you can always make an actual variable name like @code{\bar}
in any @TeX{} mode.)

During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
by @samp{[ ...@: ]}.  The same also applies to @code{\pmatrix} and
@code{\bmatrix}.  The symbol @samp{&} is interpreted as a comma,
and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
format; you may need to edit this afterwards to change @code{\matrix}
to @code{\pmatrix} or @code{\\} to @code{\cr}.

Accents like @code{\tilde} and @code{\bar} translate into function
calls internally (@samp{tilde(x)}, @samp{bar(x)}).  The @code{\underline}
sequence is treated as an accent.  The @code{\vec} accent corresponds
to the function name @code{Vec}, because @code{vec} is the name of
a built-in Calc function.  The following table shows the accents
in Calc, @TeX{}, and @dfn{eqn} (described in the next section):

@iftex
@begingroup
@let@calcindexershow=@calcindexernoshow  @c Suppress marginal notes
@let@calcindexersh=@calcindexernoshow
@end iftex
@c @starindex
@tindex acute
@c @starindex
@tindex bar
@c @starindex
@tindex breve
@c @starindex
@tindex check
@c @starindex
@tindex dot
@c @starindex
@tindex dotdot
@c @starindex
@tindex dyad
@c @starindex
@tindex grave
@c @starindex
@tindex hat
@c @starindex
@tindex Prime
@c @starindex
@tindex tilde
@c @starindex
@tindex under
@c @starindex
@tindex Vec
@iftex
@endgroup
@end iftex
@example
Calc      TeX           eqn
----      ---           ---
acute     \acute
bar       \bar          bar
breve     \breve        
check     \check
dot       \dot          dot
dotdot    \ddot         dotdot
dyad                    dyad
grave     \grave
hat       \hat          hat
Prime                   prime
tilde     \tilde        tilde
under     \underline    under
Vec       \vec          vec
@end example

The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
@samp{@{@var{a} \to @var{b}@}}.  @TeX{} defines @code{\to} as an
alias for @code{\rightarrow}.  However, if the @samp{=>} is the
top-level expression being formatted, a slightly different notation
is used:  @samp{\evalto @var{a} \to @var{b}}.  The @code{\evalto}
word is ignored by Calc's input routines, and is undefined in @TeX{}.
You will typically want to include one of the following definitions
at the top of a @TeX{} file that uses @code{\evalto}:

@example
\def\evalto@{@}
\def\evalto#1\to@{@}
@end example

The first definition formats evaluates-to operators in the usual
way.  The second causes only the @var{b} part to appear in the
printed document; the @var{a} part and the arrow are hidden.
Another definition you may wish to use is @samp{\let\to=\Rightarrow}
which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
@xref{Evaluates-To Operator}, for a discussion of @code{evalto}.

The complete set of @TeX{} control sequences that are ignored during
reading is:

@example
\hbox  \mbox  \text  \left  \right
\,  \>  \:  \;  \!  \quad  \qquad  \hfil  \hfill
\displaystyle  \textstyle  \dsize  \tsize
\scriptstyle  \scriptscriptstyle  \ssize  \ssize
\rm  \bf  \it  \sl  \roman  \bold  \italic  \slanted
\cal  \mit  \Cal  \Bbb  \frak  \goth
\evalto
@end example

Note that, because these symbols are ignored, reading a @TeX{} formula
into Calc and writing it back out may lose spacing and font information.

Also, the ``discretionary multiplication sign'' @samp{\*} is read
the same as @samp{*}.

@ifnottex
The @TeX{} version of this manual includes some printed examples at the
end of this section.
@end ifnottex
@iftex
Here are some examples of how various Calc formulas are formatted in @TeX{}:

@group
@example
sin(a^2 / b_i)
\sin\left( {a^2 \over b_i} \right)
@end example
@tex
\let\rm\goodrm
$$ \sin\left( a^2 \over b_i \right) $$
@end tex
@sp 1
@end group

@group
@example
[(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
[3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
@end example
@tex
\turnoffactive
$$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
@end tex
@sp 1
@end group

@group
@example
[abs(a), abs(a / b), floor(a), ceil(a / b)]
[|a|, \left| a \over b \right|,
 \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
@end example
@tex
$$ [|a|, \left| a \over b \right|,
    \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
@end tex
@sp 1
@end group

@group
@example
[sin(a), sin(2 a), sin(2 + a), sin(a / b)]
[\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
 \sin\left( @{a \over b@} \right)]
@end example
@tex
\turnoffactive\let\rm\goodrm
$$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
@end tex
@sp 2
@end group

@group
First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
@kbd{C-u - d T} (using the example definition
@samp{\def\foo#1@{\tilde F(#1)@}}:

@example

[f(a), foo(bar), sin(pi)]
[f(a), foo(bar), \sin{\pi}]
[f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
[f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
@end example
@tex
\let\rm\goodrm
$$ [f(a), foo(bar), \sin{\pi}] $$
$$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
$$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
@end tex
@sp 2
@end group

@group
First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:

@example

2 + 3 => 5
\evalto 2 + 3 \to 5
@end example
@tex
\turnoffactive
$$ 2 + 3 \to 5 $$
$$ 5 $$
@end tex
@sp 2
@end group

@group
First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:

@example

[2 + 3 => 5, a / 2 => (b + c) / 2]
[@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
@end example
@tex
\turnoffactive
$$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
{\let\to\Rightarrow
$$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
@end tex
@sp 2
@end group

@group
Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:

@example

[ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
\matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
\pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
@end example
@tex
\turnoffactive
$$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
$$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
@end tex
@sp 2
@end group
@end iftex

@node Eqn Language Mode, Mathematica Language Mode, TeX Language Mode, Language Modes
@subsection Eqn Language Mode

@noindent
@kindex d E
@pindex calc-eqn-language
@dfn{Eqn} is another popular formatter for math formulas.  It is
designed for use with the TROFF text formatter, and comes standard
with many versions of Unix.  The @kbd{d E} (@code{calc-eqn-language})
command selects @dfn{eqn} notation.

The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
a significant part in the parsing of the language.  For example,
@samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
@code{sqrt} operator.  @dfn{Eqn} also understands more conventional
grouping using curly braces:  @samp{sqrt@{x+1@} + y}.  Braces are
required only when the argument contains spaces.

In Calc's @dfn{eqn} mode, however, curly braces are required to
delimit arguments of operators like @code{sqrt}.  The first of the
above examples would treat only the @samp{x} as the argument of
@code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
@samp{sin * x + 1}, because @code{sin} is not a special operator
in the @dfn{eqn} language.  If you always surround the argument
with curly braces, Calc will never misunderstand.

Calc also understands parentheses as grouping characters.  Another
peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
words with spaces from any surrounding characters that aren't curly
braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
(The spaces around @code{sin} are important to make @dfn{eqn}
recognize that @code{sin} should be typeset in a roman font, and
the spaces around @code{x} and @code{y} are a good idea just in
case the @dfn{eqn} document has defined special meanings for these
names, too.)

Powers and subscripts are written with the @code{sub} and @code{sup}
operators, respectively.  Note that the caret symbol @samp{^} is
treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
symbol (these are used to introduce spaces of various widths into
the typeset output of @dfn{eqn}).

As in @TeX{} mode, Calc's formatter omits parentheses around the
arguments of functions like @code{ln} and @code{sin} if they are
``simple-looking''; in this case Calc surrounds the argument with
braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.

Font change codes (like @samp{roman @var{x}}) and positioning codes
(like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
@dfn{eqn} reader.  Also ignored are the words @code{left}, @code{right},
@code{mark}, and @code{lineup}.  Quotation marks in @dfn{eqn} mode input
are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
@samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
of quotes in @dfn{eqn}, but it is good enough for most uses.

Accent codes (@samp{@var{x} dot}) are handled by treating them as
function calls (@samp{dot(@var{x})}) internally.  @xref{TeX Language
Mode}, for a table of these accent functions.  The @code{prime} accent
is treated specially if it occurs on a variable or function name:
@samp{f prime prime @w{( x prime )}} is stored internally as
@samp{f'@w{'}(x')}.  For example, taking the derivative of @samp{f(2 x)}
with @kbd{a d x} will produce @samp{2 f'(2 x)}, which @dfn{eqn} mode
will display as @samp{2 f prime ( 2 x )}.

Assignments are written with the @samp{<-} (left-arrow) symbol,
and @code{evalto} operators are written with @samp{->} or
@samp{evalto ... ->} (@pxref{TeX Language Mode}, for a discussion
of this).  The regular Calc symbols @samp{:=} and @samp{=>} are also
recognized for these operators during reading.

Vectors in @dfn{eqn} mode use regular Calc square brackets, but
matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
The words @code{lcol} and @code{rcol} are recognized as synonyms
for @code{ccol} during input, and are generated instead of @code{ccol}
if the matrix justification mode so specifies.

@node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
@subsection Mathematica Language Mode

@noindent
@kindex d M
@pindex calc-mathematica-language
@cindex Mathematica language
The @kbd{d M} (@code{calc-mathematica-language}) command selects the
conventions of Mathematica, a powerful and popular mathematical tool
from Wolfram Research, Inc.  Notable differences in Mathematica mode
are that the names of built-in functions are capitalized, and function
calls use square brackets instead of parentheses.  Thus the Calc
formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
Mathematica mode.

Vectors and matrices use curly braces in Mathematica.  Complex numbers
are written @samp{3 + 4 I}.  The standard special constants in Calc are
written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
@code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
Mathematica mode.
Non-decimal numbers are written, e.g., @samp{16^^7fff}.  Floating-point
numbers in scientific notation are written @samp{1.23*10.^3}.
Subscripts use double square brackets: @samp{a[[i]]}.@refill

@node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
@subsection Maple Language Mode

@noindent
@kindex d W
@pindex calc-maple-language
@cindex Maple language
The @kbd{d W} (@code{calc-maple-language}) command selects the
conventions of Maple, another mathematical tool from the University
of Waterloo.  

Maple's language is much like C.  Underscores are allowed in symbol
names; square brackets are used for subscripts; explicit @samp{*}s for
multiplications are required.  Use either @samp{^} or @samp{**} to
denote powers.

Maple uses square brackets for lists and curly braces for sets.  Calc
interprets both notations as vectors, and displays vectors with square
brackets.  This means Maple sets will be converted to lists when they
pass through Calc.  As a special case, matrices are written as calls
to the function @code{matrix}, given a list of lists as the argument,
and can be read in this form or with all-capitals @code{MATRIX}.

The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
writes any kind of interval as @samp{2 .. 3}.  This means you cannot
see the difference between an open and a closed interval while in
Maple display mode.

Maple writes complex numbers as @samp{3 + 4*I}.  Its special constants
are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
@code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
Floating-point numbers are written @samp{1.23*10.^3}.

Among things not currently handled by Calc's Maple mode are the
various quote symbols, procedures and functional operators, and
inert (@samp{&}) operators.

@node Compositions, Syntax Tables, Maple Language Mode, Language Modes
@subsection Compositions

@noindent
@cindex Compositions
There are several @dfn{composition functions} which allow you to get
displays in a variety of formats similar to those in Big language
mode.  Most of these functions do not evaluate to anything; they are
placeholders which are left in symbolic form by Calc's evaluator but
are recognized by Calc's display formatting routines.

Two of these, @code{string} and @code{bstring}, are described elsewhere.
@xref{Strings}.  For example, @samp{string("ABC")} is displayed as
@samp{ABC}.  When viewed on the stack it will be indistinguishable from
the variable @code{ABC}, but internally it will be stored as
@samp{string([65, 66, 67])} and can still be manipulated this way; for
example, the selection and vector commands @kbd{j 1 v v j u} would
select the vector portion of this object and reverse the elements, then
deselect to reveal a string whose characters had been reversed.

The composition functions do the same thing in all language modes
(although their components will of course be formatted in the current
language mode).  The one exception is Unformatted mode (@kbd{d U}),
which does not give the composition functions any special treatment.
The functions are discussed here because of their relationship to
the language modes.

@menu
* Composition Basics::
* Horizontal Compositions::
* Vertical Compositions::
* Other Compositions::
* Information about Compositions::
* User-Defined Compositions::
@end menu

@node Composition Basics, Horizontal Compositions, Compositions, Compositions
@subsubsection Composition Basics

@noindent
Compositions are generally formed by stacking formulas together
horizontally or vertically in various ways.  Those formulas are
themselves compositions.  @TeX{} users will find this analogous
to @TeX{}'s ``boxes.''  Each multi-line composition has a
@dfn{baseline}; horizontal compositions use the baselines to
decide how formulas should be positioned relative to one another.
For example, in the Big mode formula

@group
@example
          2
     a + b
17 + ------
       c
@end example
@end group

@noindent
the second term of the sum is four lines tall and has line three as
its baseline.  Thus when the term is combined with 17, line three
is placed on the same level as the baseline of 17.

@tex
\bigskip
@end tex

Another important composition concept is @dfn{precedence}.  This is
an integer that represents the binding strength of various operators.
For example, @samp{*} has higher precedence (195) than @samp{+} (180),
which means that @samp{(a * b) + c} will be formatted without the
parentheses, but @samp{a * (b + c)} will keep the parentheses.

The operator table used by normal and Big language modes has the
following precedences:

@example
_     1200   @r{(subscripts)}
%     1100   @r{(as in n}%@r{)}
-     1000   @r{(as in }-@r{n)}
!     1000   @r{(as in }!@r{n)}
mod    400
+/-    300
!!     210    @r{(as in n}!!@r{)}
!      210    @r{(as in n}!@r{)}
^      200
*      195    @r{(or implicit multiplication)}
/ % \  190
+ -    180    @r{(as in a}+@r{b)}
|      170
< =    160    @r{(and other relations)}
&&     110
||     100
? :     90
!!!     85
&&&     80
|||     75
:=      50
::      45
=>      40
@end example

The general rule is that if an operator with precedence @cite{n}
occurs as an argument to an operator with precedence @cite{m}, then
the argument is enclosed in parentheses if @cite{n < m}.  Top-level
expressions and expressions which are function arguments, vector
components, etc., are formatted with precedence zero (so that they
normally never get additional parentheses).

For binary left-associative operators like @samp{+}, the righthand
argument is actually formatted with one-higher precedence than shown
in the table.  This makes sure @samp{(a + b) + c} omits the parentheses,
but the unnatural form @samp{a + (b + c)} keeps its parentheses.
Right-associative operators like @samp{^} format the lefthand argument
with one-higher precedence.

@c @starindex
@tindex cprec
The @code{cprec} function formats an expression with an arbitrary
precedence.  For example, @samp{cprec(abc, 185)} will combine into
sums and products as follows:  @samp{7 + abc}, @samp{7 (abc)} (because
this @code{cprec} form has higher precedence than addition, but lower
precedence than multiplication).

@tex
\bigskip
@end tex

A final composition issue is @dfn{line breaking}.  Calc uses two
different strategies for ``flat'' and ``non-flat'' compositions.
A non-flat composition is anything that appears on multiple lines
(not counting line breaking).  Examples would be matrices and Big
mode powers and quotients.  Non-flat compositions are displayed
exactly as specified.  If they come out wider than the current
window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
view them.

Flat compositions, on the other hand, will be broken across several
lines if they are too wide to fit the window.  Certain points in a
composition are noted internally as @dfn{break points}.  Calc's
general strategy is to fill each line as much as possible, then to
move down to the next line starting at the first break point that
didn't fit.  However, the line breaker understands the hierarchical
structure of formulas.  It will not break an ``inner'' formula if
it can use an earlier break point from an ``outer'' formula instead.
For example, a vector of sums might be formatted as:

@group
@example
[ a + b + c, d + e + f,
  g + h + i, j + k + l, m ]
@end example
@end group

@noindent
If the @samp{m} can fit, then so, it seems, could the @samp{g}.
But Calc prefers to break at the comma since the comma is part
of a ``more outer'' formula.  Calc would break at a plus sign
only if it had to, say, if the very first sum in the vector had
itself been too large to fit.

Of the composition functions described below, only @code{choriz}
generates break points.  The @code{bstring} function (@pxref{Strings})
also generates breakable items:  A break point is added after every
space (or group of spaces) except for spaces at the very beginning or
end of the string.

Composition functions themselves count as levels in the formula
hierarchy, so a @code{choriz} that is a component of a larger
@code{choriz} will be less likely to be broken.  As a special case,
if a @code{bstring} occurs as a component of a @code{choriz} or
@code{choriz}-like object (such as a vector or a list of arguments
in a function call), then the break points in that @code{bstring}
will be on the same level as the break points of the surrounding
object.

@node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
@subsubsection Horizontal Compositions

@noindent
@c @starindex
@tindex choriz
The @code{choriz} function takes a vector of objects and composes
them horizontally.  For example, @samp{choriz([17, a b/c, d])} formats
as @w{@samp{17a b / cd}} in normal language mode, or as

@group
@example
  a b
17---d
   c
@end example
@end group

@noindent
in Big language mode.  This is actually one case of the general
function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
either or both of @var{sep} and @var{prec} may be omitted.
@var{Prec} gives the @dfn{precedence} to use when formatting
each of the components of @var{vec}.  The default precedence is
the precedence from the surrounding environment.

@var{Sep} is a string (i.e., a vector of character codes as might
be entered with @code{" "} notation) which should separate components
of the composition.  Also, if @var{sep} is given, the line breaker
will allow lines to be broken after each occurrence of @var{sep}.
If @var{sep} is omitted, the composition will not be breakable
(unless any of its component compositions are breakable).

For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
formatted as @samp{2 a + b c + (d = e)}.  To get the @code{choriz}
to have precedence 180 ``outwards'' as well as ``inwards,''
enclose it in a @code{cprec} form:  @samp{2 cprec(choriz(...), 180)}
formats as @samp{2 (a + b c + (d = e))}.

The baseline of a horizontal composition is the same as the
baselines of the component compositions, which are all aligned.

@node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
@subsubsection Vertical Compositions

@noindent
@c @starindex
@tindex cvert
The @code{cvert} function makes a vertical composition.  Each
component of the vector is centered in a column.  The baseline of
the result is by default the top line of the resulting composition.
For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
formats in Big mode as

@group
@example
f( a ,  2    )
  bb   a  + 1
  ccc     2
         b
@end example
@end group

@c @starindex
@tindex cbase
There are several special composition functions that work only as
components of a vertical composition.  The @code{cbase} function
controls the baseline of the vertical composition; the baseline
will be the same as the baseline of whatever component is enclosed
in @code{cbase}.  Thus @samp{f(cvert([a, cbase(bb), ccc]),
cvert([a^2 + 1, cbase(b^2)]))} displays as

@group
@example
        2
       a  + 1
   a      2
f(bb ,   b   )
  ccc
@end example
@end group

@c @starindex
@tindex ctbase
@c @starindex
@tindex cbbase
There are also @code{ctbase} and @code{cbbase} functions which
make the baseline of the vertical composition equal to the top
or bottom line (rather than the baseline) of that component.
Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
cvert([cbbase(a / b)])} gives

@group
@example
        a
a       -
- + a + b
b   -
    b
@end example
@end group

There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
function in a given vertical composition.  These functions can also
be written with no arguments:  @samp{ctbase()} is a zero-height object
which means the baseline is the top line of the following item, and
@samp{cbbase()} means the baseline is the bottom line of the preceding
item.

@c @starindex
@tindex crule
The @code{crule} function builds a ``rule,'' or horizontal line,
across a vertical composition.  By itself @samp{crule()} uses @samp{-}
characters to build the rule.  You can specify any other character,
e.g., @samp{crule("=")}.  The argument must be a character code or
vector of exactly one character code.  It is repeated to match the
width of the widest item in the stack.  For example, a quotient
with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:

@group
@example
a + 1
=====
  2
 b
@end example
@end group

@c @starindex
@tindex clvert
@c @starindex
@tindex crvert
Finally, the functions @code{clvert} and @code{crvert} act exactly
like @code{cvert} except that the items are left- or right-justified
in the stack.  Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
gives:

@group
@example
a   +   a
bb     bb
ccc   ccc
@end example
@end group

Like @code{choriz}, the vertical compositions accept a second argument
which gives the precedence to use when formatting the components.
Vertical compositions do not support separator strings.

@node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
@subsubsection Other Compositions

@noindent
@c @starindex
@tindex csup
The @code{csup} function builds a superscripted expression.  For
example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
language mode.  This is essentially a horizontal composition of
@samp{a} and @samp{b}, where @samp{b} is shifted up so that its
bottom line is one above the baseline.

@c @starindex
@tindex csub
Likewise, the @code{csub} function builds a subscripted expression.
This shifts @samp{b} down so that its top line is one below the
bottom line of @samp{a} (note that this is not quite analogous to
@code{csup}).  Other arrangements can be obtained by using
@code{choriz} and @code{cvert} directly.

@c @starindex
@tindex cflat
The @code{cflat} function formats its argument in ``flat'' mode,
as obtained by @samp{d O}, if the current language mode is normal
or Big.  It has no effect in other language modes.  For example,
@samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
to improve its readability.

@c @starindex
@tindex cspace
The @code{cspace} function creates horizontal space.  For example,
@samp{cspace(4)} is effectively the same as @samp{string("    ")}.
A second string (i.e., vector of characters) argument is repeated
instead of the space character.  For example, @samp{cspace(4, "ab")}
looks like @samp{abababab}.  If the second argument is not a string,
it is formatted in the normal way and then several copies of that
are composed together:  @samp{cspace(4, a^2)} yields

@group
@example
 2 2 2 2
a a a a
@end example
@end group