*** empty log message ***
[emacs.git] / man / calc.texi
blob5d43afefd23f40d160fc2aa43425ea31d156bd3b
1 \input texinfo                  @c -*-texinfo-*-
2 @comment %**start of header (This is for running Texinfo on a region.)
3 @c smallbook
4 @setfilename ../info/calc
5 @c [title]
6 @settitle GNU Emacs Calc 2.02g Manual
7 @setchapternewpage odd
8 @comment %**end of header (This is for running Texinfo on a region.)
10 @tex
11 % Some special kludges to make TeX formatting prettier.
12 % Because makeinfo.c exists, we can't just define new commands.
13 % So instead, we take over little-used existing commands.
15 % Suggested by Karl Berry <karl@@freefriends.org>
16 \gdef\!{\mskip-\thinmuskip}
17 % Redefine @cite{text} to act like $text$ in regular TeX.
18 % Info will typeset this same as @samp{text}.
19 \gdef\goodtex{\tex \let\rm\goodrm \let\t\ttfont \turnoffactive}
20 \gdef\goodrm{\fam0\tenrm}
21 \gdef\cite{\goodtex$\citexxx}
22 \gdef\citexxx#1{#1$\Etex}
23 \global\let\oldxrefX=\xrefX
24 \gdef\xrefX[#1]{\begingroup\let\cite=\dfn\oldxrefX[#1]\endgroup}
26 % Redefine @c{tex-stuff} \n @whatever{info-stuff}.
27 \gdef\c{\futurelet\next\mycxxx}
28 \gdef\mycxxx{%
29   \ifx\next\bgroup \goodtex\let\next\mycxxy
30   \else\ifx\next\mindex \let\next\relax
31   \else\ifx\next\kindex \let\next\relax
32   \else\ifx\next\starindex \let\next\relax \else \let\next\comment
33   \fi\fi\fi\fi \next
35 \gdef\mycxxy#1#2{#1\Etex\mycxxz}
36 \gdef\mycxxz#1{}
37 @end tex
39 @c Fix some other things specifically for this manual.
40 @iftex
41 @finalout
42 @mathcode`@:=`@:  @c Make Calc fractions come out right in math mode
43 @tex
44 \gdef\coloneq{\mathrel{\mathord:\mathord=}}
46 \gdef\beforedisplay{\vskip-10pt}
47 \gdef\afterdisplay{\vskip-5pt}
48 \gdef\beforedisplayh{\vskip-25pt}
49 \gdef\afterdisplayh{\vskip-10pt}
50 @end tex
51 @newdimen@kyvpos @kyvpos=0pt
52 @newdimen@kyhpos @kyhpos=0pt
53 @newcount@calcclubpenalty @calcclubpenalty=1000
54 @ignore
55 @newcount@calcpageno
56 @newtoks@calcoldeverypar @calcoldeverypar=@everypar
57 @everypar={@calceverypar@the@calcoldeverypar}
58 @ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi
59 @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
60 @catcode`@\=0 \catcode`\@=11
61 \r@ggedbottomtrue
62 \catcode`\@=0 @catcode`@\=@active
63 @end ignore
64 @end iftex
66 @copying
67 This file documents Calc, the GNU Emacs calculator.
69 Copyright (C) 1990, 1991, 2001, 2002 Free Software Foundation, Inc.
71 @quotation
72 Permission is granted to copy, distribute and/or modify this document
73 under the terms of the GNU Free Documentation License, Version 1.1 or
74 any later version published by the Free Software Foundation; with the
75 Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the
76 Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover
77 Texts as in (a) below.
79 (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
80 this GNU Manual, like GNU software.  Copies published by the Free
81 Software Foundation raise funds for GNU development.''
82 @end quotation
83 @end copying
85 @dircategory Emacs
86 @direntry
87 * Calc: (calc).         Advanced desk calculator and mathematical tool.
88 @end direntry
90 @titlepage
91 @sp 6
92 @center @titlefont{Calc Manual}
93 @sp 4
94 @center GNU Emacs Calc Version 2.02g
95 @c [volume]
96 @sp 1
97 @center January 2002
98 @sp 5
99 @center Dave Gillespie
100 @center daveg@@synaptics.com
101 @page
103 @vskip 0pt plus 1filll
104 Copyright @copyright{} 1990, 1991, 2001, 2002 Free Software Foundation, Inc.
105 @insertcopying
106 @end titlepage
108 @c [begin]
109 @ifinfo
110 @node Top, , (dir), (dir)
111 @chapter The GNU Emacs Calculator
113 @noindent
114 @dfn{Calc} is an advanced desk calculator and mathematical tool
115 that runs as part of the GNU Emacs environment.
117 This manual is divided into three major parts: ``Getting Started,''
118 the ``Calc Tutorial,'' and the ``Calc Reference.''  The Tutorial
119 introduces all the major aspects of Calculator use in an easy,
120 hands-on way.  The remainder of the manual is a complete reference to
121 the features of the Calculator.
123 For help in the Emacs Info system (which you are using to read this
124 file), type @kbd{?}.  (You can also type @kbd{h} to run through a
125 longer Info tutorial.)
127 @end ifinfo
128 @menu
129 * Copying::               How you can copy and share Calc.
131 * Getting Started::       General description and overview.
132 * Interactive Tutorial::
133 * Tutorial::              A step-by-step introduction for beginners.
135 * Introduction::          Introduction to the Calc reference manual.
136 * Data Types::            Types of objects manipulated by Calc.
137 * Stack and Trail::       Manipulating the stack and trail buffers.
138 * Mode Settings::         Adjusting display format and other modes.
139 * Arithmetic::            Basic arithmetic functions.
140 * Scientific Functions::  Transcendentals and other scientific functions.
141 * Matrix Functions::      Operations on vectors and matrices.
142 * Algebra::               Manipulating expressions algebraically.
143 * Units::                 Operations on numbers with units.
144 * Store and Recall::      Storing and recalling variables.
145 * Graphics::              Commands for making graphs of data.
146 * Kill and Yank::         Moving data into and out of Calc.
147 * Embedded Mode::         Working with formulas embedded in a file.
148 * Programming::           Calc as a programmable calculator.
150 * Installation::          Installing Calc as a part of GNU Emacs.
151 * Reporting Bugs::        How to report bugs and make suggestions.
153 * Summary::               Summary of Calc commands and functions.
155 * Key Index::             The standard Calc key sequences.
156 * Command Index::         The interactive Calc commands.
157 * Function Index::        Functions (in algebraic formulas).
158 * Concept Index::         General concepts.
159 * Variable Index::        Variables used by Calc (both user and internal).
160 * Lisp Function Index::   Internal Lisp math functions.
161 @end menu
163 @node Copying, Getting Started, Top, Top
164 @unnumbered GNU GENERAL PUBLIC LICENSE
165 @center Version 1, February 1989
167 @display
168 Copyright @copyright{} 1989 Free Software Foundation, Inc.
169 675 Mass Ave, Cambridge, MA 02139, USA
171 Everyone is permitted to copy and distribute verbatim copies
172 of this license document, but changing it is not allowed.
173 @end display
175 @unnumberedsec Preamble
177   The license agreements of most software companies try to keep users
178 at the mercy of those companies.  By contrast, our General Public
179 License is intended to guarantee your freedom to share and change free
180 software---to make sure the software is free for all its users.  The
181 General Public License applies to the Free Software Foundation's
182 software and to any other program whose authors commit to using it.
183 You can use it for your programs, too.
185   When we speak of free software, we are referring to freedom, not
186 price.  Specifically, the General Public License is designed to make
187 sure that you have the freedom to give away or sell copies of free
188 software, that you receive source code or can get it if you want it,
189 that you can change the software or use pieces of it in new free
190 programs; and that you know you can do these things.
192   To protect your rights, we need to make restrictions that forbid
193 anyone to deny you these rights or to ask you to surrender the rights.
194 These restrictions translate to certain responsibilities for you if you
195 distribute copies of the software, or if you modify it.
197   For example, if you distribute copies of a such a program, whether
198 gratis or for a fee, you must give the recipients all the rights that
199 you have.  You must make sure that they, too, receive or can get the
200 source code.  And you must tell them their rights.
202   We protect your rights with two steps: (1) copyright the software, and
203 (2) offer you this license which gives you legal permission to copy,
204 distribute and/or modify the software.
206   Also, for each author's protection and ours, we want to make certain
207 that everyone understands that there is no warranty for this free
208 software.  If the software is modified by someone else and passed on, we
209 want its recipients to know that what they have is not the original, so
210 that any problems introduced by others will not reflect on the original
211 authors' reputations.
213   The precise terms and conditions for copying, distribution and
214 modification follow.
216 @iftex
217 @unnumberedsec TERMS AND CONDITIONS
218 @end iftex
219 @ifinfo
220 @center TERMS AND CONDITIONS
221 @end ifinfo
223 @enumerate
224 @item
225 This License Agreement applies to any program or other work which
226 contains a notice placed by the copyright holder saying it may be
227 distributed under the terms of this General Public License.  The
228 ``Program'', below, refers to any such program or work, and a ``work based
229 on the Program'' means either the Program or any work containing the
230 Program or a portion of it, either verbatim or with modifications.  Each
231 licensee is addressed as ``you''.
233 @item
234 You may copy and distribute verbatim copies of the Program's source
235 code as you receive it, in any medium, provided that you conspicuously and
236 appropriately publish on each copy an appropriate copyright notice and
237 disclaimer of warranty; keep intact all the notices that refer to this
238 General Public License and to the absence of any warranty; and give any
239 other recipients of the Program a copy of this General Public License
240 along with the Program.  You may charge a fee for the physical act of
241 transferring a copy.
243 @item
244 You may modify your copy or copies of the Program or any portion of
245 it, and copy and distribute such modifications under the terms of Paragraph
246 1 above, provided that you also do the following:
248 @itemize @bullet
249 @item
250 cause the modified files to carry prominent notices stating that
251 you changed the files and the date of any change; and
253 @item
254 cause the whole of any work that you distribute or publish, that
255 in whole or in part contains the Program or any part thereof, either
256 with or without modifications, to be licensed at no charge to all
257 third parties under the terms of this General Public License (except
258 that you may choose to grant warranty protection to some or all
259 third parties, at your option).
261 @item
262 If the modified program normally reads commands interactively when
263 run, you must cause it, when started running for such interactive use
264 in the simplest and most usual way, to print or display an
265 announcement including an appropriate copyright notice and a notice
266 that there is no warranty (or else, saying that you provide a
267 warranty) and that users may redistribute the program under these
268 conditions, and telling the user how to view a copy of this General
269 Public License.
271 @item
272 You may charge a fee for the physical act of transferring a
273 copy, and you may at your option offer warranty protection in
274 exchange for a fee.
275 @end itemize
277 Mere aggregation of another independent work with the Program (or its
278 derivative) on a volume of a storage or distribution medium does not bring
279 the other work under the scope of these terms.
281 @item
282 You may copy and distribute the Program (or a portion or derivative of
283 it, under Paragraph 2) in object code or executable form under the terms of
284 Paragraphs 1 and 2 above provided that you also do one of the following:
286 @itemize @bullet
287 @item
288 accompany it with the complete corresponding machine-readable
289 source code, which must be distributed under the terms of
290 Paragraphs 1 and 2 above; or,
292 @item
293 accompany it with a written offer, valid for at least three
294 years, to give any third party free (except for a nominal charge
295 for the cost of distribution) a complete machine-readable copy of the
296 corresponding source code, to be distributed under the terms of
297 Paragraphs 1 and 2 above; or,
299 @item
300 accompany it with the information you received as to where the
301 corresponding source code may be obtained.  (This alternative is
302 allowed only for noncommercial distribution and only if you
303 received the program in object code or executable form alone.)
304 @end itemize
306 Source code for a work means the preferred form of the work for making
307 modifications to it.  For an executable file, complete source code means
308 all the source code for all modules it contains; but, as a special
309 exception, it need not include source code for modules which are standard
310 libraries that accompany the operating system on which the executable
311 file runs, or for standard header files or definitions files that
312 accompany that operating system.
314 @item
315 You may not copy, modify, sublicense, distribute or transfer the
316 Program except as expressly provided under this General Public License.
317 Any attempt otherwise to copy, modify, sublicense, distribute or transfer
318 the Program is void, and will automatically terminate your rights to use
319 the Program under this License.  However, parties who have received
320 copies, or rights to use copies, from you under this General Public
321 License will not have their licenses terminated so long as such parties
322 remain in full compliance.
324 @item
325 By copying, distributing or modifying the Program (or any work based
326 on the Program) you indicate your acceptance of this license to do so,
327 and all its terms and conditions.
329 @item
330 Each time you redistribute the Program (or any work based on the
331 Program), the recipient automatically receives a license from the original
332 licensor to copy, distribute or modify the Program subject to these
333 terms and conditions.  You may not impose any further restrictions on the
334 recipients' exercise of the rights granted herein.
336 @item
337 The Free Software Foundation may publish revised and/or new versions
338 of the General Public License from time to time.  Such new versions will
339 be similar in spirit to the present version, but may differ in detail to
340 address new problems or concerns.
342 Each version is given a distinguishing version number.  If the Program
343 specifies a version number of the license which applies to it and ``any
344 later version'', you have the option of following the terms and conditions
345 either of that version or of any later version published by the Free
346 Software Foundation.  If the Program does not specify a version number of
347 the license, you may choose any version ever published by the Free Software
348 Foundation.
350 @item
351 If you wish to incorporate parts of the Program into other free
352 programs whose distribution conditions are different, write to the author
353 to ask for permission.  For software which is copyrighted by the Free
354 Software Foundation, write to the Free Software Foundation; we sometimes
355 make exceptions for this.  Our decision will be guided by the two goals
356 of preserving the free status of all derivatives of our free software and
357 of promoting the sharing and reuse of software generally.
359 @iftex
360 @heading NO WARRANTY
361 @end iftex
362 @ifinfo
363 @center NO WARRANTY
364 @end ifinfo
366 @item
367 BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
368 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
369 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
370 PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
371 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
372 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
373 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
374 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
375 REPAIR OR CORRECTION.
377 @item
378 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
379 ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
380 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
381 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
382 ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
383 LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
384 SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
385 WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
386 ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
387 @end enumerate
389 @node Getting Started, Tutorial, Copying, Top
390 @chapter Getting Started
391 @noindent
392 This chapter provides a general overview of Calc, the GNU Emacs
393 Calculator:  What it is, how to start it and how to exit from it,
394 and what are the various ways that it can be used.
396 @menu
397 * What is Calc::
398 * About This Manual::
399 * Notations Used in This Manual::
400 * Using Calc::
401 * Demonstration of Calc::
402 * History and Acknowledgements::
403 @end menu
405 @node What is Calc, About This Manual, Getting Started, Getting Started
406 @section What is Calc?
408 @noindent
409 @dfn{Calc} is an advanced calculator and mathematical tool that runs as
410 part of the GNU Emacs environment.  Very roughly based on the HP-28/48
411 series of calculators, its many features include:
413 @itemize @bullet
414 @item
415 Choice of algebraic or RPN (stack-based) entry of calculations.
417 @item
418 Arbitrary precision integers and floating-point numbers.
420 @item
421 Arithmetic on rational numbers, complex numbers (rectangular and polar),
422 error forms with standard deviations, open and closed intervals, vectors
423 and matrices, dates and times, infinities, sets, quantities with units,
424 and algebraic formulas.
426 @item
427 Mathematical operations such as logarithms and trigonometric functions.
429 @item
430 Programmer's features (bitwise operations, non-decimal numbers).
432 @item
433 Financial functions such as future value and internal rate of return.
435 @item
436 Number theoretical features such as prime factorization and arithmetic
437 modulo @var{m} for any @var{m}.
439 @item
440 Algebraic manipulation features, including symbolic calculus.
442 @item
443 Moving data to and from regular editing buffers.
445 @item
446 ``Embedded mode'' for manipulating Calc formulas and data directly
447 inside any editing buffer.
449 @item
450 Graphics using GNUPLOT, a versatile (and free) plotting program.
452 @item
453 Easy programming using keyboard macros, algebraic formulas,
454 algebraic rewrite rules, or extended Emacs Lisp.
455 @end itemize
457 Calc tries to include a little something for everyone; as a result it is
458 large and might be intimidating to the first-time user.  If you plan to
459 use Calc only as a traditional desk calculator, all you really need to
460 read is the ``Getting Started'' chapter of this manual and possibly the
461 first few sections of the tutorial.  As you become more comfortable with
462 the program you can learn its additional features.  In terms of efficiency,
463 scope and depth, Calc cannot replace a powerful tool like Mathematica.
464 But Calc has the advantages of convenience, portability, and availability
465 of the source code.  And, of course, it's free!
467 @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
468 @section About This Manual
470 @noindent
471 This document serves as a complete description of the GNU Emacs
472 Calculator.  It works both as an introduction for novices, and as
473 a reference for experienced users.  While it helps to have some
474 experience with GNU Emacs in order to get the most out of Calc,
475 this manual ought to be readable even if you don't know or use Emacs
476 regularly.
478 @ifinfo
479 The manual is divided into three major parts:@: the ``Getting
480 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
481 and the Calc reference manual (the remaining chapters and appendices).
482 @end ifinfo
483 @iftex
484 The manual is divided into three major parts:@: the ``Getting
485 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
486 and the Calc reference manual (the remaining chapters and appendices).
487 @c [when-split]
488 @c This manual has been printed in two volumes, the @dfn{Tutorial} and the
489 @c @dfn{Reference}.  Both volumes include a copy of the ``Getting Started''
490 @c chapter.
491 @end iftex
493 If you are in a hurry to use Calc, there is a brief ``demonstration''
494 below which illustrates the major features of Calc in just a couple of
495 pages.  If you don't have time to go through the full tutorial, this
496 will show you everything you need to know to begin.
497 @xref{Demonstration of Calc}.
499 The tutorial chapter walks you through the various parts of Calc
500 with lots of hands-on examples and explanations.  If you are new
501 to Calc and you have some time, try going through at least the
502 beginning of the tutorial.  The tutorial includes about 70 exercises
503 with answers.  These exercises give you some guided practice with
504 Calc, as well as pointing out some interesting and unusual ways
505 to use its features.
507 The reference section discusses Calc in complete depth.  You can read
508 the reference from start to finish if you want to learn every aspect
509 of Calc.  Or, you can look in the table of contents or the Concept
510 Index to find the parts of the manual that discuss the things you
511 need to know.
513 @cindex Marginal notes
514 Every Calc keyboard command is listed in the Calc Summary, and also
515 in the Key Index.  Algebraic functions, @kbd{M-x} commands, and
516 variables also have their own indices.  @c{Each}
517 @asis{In the printed manual, each}
518 paragraph that is referenced in the Key or Function Index is marked
519 in the margin with its index entry.
521 @c [fix-ref Help Commands]
522 You can access this manual on-line at any time within Calc by
523 pressing the @kbd{h i} key sequence.  Outside of the Calc window,
524 you can press @kbd{M-# i} to read the manual on-line.  Also, you
525 can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{M-# t},
526 or to the Summary by pressing @kbd{h s} or @kbd{M-# s}.  Within Calc,
527 you can also go to the part of the manual describing any Calc key,
528 function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v},
529 respectively.  @xref{Help Commands}.
531 Printed copies of this manual are also available from the Free Software
532 Foundation.
534 @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
535 @section Notations Used in This Manual
537 @noindent
538 This section describes the various notations that are used
539 throughout the Calc manual.
541 In keystroke sequences, uppercase letters mean you must hold down
542 the shift key while typing the letter.  Keys pressed with Control
543 held down are shown as @kbd{C-x}.  Keys pressed with Meta held down
544 are shown as @kbd{M-x}.  Other notations are @key{RET} for the
545 Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
546 @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.
548 (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
549 the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
550 If you don't have a Meta key, look for Alt or Extend Char.  You can
551 also press @key{ESC} or @key{C-[} first to get the same effect, so
552 that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
554 Sometimes the @key{RET} key is not shown when it is ``obvious''
555 that you must press @key{RET} to proceed.  For example, the @key{RET}
556 is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
558 Commands are generally shown like this:  @kbd{p} (@code{calc-precision})
559 or @kbd{M-# k} (@code{calc-keypad}).  This means that the command is
560 normally used by pressing the @kbd{p} key or @kbd{M-# k} key sequence,
561 but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
563 Commands that correspond to functions in algebraic notation
564 are written:  @kbd{C} (@code{calc-cos}) [@code{cos}].  This means
565 the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
566 the corresponding function in an algebraic-style formula would
567 be @samp{cos(@var{x})}.
569 A few commands don't have key equivalents:  @code{calc-sincos}
570 [@code{sincos}].@refill
572 @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
573 @section A Demonstration of Calc
575 @noindent
576 @cindex Demonstration of Calc
577 This section will show some typical small problems being solved with
578 Calc.  The focus is more on demonstration than explanation, but
579 everything you see here will be covered more thoroughly in the
580 Tutorial.
582 To begin, start Emacs if necessary (usually the command @code{emacs}
583 does this), and type @kbd{M-# c} (or @kbd{@key{ESC} # c}) to start the
584 Calculator.  (@xref{Starting Calc}, if this doesn't work for you.)
586 Be sure to type all the sample input exactly, especially noting the
587 difference between lower-case and upper-case letters.  Remember,
588 @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
589 Delete, and Space keys.
591 @strong{RPN calculation.}  In RPN, you type the input number(s) first,
592 then the command to operate on the numbers.
594 @noindent
595 Type @kbd{2 @key{RET} 3 + Q} to compute @c{$\sqrt{2+3} = 2.2360679775$}
596 @asis{the square root of 2+3, which is 2.2360679775}.
598 @noindent
599 Type @kbd{P 2 ^} to compute @c{$\pi^2 = 9.86960440109$}
600 @asis{the value of `pi' squared, 9.86960440109}.
602 @noindent
603 Type @key{TAB} to exchange the order of these two results.
605 @noindent
606 Type @kbd{- I H S} to subtract these results and compute the Inverse
607 Hyperbolic sine of the difference, 2.72996136574.
609 @noindent
610 Type @key{DEL} to erase this result.
612 @strong{Algebraic calculation.}  You can also enter calculations using
613 conventional ``algebraic'' notation.  To enter an algebraic formula,
614 use the apostrophe key.
616 @noindent
617 Type @kbd{' sqrt(2+3) @key{RET}} to compute @c{$\sqrt{2+3}$}
618 @asis{the square root of 2+3}.
620 @noindent
621 Type @kbd{' pi^2 @key{RET}} to enter @c{$\pi^2$}
622 @asis{`pi' squared}.  To evaluate this symbolic
623 formula as a number, type @kbd{=}.
625 @noindent
626 Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
627 result from the most-recent and compute the Inverse Hyperbolic sine.
629 @strong{Keypad mode.}  If you are using the X window system, press
630 @w{@kbd{M-# k}} to get Keypad mode.  (If you don't use X, skip to
631 the next section.)
633 @noindent
634 Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
635 ``buttons'' using your left mouse button.
637 @noindent
638 Click on @key{PI}, @key{2}, and @t{y^x}.
640 @noindent
641 Click on @key{INV}, then @key{ENTER} to swap the two results.
643 @noindent
644 Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
646 @noindent
647 Click on @key{<-} to erase the result, then click @key{OFF} to turn
648 the Keypad Calculator off.
650 @strong{Grabbing data.}  Type @kbd{M-# x} if necessary to exit Calc.
651 Now select the following numbers as an Emacs region:  ``Mark'' the
652 front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
653 then move to the other end of the list.  (Either get this list from
654 the on-line copy of this manual, accessed by @w{@kbd{M-# i}}, or just
655 type these numbers into a scratch file.)  Now type @kbd{M-# g} to
656 ``grab'' these numbers into Calc.
658 @example
659 @group
660 1.23  1.97
661 1.6   2
662 1.19  1.08
663 @end group
664 @end example
666 @noindent
667 The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
668 Type @w{@kbd{V R +}} to compute the sum of these numbers.
670 @noindent
671 Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
672 the product of the numbers.
674 @noindent
675 You can also grab data as a rectangular matrix.  Place the cursor on
676 the upper-leftmost @samp{1} and set the mark, then move to just after
677 the lower-right @samp{8} and press @kbd{M-# r}.
679 @noindent
680 Type @kbd{v t} to transpose this @c{$3\times2$}
681 @asis{3x2} matrix into a @c{$2\times3$}
682 @asis{2x3} matrix.  Type
683 @w{@kbd{v u}} to unpack the rows into two separate vectors.  Now type
684 @w{@kbd{V R + @key{TAB} V R +}} to compute the sums of the two original columns.
685 (There is also a special grab-and-sum-columns command, @kbd{M-# :}.)
687 @strong{Units conversion.}  Units are entered algebraically.
688 Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
689 Type @w{@kbd{u c km/hr @key{RET}}}.  Type @w{@kbd{u c m/s @key{RET}}}.
691 @strong{Date arithmetic.}  Type @kbd{t N} to get the current date and
692 time.  Type @kbd{90 +} to find the date 90 days from now.  Type
693 @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
694 many weeks have passed since then.
696 @strong{Algebra.}  Algebraic entries can also include formulas
697 or equations involving variables.  Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
698 to enter a pair of equations involving three variables.
699 (Note the leading apostrophe in this example; also, note that the space
700 between @samp{x y} is required.)  Type @w{@kbd{a S x,y @key{RET}}} to solve
701 these equations for the variables @cite{x} and @cite{y}.@refill
703 @noindent
704 Type @kbd{d B} to view the solutions in more readable notation.
705 Type @w{@kbd{d C}} to view them in C language notation, and @kbd{d T}
706 to view them in the notation for the @TeX{} typesetting system.
707 Type @kbd{d N} to return to normal notation.
709 @noindent
710 Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @cite{a = 7.5} in these formulas.
711 (That's a letter @kbd{l}, not a numeral @kbd{1}.)
713 @iftex
714 @strong{Help functions.}  You can read about any command in the on-line
715 manual.  Type @kbd{M-# c} to return to Calc after each of these
716 commands: @kbd{h k t N} to read about the @kbd{t N} command,
717 @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
718 @kbd{h s} to read the Calc summary.
719 @end iftex
720 @ifinfo
721 @strong{Help functions.}  You can read about any command in the on-line
722 manual.  Remember to type the letter @kbd{l}, then @kbd{M-# c}, to
723 return here after each of these commands: @w{@kbd{h k t N}} to read
724 about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
725 @code{sqrt} function, and @kbd{h s} to read the Calc summary.
726 @end ifinfo
728 Press @key{DEL} repeatedly to remove any leftover results from the stack.
729 To exit from Calc, press @kbd{q} or @kbd{M-# c} again.
731 @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
732 @section Using Calc
734 @noindent
735 Calc has several user interfaces that are specialized for
736 different kinds of tasks.  As well as Calc's standard interface,
737 there are Quick Mode, Keypad Mode, and Embedded Mode.
739 @c [fix-ref Installation]
740 Calc must be @dfn{installed} before it can be used.  @xref{Installation},
741 for instructions on setting up and installing Calc.  We will assume
742 you or someone on your system has already installed Calc as described
743 there.
745 @menu
746 * Starting Calc::
747 * The Standard Interface::
748 * Quick Mode Overview::
749 * Keypad Mode Overview::
750 * Standalone Operation::
751 * Embedded Mode Overview::
752 * Other M-# Commands::
753 @end menu
755 @node Starting Calc, The Standard Interface, Using Calc, Using Calc
756 @subsection Starting Calc
758 @noindent
759 On most systems, you can type @kbd{M-#} to start the Calculator.
760 The notation @kbd{M-#} is short for Meta-@kbd{#}.  On most
761 keyboards this means holding down the Meta (or Alt) and
762 Shift keys while typing @kbd{3}.
764 @cindex META key
765 Once again, if you don't have a Meta key on your keyboard you can type
766 @key{ESC} first, then @kbd{#}, to accomplish the same thing.  If you
767 don't even have an @key{ESC} key, you can fake it by holding down
768 Control or @key{CTRL} while typing a left square bracket
769 (that's @kbd{C-[} in Emacs notation).@refill
771 @kbd{M-#} is a @dfn{prefix key}; when you press it, Emacs waits for
772 you to press a second key to complete the command.  In this case,
773 you will follow @kbd{M-#} with a letter (upper- or lower-case, it
774 doesn't matter for @kbd{M-#}) that says which Calc interface you
775 want to use.
777 To get Calc's standard interface, type @kbd{M-# c}.  To get
778 Keypad Mode, type @kbd{M-# k}.  Type @kbd{M-# ?} to get a brief
779 list of the available options, and type a second @kbd{?} to get
780 a complete list.
782 To ease typing, @kbd{M-# M-#} (or @kbd{M-# #} if that's easier)
783 also works to start Calc.  It starts the same interface (either
784 @kbd{M-# c} or @w{@kbd{M-# k}}) that you last used, selecting the
785 @kbd{M-# c} interface by default.  (If your installation has
786 a special function key set up to act like @kbd{M-#}, hitting that
787 function key twice is just like hitting @kbd{M-# M-#}.)
789 If @kbd{M-#} doesn't work for you, you can always type explicit
790 commands like @kbd{M-x calc} (for the standard user interface) or
791 @w{@kbd{M-x calc-keypad}} (for Keypad Mode).  First type @kbd{M-x}
792 (that's Meta with the letter @kbd{x}), then, at the prompt,
793 type the full command (like @kbd{calc-keypad}) and press Return.
795 If you type @kbd{M-x calc} and Emacs still doesn't recognize the
796 command (it will say @samp{[No match]} when you try to press
797 @key{RET}), then Calc has not been properly installed.
799 The same commands (like @kbd{M-# c} or @kbd{M-# M-#}) that start
800 the Calculator also turn it off if it is already on.
802 @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
803 @subsection The Standard Calc Interface
805 @noindent
806 @cindex Standard user interface
807 Calc's standard interface acts like a traditional RPN calculator,
808 operated by the normal Emacs keyboard.  When you type @kbd{M-# c}
809 to start the Calculator, the Emacs screen splits into two windows
810 with the file you were editing on top and Calc on the bottom.
812 @smallexample
813 @group
816 --**-Emacs: myfile             (Fundamental)----All----------------------
817 --- Emacs Calculator Mode ---                   |Emacs Calc Mode v2.00...
818 2:  17.3                                        |    17.3
819 1:  -5                                          |    3
820     .                                           |    2
821                                                 |    4
822                                                 |  * 8
823                                                 |  ->-5
824                                                 |
825 --%%-Calc: 12 Deg       (Calculator)----All----- --%%-Emacs: *Calc Trail*
826 @end group
827 @end smallexample
829 In this figure, the mode-line for @file{myfile} has moved up and the
830 ``Calculator'' window has appeared below it.  As you can see, Calc
831 actually makes two windows side-by-side.  The lefthand one is
832 called the @dfn{stack window} and the righthand one is called the
833 @dfn{trail window.}  The stack holds the numbers involved in the
834 calculation you are currently performing.  The trail holds a complete
835 record of all calculations you have done.  In a desk calculator with
836 a printer, the trail corresponds to the paper tape that records what
837 you do.
839 In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
840 were first entered into the Calculator, then the 2 and 4 were
841 multiplied to get 8, then the 3 and 8 were subtracted to get @i{-5}.
842 (The @samp{>} symbol shows that this was the most recent calculation.)
843 The net result is the two numbers 17.3 and @i{-5} sitting on the stack.
845 Most Calculator commands deal explicitly with the stack only, but
846 there is a set of commands that allow you to search back through
847 the trail and retrieve any previous result.
849 Calc commands use the digits, letters, and punctuation keys.
850 Shifted (i.e., upper-case) letters are different from lowercase
851 letters.  Some letters are @dfn{prefix} keys that begin two-letter
852 commands.  For example, @kbd{e} means ``enter exponent'' and shifted
853 @kbd{E} means @cite{e^x}.  With the @kbd{d} (``display modes'') prefix
854 the letter ``e'' takes on very different meanings:  @kbd{d e} means
855 ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
857 There is nothing stopping you from switching out of the Calc
858 window and back into your editing window, say by using the Emacs
859 @w{@kbd{C-x o}} (@code{other-window}) command.  When the cursor is
860 inside a regular window, Emacs acts just like normal.  When the
861 cursor is in the Calc stack or trail windows, keys are interpreted
862 as Calc commands.
864 When you quit by pressing @kbd{M-# c} a second time, the Calculator
865 windows go away but the actual Stack and Trail are not gone, just
866 hidden.  When you press @kbd{M-# c} once again you will get the
867 same stack and trail contents you had when you last used the
868 Calculator.
870 The Calculator does not remember its state between Emacs sessions.
871 Thus if you quit Emacs and start it again, @kbd{M-# c} will give you
872 a fresh stack and trail.  There is a command (@kbd{m m}) that lets
873 you save your favorite mode settings between sessions, though.
874 One of the things it saves is which user interface (standard or
875 Keypad) you last used; otherwise, a freshly started Emacs will
876 always treat @kbd{M-# M-#} the same as @kbd{M-# c}.
878 The @kbd{q} key is another equivalent way to turn the Calculator off.
880 If you type @kbd{M-# b} first and then @kbd{M-# c}, you get a
881 full-screen version of Calc (@code{full-calc}) in which the stack and
882 trail windows are still side-by-side but are now as tall as the whole
883 Emacs screen.  When you press @kbd{q} or @kbd{M-# c} again to quit,
884 the file you were editing before reappears.  The @kbd{M-# b} key
885 switches back and forth between ``big'' full-screen mode and the
886 normal partial-screen mode.
888 Finally, @kbd{M-# o} (@code{calc-other-window}) is like @kbd{M-# c}
889 except that the Calc window is not selected.  The buffer you were
890 editing before remains selected instead.  @kbd{M-# o} is a handy
891 way to switch out of Calc momentarily to edit your file; type
892 @kbd{M-# c} to switch back into Calc when you are done.
894 @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
895 @subsection Quick Mode (Overview)
897 @noindent
898 @dfn{Quick Mode} is a quick way to use Calc when you don't need the
899 full complexity of the stack and trail.  To use it, type @kbd{M-# q}
900 (@code{quick-calc}) in any regular editing buffer.
902 Quick Mode is very simple:  It prompts you to type any formula in
903 standard algebraic notation (like @samp{4 - 2/3}) and then displays
904 the result at the bottom of the Emacs screen (@i{3.33333333333}
905 in this case).  You are then back in the same editing buffer you
906 were in before, ready to continue editing or to type @kbd{M-# q}
907 again to do another quick calculation.  The result of the calculation
908 will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
909 at this point will yank the result into your editing buffer.
911 Calc mode settings affect Quick Mode, too, though you will have to
912 go into regular Calc (with @kbd{M-# c}) to change the mode settings.
914 @c [fix-ref Quick Calculator mode]
915 @xref{Quick Calculator}, for further information.
917 @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
918 @subsection Keypad Mode (Overview)
920 @noindent
921 @dfn{Keypad Mode} is a mouse-based interface to the Calculator.
922 It is designed for use with terminals that support a mouse.  If you
923 don't have a mouse, you will have to operate keypad mode with your
924 arrow keys (which is probably more trouble than it's worth).  Keypad
925 mode is currently not supported under Emacs 19.
927 Type @kbd{M-# k} to turn Keypad Mode on or off.  Once again you
928 get two new windows, this time on the righthand side of the screen
929 instead of at the bottom.  The upper window is the familiar Calc
930 Stack; the lower window is a picture of a typical calculator keypad.
932 @tex
933 \dimen0=\pagetotal%
934 \advance \dimen0 by 24\baselineskip%
935 \ifdim \dimen0>\pagegoal \vfill\eject \fi%
936 \medskip
937 @end tex
938 @smallexample
939                                         |--- Emacs Calculator Mode ---
940                                         |2:  17.3
941                                         |1:  -5
942                                         |    .
943                                         |--%%-Calc: 12 Deg       (Calcul
944                                         |----+-----Calc 2.00-----+----1
945                                         |FLR |CEIL|RND |TRNC|CLN2|FLT |
946                                         |----+----+----+----+----+----|
947                                         | LN |EXP |    |ABS |IDIV|MOD |
948                                         |----+----+----+----+----+----|
949                                         |SIN |COS |TAN |SQRT|y^x |1/x |
950                                         |----+----+----+----+----+----|
951                                         |  ENTER  |+/- |EEX |UNDO| <- |
952                                         |-----+---+-+--+--+-+---++----|
953                                         | INV |  7  |  8  |  9  |  /  |
954                                         |-----+-----+-----+-----+-----|
955                                         | HYP |  4  |  5  |  6  |  *  |
956                                         |-----+-----+-----+-----+-----|
957                                         |EXEC |  1  |  2  |  3  |  -  |
958                                         |-----+-----+-----+-----+-----|
959                                         | OFF |  0  |  .  | PI  |  +  |
960                                         |-----+-----+-----+-----+-----+
961 @end smallexample
963 Keypad Mode is much easier for beginners to learn, because there
964 is no need to memorize lots of obscure key sequences.  But not all
965 commands in regular Calc are available on the Keypad.  You can
966 always switch the cursor into the Calc stack window to use
967 standard Calc commands if you need.  Serious Calc users, though,
968 often find they prefer the standard interface over Keypad Mode.
970 To operate the Calculator, just click on the ``buttons'' of the
971 keypad using your left mouse button.  To enter the two numbers
972 shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
973 add them together you would then click @kbd{+} (to get 12.3 on
974 the stack).
976 If you click the right mouse button, the top three rows of the
977 keypad change to show other sets of commands, such as advanced
978 math functions, vector operations, and operations on binary
979 numbers.
981 Because Keypad Mode doesn't use the regular keyboard, Calc leaves
982 the cursor in your original editing buffer.  You can type in
983 this buffer in the usual way while also clicking on the Calculator
984 keypad.  One advantage of Keypad Mode is that you don't need an
985 explicit command to switch between editing and calculating.
987 If you press @kbd{M-# b} first, you get a full-screen Keypad Mode
988 (@code{full-calc-keypad}) with three windows:  The keypad in the lower
989 left, the stack in the lower right, and the trail on top.
991 @c [fix-ref Keypad Mode]
992 @xref{Keypad Mode}, for further information.
994 @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
995 @subsection Standalone Operation
997 @noindent
998 @cindex Standalone Operation
999 If you are not in Emacs at the moment but you wish to use Calc,
1000 you must start Emacs first.  If all you want is to run Calc, you
1001 can give the commands:
1003 @example
1004 emacs -f full-calc
1005 @end example
1007 @noindent
1010 @example
1011 emacs -f full-calc-keypad
1012 @end example
1014 @noindent
1015 which run a full-screen Calculator (as if by @kbd{M-# b M-# c}) or
1016 a full-screen X-based Calculator (as if by @kbd{M-# b M-# k}).
1017 In standalone operation, quitting the Calculator (by pressing
1018 @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
1019 itself.
1021 @node Embedded Mode Overview, Other M-# Commands, Standalone Operation, Using Calc
1022 @subsection Embedded Mode (Overview)
1024 @noindent
1025 @dfn{Embedded Mode} is a way to use Calc directly from inside an
1026 editing buffer.  Suppose you have a formula written as part of a
1027 document like this:
1029 @smallexample
1030 @group
1031 The derivative of
1033                                    ln(ln(x))
1036 @end group
1037 @end smallexample
1039 @noindent
1040 and you wish to have Calc compute and format the derivative for
1041 you and store this derivative in the buffer automatically.  To
1042 do this with Embedded Mode, first copy the formula down to where
1043 you want the result to be:
1045 @smallexample
1046 @group
1047 The derivative of
1049                                    ln(ln(x))
1053                                    ln(ln(x))
1054 @end group
1055 @end smallexample
1057 Now, move the cursor onto this new formula and press @kbd{M-# e}.
1058 Calc will read the formula (using the surrounding blank lines to
1059 tell how much text to read), then push this formula (invisibly)
1060 onto the Calc stack.  The cursor will stay on the formula in the
1061 editing buffer, but the buffer's mode line will change to look
1062 like the Calc mode line (with mode indicators like @samp{12 Deg}
1063 and so on).  Even though you are still in your editing buffer,
1064 the keyboard now acts like the Calc keyboard, and any new result
1065 you get is copied from the stack back into the buffer.  To take
1066 the derivative, you would type @kbd{a d x @key{RET}}.
1068 @smallexample
1069 @group
1070 The derivative of
1072                                    ln(ln(x))
1076 1 / ln(x) x
1077 @end group
1078 @end smallexample
1080 To make this look nicer, you might want to press @kbd{d =} to center
1081 the formula, and even @kbd{d B} to use ``big'' display mode.
1083 @smallexample
1084 @group
1085 The derivative of
1087                                    ln(ln(x))
1090 % [calc-mode: justify: center]
1091 % [calc-mode: language: big]
1093                                        1
1094                                     -------
1095                                     ln(x) x
1096 @end group
1097 @end smallexample
1099 Calc has added annotations to the file to help it remember the modes
1100 that were used for this formula.  They are formatted like comments
1101 in the @TeX{} typesetting language, just in case you are using @TeX{}.
1102 (In this example @TeX{} is not being used, so you might want to move
1103 these comments up to the top of the file or otherwise put them out
1104 of the way.)
1106 As an extra flourish, we can add an equation number using a
1107 righthand label:  Type @kbd{d @} (1) @key{RET}}.
1109 @smallexample
1110 @group
1111 % [calc-mode: justify: center]
1112 % [calc-mode: language: big]
1113 % [calc-mode: right-label: " (1)"]
1115                                        1
1116                                     -------                      (1)
1117                                     ln(x) x
1118 @end group
1119 @end smallexample
1121 To leave Embedded Mode, type @kbd{M-# e} again.  The mode line
1122 and keyboard will revert to the way they were before.  (If you have
1123 actually been trying this as you read along, you'll want to press
1124 @kbd{M-# 0} [with the digit zero] now to reset the modes you changed.)
1126 The related command @kbd{M-# w} operates on a single word, which
1127 generally means a single number, inside text.  It uses any
1128 non-numeric characters rather than blank lines to delimit the
1129 formula it reads.  Here's an example of its use:
1131 @smallexample
1132 A slope of one-third corresponds to an angle of 1 degrees.
1133 @end smallexample
1135 Place the cursor on the @samp{1}, then type @kbd{M-# w} to enable
1136 Embedded Mode on that number.  Now type @kbd{3 /} (to get one-third),
1137 and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
1138 then @w{@kbd{M-# w}} again to exit Embedded mode.
1140 @smallexample
1141 A slope of one-third corresponds to an angle of 18.4349488229 degrees.
1142 @end smallexample
1144 @c [fix-ref Embedded Mode]
1145 @xref{Embedded Mode}, for full details.
1147 @node Other M-# Commands, , Embedded Mode Overview, Using Calc
1148 @subsection Other @kbd{M-#} Commands
1150 @noindent
1151 Two more Calc-related commands are @kbd{M-# g} and @kbd{M-# r},
1152 which ``grab'' data from a selected region of a buffer into the
1153 Calculator.  The region is defined in the usual Emacs way, by
1154 a ``mark'' placed at one end of the region, and the Emacs
1155 cursor or ``point'' placed at the other.
1157 The @kbd{M-# g} command reads the region in the usual left-to-right,
1158 top-to-bottom order.  The result is packaged into a Calc vector
1159 of numbers and placed on the stack.  Calc (in its standard
1160 user interface) is then started.  Type @kbd{v u} if you want
1161 to unpack this vector into separate numbers on the stack.  Also,
1162 @kbd{C-u M-# g} interprets the region as a single number or
1163 formula.
1165 The @kbd{M-# r} command reads a rectangle, with the point and
1166 mark defining opposite corners of the rectangle.  The result
1167 is a matrix of numbers on the Calculator stack.
1169 Complementary to these is @kbd{M-# y}, which ``yanks'' the
1170 value at the top of the Calc stack back into an editing buffer.
1171 If you type @w{@kbd{M-# y}} while in such a buffer, the value is
1172 yanked at the current position.  If you type @kbd{M-# y} while
1173 in the Calc buffer, Calc makes an educated guess as to which
1174 editing buffer you want to use.  The Calc window does not have
1175 to be visible in order to use this command, as long as there
1176 is something on the Calc stack.
1178 Here, for reference, is the complete list of @kbd{M-#} commands.
1179 The shift, control, and meta keys are ignored for the keystroke
1180 following @kbd{M-#}.
1182 @noindent
1183 Commands for turning Calc on and off:
1185 @table @kbd
1186 @item #
1187 Turn Calc on or off, employing the same user interface as last time.
1189 @item C
1190 Turn Calc on or off using its standard bottom-of-the-screen
1191 interface.  If Calc is already turned on but the cursor is not
1192 in the Calc window, move the cursor into the window.
1194 @item O
1195 Same as @kbd{C}, but don't select the new Calc window.  If
1196 Calc is already turned on and the cursor is in the Calc window,
1197 move it out of that window.
1199 @item B
1200 Control whether @kbd{M-# c} and @kbd{M-# k} use the full screen.
1202 @item Q
1203 Use Quick Mode for a single short calculation.
1205 @item K
1206 Turn Calc Keypad mode on or off.
1208 @item E
1209 Turn Calc Embedded mode on or off at the current formula.
1211 @item J
1212 Turn Calc Embedded mode on or off, select the interesting part.
1214 @item W
1215 Turn Calc Embedded mode on or off at the current word (number).
1217 @item Z
1218 Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
1220 @item X
1221 Quit Calc; turn off standard, Keypad, or Embedded mode if on.
1222 (This is like @kbd{q} or @key{OFF} inside of Calc.)
1223 @end table
1224 @iftex
1225 @sp 2
1226 @end iftex
1228 @noindent
1229 Commands for moving data into and out of the Calculator:
1231 @table @kbd
1232 @item G
1233 Grab the region into the Calculator as a vector.
1235 @item R
1236 Grab the rectangular region into the Calculator as a matrix.
1238 @item :
1239 Grab the rectangular region and compute the sums of its columns.
1241 @item _
1242 Grab the rectangular region and compute the sums of its rows.
1244 @item Y
1245 Yank a value from the Calculator into the current editing buffer.
1246 @end table
1247 @iftex
1248 @sp 2
1249 @end iftex
1251 @noindent
1252 Commands for use with Embedded Mode:
1254 @table @kbd
1255 @item A
1256 ``Activate'' the current buffer.  Locate all formulas that
1257 contain @samp{:=} or @samp{=>} symbols and record their locations
1258 so that they can be updated automatically as variables are changed.
1260 @item D
1261 Duplicate the current formula immediately below and select
1262 the duplicate.
1264 @item F
1265 Insert a new formula at the current point.
1267 @item N
1268 Move the cursor to the next active formula in the buffer.
1270 @item P
1271 Move the cursor to the previous active formula in the buffer.
1273 @item U
1274 Update (i.e., as if by the @kbd{=} key) the formula at the current point.
1276 @item `
1277 Edit (as if by @code{calc-edit}) the formula at the current point.
1278 @end table
1279 @iftex
1280 @sp 2
1281 @end iftex
1283 @noindent
1284 Miscellaneous commands:
1286 @table @kbd
1287 @item I
1288 Run the Emacs Info system to read the Calc manual.
1289 (This is the same as @kbd{h i} inside of Calc.)
1291 @item T
1292 Run the Emacs Info system to read the Calc Tutorial.
1294 @item S
1295 Run the Emacs Info system to read the Calc Summary.
1297 @item L
1298 Load Calc entirely into memory.  (Normally the various parts
1299 are loaded only as they are needed.)
1301 @item M
1302 Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
1303 and record them as the current keyboard macro.
1305 @item 0
1306 (This is the ``zero'' digit key.)  Reset the Calculator to
1307 its default state:  Empty stack, and default mode settings.
1308 With any prefix argument, reset everything but the stack.
1309 @end table
1311 @node History and Acknowledgements, , Using Calc, Getting Started
1312 @section History and Acknowledgements
1314 @noindent
1315 Calc was originally started as a two-week project to occupy a lull
1316 in the author's schedule.  Basically, a friend asked if I remembered
1317 the value of @c{$2^{32}$}
1318 @cite{2^32}.  I didn't offhand, but I said, ``that's
1319 easy, just call up an @code{xcalc}.''  @code{Xcalc} duly reported
1320 that the answer to our question was @samp{4.294967e+09}---with no way to
1321 see the full ten digits even though we knew they were there in the
1322 program's memory!  I was so annoyed, I vowed to write a calculator
1323 of my own, once and for all.
1325 I chose Emacs Lisp, a) because I had always been curious about it
1326 and b) because, being only a text editor extension language after
1327 all, Emacs Lisp would surely reach its limits long before the project
1328 got too far out of hand.
1330 To make a long story short, Emacs Lisp turned out to be a distressingly
1331 solid implementation of Lisp, and the humble task of calculating
1332 turned out to be more open-ended than one might have expected.
1334 Emacs Lisp doesn't have built-in floating point math, so it had to be
1335 simulated in software.  In fact, Emacs integers will only comfortably
1336 fit six decimal digits or so---not enough for a decent calculator.  So
1337 I had to write my own high-precision integer code as well, and once I had
1338 this I figured that arbitrary-size integers were just as easy as large
1339 integers.  Arbitrary floating-point precision was the logical next step.
1340 Also, since the large integer arithmetic was there anyway it seemed only
1341 fair to give the user direct access to it, which in turn made it practical
1342 to support fractions as well as floats.  All these features inspired me
1343 to look around for other data types that might be worth having.
1345 Around this time, my friend Rick Koshi showed me his nifty new HP-28
1346 calculator.  It allowed the user to manipulate formulas as well as
1347 numerical quantities, and it could also operate on matrices.  I decided
1348 that these would be good for Calc to have, too.  And once things had
1349 gone this far, I figured I might as well take a look at serious algebra
1350 systems like Mathematica, Macsyma, and Maple for further ideas.  Since
1351 these systems did far more than I could ever hope to implement, I decided
1352 to focus on rewrite rules and other programming features so that users
1353 could implement what they needed for themselves.
1355 Rick complained that matrices were hard to read, so I put in code to
1356 format them in a 2D style.  Once these routines were in place, Big mode
1357 was obligatory.  Gee, what other language modes would be useful?
1359 Scott Hemphill and Allen Knutson, two friends with a strong mathematical
1360 bent, contributed ideas and algorithms for a number of Calc features
1361 including modulo forms, primality testing, and float-to-fraction conversion.
1363 Units were added at the eager insistence of Mass Sivilotti.  Later,
1364 Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
1365 expert assistance with the units table.  As far as I can remember, the
1366 idea of using algebraic formulas and variables to represent units dates
1367 back to an ancient article in Byte magazine about muMath, an early
1368 algebra system for microcomputers.
1370 Many people have contributed to Calc by reporting bugs and suggesting
1371 features, large and small.  A few deserve special mention:  Tim Peters,
1372 who helped develop the ideas that led to the selection commands, rewrite
1373 rules, and many other algebra features; @c{Fran\c cois}
1374 @asis{Francois} Pinard, who contributed
1375 an early prototype of the Calc Summary appendix as well as providing
1376 valuable suggestions in many other areas of Calc; Carl Witty, whose eagle
1377 eyes discovered many typographical and factual errors in the Calc manual;
1378 Tim Kay, who drove the development of Embedded mode; Ove Ewerlid, who
1379 made many suggestions relating to the algebra commands and contributed
1380 some code for polynomial operations; Randal Schwartz, who suggested the
1381 @code{calc-eval} function; Robert J. Chassell, who suggested the Calc
1382 Tutorial and exercises; and Juha Sarlin, who first worked out how to split
1383 Calc into quickly-loading parts.  Bob Weiner helped immensely with the
1384 Lucid Emacs port.
1386 @cindex Bibliography
1387 @cindex Knuth, Art of Computer Programming
1388 @cindex Numerical Recipes
1389 @c Should these be expanded into more complete references?
1390 Among the books used in the development of Calc were Knuth's @emph{Art
1391 of Computer Programming} (especially volume II, @emph{Seminumerical
1392 Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
1393 and Vetterling; Bevington's @emph{Data Reduction and Error Analysis for
1394 the Physical Sciences}; @emph{Concrete Mathematics} by Graham, Knuth,
1395 and Patashnik; Steele's @emph{Common Lisp, the Language}; the @emph{CRC
1396 Standard Math Tables} (William H. Beyer, ed.); and Abramowitz and
1397 Stegun's venerable @emph{Handbook of Mathematical Functions}.  I
1398 consulted the user's manuals for the HP-28 and HP-48 calculators, as
1399 well as for the programs Mathematica, SMP, Macsyma, Maple, MathCAD,
1400 Gnuplot, and others.  Also, of course, Calc could not have been written
1401 without the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil
1402 Lewis and Dan LaLiberte.
1404 Final thanks go to Richard Stallman, without whose fine implementations
1405 of the Emacs editor, language, and environment, Calc would have been
1406 finished in two weeks.
1408 @c [tutorial]
1410 @ifinfo
1411 @c This node is accessed by the `M-# t' command.
1412 @node Interactive Tutorial, , , Top
1413 @chapter Tutorial
1415 @noindent
1416 Some brief instructions on using the Emacs Info system for this tutorial:
1418 Press the space bar and Delete keys to go forward and backward in a
1419 section by screenfuls (or use the regular Emacs scrolling commands
1420 for this).
1422 Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
1423 If the section has a @dfn{menu}, press a digit key like @kbd{1}
1424 or @kbd{2} to go to a sub-section from the menu.  Press @kbd{u} to
1425 go back up from a sub-section to the menu it is part of.
1427 Exercises in the tutorial all have cross-references to the
1428 appropriate page of the ``answers'' section.  Press @kbd{f}, then
1429 the exercise number, to see the answer to an exercise.  After
1430 you have followed a cross-reference, you can press the letter
1431 @kbd{l} to return to where you were before.
1433 You can press @kbd{?} at any time for a brief summary of Info commands.
1435 Press @kbd{1} now to enter the first section of the Tutorial.
1437 @menu
1438 * Tutorial::
1439 @end menu
1440 @end ifinfo
1442 @node Tutorial, Introduction, Getting Started, Top
1443 @chapter Tutorial
1445 @noindent
1446 This chapter explains how to use Calc and its many features, in
1447 a step-by-step, tutorial way.  You are encouraged to run Calc and
1448 work along with the examples as you read (@pxref{Starting Calc}).
1449 If you are already familiar with advanced calculators, you may wish
1450 @c [not-split]
1451 to skip on to the rest of this manual.
1452 @c [when-split]
1453 @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
1455 @c [fix-ref Embedded Mode]
1456 This tutorial describes the standard user interface of Calc only.
1457 The ``Quick Mode'' and ``Keypad Mode'' interfaces are fairly
1458 self-explanatory.  @xref{Embedded Mode}, for a description of
1459 the ``Embedded Mode'' interface.
1461 @ifinfo
1462 The easiest way to read this tutorial on-line is to have two windows on
1463 your Emacs screen, one with Calc and one with the Info system.  (If you
1464 have a printed copy of the manual you can use that instead.)  Press
1465 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1466 press @kbd{M-# i} to start the Info system or to switch into its window.
1467 Or, you may prefer to use the tutorial in printed form.
1468 @end ifinfo
1469 @iftex
1470 The easiest way to read this tutorial on-line is to have two windows on
1471 your Emacs screen, one with Calc and one with the Info system.  (If you
1472 have a printed copy of the manual you can use that instead.)  Press
1473 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1474 press @kbd{M-# i} to start the Info system or to switch into its window.
1475 @end iftex
1477 This tutorial is designed to be done in sequence.  But the rest of this
1478 manual does not assume you have gone through the tutorial.  The tutorial
1479 does not cover everything in the Calculator, but it touches on most
1480 general areas.
1482 @ifinfo
1483 You may wish to print out a copy of the Calc Summary and keep notes on
1484 it as you learn Calc.  @xref{Installation}, to see how to make a printed
1485 summary.  @xref{Summary}.
1486 @end ifinfo
1487 @iftex
1488 The Calc Summary at the end of the reference manual includes some blank
1489 space for your own use.  You may wish to keep notes there as you learn
1490 Calc.
1491 @end iftex
1493 @menu
1494 * Basic Tutorial::
1495 * Arithmetic Tutorial::
1496 * Vector/Matrix Tutorial::
1497 * Types Tutorial::
1498 * Algebra Tutorial::
1499 * Programming Tutorial::
1501 * Answers to Exercises::
1502 @end menu
1504 @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
1505 @section Basic Tutorial
1507 @noindent
1508 In this section, we learn how RPN and algebraic-style calculations
1509 work, how to undo and redo an operation done by mistake, and how
1510 to control various modes of the Calculator.
1512 @menu
1513 * RPN Tutorial::            Basic operations with the stack.
1514 * Algebraic Tutorial::      Algebraic entry; variables.
1515 * Undo Tutorial::           If you make a mistake: Undo and the trail.
1516 * Modes Tutorial::          Common mode-setting commands.
1517 @end menu
1519 @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
1520 @subsection RPN Calculations and the Stack
1522 @cindex RPN notation
1523 @ifinfo
1524 @noindent
1525 Calc normally uses RPN notation.  You may be familiar with the RPN
1526 system from Hewlett-Packard calculators, FORTH, or PostScript.
1527 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1528 Jan Lukasiewicz.)
1529 @end ifinfo
1530 @tex
1531 \noindent
1532 Calc normally uses RPN notation.  You may be familiar with the RPN
1533 system from Hewlett-Packard calculators, FORTH, or PostScript.
1534 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1535 Jan \L ukasiewicz.)
1536 @end tex
1538 The central component of an RPN calculator is the @dfn{stack}.  A
1539 calculator stack is like a stack of dishes.  New dishes (numbers) are
1540 added at the top of the stack, and numbers are normally only removed
1541 from the top of the stack.
1543 @cindex Operators
1544 @cindex Operands
1545 In an operation like @cite{2+3}, the 2 and 3 are called the @dfn{operands}
1546 and the @cite{+} is the @dfn{operator}.  In an RPN calculator you always
1547 enter the operands first, then the operator.  Each time you type a
1548 number, Calc adds or @dfn{pushes} it onto the top of the Stack.
1549 When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
1550 number of operands from the stack and pushes back the result.
1552 Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
1553 @kbd{2 @key{RET} 3 @key{RET} +}.  (The @key{RET} key, Return, corresponds to
1554 the @key{ENTER} key on traditional RPN calculators.)  Try this now if
1555 you wish; type @kbd{M-# c} to switch into the Calc window (you can type
1556 @kbd{M-# c} again or @kbd{M-# o} to switch back to the Tutorial window).
1557 The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
1558 The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
1559 and pushes the result (5) back onto the stack.  Here's how the stack
1560 will look at various points throughout the calculation:@refill
1562 @smallexample
1563 @group
1564     .          1:  2          2:  2          1:  5              .
1565                    .          1:  3              .
1566                                   .
1568   M-# c          2 @key{RET}          3 @key{RET}            +             @key{DEL}
1569 @end group
1570 @end smallexample
1572 The @samp{.} symbol is a marker that represents the top of the stack.
1573 Note that the ``top'' of the stack is really shown at the bottom of
1574 the Stack window.  This may seem backwards, but it turns out to be
1575 less distracting in regular use.
1577 @cindex Stack levels
1578 @cindex Levels of stack
1579 The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
1580 numbers}.  Old RPN calculators always had four stack levels called
1581 @cite{x}, @cite{y}, @cite{z}, and @cite{t}.  Calc's stack can grow
1582 as large as you like, so it uses numbers instead of letters.  Some
1583 stack-manipulation commands accept a numeric argument that says
1584 which stack level to work on.  Normal commands like @kbd{+} always
1585 work on the top few levels of the stack.@refill
1587 @c [fix-ref Truncating the Stack]
1588 The Stack buffer is just an Emacs buffer, and you can move around in
1589 it using the regular Emacs motion commands.  But no matter where the
1590 cursor is, even if you have scrolled the @samp{.} marker out of
1591 view, most Calc commands always move the cursor back down to level 1
1592 before doing anything.  It is possible to move the @samp{.} marker
1593 upwards through the stack, temporarily ``hiding'' some numbers from
1594 commands like @kbd{+}.  This is called @dfn{stack truncation} and
1595 we will not cover it in this tutorial; @pxref{Truncating the Stack},
1596 if you are interested.
1598 You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
1599 @key{RET} +}.  That's because if you type any operator name or
1600 other non-numeric key when you are entering a number, the Calculator
1601 automatically enters that number and then does the requested command.
1602 Thus @kbd{2 @key{RET} 3 +} will work just as well.@refill
1604 Examples in this tutorial will often omit @key{RET} even when the
1605 stack displays shown would only happen if you did press @key{RET}:
1607 @smallexample
1608 @group
1609 1:  2          2:  2          1:  5
1610     .          1:  3              .
1611                    .
1613   2 @key{RET}            3              +
1614 @end group
1615 @end smallexample
1617 @noindent
1618 Here, after pressing @kbd{3} the stack would really show @samp{1:  2}
1619 with @samp{Calc:@: 3} in the minibuffer.  In these situations, you can
1620 press the optional @key{RET} to see the stack as the figure shows.
1622 (@bullet{}) @strong{Exercise 1.}  (This tutorial will include exercises
1623 at various points.  Try them if you wish.  Answers to all the exercises
1624 are located at the end of the Tutorial chapter.  Each exercise will
1625 include a cross-reference to its particular answer.  If you are
1626 reading with the Emacs Info system, press @kbd{f} and the
1627 exercise number to go to the answer, then the letter @kbd{l} to
1628 return to where you were.)
1630 @noindent
1631 Here's the first exercise:  What will the keystrokes @kbd{1 @key{RET} 2
1632 @key{RET} 3 @key{RET} 4 + * -} compute?  (@samp{*} is the symbol for
1633 multiplication.)  Figure it out by hand, then try it with Calc to see
1634 if you're right.  @xref{RPN Answer 1, 1}. (@bullet{})
1636 (@bullet{}) @strong{Exercise 2.}  Compute @c{$(2\times4) + (7\times9.4) + {5\over4}$}
1637 @cite{2*4 + 7*9.5 + 5/4} using the
1638 stack.  @xref{RPN Answer 2, 2}. (@bullet{})
1640 The @key{DEL} key is called Backspace on some keyboards.  It is
1641 whatever key you would use to correct a simple typing error when
1642 regularly using Emacs.  The @key{DEL} key pops and throws away the
1643 top value on the stack.  (You can still get that value back from
1644 the Trail if you should need it later on.)  There are many places
1645 in this tutorial where we assume you have used @key{DEL} to erase the
1646 results of the previous example at the beginning of a new example.
1647 In the few places where it is really important to use @key{DEL} to
1648 clear away old results, the text will remind you to do so.
1650 (It won't hurt to let things accumulate on the stack, except that
1651 whenever you give a display-mode-changing command Calc will have to
1652 spend a long time reformatting such a large stack.)
1654 Since the @kbd{-} key is also an operator (it subtracts the top two
1655 stack elements), how does one enter a negative number?  Calc uses
1656 the @kbd{_} (underscore) key to act like the minus sign in a number.
1657 So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
1658 will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
1660 You can also press @kbd{n}, which means ``change sign.''  It changes
1661 the number at the top of the stack (or the number being entered)
1662 from positive to negative or vice-versa:  @kbd{5 n @key{RET}}.
1664 @cindex Duplicating a stack entry
1665 If you press @key{RET} when you're not entering a number, the effect
1666 is to duplicate the top number on the stack.  Consider this calculation:
1668 @smallexample
1669 @group
1670 1:  3          2:  3          1:  9          2:  9          1:  81
1671     .          1:  3              .          1:  9              .
1672                    .                             .
1674   3 @key{RET}           @key{RET}             *             @key{RET}             *
1675 @end group
1676 @end smallexample
1678 @noindent
1679 (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
1680 to raise 3 to the fourth power.)
1682 The space-bar key (denoted @key{SPC} here) performs the same function
1683 as @key{RET}; you could replace all three occurrences of @key{RET} in
1684 the above example with @key{SPC} and the effect would be the same.
1686 @cindex Exchanging stack entries
1687 Another stack manipulation key is @key{TAB}.  This exchanges the top
1688 two stack entries.  Suppose you have computed @kbd{2 @key{RET} 3 +}
1689 to get 5, and then you realize what you really wanted to compute
1690 was @cite{20 / (2+3)}.
1692 @smallexample
1693 @group
1694 1:  5          2:  5          2:  20         1:  4
1695     .          1:  20         1:  5              .
1696                    .              .
1698  2 @key{RET} 3 +         20            @key{TAB}             /
1699 @end group
1700 @end smallexample
1702 @noindent
1703 Planning ahead, the calculation would have gone like this:
1705 @smallexample
1706 @group
1707 1:  20         2:  20         3:  20         2:  20         1:  4
1708     .          1:  2          2:  2          1:  5              .
1709                    .          1:  3              .
1710                                   .
1712   20 @key{RET}         2 @key{RET}            3              +              /
1713 @end group
1714 @end smallexample
1716 A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
1717 @key{TAB}).  It rotates the top three elements of the stack upward,
1718 bringing the object in level 3 to the top.
1720 @smallexample
1721 @group
1722 1:  10         2:  10         3:  10         3:  20         3:  30
1723     .          1:  20         2:  20         2:  30         2:  10
1724                    .          1:  30         1:  10         1:  20
1725                                   .              .              .
1727   10 @key{RET}         20 @key{RET}         30 @key{RET}         M-@key{TAB}          M-@key{TAB}
1728 @end group
1729 @end smallexample
1731 (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
1732 on the stack.  Figure out how to add one to the number in level 2
1733 without affecting the rest of the stack.  Also figure out how to add
1734 one to the number in level 3.  @xref{RPN Answer 3, 3}. (@bullet{})
1736 Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
1737 arguments from the stack and push a result.  Operations like @kbd{n} and
1738 @kbd{Q} (square root) pop a single number and push the result.  You can
1739 think of them as simply operating on the top element of the stack.
1741 @smallexample
1742 @group
1743 1:  3          1:  9          2:  9          1:  25         1:  5
1744     .              .          1:  16             .              .
1745                                   .
1747   3 @key{RET}          @key{RET} *        4 @key{RET} @key{RET} *        +              Q
1748 @end group
1749 @end smallexample
1751 @noindent
1752 (Note that capital @kbd{Q} means to hold down the Shift key while
1753 typing @kbd{q}.  Remember, plain unshifted @kbd{q} is the Quit command.)
1755 @cindex Pythagorean Theorem
1756 Here we've used the Pythagorean Theorem to determine the hypotenuse of a
1757 right triangle.  Calc actually has a built-in command for that called
1758 @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
1759 We can still enter it by its full name using @kbd{M-x} notation:
1761 @smallexample
1762 @group
1763 1:  3          2:  3          1:  5
1764     .          1:  4              .
1765                    .
1767   3 @key{RET}          4 @key{RET}      M-x calc-hypot
1768 @end group
1769 @end smallexample
1771 All Calculator commands begin with the word @samp{calc-}.  Since it
1772 gets tiring to type this, Calc provides an @kbd{x} key which is just
1773 like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
1774 prefix for you:
1776 @smallexample
1777 @group
1778 1:  3          2:  3          1:  5
1779     .          1:  4              .
1780                    .
1782   3 @key{RET}          4 @key{RET}         x hypot
1783 @end group
1784 @end smallexample
1786 What happens if you take the square root of a negative number?
1788 @smallexample
1789 @group
1790 1:  4          1:  -4         1:  (0, 2)
1791     .              .              .
1793   4 @key{RET}            n              Q
1794 @end group
1795 @end smallexample
1797 @noindent
1798 The notation @cite{(a, b)} represents a complex number.
1799 Complex numbers are more traditionally written @c{$a + b i$}
1800 @cite{a + b i};
1801 Calc can display in this format, too, but for now we'll stick to the
1802 @cite{(a, b)} notation.
1804 If you don't know how complex numbers work, you can safely ignore this
1805 feature.  Complex numbers only arise from operations that would be
1806 errors in a calculator that didn't have complex numbers.  (For example,
1807 taking the square root or logarithm of a negative number produces a
1808 complex result.)
1810 Complex numbers are entered in the notation shown.  The @kbd{(} and
1811 @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
1813 @smallexample
1814 @group
1815 1:  ( ...      2:  ( ...      1:  (2, ...    1:  (2, ...    1:  (2, 3)
1816     .          1:  2              .              3              .
1817                    .                             .
1819     (              2              ,              3              )
1820 @end group
1821 @end smallexample
1823 You can perform calculations while entering parts of incomplete objects.
1824 However, an incomplete object cannot actually participate in a calculation:
1826 @smallexample
1827 @group
1828 1:  ( ...      2:  ( ...      3:  ( ...      1:  ( ...      1:  ( ...
1829     .          1:  2          2:  2              5              5
1830                    .          1:  3              .              .
1831                                   .
1832                                                              (error)
1833     (             2 @key{RET}           3              +              +
1834 @end group
1835 @end smallexample
1837 @noindent
1838 Adding 5 to an incomplete object makes no sense, so the last command
1839 produces an error message and leaves the stack the same.
1841 Incomplete objects can't participate in arithmetic, but they can be
1842 moved around by the regular stack commands.
1844 @smallexample
1845 @group
1846 2:  2          3:  2          3:  3          1:  ( ...      1:  (2, 3)
1847 1:  3          2:  3          2:  ( ...          2              .
1848     .          1:  ( ...      1:  2              3
1849                    .              .              .
1851 2 @key{RET} 3 @key{RET}        (            M-@key{TAB}          M-@key{TAB}            )
1852 @end group
1853 @end smallexample
1855 @noindent
1856 Note that the @kbd{,} (comma) key did not have to be used here.
1857 When you press @kbd{)} all the stack entries between the incomplete
1858 entry and the top are collected, so there's never really a reason
1859 to use the comma.  It's up to you.
1861 (@bullet{}) @strong{Exercise 4.}  To enter the complex number @cite{(2, 3)},
1862 your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}.  What happened?
1863 (Joe thought of a clever way to correct his mistake in only two
1864 keystrokes, but it didn't quite work.  Try it to find out why.)
1865 @xref{RPN Answer 4, 4}. (@bullet{})
1867 Vectors are entered the same way as complex numbers, but with square
1868 brackets in place of parentheses.  We'll meet vectors again later in
1869 the tutorial.
1871 Any Emacs command can be given a @dfn{numeric prefix argument} by
1872 typing a series of @key{META}-digits beforehand.  If @key{META} is
1873 awkward for you, you can instead type @kbd{C-u} followed by the
1874 necessary digits.  Numeric prefix arguments can be negative, as in
1875 @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}.  Calc commands use numeric
1876 prefix arguments in a variety of ways.  For example, a numeric prefix
1877 on the @kbd{+} operator adds any number of stack entries at once:
1879 @smallexample
1880 @group
1881 1:  10         2:  10         3:  10         3:  10         1:  60
1882     .          1:  20         2:  20         2:  20             .
1883                    .          1:  30         1:  30
1884                                   .              .
1886   10 @key{RET}         20 @key{RET}         30 @key{RET}         C-u 3            +
1887 @end group
1888 @end smallexample
1890 For stack manipulation commands like @key{RET}, a positive numeric
1891 prefix argument operates on the top @var{n} stack entries at once.  A
1892 negative argument operates on the entry in level @var{n} only.  An
1893 argument of zero operates on the entire stack.  In this example, we copy
1894 the second-to-top element of the stack:
1896 @smallexample
1897 @group
1898 1:  10         2:  10         3:  10         3:  10         4:  10
1899     .          1:  20         2:  20         2:  20         3:  20
1900                    .          1:  30         1:  30         2:  30
1901                                   .              .          1:  20
1902                                                                 .
1904   10 @key{RET}         20 @key{RET}         30 @key{RET}         C-u -2          @key{RET}
1905 @end group
1906 @end smallexample
1908 @cindex Clearing the stack
1909 @cindex Emptying the stack
1910 Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
1911 (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
1912 entire stack.)
1914 @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
1915 @subsection Algebraic-Style Calculations
1917 @noindent
1918 If you are not used to RPN notation, you may prefer to operate the
1919 Calculator in ``algebraic mode,'' which is closer to the way
1920 non-RPN calculators work.  In algebraic mode, you enter formulas
1921 in traditional @cite{2+3} notation.
1923 You don't really need any special ``mode'' to enter algebraic formulas.
1924 You can enter a formula at any time by pressing the apostrophe (@kbd{'})
1925 key.  Answer the prompt with the desired formula, then press @key{RET}.
1926 The formula is evaluated and the result is pushed onto the RPN stack.
1927 If you don't want to think in RPN at all, you can enter your whole
1928 computation as a formula, read the result from the stack, then press
1929 @key{DEL} to delete it from the stack.
1931 Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
1932 The result should be the number 9.
1934 Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
1935 @samp{/}, and @samp{^}.  You can use parentheses to make the order
1936 of evaluation clear.  In the absence of parentheses, @samp{^} is
1937 evaluated first, then @samp{*}, then @samp{/}, then finally
1938 @samp{+} and @samp{-}.  For example, the expression
1940 @example
1941 2 + 3*4*5 / 6*7^8 - 9
1942 @end example
1944 @noindent
1945 is equivalent to
1947 @example
1948 2 + ((3*4*5) / (6*(7^8)) - 9
1949 @end example
1951 @noindent
1952 or, in large mathematical notation,
1954 @ifinfo
1955 @example
1956 @group
1957     3 * 4 * 5
1958 2 + --------- - 9
1959           8
1960      6 * 7
1961 @end group
1962 @end example
1963 @end ifinfo
1964 @tex
1965 \turnoffactive
1966 \beforedisplay
1967 $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
1968 \afterdisplay
1969 @end tex
1971 @noindent
1972 The result of this expression will be the number @i{-6.99999826533}.
1974 Calc's order of evaluation is the same as for most computer languages,
1975 except that @samp{*} binds more strongly than @samp{/}, as the above
1976 example shows.  As in normal mathematical notation, the @samp{*} symbol
1977 can often be omitted:  @samp{2 a} is the same as @samp{2*a}.
1979 Operators at the same level are evaluated from left to right, except
1980 that @samp{^} is evaluated from right to left.  Thus, @samp{2-3-4} is
1981 equivalent to @samp{(2-3)-4} or @i{-5}, whereas @samp{2^3^4} is equivalent
1982 to @samp{2^(3^4)} (a very large integer; try it!).
1984 If you tire of typing the apostrophe all the time, there is an
1985 ``algebraic mode'' you can select in which Calc automatically senses
1986 when you are about to type an algebraic expression.  To enter this
1987 mode, press the two letters @w{@kbd{m a}}.  (An @samp{Alg} indicator
1988 should appear in the Calc window's mode line.)
1990 Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
1992 In algebraic mode, when you press any key that would normally begin
1993 entering a number (such as a digit, a decimal point, or the @kbd{_}
1994 key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
1995 an algebraic entry.
1997 Functions which do not have operator symbols like @samp{+} and @samp{*}
1998 must be entered in formulas using function-call notation.  For example,
1999 the function name corresponding to the square-root key @kbd{Q} is
2000 @code{sqrt}.  To compute a square root in a formula, you would use
2001 the notation @samp{sqrt(@var{x})}.
2003 Press the apostrophe, then type @kbd{sqrt(5*2) - 3}.  The result should
2004 be @cite{0.16227766017}.
2006 Note that if the formula begins with a function name, you need to use
2007 the apostrophe even if you are in algebraic mode.  If you type @kbd{arcsin}
2008 out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
2009 command, and the @kbd{csin} will be taken as the name of the rewrite
2010 rule to use!
2012 Some people prefer to enter complex numbers and vectors in algebraic
2013 form because they find RPN entry with incomplete objects to be too
2014 distracting, even though they otherwise use Calc as an RPN calculator.
2016 Still in algebraic mode, type:
2018 @smallexample
2019 @group
2020 1:  (2, 3)     2:  (2, 3)     1:  (8, -1)    2:  (8, -1)    1:  (9, -1)
2021     .          1:  (1, -2)        .          1:  1              .
2022                    .                             .
2024  (2,3) @key{RET}      (1,-2) @key{RET}        *              1 @key{RET}          +
2025 @end group
2026 @end smallexample
2028 Algebraic mode allows us to enter complex numbers without pressing
2029 an apostrophe first, but it also means we need to press @key{RET}
2030 after every entry, even for a simple number like @cite{1}.
2032 (You can type @kbd{C-u m a} to enable a special ``incomplete algebraic
2033 mode'' in which the @kbd{(} and @kbd{[} keys use algebraic entry even
2034 though regular numeric keys still use RPN numeric entry.  There is also
2035 a ``total algebraic mode,'' started by typing @kbd{m t}, in which all
2036 normal keys begin algebraic entry.  You must then use the @key{META} key
2037 to type Calc commands:  @kbd{M-m t} to get back out of total algebraic
2038 mode, @kbd{M-q} to quit, etc.  Total algebraic mode is not supported
2039 under Emacs 19.)
2041 If you're still in algebraic mode, press @kbd{m a} again to turn it off.
2043 Actual non-RPN calculators use a mixture of algebraic and RPN styles.
2044 In general, operators of two numbers (like @kbd{+} and @kbd{*})
2045 use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
2046 use RPN form.  Also, a non-RPN calculator allows you to see the
2047 intermediate results of a calculation as you go along.  You can
2048 accomplish this in Calc by performing your calculation as a series
2049 of algebraic entries, using the @kbd{$} sign to tie them together.
2050 In an algebraic formula, @kbd{$} represents the number on the top
2051 of the stack.  Here, we perform the calculation @c{$\sqrt{2\times4+1}$}
2052 @cite{sqrt(2*4+1)},
2053 which on a traditional calculator would be done by pressing
2054 @kbd{2 * 4 + 1 =} and then the square-root key.
2056 @smallexample
2057 @group
2058 1:  8          1:  9          1:  3
2059     .              .              .
2061   ' 2*4 @key{RET}        $+1 @key{RET}        Q
2062 @end group
2063 @end smallexample
2065 @noindent
2066 Notice that we didn't need to press an apostrophe for the @kbd{$+1},
2067 because the dollar sign always begins an algebraic entry.
2069 (@bullet{}) @strong{Exercise 1.}  How could you get the same effect as
2070 pressing @kbd{Q} but using an algebraic entry instead?  How about
2071 if the @kbd{Q} key on your keyboard were broken?
2072 @xref{Algebraic Answer 1, 1}. (@bullet{})
2074 The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
2075 entries.  For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
2077 Algebraic formulas can include @dfn{variables}.  To store in a
2078 variable, press @kbd{s s}, then type the variable name, then press
2079 @key{RET}.  (There are actually two flavors of store command:
2080 @kbd{s s} stores a number in a variable but also leaves the number
2081 on the stack, while @w{@kbd{s t}} removes a number from the stack and
2082 stores it in the variable.)  A variable name should consist of one
2083 or more letters or digits, beginning with a letter.
2085 @smallexample
2086 @group
2087 1:  17             .          1:  a + a^2    1:  306
2088     .                             .              .
2090     17          s t a @key{RET}      ' a+a^2 @key{RET}       =
2091 @end group
2092 @end smallexample
2094 @noindent
2095 The @kbd{=} key @dfn{evaluates} a formula by replacing all its
2096 variables by the values that were stored in them.
2098 For RPN calculations, you can recall a variable's value on the
2099 stack either by entering its name as a formula and pressing @kbd{=},
2100 or by using the @kbd{s r} command.
2102 @smallexample
2103 @group
2104 1:  17         2:  17         3:  17         2:  17         1:  306
2105     .          1:  17         2:  17         1:  289            .
2106                    .          1:  2              .
2107                                   .
2109   s r a @key{RET}     ' a @key{RET} =         2              ^              +
2110 @end group
2111 @end smallexample
2113 If you press a single digit for a variable name (as in @kbd{s t 3}, you
2114 get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
2115 They are ``quick'' simply because you don't have to type the letter
2116 @code{q} or the @key{RET} after their names.  In fact, you can type
2117 simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
2118 @kbd{t 3} and @w{@kbd{r 3}}.
2120 Any variables in an algebraic formula for which you have not stored
2121 values are left alone, even when you evaluate the formula.
2123 @smallexample
2124 @group
2125 1:  2 a + 2 b     1:  34 + 2 b
2126     .                 .
2128  ' 2a+2b @key{RET}          =
2129 @end group
2130 @end smallexample
2132 Calls to function names which are undefined in Calc are also left
2133 alone, as are calls for which the value is undefined.
2135 @smallexample
2136 @group
2137 1:  2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
2138     .
2140  ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
2141 @end group
2142 @end smallexample
2144 @noindent
2145 In this example, the first call to @code{log10} works, but the other
2146 calls are not evaluated.  In the second call, the logarithm is
2147 undefined for that value of the argument; in the third, the argument
2148 is symbolic, and in the fourth, there are too many arguments.  In the
2149 fifth case, there is no function called @code{foo}.  You will see a
2150 ``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
2151 Press the @kbd{w} (``why'') key to see any other messages that may
2152 have arisen from the last calculation.  In this case you will get
2153 ``logarithm of zero,'' then ``number expected: @code{x}''.  Calc
2154 automatically displays the first message only if the message is
2155 sufficiently important; for example, Calc considers ``wrong number
2156 of arguments'' and ``logarithm of zero'' to be important enough to
2157 report automatically, while a message like ``number expected: @code{x}''
2158 will only show up if you explicitly press the @kbd{w} key.
2160 (@bullet{}) @strong{Exercise 2.}  Joe entered the formula @samp{2 x y},
2161 stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
2162 @samp{10 y}.  He then tried the same for the formula @samp{2 x (1+y)},
2163 expecting @samp{10 (1+y)}, but it didn't work.  Why not?
2164 @xref{Algebraic Answer 2, 2}. (@bullet{})
2166 (@bullet{}) @strong{Exercise 3.}  What result would you expect
2167 @kbd{1 @key{RET} 0 /} to give?  What if you then type @kbd{0 *}?
2168 @xref{Algebraic Answer 3, 3}. (@bullet{})
2170 One interesting way to work with variables is to use the
2171 @dfn{evaluates-to} (@samp{=>}) operator.  It works like this:
2172 Enter a formula algebraically in the usual way, but follow
2173 the formula with an @samp{=>} symbol.  (There is also an @kbd{s =}
2174 command which builds an @samp{=>} formula using the stack.)  On
2175 the stack, you will see two copies of the formula with an @samp{=>}
2176 between them.  The lefthand formula is exactly like you typed it;
2177 the righthand formula has been evaluated as if by typing @kbd{=}.
2179 @smallexample
2180 @group
2181 2:  2 + 3 => 5                     2:  2 + 3 => 5
2182 1:  2 a + 2 b => 34 + 2 b          1:  2 a + 2 b => 20 + 2 b
2183     .                                  .
2185 ' 2+3 => @key{RET}  ' 2a+2b @key{RET} s =          10 s t a @key{RET}
2186 @end group
2187 @end smallexample
2189 @noindent
2190 Notice that the instant we stored a new value in @code{a}, all
2191 @samp{=>} operators already on the stack that referred to @cite{a}
2192 were updated to use the new value.  With @samp{=>}, you can push a
2193 set of formulas on the stack, then change the variables experimentally
2194 to see the effects on the formulas' values.
2196 You can also ``unstore'' a variable when you are through with it:
2198 @smallexample
2199 @group
2200 2:  2 + 5 => 5
2201 1:  2 a + 2 b => 2 a + 2 b
2202     .
2204     s u a @key{RET}
2205 @end group
2206 @end smallexample
2208 We will encounter formulas involving variables and functions again
2209 when we discuss the algebra and calculus features of the Calculator.
2211 @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
2212 @subsection Undo and Redo
2214 @noindent
2215 If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
2216 the ``undo'' command.  First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
2217 and restart Calc (@kbd{M-# M-# M-# M-#}) to make sure things start off
2218 with a clean slate.  Now:
2220 @smallexample
2221 @group
2222 1:  2          2:  2          1:  8          2:  2          1:  6
2223     .          1:  3              .          1:  3              .
2224                    .                             .
2226    2 @key{RET}           3              ^              U              *
2227 @end group
2228 @end smallexample
2230 You can undo any number of times.  Calc keeps a complete record of
2231 all you have done since you last opened the Calc window.  After the
2232 above example, you could type:
2234 @smallexample
2235 @group
2236 1:  6          2:  2          1:  2              .              .
2237     .          1:  3              .
2238                    .
2239                                                              (error)
2240                    U              U              U              U
2241 @end group
2242 @end smallexample
2244 You can also type @kbd{D} to ``redo'' a command that you have undone
2245 mistakenly.
2247 @smallexample
2248 @group
2249     .          1:  2          2:  2          1:  6          1:  6
2250                    .          1:  3              .              .
2251                                   .
2252                                                              (error)
2253                    D              D              D              D
2254 @end group
2255 @end smallexample
2257 @noindent
2258 It was not possible to redo past the @cite{6}, since that was placed there
2259 by something other than an undo command.
2261 @cindex Time travel
2262 You can think of undo and redo as a sort of ``time machine.''  Press
2263 @kbd{U} to go backward in time, @kbd{D} to go forward.  If you go
2264 backward and do something (like @kbd{*}) then, as any science fiction
2265 reader knows, you have changed your future and you cannot go forward
2266 again.  Thus, the inability to redo past the @cite{6} even though there
2267 was an earlier undo command.
2269 You can always recall an earlier result using the Trail.  We've ignored
2270 the trail so far, but it has been faithfully recording everything we
2271 did since we loaded the Calculator.  If the Trail is not displayed,
2272 press @kbd{t d} now to turn it on.
2274 Let's try grabbing an earlier result.  The @cite{8} we computed was
2275 undone by a @kbd{U} command, and was lost even to Redo when we pressed
2276 @kbd{*}, but it's still there in the trail.  There should be a little
2277 @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
2278 entry.  If there isn't, press @kbd{t ]} to reset the trail pointer.
2279 Now, press @w{@kbd{t p}} to move the arrow onto the line containing
2280 @cite{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
2281 stack.
2283 If you press @kbd{t ]} again, you will see that even our Yank command
2284 went into the trail.
2286 Let's go further back in time.  Earlier in the tutorial we computed
2287 a huge integer using the formula @samp{2^3^4}.  We don't remember
2288 what it was, but the first digits were ``241''.  Press @kbd{t r}
2289 (which stands for trail-search-reverse), then type @kbd{241}.
2290 The trail cursor will jump back to the next previous occurrence of
2291 the string ``241'' in the trail.  This is just a regular Emacs
2292 incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
2293 continue the search forwards or backwards as you like.
2295 To finish the search, press @key{RET}.  This halts the incremental
2296 search and leaves the trail pointer at the thing we found.  Now we
2297 can type @kbd{t y} to yank that number onto the stack.  If we hadn't
2298 remembered the ``241'', we could simply have searched for @kbd{2^3^4},
2299 then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
2301 You may have noticed that all the trail-related commands begin with
2302 the letter @kbd{t}.  (The store-and-recall commands, on the other hand,
2303 all began with @kbd{s}.)  Calc has so many commands that there aren't
2304 enough keys for all of them, so various commands are grouped into
2305 two-letter sequences where the first letter is called the @dfn{prefix}
2306 key.  If you type a prefix key by accident, you can press @kbd{C-g}
2307 to cancel it.  (In fact, you can press @kbd{C-g} to cancel almost
2308 anything in Emacs.)  To get help on a prefix key, press that key
2309 followed by @kbd{?}.  Some prefixes have several lines of help,
2310 so you need to press @kbd{?} repeatedly to see them all.  This may
2311 not work under Lucid Emacs, but you can also type @kbd{h h} to
2312 see all the help at once.
2314 Try pressing @kbd{t ?} now.  You will see a line of the form,
2316 @smallexample
2317 trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank:  [MORE]  t-
2318 @end smallexample
2320 @noindent
2321 The word ``trail'' indicates that the @kbd{t} prefix key contains
2322 trail-related commands.  Each entry on the line shows one command,
2323 with a single capital letter showing which letter you press to get
2324 that command.  We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
2325 @kbd{t y} so far.  The @samp{[MORE]} means you can press @kbd{?}
2326 again to see more @kbd{t}-prefix commands.  Notice that the commands
2327 are roughly divided (by semicolons) into related groups.
2329 When you are in the help display for a prefix key, the prefix is
2330 still active.  If you press another key, like @kbd{y} for example,
2331 it will be interpreted as a @kbd{t y} command.  If all you wanted
2332 was to look at the help messages, press @kbd{C-g} afterwards to cancel
2333 the prefix.
2335 One more way to correct an error is by editing the stack entries.
2336 The actual Stack buffer is marked read-only and must not be edited
2337 directly, but you can press @kbd{`} (the backquote or accent grave)
2338 to edit a stack entry.
2340 Try entering @samp{3.141439} now.  If this is supposed to represent
2341 @c{$\pi$}
2342 @cite{pi}, it's got several errors.  Press @kbd{`} to edit this number.
2343 Now use the normal Emacs cursor motion and editing keys to change
2344 the second 4 to a 5, and to transpose the 3 and the 9.  When you
2345 press @key{RET}, the number on the stack will be replaced by your
2346 new number.  This works for formulas, vectors, and all other types
2347 of values you can put on the stack.  The @kbd{`} key also works
2348 during entry of a number or algebraic formula.
2350 @node Modes Tutorial, , Undo Tutorial, Basic Tutorial
2351 @subsection Mode-Setting Commands
2353 @noindent
2354 Calc has many types of @dfn{modes} that affect the way it interprets
2355 your commands or the way it displays data.  We have already seen one
2356 mode, namely algebraic mode.  There are many others, too; we'll
2357 try some of the most common ones here.
2359 Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
2360 Notice the @samp{12} on the Calc window's mode line:
2362 @smallexample
2363 --%%-Calc: 12 Deg       (Calculator)----All------
2364 @end smallexample
2366 @noindent
2367 Most of the symbols there are Emacs things you don't need to worry
2368 about, but the @samp{12} and the @samp{Deg} are mode indicators.
2369 The @samp{12} means that calculations should always be carried to
2370 12 significant figures.  That is why, when we type @kbd{1 @key{RET} 7 /},
2371 we get @cite{0.142857142857} with exactly 12 digits, not counting
2372 leading and trailing zeros.
2374 You can set the precision to anything you like by pressing @kbd{p},
2375 then entering a suitable number.  Try pressing @kbd{p 30 @key{RET}},
2376 then doing @kbd{1 @key{RET} 7 /} again:
2378 @smallexample
2379 @group
2380 1:  0.142857142857
2381 2:  0.142857142857142857142857142857
2382     .
2383 @end group
2384 @end smallexample
2386 Although the precision can be set arbitrarily high, Calc always
2387 has to have @emph{some} value for the current precision.  After
2388 all, the true value @cite{1/7} is an infinitely repeating decimal;
2389 Calc has to stop somewhere.
2391 Of course, calculations are slower the more digits you request.
2392 Press @w{@kbd{p 12}} now to set the precision back down to the default.
2394 Calculations always use the current precision.  For example, even
2395 though we have a 30-digit value for @cite{1/7} on the stack, if
2396 we use it in a calculation in 12-digit mode it will be rounded
2397 down to 12 digits before it is used.  Try it; press @key{RET} to
2398 duplicate the number, then @w{@kbd{1 +}}.  Notice that the @key{RET}
2399 key didn't round the number, because it doesn't do any calculation.
2400 But the instant we pressed @kbd{+}, the number was rounded down.
2402 @smallexample
2403 @group
2404 1:  0.142857142857
2405 2:  0.142857142857142857142857142857
2406 3:  1.14285714286
2407     .
2408 @end group
2409 @end smallexample
2411 @noindent
2412 In fact, since we added a digit on the left, we had to lose one
2413 digit on the right from even the 12-digit value of @cite{1/7}.
2415 How did we get more than 12 digits when we computed @samp{2^3^4}?  The
2416 answer is that Calc makes a distinction between @dfn{integers} and
2417 @dfn{floating-point} numbers, or @dfn{floats}.  An integer is a number
2418 that does not contain a decimal point.  There is no such thing as an
2419 ``infinitely repeating fraction integer,'' so Calc doesn't have to limit
2420 itself.  If you asked for @samp{2^10000} (don't try this!), you would
2421 have to wait a long time but you would eventually get an exact answer.
2422 If you ask for @samp{2.^10000}, you will quickly get an answer which is
2423 correct only to 12 places.  The decimal point tells Calc that it should
2424 use floating-point arithmetic to get the answer, not exact integer
2425 arithmetic.
2427 You can use the @kbd{F} (@code{calc-floor}) command to convert a
2428 floating-point value to an integer, and @kbd{c f} (@code{calc-float})
2429 to convert an integer to floating-point form.
2431 Let's try entering that last calculation:
2433 @smallexample
2434 @group
2435 1:  2.         2:  2.         1:  1.99506311689e3010
2436     .          1:  10000          .
2437                    .
2439   2.0 @key{RET}          10000 @key{RET}      ^
2440 @end group
2441 @end smallexample
2443 @noindent
2444 @cindex Scientific notation, entry of
2445 Notice the letter @samp{e} in there.  It represents ``times ten to the
2446 power of,'' and is used by Calc automatically whenever writing the
2447 number out fully would introduce more extra zeros than you probably
2448 want to see.  You can enter numbers in this notation, too.
2450 @smallexample
2451 @group
2452 1:  2.         2:  2.         1:  1.99506311678e3010
2453     .          1:  10000.         .
2454                    .
2456   2.0 @key{RET}          1e4 @key{RET}        ^
2457 @end group
2458 @end smallexample
2460 @cindex Round-off errors
2461 @noindent
2462 Hey, the answer is different!  Look closely at the middle columns
2463 of the two examples.  In the first, the stack contained the
2464 exact integer @cite{10000}, but in the second it contained
2465 a floating-point value with a decimal point.  When you raise a
2466 number to an integer power, Calc uses repeated squaring and
2467 multiplication to get the answer.  When you use a floating-point
2468 power, Calc uses logarithms and exponentials.  As you can see,
2469 a slight error crept in during one of these methods.  Which
2470 one should we trust?  Let's raise the precision a bit and find
2471 out:
2473 @smallexample
2474 @group
2475     .          1:  2.         2:  2.         1:  1.995063116880828e3010
2476                    .          1:  10000.         .
2477                                   .
2479  p 16 @key{RET}        2. @key{RET}           1e4            ^    p 12 @key{RET}
2480 @end group
2481 @end smallexample
2483 @noindent
2484 @cindex Guard digits
2485 Presumably, it doesn't matter whether we do this higher-precision
2486 calculation using an integer or floating-point power, since we
2487 have added enough ``guard digits'' to trust the first 12 digits
2488 no matter what.  And the verdict is@dots{}  Integer powers were more
2489 accurate; in fact, the result was only off by one unit in the
2490 last place.
2492 @cindex Guard digits
2493 Calc does many of its internal calculations to a slightly higher
2494 precision, but it doesn't always bump the precision up enough.
2495 In each case, Calc added about two digits of precision during
2496 its calculation and then rounded back down to 12 digits
2497 afterward.  In one case, it was enough; in the other, it
2498 wasn't.  If you really need @var{x} digits of precision, it
2499 never hurts to do the calculation with a few extra guard digits.
2501 What if we want guard digits but don't want to look at them?
2502 We can set the @dfn{float format}.  Calc supports four major
2503 formats for floating-point numbers, called @dfn{normal},
2504 @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
2505 notation}.  You get them by pressing @w{@kbd{d n}}, @kbd{d f},
2506 @kbd{d s}, and @kbd{d e}, respectively.  In each case, you can
2507 supply a numeric prefix argument which says how many digits
2508 should be displayed.  As an example, let's put a few numbers
2509 onto the stack and try some different display modes.  First,
2510 use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
2511 numbers shown here:
2513 @smallexample
2514 @group
2515 4:  12345      4:  12345      4:  12345      4:  12345      4:  12345
2516 3:  12345.     3:  12300.     3:  1.2345e4   3:  1.23e4     3:  12345.000
2517 2:  123.45     2:  123.       2:  1.2345e2   2:  1.23e2     2:  123.450
2518 1:  12.345     1:  12.3       1:  1.2345e1   1:  1.23e1     1:  12.345
2519     .              .              .              .              .
2521    d n          M-3 d n          d s          M-3 d s        M-3 d f
2522 @end group
2523 @end smallexample
2525 @noindent
2526 Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
2527 to three significant digits, but then when we typed @kbd{d s} all
2528 five significant figures reappeared.  The float format does not
2529 affect how numbers are stored, it only affects how they are
2530 displayed.  Only the current precision governs the actual rounding
2531 of numbers in the Calculator's memory.
2533 Engineering notation, not shown here, is like scientific notation
2534 except the exponent (the power-of-ten part) is always adjusted to be
2535 a multiple of three (as in ``kilo,'' ``micro,'' etc.).  As a result
2536 there will be one, two, or three digits before the decimal point.
2538 Whenever you change a display-related mode, Calc redraws everything
2539 in the stack.  This may be slow if there are many things on the stack,
2540 so Calc allows you to type shift-@kbd{H} before any mode command to
2541 prevent it from updating the stack.  Anything Calc displays after the
2542 mode-changing command will appear in the new format.
2544 @smallexample
2545 @group
2546 4:  12345      4:  12345      4:  12345      4:  12345      4:  12345
2547 3:  12345.000  3:  12345.000  3:  12345.000  3:  1.2345e4   3:  12345.
2548 2:  123.450    2:  123.450    2:  1.2345e1   2:  1.2345e1   2:  123.45
2549 1:  12.345     1:  1.2345e1   1:  1.2345e2   1:  1.2345e2   1:  12.345
2550     .              .              .              .              .
2552     H d s          @key{DEL} U          @key{TAB}            d @key{SPC}          d n
2553 @end group
2554 @end smallexample
2556 @noindent
2557 Here the @kbd{H d s} command changes to scientific notation but without
2558 updating the screen.  Deleting the top stack entry and undoing it back
2559 causes it to show up in the new format; swapping the top two stack
2560 entries reformats both entries.  The @kbd{d @key{SPC}} command refreshes the
2561 whole stack.  The @kbd{d n} command changes back to the normal float
2562 format; since it doesn't have an @kbd{H} prefix, it also updates all
2563 the stack entries to be in @kbd{d n} format.
2565 Notice that the integer @cite{12345} was not affected by any
2566 of the float formats.  Integers are integers, and are always
2567 displayed exactly.
2569 @cindex Large numbers, readability
2570 Large integers have their own problems.  Let's look back at
2571 the result of @kbd{2^3^4}.
2573 @example
2574 2417851639229258349412352
2575 @end example
2577 @noindent
2578 Quick---how many digits does this have?  Try typing @kbd{d g}:
2580 @example
2581 2,417,851,639,229,258,349,412,352
2582 @end example
2584 @noindent
2585 Now how many digits does this have?  It's much easier to tell!
2586 We can actually group digits into clumps of any size.  Some
2587 people prefer @kbd{M-5 d g}:
2589 @example
2590 24178,51639,22925,83494,12352
2591 @end example
2593 Let's see what happens to floating-point numbers when they are grouped.
2594 First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
2595 to get ourselves into trouble.  Now, type @kbd{1e13 /}:
2597 @example
2598 24,17851,63922.9258349412352
2599 @end example
2601 @noindent
2602 The integer part is grouped but the fractional part isn't.  Now try
2603 @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
2605 @example
2606 24,17851,63922.92583,49412,352
2607 @end example
2609 If you find it hard to tell the decimal point from the commas, try
2610 changing the grouping character to a space with @kbd{d , @key{SPC}}:
2612 @example
2613 24 17851 63922.92583 49412 352
2614 @end example
2616 Type @kbd{d , ,} to restore the normal grouping character, then
2617 @kbd{d g} again to turn grouping off.  Also, press @kbd{p 12} to
2618 restore the default precision.
2620 Press @kbd{U} enough times to get the original big integer back.
2621 (Notice that @kbd{U} does not undo each mode-setting command; if
2622 you want to undo a mode-setting command, you have to do it yourself.)
2623 Now, type @kbd{d r 16 @key{RET}}:
2625 @example
2626 16#200000000000000000000
2627 @end example
2629 @noindent
2630 The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
2631 Suddenly it looks pretty simple; this should be no surprise, since we
2632 got this number by computing a power of two, and 16 is a power of 2.
2633 In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
2634 form:
2636 @example
2637 2#1000000000000000000000000000000000000000000000000000000 @dots{}
2638 @end example
2640 @noindent
2641 We don't have enough space here to show all the zeros!  They won't
2642 fit on a typical screen, either, so you will have to use horizontal
2643 scrolling to see them all.  Press @kbd{<} and @kbd{>} to scroll the
2644 stack window left and right by half its width.  Another way to view
2645 something large is to press @kbd{`} (back-quote) to edit the top of
2646 stack in a separate window.  (Press @kbd{M-# M-#} when you are done.)
2648 You can enter non-decimal numbers using the @kbd{#} symbol, too.
2649 Let's see what the hexadecimal number @samp{5FE} looks like in
2650 binary.  Type @kbd{16#5FE} (the letters can be typed in upper or
2651 lower case; they will always appear in upper case).  It will also
2652 help to turn grouping on with @kbd{d g}:
2654 @example
2655 2#101,1111,1110
2656 @end example
2658 Notice that @kbd{d g} groups by fours by default if the display radix
2659 is binary or hexadecimal, but by threes if it is decimal, octal, or any
2660 other radix.
2662 Now let's see that number in decimal; type @kbd{d r 10}:
2664 @example
2665 1,534
2666 @end example
2668 Numbers are not @emph{stored} with any particular radix attached.  They're
2669 just numbers; they can be entered in any radix, and are always displayed
2670 in whatever radix you've chosen with @kbd{d r}.  The current radix applies
2671 to integers, fractions, and floats.
2673 @cindex Roundoff errors, in non-decimal numbers
2674 (@bullet{}) @strong{Exercise 1.}  Your friend Joe tried to enter one-third
2675 as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12.  He got
2676 @samp{3#0.0222222...} (with 25 2's) in the display.  When he multiplied
2677 that by three, he got @samp{3#0.222222...} instead of the expected
2678 @samp{3#1}.  Next, Joe entered @samp{3#0.2} and, to his great relief,
2679 saw @samp{3#0.2} on the screen.  But when he typed @kbd{2 /}, he got
2680 @samp{3#0.10000001} (some zeros omitted).  What's going on here?
2681 @xref{Modes Answer 1, 1}. (@bullet{})
2683 @cindex Scientific notation, in non-decimal numbers
2684 (@bullet{}) @strong{Exercise 2.}  Scientific notation works in non-decimal
2685 modes in the natural way (the exponent is a power of the radix instead of
2686 a power of ten, although the exponent itself is always written in decimal).
2687 Thus @samp{8#1.23e3 = 8#1230.0}.  Suppose we have the hexadecimal number
2688 @samp{f.e8f} times 16 to the 15th power:  We write @samp{16#f.e8fe15}.
2689 What is wrong with this picture?  What could we write instead that would
2690 work better?  @xref{Modes Answer 2, 2}. (@bullet{})
2692 The @kbd{m} prefix key has another set of modes, relating to the way
2693 Calc interprets your inputs and does computations.  Whereas @kbd{d}-prefix
2694 modes generally affect the way things look, @kbd{m}-prefix modes affect
2695 the way they are actually computed.
2697 The most popular @kbd{m}-prefix mode is the @dfn{angular mode}.  Notice
2698 the @samp{Deg} indicator in the mode line.  This means that if you use
2699 a command that interprets a number as an angle, it will assume the
2700 angle is measured in degrees.  For example,
2702 @smallexample
2703 @group
2704 1:  45         1:  0.707106781187   1:  0.500000000001    1:  0.5
2705     .              .                    .                     .
2707     45             S                    2 ^                   c 1
2708 @end group
2709 @end smallexample
2711 @noindent
2712 The shift-@kbd{S} command computes the sine of an angle.  The sine
2713 of 45 degrees is @c{$\sqrt{2}/2$}
2714 @cite{sqrt(2)/2}; squaring this yields @cite{2/4 = 0.5}.
2715 However, there has been a slight roundoff error because the
2716 representation of @c{$\sqrt{2}/2$}
2717 @cite{sqrt(2)/2} wasn't exact.  The @kbd{c 1}
2718 command is a handy way to clean up numbers in this case; it
2719 temporarily reduces the precision by one digit while it
2720 re-rounds the number on the top of the stack.
2722 @cindex Roundoff errors, examples
2723 (@bullet{}) @strong{Exercise 3.}  Your friend Joe computed the sine
2724 of 45 degrees as shown above, then, hoping to avoid an inexact
2725 result, he increased the precision to 16 digits before squaring.
2726 What happened?  @xref{Modes Answer 3, 3}. (@bullet{})
2728 To do this calculation in radians, we would type @kbd{m r} first.
2729 (The indicator changes to @samp{Rad}.)  45 degrees corresponds to
2730 @c{$\pi\over4$}
2731 @cite{pi/4} radians.  To get @c{$\pi$}
2732 @cite{pi}, press the @kbd{P} key.  (Once
2733 again, this is a shifted capital @kbd{P}.  Remember, unshifted
2734 @kbd{p} sets the precision.)
2736 @smallexample
2737 @group
2738 1:  3.14159265359   1:  0.785398163398   1:  0.707106781187
2739     .                   .                .
2741     P                   4 /       m r    S
2742 @end group
2743 @end smallexample
2745 Likewise, inverse trigonometric functions generate results in
2746 either radians or degrees, depending on the current angular mode.
2748 @smallexample
2749 @group
2750 1:  0.707106781187   1:  0.785398163398   1:  45.
2751     .                    .                    .
2753     .5 Q        m r      I S        m d       U I S
2754 @end group
2755 @end smallexample
2757 @noindent
2758 Here we compute the Inverse Sine of @c{$\sqrt{0.5}$}
2759 @cite{sqrt(0.5)}, first in
2760 radians, then in degrees.
2762 Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
2763 and vice-versa.
2765 @smallexample
2766 @group
2767 1:  45         1:  0.785398163397     1:  45.
2768     .              .                      .
2770     45             c r                    c d
2771 @end group
2772 @end smallexample
2774 Another interesting mode is @dfn{fraction mode}.  Normally,
2775 dividing two integers produces a floating-point result if the
2776 quotient can't be expressed as an exact integer.  Fraction mode
2777 causes integer division to produce a fraction, i.e., a rational
2778 number, instead.
2780 @smallexample
2781 @group
2782 2:  12         1:  1.33333333333    1:  4:3
2783 1:  9              .                    .
2784     .
2786  12 @key{RET} 9          /          m f       U /      m f
2787 @end group
2788 @end smallexample
2790 @noindent
2791 In the first case, we get an approximate floating-point result.
2792 In the second case, we get an exact fractional result (four-thirds).
2794 You can enter a fraction at any time using @kbd{:} notation.
2795 (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
2796 because @kbd{/} is already used to divide the top two stack
2797 elements.)  Calculations involving fractions will always
2798 produce exact fractional results; fraction mode only says
2799 what to do when dividing two integers.
2801 @cindex Fractions vs. floats
2802 @cindex Floats vs. fractions
2803 (@bullet{}) @strong{Exercise 4.}  If fractional arithmetic is exact,
2804 why would you ever use floating-point numbers instead?
2805 @xref{Modes Answer 4, 4}. (@bullet{})
2807 Typing @kbd{m f} doesn't change any existing values in the stack.
2808 In the above example, we had to Undo the division and do it over
2809 again when we changed to fraction mode.  But if you use the
2810 evaluates-to operator you can get commands like @kbd{m f} to
2811 recompute for you.
2813 @smallexample
2814 @group
2815 1:  12 / 9 => 1.33333333333    1:  12 / 9 => 1.333    1:  12 / 9 => 4:3
2816     .                              .                      .
2818    ' 12/9 => @key{RET}                   p 4 @key{RET}                m f
2819 @end group
2820 @end smallexample
2822 @noindent
2823 In this example, the righthand side of the @samp{=>} operator
2824 on the stack is recomputed when we change the precision, then
2825 again when we change to fraction mode.  All @samp{=>} expressions
2826 on the stack are recomputed every time you change any mode that
2827 might affect their values.
2829 @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
2830 @section Arithmetic Tutorial
2832 @noindent
2833 In this section, we explore the arithmetic and scientific functions
2834 available in the Calculator.
2836 The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
2837 and @kbd{^}.  Each normally takes two numbers from the top of the stack
2838 and pushes back a result.  The @kbd{n} and @kbd{&} keys perform
2839 change-sign and reciprocal operations, respectively.
2841 @smallexample
2842 @group
2843 1:  5          1:  0.2        1:  5.         1:  -5.        1:  5.
2844     .              .              .              .              .
2846     5              &              &              n              n
2847 @end group
2848 @end smallexample
2850 @cindex Binary operators
2851 You can apply a ``binary operator'' like @kbd{+} across any number of
2852 stack entries by giving it a numeric prefix.  You can also apply it
2853 pairwise to several stack elements along with the top one if you use
2854 a negative prefix.
2856 @smallexample
2857 @group
2858 3:  2          1:  9          3:  2          4:  2          3:  12
2859 2:  3              .          2:  3          3:  3          2:  13
2860 1:  4                         1:  4          2:  4          1:  14
2861     .                             .          1:  10             .
2862                                                  .
2864 2 @key{RET} 3 @key{RET} 4     M-3 +           U              10          M-- M-3 +
2865 @end group
2866 @end smallexample
2868 @cindex Unary operators
2869 You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
2870 stack entries with a numeric prefix, too.
2872 @smallexample
2873 @group
2874 3:  2          3:  0.5                3:  0.5
2875 2:  3          2:  0.333333333333     2:  3.
2876 1:  4          1:  0.25               1:  4.
2877     .              .                      .
2879 2 @key{RET} 3 @key{RET} 4      M-3 &                  M-2 &
2880 @end group
2881 @end smallexample
2883 Notice that the results here are left in floating-point form.
2884 We can convert them back to integers by pressing @kbd{F}, the
2885 ``floor'' function.  This function rounds down to the next lower
2886 integer.  There is also @kbd{R}, which rounds to the nearest
2887 integer.
2889 @smallexample
2890 @group
2891 7:  2.         7:  2          7:  2
2892 6:  2.4        6:  2          6:  2
2893 5:  2.5        5:  2          5:  3
2894 4:  2.6        4:  2          4:  3
2895 3:  -2.        3:  -2         3:  -2
2896 2:  -2.4       2:  -3         2:  -2
2897 1:  -2.6       1:  -3         1:  -3
2898     .              .              .
2900                   M-7 F        U M-7 R
2901 @end group
2902 @end smallexample
2904 Since dividing-and-flooring (i.e., ``integer quotient'') is such a
2905 common operation, Calc provides a special command for that purpose, the
2906 backslash @kbd{\}.  Another common arithmetic operator is @kbd{%}, which
2907 computes the remainder that would arise from a @kbd{\} operation, i.e.,
2908 the ``modulo'' of two numbers.  For example,
2910 @smallexample
2911 @group
2912 2:  1234       1:  12         2:  1234       1:  34
2913 1:  100            .          1:  100            .
2914     .                             .
2916 1234 @key{RET} 100       \              U              %
2917 @end group
2918 @end smallexample
2920 These commands actually work for any real numbers, not just integers.
2922 @smallexample
2923 @group
2924 2:  3.1415     1:  3          2:  3.1415     1:  0.1415
2925 1:  1              .          1:  1              .
2926     .                             .
2928 3.1415 @key{RET} 1       \              U              %
2929 @end group
2930 @end smallexample
2932 (@bullet{}) @strong{Exercise 1.}  The @kbd{\} command would appear to be a
2933 frill, since you could always do the same thing with @kbd{/ F}.  Think
2934 of a situation where this is not true---@kbd{/ F} would be inadequate.
2935 Now think of a way you could get around the problem if Calc didn't
2936 provide a @kbd{\} command.  @xref{Arithmetic Answer 1, 1}. (@bullet{})
2938 We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
2939 commands.  Other commands along those lines are @kbd{C} (cosine),
2940 @kbd{T} (tangent), @kbd{E} (@cite{e^x}) and @kbd{L} (natural
2941 logarithm).  These can be modified by the @kbd{I} (inverse) and
2942 @kbd{H} (hyperbolic) prefix keys.
2944 Let's compute the sine and cosine of an angle, and verify the
2945 identity @c{$\sin^2x + \cos^2x = 1$}
2946 @cite{sin(x)^2 + cos(x)^2 = 1}.  We'll
2947 arbitrarily pick @i{-64} degrees as a good value for @cite{x}.  With
2948 the angular mode set to degrees (type @w{@kbd{m d}}), do:
2950 @smallexample
2951 @group
2952 2:  -64        2:  -64        2:  -0.89879   2:  -0.89879   1:  1.
2953 1:  -64        1:  -0.89879   1:  -64        1:  0.43837        .
2954     .              .              .              .
2956  64 n @key{RET} @key{RET}      S              @key{TAB}            C              f h
2957 @end group
2958 @end smallexample
2960 @noindent
2961 (For brevity, we're showing only five digits of the results here.
2962 You can of course do these calculations to any precision you like.)
2964 Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
2965 of squares, command.
2967 Another identity is @c{$\displaystyle\tan x = {\sin x \over \cos x}$}
2968 @cite{tan(x) = sin(x) / cos(x)}.
2969 @smallexample
2970 @group
2972 2:  -0.89879   1:  -2.0503    1:  -64.
2973 1:  0.43837        .              .
2974     .
2976     U              /              I T
2977 @end group
2978 @end smallexample
2980 A physical interpretation of this calculation is that if you move
2981 @cite{0.89879} units downward and @cite{0.43837} units to the right,
2982 your direction of motion is @i{-64} degrees from horizontal.  Suppose
2983 we move in the opposite direction, up and to the left:
2985 @smallexample
2986 @group
2987 2:  -0.89879   2:  0.89879    1:  -2.0503    1:  -64.
2988 1:  0.43837    1:  -0.43837       .              .
2989     .              .
2991     U U            M-2 n          /              I T
2992 @end group
2993 @end smallexample
2995 @noindent
2996 How can the angle be the same?  The answer is that the @kbd{/} operation
2997 loses information about the signs of its inputs.  Because the quotient
2998 is negative, we know exactly one of the inputs was negative, but we
2999 can't tell which one.  There is an @kbd{f T} [@code{arctan2}] function which
3000 computes the inverse tangent of the quotient of a pair of numbers.
3001 Since you feed it the two original numbers, it has enough information
3002 to give you a full 360-degree answer.
3004 @smallexample
3005 @group
3006 2:  0.89879    1:  116.       3:  116.       2:  116.       1:  180.
3007 1:  -0.43837       .          2:  -0.89879   1:  -64.           .
3008     .                         1:  0.43837        .
3009                                   .
3011     U U            f T         M-@key{RET} M-2 n       f T            -
3012 @end group
3013 @end smallexample
3015 @noindent
3016 The resulting angles differ by 180 degrees; in other words, they
3017 point in opposite directions, just as we would expect.
3019 The @key{META}-@key{RET} we used in the third step is the
3020 ``last-arguments'' command.  It is sort of like Undo, except that it
3021 restores the arguments of the last command to the stack without removing
3022 the command's result.  It is useful in situations like this one,
3023 where we need to do several operations on the same inputs.  We could
3024 have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
3025 the top two stack elements right after the @kbd{U U}, then a pair of
3026 @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
3028 A similar identity is supposed to hold for hyperbolic sines and cosines,
3029 except that it is the @emph{difference}
3030 @c{$\cosh^2x - \sinh^2x$}
3031 @cite{cosh(x)^2 - sinh(x)^2} that always equals one.
3032 Let's try to verify this identity.@refill
3034 @smallexample
3035 @group
3036 2:  -64        2:  -64        2:  -64        2:  9.7192e54  2:  9.7192e54
3037 1:  -64        1:  -3.1175e27 1:  9.7192e54  1:  -64        1:  9.7192e54
3038     .              .              .              .              .
3040  64 n @key{RET} @key{RET}      H C            2 ^            @key{TAB}            H S 2 ^
3041 @end group
3042 @end smallexample
3044 @noindent
3045 @cindex Roundoff errors, examples
3046 Something's obviously wrong, because when we subtract these numbers
3047 the answer will clearly be zero!  But if you think about it, if these
3048 numbers @emph{did} differ by one, it would be in the 55th decimal
3049 place.  The difference we seek has been lost entirely to roundoff
3050 error.
3052 We could verify this hypothesis by doing the actual calculation with,
3053 say, 60 decimal places of precision.  This will be slow, but not
3054 enormously so.  Try it if you wish; sure enough, the answer is
3055 0.99999, reasonably close to 1.
3057 Of course, a more reasonable way to verify the identity is to use
3058 a more reasonable value for @cite{x}!
3060 @cindex Common logarithm
3061 Some Calculator commands use the Hyperbolic prefix for other purposes.
3062 The logarithm and exponential functions, for example, work to the base
3063 @cite{e} normally but use base-10 instead if you use the Hyperbolic
3064 prefix.
3066 @smallexample
3067 @group
3068 1:  1000       1:  6.9077     1:  1000       1:  3
3069     .              .              .              .
3071     1000           L              U              H L
3072 @end group
3073 @end smallexample
3075 @noindent
3076 First, we mistakenly compute a natural logarithm.  Then we undo
3077 and compute a common logarithm instead.
3079 The @kbd{B} key computes a general base-@var{b} logarithm for any
3080 value of @var{b}.
3082 @smallexample
3083 @group
3084 2:  1000       1:  3          1:  1000.      2:  1000.      1:  6.9077
3085 1:  10             .              .          1:  2.71828        .
3086     .                                            .
3088  1000 @key{RET} 10       B              H E            H P            B
3089 @end group
3090 @end smallexample
3092 @noindent
3093 Here we first use @kbd{B} to compute the base-10 logarithm, then use
3094 the ``hyperbolic'' exponential as a cheap hack to recover the number
3095 1000, then use @kbd{B} again to compute the natural logarithm.  Note
3096 that @kbd{P} with the hyperbolic prefix pushes the constant @cite{e}
3097 onto the stack.
3099 You may have noticed that both times we took the base-10 logarithm
3100 of 1000, we got an exact integer result.  Calc always tries to give
3101 an exact rational result for calculations involving rational numbers
3102 where possible.  But when we used @kbd{H E}, the result was a
3103 floating-point number for no apparent reason.  In fact, if we had
3104 computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
3105 exact integer 1000.  But the @kbd{H E} command is rigged to generate
3106 a floating-point result all of the time so that @kbd{1000 H E} will
3107 not waste time computing a thousand-digit integer when all you
3108 probably wanted was @samp{1e1000}.
3110 (@bullet{}) @strong{Exercise 2.}  Find a pair of integer inputs to
3111 the @kbd{B} command for which Calc could find an exact rational
3112 result but doesn't.  @xref{Arithmetic Answer 2, 2}. (@bullet{})
3114 The Calculator also has a set of functions relating to combinatorics
3115 and statistics.  You may be familiar with the @dfn{factorial} function,
3116 which computes the product of all the integers up to a given number.
3118 @smallexample
3119 @group
3120 1:  100        1:  93326215443...    1:  100.       1:  9.3326e157
3121     .              .                     .              .
3123     100            !                     U c f          !
3124 @end group
3125 @end smallexample
3127 @noindent
3128 Recall, the @kbd{c f} command converts the integer or fraction at the
3129 top of the stack to floating-point format.  If you take the factorial
3130 of a floating-point number, you get a floating-point result
3131 accurate to the current precision.  But if you give @kbd{!} an
3132 exact integer, you get an exact integer result (158 digits long
3133 in this case).
3135 If you take the factorial of a non-integer, Calc uses a generalized
3136 factorial function defined in terms of Euler's Gamma function
3137 @c{$\Gamma(n)$}
3138 @cite{gamma(n)}
3139 (which is itself available as the @kbd{f g} command).
3141 @smallexample
3142 @group
3143 3:  4.         3:  24.               1:  5.5        1:  52.342777847
3144 2:  4.5        2:  52.3427777847         .              .
3145 1:  5.         1:  120.
3146     .              .
3148                    M-3 !              M-0 @key{DEL} 5.5       f g
3149 @end group
3150 @end smallexample
3152 @noindent
3153 Here we verify the identity @c{$n! = \Gamma(n+1)$}
3154 @cite{@var{n}!@: = gamma(@var{n}+1)}.
3156 The binomial coefficient @var{n}-choose-@var{m}@c{ or $\displaystyle {n \choose m}$}
3157 @asis{} is defined by
3158 @c{$\displaystyle {n! \over m! \, (n-m)!}$}
3159 @cite{n!@: / m!@: (n-m)!} for all reals @cite{n} and
3160 @cite{m}.  The intermediate results in this formula can become quite
3161 large even if the final result is small; the @kbd{k c} command computes
3162 a binomial coefficient in a way that avoids large intermediate
3163 values.
3165 The @kbd{k} prefix key defines several common functions out of
3166 combinatorics and number theory.  Here we compute the binomial
3167 coefficient 30-choose-20, then determine its prime factorization.
3169 @smallexample
3170 @group
3171 2:  30         1:  30045015   1:  [3, 3, 5, 7, 11, 13, 23, 29]
3172 1:  20             .              .
3173     .
3175  30 @key{RET} 20         k c            k f
3176 @end group
3177 @end smallexample
3179 @noindent
3180 You can verify these prime factors by using @kbd{v u} to ``unpack''
3181 this vector into 8 separate stack entries, then @kbd{M-8 *} to
3182 multiply them back together.  The result is the original number,
3183 30045015.
3185 @cindex Hash tables
3186 Suppose a program you are writing needs a hash table with at least
3187 10000 entries.  It's best to use a prime number as the actual size
3188 of a hash table.  Calc can compute the next prime number after 10000:
3190 @smallexample
3191 @group
3192 1:  10000      1:  10007      1:  9973
3193     .              .              .
3195     10000          k n            I k n
3196 @end group
3197 @end smallexample
3199 @noindent
3200 Just for kicks we've also computed the next prime @emph{less} than
3201 10000.
3203 @c [fix-ref Financial Functions]
3204 @xref{Financial Functions}, for a description of the Calculator
3205 commands that deal with business and financial calculations (functions
3206 like @code{pv}, @code{rate}, and @code{sln}).
3208 @c [fix-ref Binary Number Functions]
3209 @xref{Binary Functions}, to read about the commands for operating
3210 on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
3212 @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
3213 @section Vector/Matrix Tutorial
3215 @noindent
3216 A @dfn{vector} is a list of numbers or other Calc data objects.
3217 Calc provides a large set of commands that operate on vectors.  Some
3218 are familiar operations from vector analysis.  Others simply treat
3219 a vector as a list of objects.
3221 @menu
3222 * Vector Analysis Tutorial::
3223 * Matrix Tutorial::
3224 * List Tutorial::
3225 @end menu
3227 @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
3228 @subsection Vector Analysis
3230 @noindent
3231 If you add two vectors, the result is a vector of the sums of the
3232 elements, taken pairwise.
3234 @smallexample
3235 @group
3236 1:  [1, 2, 3]     2:  [1, 2, 3]     1:  [8, 8, 3]
3237     .             1:  [7, 6, 0]         .
3238                       .
3240     [1,2,3]  s 1      [7 6 0]  s 2      +
3241 @end group
3242 @end smallexample
3244 @noindent
3245 Note that we can separate the vector elements with either commas or
3246 spaces.  This is true whether we are using incomplete vectors or
3247 algebraic entry.  The @kbd{s 1} and @kbd{s 2} commands save these
3248 vectors so we can easily reuse them later.
3250 If you multiply two vectors, the result is the sum of the products
3251 of the elements taken pairwise.  This is called the @dfn{dot product}
3252 of the vectors.
3254 @smallexample
3255 @group
3256 2:  [1, 2, 3]     1:  19
3257 1:  [7, 6, 0]         .
3258     .
3260     r 1 r 2           *
3261 @end group
3262 @end smallexample
3264 @cindex Dot product
3265 The dot product of two vectors is equal to the product of their
3266 lengths times the cosine of the angle between them.  (Here the vector
3267 is interpreted as a line from the origin @cite{(0,0,0)} to the
3268 specified point in three-dimensional space.)  The @kbd{A}
3269 (absolute value) command can be used to compute the length of a
3270 vector.
3272 @smallexample
3273 @group
3274 3:  19            3:  19          1:  0.550782    1:  56.579
3275 2:  [1, 2, 3]     2:  3.741657        .               .
3276 1:  [7, 6, 0]     1:  9.219544
3277     .                 .
3279     M-@key{RET}             M-2 A          * /             I C
3280 @end group
3281 @end smallexample
3283 @noindent
3284 First we recall the arguments to the dot product command, then
3285 we compute the absolute values of the top two stack entries to
3286 obtain the lengths of the vectors, then we divide the dot product
3287 by the product of the lengths to get the cosine of the angle.
3288 The inverse cosine finds that the angle between the vectors
3289 is about 56 degrees.
3291 @cindex Cross product
3292 @cindex Perpendicular vectors
3293 The @dfn{cross product} of two vectors is a vector whose length
3294 is the product of the lengths of the inputs times the sine of the
3295 angle between them, and whose direction is perpendicular to both
3296 input vectors.  Unlike the dot product, the cross product is
3297 defined only for three-dimensional vectors.  Let's double-check
3298 our computation of the angle using the cross product.
3300 @smallexample
3301 @group
3302 2:  [1, 2, 3]  3:  [-18, 21, -8]  1:  [-0.52, 0.61, -0.23]  1:  56.579
3303 1:  [7, 6, 0]  2:  [1, 2, 3]          .                         .
3304     .          1:  [7, 6, 0]
3305                    .
3307     r 1 r 2        V C  s 3  M-@key{RET}    M-2 A * /                 A I S
3308 @end group
3309 @end smallexample
3311 @noindent
3312 First we recall the original vectors and compute their cross product,
3313 which we also store for later reference.  Now we divide the vector
3314 by the product of the lengths of the original vectors.  The length of
3315 this vector should be the sine of the angle; sure enough, it is!
3317 @c [fix-ref General Mode Commands]
3318 Vector-related commands generally begin with the @kbd{v} prefix key.
3319 Some are uppercase letters and some are lowercase.  To make it easier
3320 to type these commands, the shift-@kbd{V} prefix key acts the same as
3321 the @kbd{v} key.  (@xref{General Mode Commands}, for a way to make all
3322 prefix keys have this property.)
3324 If we take the dot product of two perpendicular vectors we expect
3325 to get zero, since the cosine of 90 degrees is zero.  Let's check
3326 that the cross product is indeed perpendicular to both inputs:
3328 @smallexample
3329 @group
3330 2:  [1, 2, 3]      1:  0          2:  [7, 6, 0]      1:  0
3331 1:  [-18, 21, -8]      .          1:  [-18, 21, -8]      .
3332     .                                 .
3334     r 1 r 3            *          @key{DEL} r 2 r 3            *
3335 @end group
3336 @end smallexample
3338 @cindex Normalizing a vector
3339 @cindex Unit vectors
3340 (@bullet{}) @strong{Exercise 1.}  Given a vector on the top of the
3341 stack, what keystrokes would you use to @dfn{normalize} the
3342 vector, i.e., to reduce its length to one without changing its
3343 direction?  @xref{Vector Answer 1, 1}. (@bullet{})
3345 (@bullet{}) @strong{Exercise 2.}  Suppose a certain particle can be
3346 at any of several positions along a ruler.  You have a list of
3347 those positions in the form of a vector, and another list of the
3348 probabilities for the particle to be at the corresponding positions.
3349 Find the average position of the particle.
3350 @xref{Vector Answer 2, 2}. (@bullet{})
3352 @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
3353 @subsection Matrices
3355 @noindent
3356 A @dfn{matrix} is just a vector of vectors, all the same length.
3357 This means you can enter a matrix using nested brackets.  You can
3358 also use the semicolon character to enter a matrix.  We'll show
3359 both methods here:
3361 @smallexample
3362 @group
3363 1:  [ [ 1, 2, 3 ]             1:  [ [ 1, 2, 3 ]
3364       [ 4, 5, 6 ] ]                 [ 4, 5, 6 ] ]
3365     .                             .
3367   [[1 2 3] [4 5 6]]             ' [1 2 3; 4 5 6] @key{RET}
3368 @end group
3369 @end smallexample
3371 @noindent
3372 We'll be using this matrix again, so type @kbd{s 4} to save it now.
3374 Note that semicolons work with incomplete vectors, but they work
3375 better in algebraic entry.  That's why we use the apostrophe in
3376 the second example.
3378 When two matrices are multiplied, the lefthand matrix must have
3379 the same number of columns as the righthand matrix has rows.
3380 Row @cite{i}, column @cite{j} of the result is effectively the
3381 dot product of row @cite{i} of the left matrix by column @cite{j}
3382 of the right matrix.
3384 If we try to duplicate this matrix and multiply it by itself,
3385 the dimensions are wrong and the multiplication cannot take place:
3387 @smallexample
3388 @group
3389 1:  [ [ 1, 2, 3 ]   * [ [ 1, 2, 3 ]
3390       [ 4, 5, 6 ] ]     [ 4, 5, 6 ] ]
3391     .
3393     @key{RET} *
3394 @end group
3395 @end smallexample
3397 @noindent
3398 Though rather hard to read, this is a formula which shows the product
3399 of two matrices.  The @samp{*} function, having invalid arguments, has
3400 been left in symbolic form.
3402 We can multiply the matrices if we @dfn{transpose} one of them first.
3404 @smallexample
3405 @group
3406 2:  [ [ 1, 2, 3 ]       1:  [ [ 14, 32 ]      1:  [ [ 17, 22, 27 ]
3407       [ 4, 5, 6 ] ]           [ 32, 77 ] ]          [ 22, 29, 36 ]
3408 1:  [ [ 1, 4 ]              .                       [ 27, 36, 45 ] ]
3409       [ 2, 5 ]                                    .
3410       [ 3, 6 ] ]
3411     .
3413     U v t                   *                     U @key{TAB} *
3414 @end group
3415 @end smallexample
3417 Matrix multiplication is not commutative; indeed, switching the
3418 order of the operands can even change the dimensions of the result
3419 matrix, as happened here!
3421 If you multiply a plain vector by a matrix, it is treated as a
3422 single row or column depending on which side of the matrix it is
3423 on.  The result is a plain vector which should also be interpreted
3424 as a row or column as appropriate.
3426 @smallexample
3427 @group
3428 2:  [ [ 1, 2, 3 ]      1:  [14, 32]
3429       [ 4, 5, 6 ] ]        .
3430 1:  [1, 2, 3]
3431     .
3433     r 4 r 1                *
3434 @end group
3435 @end smallexample
3437 Multiplying in the other order wouldn't work because the number of
3438 rows in the matrix is different from the number of elements in the
3439 vector.
3441 (@bullet{}) @strong{Exercise 1.}  Use @samp{*} to sum along the rows
3442 of the above @c{$2\times3$}
3443 @asis{2x3} matrix to get @cite{[6, 15]}.  Now use @samp{*} to
3444 sum along the columns to get @cite{[5, 7, 9]}.
3445 @xref{Matrix Answer 1, 1}. (@bullet{})
3447 @cindex Identity matrix
3448 An @dfn{identity matrix} is a square matrix with ones along the
3449 diagonal and zeros elsewhere.  It has the property that multiplication
3450 by an identity matrix, on the left or on the right, always produces
3451 the original matrix.
3453 @smallexample
3454 @group
3455 1:  [ [ 1, 2, 3 ]      2:  [ [ 1, 2, 3 ]      1:  [ [ 1, 2, 3 ]
3456       [ 4, 5, 6 ] ]          [ 4, 5, 6 ] ]          [ 4, 5, 6 ] ]
3457     .                  1:  [ [ 1, 0, 0 ]          .
3458                              [ 0, 1, 0 ]
3459                              [ 0, 0, 1 ] ]
3460                            .
3462     r 4                    v i 3 @key{RET}              *
3463 @end group
3464 @end smallexample
3466 If a matrix is square, it is often possible to find its @dfn{inverse},
3467 that is, a matrix which, when multiplied by the original matrix, yields
3468 an identity matrix.  The @kbd{&} (reciprocal) key also computes the
3469 inverse of a matrix.
3471 @smallexample
3472 @group
3473 1:  [ [ 1, 2, 3 ]      1:  [ [   -2.4,     1.2,   -0.2 ]
3474       [ 4, 5, 6 ]            [    2.8,    -1.4,    0.4 ]
3475       [ 7, 6, 0 ] ]          [ -0.73333, 0.53333, -0.2 ] ]
3476     .                      .
3478     r 4 r 2 |  s 5         &
3479 @end group
3480 @end smallexample
3482 @noindent
3483 The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
3484 matrices together.  Here we have used it to add a new row onto
3485 our matrix to make it square.
3487 We can multiply these two matrices in either order to get an identity.
3489 @smallexample
3490 @group
3491 1:  [ [ 1., 0., 0. ]      1:  [ [ 1., 0., 0. ]
3492       [ 0., 1., 0. ]            [ 0., 1., 0. ]
3493       [ 0., 0., 1. ] ]          [ 0., 0., 1. ] ]
3494     .                         .
3496     M-@key{RET}  *                  U @key{TAB} *
3497 @end group
3498 @end smallexample
3500 @cindex Systems of linear equations
3501 @cindex Linear equations, systems of
3502 Matrix inverses are related to systems of linear equations in algebra.
3503 Suppose we had the following set of equations:
3505 @ifinfo
3506 @group
3507 @example
3508     a + 2b + 3c = 6
3509    4a + 5b + 6c = 2
3510    7a + 6b      = 3
3511 @end example
3512 @end group
3513 @end ifinfo
3514 @tex
3515 \turnoffactive
3516 \beforedisplayh
3517 $$ \openup1\jot \tabskip=0pt plus1fil
3518 \halign to\displaywidth{\tabskip=0pt
3519    $\hfil#$&$\hfil{}#{}$&
3520    $\hfil#$&$\hfil{}#{}$&
3521    $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3522   a&+&2b&+&3c&=6 \cr
3523  4a&+&5b&+&6c&=2 \cr
3524  7a&+&6b& &  &=3 \cr}
3526 \afterdisplayh
3527 @end tex
3529 @noindent
3530 This can be cast into the matrix equation,
3532 @ifinfo
3533 @group
3534 @example
3535    [ [ 1, 2, 3 ]     [ [ a ]     [ [ 6 ]
3536      [ 4, 5, 6 ]   *   [ b ]   =   [ 2 ]
3537      [ 7, 6, 0 ] ]     [ c ] ]     [ 3 ] ]
3538 @end example
3539 @end group
3540 @end ifinfo
3541 @tex
3542 \turnoffactive
3543 \beforedisplay
3544 $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
3545    \times
3546    \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
3548 \afterdisplay
3549 @end tex
3551 We can solve this system of equations by multiplying both sides by the
3552 inverse of the matrix.  Calc can do this all in one step:
3554 @smallexample
3555 @group
3556 2:  [6, 2, 3]          1:  [-12.6, 15.2, -3.93333]
3557 1:  [ [ 1, 2, 3 ]          .
3558       [ 4, 5, 6 ]
3559       [ 7, 6, 0 ] ]
3560     .
3562     [6,2,3] r 5            /
3563 @end group
3564 @end smallexample
3566 @noindent
3567 The result is the @cite{[a, b, c]} vector that solves the equations.
3568 (Dividing by a square matrix is equivalent to multiplying by its
3569 inverse.)
3571 Let's verify this solution:
3573 @smallexample
3574 @group
3575 2:  [ [ 1, 2, 3 ]                1:  [6., 2., 3.]
3576       [ 4, 5, 6 ]                    .
3577       [ 7, 6, 0 ] ]
3578 1:  [-12.6, 15.2, -3.93333]
3579     .
3581     r 5  @key{TAB}                         *
3582 @end group
3583 @end smallexample
3585 @noindent
3586 Note that we had to be careful about the order in which we multiplied
3587 the matrix and vector.  If we multiplied in the other order, Calc would
3588 assume the vector was a row vector in order to make the dimensions
3589 come out right, and the answer would be incorrect.  If you
3590 don't feel safe letting Calc take either interpretation of your
3591 vectors, use explicit @c{$N\times1$}
3592 @asis{Nx1} or @c{$1\times N$}
3593 @asis{1xN} matrices instead.
3594 In this case, you would enter the original column vector as
3595 @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
3597 (@bullet{}) @strong{Exercise 2.}  Algebraic entry allows you to make
3598 vectors and matrices that include variables.  Solve the following
3599 system of equations to get expressions for @cite{x} and @cite{y}
3600 in terms of @cite{a} and @cite{b}.
3602 @ifinfo
3603 @group
3604 @example
3605    x + a y = 6
3606    x + b y = 10
3607 @end example
3608 @end group
3609 @end ifinfo
3610 @tex
3611 \turnoffactive
3612 \beforedisplay
3613 $$ \eqalign{ x &+ a y = 6 \cr
3614              x &+ b y = 10}
3616 \afterdisplay
3617 @end tex
3619 @noindent
3620 @xref{Matrix Answer 2, 2}. (@bullet{})
3622 @cindex Least-squares for over-determined systems
3623 @cindex Over-determined systems of equations
3624 (@bullet{}) @strong{Exercise 3.}  A system of equations is ``over-determined''
3625 if it has more equations than variables.  It is often the case that
3626 there are no values for the variables that will satisfy all the
3627 equations at once, but it is still useful to find a set of values
3628 which ``nearly'' satisfy all the equations.  In terms of matrix equations,
3629 you can't solve @cite{A X = B} directly because the matrix @cite{A}
3630 is not square for an over-determined system.  Matrix inversion works
3631 only for square matrices.  One common trick is to multiply both sides
3632 on the left by the transpose of @cite{A}:
3633 @ifinfo
3634 @samp{trn(A)*A*X = trn(A)*B}.
3635 @end ifinfo
3636 @tex
3637 \turnoffactive
3638 $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
3639 @end tex
3640 Now @c{$A^T A$}
3641 @cite{trn(A)*A} is a square matrix so a solution is possible.  It
3642 turns out that the @cite{X} vector you compute in this way will be a
3643 ``least-squares'' solution, which can be regarded as the ``closest''
3644 solution to the set of equations.  Use Calc to solve the following
3645 over-determined system:@refill
3647 @ifinfo
3648 @group
3649 @example
3650     a + 2b + 3c = 6
3651    4a + 5b + 6c = 2
3652    7a + 6b      = 3
3653    2a + 4b + 6c = 11
3654 @end example
3655 @end group
3656 @end ifinfo
3657 @tex
3658 \turnoffactive
3659 \beforedisplayh
3660 $$ \openup1\jot \tabskip=0pt plus1fil
3661 \halign to\displaywidth{\tabskip=0pt
3662    $\hfil#$&$\hfil{}#{}$&
3663    $\hfil#$&$\hfil{}#{}$&
3664    $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3665   a&+&2b&+&3c&=6 \cr
3666  4a&+&5b&+&6c&=2 \cr
3667  7a&+&6b& &  &=3 \cr
3668  2a&+&4b&+&6c&=11 \cr}
3670 \afterdisplayh
3671 @end tex
3673 @noindent
3674 @xref{Matrix Answer 3, 3}. (@bullet{})
3676 @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
3677 @subsection Vectors as Lists
3679 @noindent
3680 @cindex Lists
3681 Although Calc has a number of features for manipulating vectors and
3682 matrices as mathematical objects, you can also treat vectors as
3683 simple lists of values.  For example, we saw that the @kbd{k f}
3684 command returns a vector which is a list of the prime factors of a
3685 number.
3687 You can pack and unpack stack entries into vectors:
3689 @smallexample
3690 @group
3691 3:  10         1:  [10, 20, 30]     3:  10
3692 2:  20             .                2:  20
3693 1:  30                              1:  30
3694     .                                   .
3696                    M-3 v p              v u
3697 @end group
3698 @end smallexample
3700 You can also build vectors out of consecutive integers, or out
3701 of many copies of a given value:
3703 @smallexample
3704 @group
3705 1:  [1, 2, 3, 4]    2:  [1, 2, 3, 4]    2:  [1, 2, 3, 4]
3706     .               1:  17              1:  [17, 17, 17, 17]
3707                         .                   .
3709     v x 4 @key{RET}           17                  v b 4 @key{RET}
3710 @end group
3711 @end smallexample
3713 You can apply an operator to every element of a vector using the
3714 @dfn{map} command.
3716 @smallexample
3717 @group
3718 1:  [17, 34, 51, 68]   1:  [289, 1156, 2601, 4624]  1:  [17, 34, 51, 68]
3719     .                      .                            .
3721     V M *                  2 V M ^                      V M Q
3722 @end group
3723 @end smallexample
3725 @noindent
3726 In the first step, we multiply the vector of integers by the vector
3727 of 17's elementwise.  In the second step, we raise each element to
3728 the power two.  (The general rule is that both operands must be
3729 vectors of the same length, or else one must be a vector and the
3730 other a plain number.)  In the final step, we take the square root
3731 of each element.
3733 (@bullet{}) @strong{Exercise 1.}  Compute a vector of powers of two
3734 from @c{$2^{-4}$}
3735 @cite{2^-4} to @cite{2^4}.  @xref{List Answer 1, 1}. (@bullet{})
3737 You can also @dfn{reduce} a binary operator across a vector.
3738 For example, reducing @samp{*} computes the product of all the
3739 elements in the vector:
3741 @smallexample
3742 @group
3743 1:  123123     1:  [3, 7, 11, 13, 41]      1:  123123
3744     .              .                           .
3746     123123         k f                         V R *
3747 @end group
3748 @end smallexample
3750 @noindent
3751 In this example, we decompose 123123 into its prime factors, then
3752 multiply those factors together again to yield the original number.
3754 We could compute a dot product ``by hand'' using mapping and
3755 reduction:
3757 @smallexample
3758 @group
3759 2:  [1, 2, 3]     1:  [7, 12, 0]     1:  19
3760 1:  [7, 6, 0]         .                  .
3761     .
3763     r 1 r 2           V M *              V R +
3764 @end group
3765 @end smallexample
3767 @noindent
3768 Recalling two vectors from the previous section, we compute the
3769 sum of pairwise products of the elements to get the same answer
3770 for the dot product as before.
3772 A slight variant of vector reduction is the @dfn{accumulate} operation,
3773 @kbd{V U}.  This produces a vector of the intermediate results from
3774 a corresponding reduction.  Here we compute a table of factorials:
3776 @smallexample
3777 @group
3778 1:  [1, 2, 3, 4, 5, 6]    1:  [1, 2, 6, 24, 120, 720]
3779     .                         .
3781     v x 6 @key{RET}                 V U *
3782 @end group
3783 @end smallexample
3785 Calc allows vectors to grow as large as you like, although it gets
3786 rather slow if vectors have more than about a hundred elements.
3787 Actually, most of the time is spent formatting these large vectors
3788 for display, not calculating on them.  Try the following experiment
3789 (if your computer is very fast you may need to substitute a larger
3790 vector size).
3792 @smallexample
3793 @group
3794 1:  [1, 2, 3, 4, ...      1:  [2, 3, 4, 5, ...
3795     .                         .
3797     v x 500 @key{RET}               1 V M +
3798 @end group
3799 @end smallexample
3801 Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
3802 experiment again.  In @kbd{v .} mode, long vectors are displayed
3803 ``abbreviated'' like this:
3805 @smallexample
3806 @group
3807 1:  [1, 2, 3, ..., 500]   1:  [2, 3, 4, ..., 501]
3808     .                         .
3810     v x 500 @key{RET}               1 V M +
3811 @end group
3812 @end smallexample
3814 @noindent
3815 (where now the @samp{...} is actually part of the Calc display).
3816 You will find both operations are now much faster.  But notice that
3817 even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
3818 Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
3819 experiment one more time.  Operations on long vectors are now quite
3820 fast!  (But of course if you use @kbd{t .} you will lose the ability
3821 to get old vectors back using the @kbd{t y} command.)
3823 An easy way to view a full vector when @kbd{v .} mode is active is
3824 to press @kbd{`} (back-quote) to edit the vector; editing always works
3825 with the full, unabbreviated value.
3827 @cindex Least-squares for fitting a straight line
3828 @cindex Fitting data to a line
3829 @cindex Line, fitting data to
3830 @cindex Data, extracting from buffers
3831 @cindex Columns of data, extracting
3832 As a larger example, let's try to fit a straight line to some data,
3833 using the method of least squares.  (Calc has a built-in command for
3834 least-squares curve fitting, but we'll do it by hand here just to
3835 practice working with vectors.)  Suppose we have the following list
3836 of values in a file we have loaded into Emacs:
3838 @smallexample
3839   x        y
3840  ---      ---
3841  1.34    0.234
3842  1.41    0.298
3843  1.49    0.402
3844  1.56    0.412
3845  1.64    0.466
3846  1.73    0.473
3847  1.82    0.601
3848  1.91    0.519
3849  2.01    0.603
3850  2.11    0.637
3851  2.22    0.645
3852  2.33    0.705
3853  2.45    0.917
3854  2.58    1.009
3855  2.71    0.971
3856  2.85    1.062
3857  3.00    1.148
3858  3.15    1.157
3859  3.32    1.354
3860 @end smallexample
3862 @noindent
3863 If you are reading this tutorial in printed form, you will find it
3864 easiest to press @kbd{M-# i} to enter the on-line Info version of
3865 the manual and find this table there.  (Press @kbd{g}, then type
3866 @kbd{List Tutorial}, to jump straight to this section.)
3868 Position the cursor at the upper-left corner of this table, just
3869 to the left of the @cite{1.34}.  Press @kbd{C-@@} to set the mark.
3870 (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
3871 Now position the cursor to the lower-right, just after the @cite{1.354}.
3872 You have now defined this region as an Emacs ``rectangle.''  Still
3873 in the Info buffer, type @kbd{M-# r}.  This command
3874 (@code{calc-grab-rectangle}) will pop you back into the Calculator, with
3875 the contents of the rectangle you specified in the form of a matrix.@refill
3877 @smallexample
3878 @group
3879 1:  [ [ 1.34, 0.234 ]
3880       [ 1.41, 0.298 ]
3881       @dots{}
3882 @end group
3883 @end smallexample
3885 @noindent
3886 (You may wish to use @kbd{v .} mode to abbreviate the display of this
3887 large matrix.)
3889 We want to treat this as a pair of lists.  The first step is to
3890 transpose this matrix into a pair of rows.  Remember, a matrix is
3891 just a vector of vectors.  So we can unpack the matrix into a pair
3892 of row vectors on the stack.
3894 @smallexample
3895 @group
3896 1:  [ [ 1.34,  1.41,  1.49,  ... ]     2:  [1.34, 1.41, 1.49, ... ]
3897       [ 0.234, 0.298, 0.402, ... ] ]   1:  [0.234, 0.298, 0.402, ... ]
3898     .                                      .
3900     v t                                    v u
3901 @end group
3902 @end smallexample
3904 @noindent
3905 Let's store these in quick variables 1 and 2, respectively.
3907 @smallexample
3908 @group
3909 1:  [1.34, 1.41, 1.49, ... ]        .
3910     .
3912     t 2                             t 1
3913 @end group
3914 @end smallexample
3916 @noindent
3917 (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
3918 stored value from the stack.)
3920 In a least squares fit, the slope @cite{m} is given by the formula
3922 @ifinfo
3923 @example
3924 m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
3925 @end example
3926 @end ifinfo
3927 @tex
3928 \turnoffactive
3929 \beforedisplay
3930 $$ m = {N \sum x y - \sum x \sum y  \over
3931         N \sum x^2 - \left( \sum x \right)^2} $$
3932 \afterdisplay
3933 @end tex
3935 @noindent
3936 where @c{$\sum x$}
3937 @cite{sum(x)} represents the sum of all the values of @cite{x}.
3938 While there is an actual @code{sum} function in Calc, it's easier to
3939 sum a vector using a simple reduction.  First, let's compute the four
3940 different sums that this formula uses.
3942 @smallexample
3943 @group
3944 1:  41.63                 1:  98.0003
3945     .                         .
3947  r 1 V R +   t 3           r 1 2 V M ^ V R +   t 4
3949 @end group
3950 @end smallexample
3951 @noindent
3952 @smallexample
3953 @group
3954 1:  13.613                1:  33.36554
3955     .                         .
3957  r 2 V R +   t 5           r 1 r 2 V M * V R +   t 6
3958 @end group
3959 @end smallexample
3961 @ifinfo
3962 @noindent
3963 These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
3964 respectively.  (We could have used @kbd{*} to compute @samp{sum(x^2)} and
3965 @samp{sum(x y)}.)
3966 @end ifinfo
3967 @tex
3968 \turnoffactive
3969 These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
3970 respectively.  (We could have used \kbd{*} to compute $\sum x^2$ and
3971 $\sum x y$.)
3972 @end tex
3974 Finally, we also need @cite{N}, the number of data points.  This is just
3975 the length of either of our lists.
3977 @smallexample
3978 @group
3979 1:  19
3980     .
3982  r 1 v l   t 7
3983 @end group
3984 @end smallexample
3986 @noindent
3987 (That's @kbd{v} followed by a lower-case @kbd{l}.)
3989 Now we grind through the formula:
3991 @smallexample
3992 @group
3993 1:  633.94526  2:  633.94526  1:  67.23607
3994     .          1:  566.70919      .
3995                    .
3997  r 7 r 6 *      r 3 r 5 *         -
3999 @end group
4000 @end smallexample
4001 @noindent
4002 @smallexample
4003 @group
4004 2:  67.23607   3:  67.23607   2:  67.23607   1:  0.52141679
4005 1:  1862.0057  2:  1862.0057  1:  128.9488       .
4006     .          1:  1733.0569      .
4007                    .
4009  r 7 r 4 *      r 3 2 ^           -              /   t 8
4010 @end group
4011 @end smallexample
4013 That gives us the slope @cite{m}.  The y-intercept @cite{b} can now
4014 be found with the simple formula,
4016 @ifinfo
4017 @example
4018 b = (sum(y) - m sum(x)) / N
4019 @end example
4020 @end ifinfo
4021 @tex
4022 \turnoffactive
4023 \beforedisplay
4024 $$ b = {\sum y - m \sum x \over N} $$
4025 \afterdisplay
4026 \vskip10pt
4027 @end tex
4029 @smallexample
4030 @group
4031 1:  13.613     2:  13.613     1:  -8.09358   1:  -0.425978
4032     .          1:  21.70658       .              .
4033                    .
4035    r 5            r 8 r 3 *       -              r 7 /   t 9
4036 @end group
4037 @end smallexample
4039 Let's ``plot'' this straight line approximation, @c{$y \approx m x + b$}
4040 @cite{m x + b}, and compare it with the original data.@refill
4042 @smallexample
4043 @group
4044 1:  [0.699, 0.735, ... ]    1:  [0.273, 0.309, ... ]
4045     .                           .
4047     r 1 r 8 *                   r 9 +    s 0
4048 @end group
4049 @end smallexample
4051 @noindent
4052 Notice that multiplying a vector by a constant, and adding a constant
4053 to a vector, can be done without mapping commands since these are
4054 common operations from vector algebra.  As far as Calc is concerned,
4055 we've just been doing geometry in 19-dimensional space!
4057 We can subtract this vector from our original @cite{y} vector to get
4058 a feel for the error of our fit.  Let's find the maximum error:
4060 @smallexample
4061 @group
4062 1:  [0.0387, 0.0112, ... ]   1:  [0.0387, 0.0112, ... ]   1:  0.0897
4063     .                            .                            .
4065     r 2 -                        V M A                        V R X
4066 @end group
4067 @end smallexample
4069 @noindent
4070 First we compute a vector of differences, then we take the absolute
4071 values of these differences, then we reduce the @code{max} function
4072 across the vector.  (The @code{max} function is on the two-key sequence
4073 @kbd{f x}; because it is so common to use @code{max} in a vector
4074 operation, the letters @kbd{X} and @kbd{N} are also accepted for
4075 @code{max} and @code{min} in this context.  In general, you answer
4076 the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
4077 invokes the function you want.  You could have typed @kbd{V R f x} or
4078 even @kbd{V R x max @key{RET}} if you had preferred.)
4080 If your system has the GNUPLOT program, you can see graphs of your
4081 data and your straight line to see how well they match.  (If you have
4082 GNUPLOT 3.0, the following instructions will work regardless of the
4083 kind of display you have.  Some GNUPLOT 2.0, non-X-windows systems
4084 may require additional steps to view the graphs.)
4086 Let's start by plotting the original data.  Recall the ``@var{x}'' and ``@var{y}''
4087 vectors onto the stack and press @kbd{g f}.  This ``fast'' graphing
4088 command does everything you need to do for simple, straightforward
4089 plotting of data.
4091 @smallexample
4092 @group
4093 2:  [1.34, 1.41, 1.49, ... ]
4094 1:  [0.234, 0.298, 0.402, ... ]
4095     .
4097     r 1 r 2    g f
4098 @end group
4099 @end smallexample
4101 If all goes well, you will shortly get a new window containing a graph
4102 of the data.  (If not, contact your GNUPLOT or Calc installer to find
4103 out what went wrong.)  In the X window system, this will be a separate
4104 graphics window.  For other kinds of displays, the default is to
4105 display the graph in Emacs itself using rough character graphics.
4106 Press @kbd{q} when you are done viewing the character graphics.
4108 Next, let's add the line we got from our least-squares fit:
4110 @smallexample
4111 @group
4112 2:  [1.34, 1.41, 1.49, ... ]
4113 1:  [0.273, 0.309, 0.351, ... ]
4114     .
4116     @key{DEL} r 0    g a  g p
4117 @end group
4118 @end smallexample
4120 It's not very useful to get symbols to mark the data points on this
4121 second curve; you can type @kbd{g S g p} to remove them.  Type @kbd{g q}
4122 when you are done to remove the X graphics window and terminate GNUPLOT.
4124 (@bullet{}) @strong{Exercise 2.}  An earlier exercise showed how to do
4125 least squares fitting to a general system of equations.  Our 19 data
4126 points are really 19 equations of the form @cite{y_i = m x_i + b} for
4127 different pairs of @cite{(x_i,y_i)}.  Use the matrix-transpose method
4128 to solve for @cite{m} and @cite{b}, duplicating the above result.
4129 @xref{List Answer 2, 2}. (@bullet{})
4131 @cindex Geometric mean
4132 (@bullet{}) @strong{Exercise 3.}  If the input data do not form a
4133 rectangle, you can use @w{@kbd{M-# g}} (@code{calc-grab-region})
4134 to grab the data the way Emacs normally works with regions---it reads
4135 left-to-right, top-to-bottom, treating line breaks the same as spaces.
4136 Use this command to find the geometric mean of the following numbers.
4137 (The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
4139 @example
4140 2.3  6  22  15.1  7
4141   15  14  7.5
4142   2.5
4143 @end example
4145 @noindent
4146 The @kbd{M-# g} command accepts numbers separated by spaces or commas,
4147 with or without surrounding vector brackets.
4148 @xref{List Answer 3, 3}. (@bullet{})
4150 @ifinfo
4151 As another example, a theorem about binomial coefficients tells
4152 us that the alternating sum of binomial coefficients
4153 @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
4154 on up to @var{n}-choose-@var{n},
4155 always comes out to zero.  Let's verify this
4156 for @cite{n=6}.@refill
4157 @end ifinfo
4158 @tex
4159 As another example, a theorem about binomial coefficients tells
4160 us that the alternating sum of binomial coefficients
4161 ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
4162 always comes out to zero.  Let's verify this
4163 for \cite{n=6}.
4164 @end tex
4166 @smallexample
4167 @group
4168 1:  [1, 2, 3, 4, 5, 6, 7]     1:  [0, 1, 2, 3, 4, 5, 6]
4169     .                             .
4171     v x 7 @key{RET}                     1 -
4173 @end group
4174 @end smallexample
4175 @noindent
4176 @smallexample
4177 @group
4178 1:  [1, -6, 15, -20, 15, -6, 1]          1:  0
4179     .                                        .
4181     V M ' (-1)^$ choose(6,$) @key{RET}             V R +
4182 @end group
4183 @end smallexample
4185 The @kbd{V M '} command prompts you to enter any algebraic expression
4186 to define the function to map over the vector.  The symbol @samp{$}
4187 inside this expression represents the argument to the function.
4188 The Calculator applies this formula to each element of the vector,
4189 substituting each element's value for the @samp{$} sign(s) in turn.
4191 To define a two-argument function, use @samp{$$} for the first
4192 argument and @samp{$} for the second:  @kbd{V M ' $$-$ @key{RET}} is
4193 equivalent to @kbd{V M -}.  This is analogous to regular algebraic
4194 entry, where @samp{$$} would refer to the next-to-top stack entry
4195 and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
4196 would act exactly like @kbd{-}.
4198 Notice that the @kbd{V M '} command has recorded two things in the
4199 trail:  The result, as usual, and also a funny-looking thing marked
4200 @samp{oper} that represents the operator function you typed in.
4201 The function is enclosed in @samp{< >} brackets, and the argument is
4202 denoted by a @samp{#} sign.  If there were several arguments, they
4203 would be shown as @samp{#1}, @samp{#2}, and so on.  (For example,
4204 @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
4205 trail.)  This object is a ``nameless function''; you can use nameless
4206 @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
4207 Nameless function notation has the interesting, occasionally useful
4208 property that a nameless function is not actually evaluated until
4209 it is used.  For example, @kbd{V M ' $+random(2.0)} evaluates
4210 @samp{random(2.0)} once and adds that random number to all elements
4211 of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
4212 @samp{random(2.0)} separately for each vector element.
4214 Another group of operators that are often useful with @kbd{V M} are
4215 the relational operators:  @kbd{a =}, for example, compares two numbers
4216 and gives the result 1 if they are equal, or 0 if not.  Similarly,
4217 @w{@kbd{a <}} checks for one number being less than another.
4219 Other useful vector operations include @kbd{v v}, to reverse a
4220 vector end-for-end; @kbd{V S}, to sort the elements of a vector
4221 into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
4222 one row or column of a matrix, or (in both cases) to extract one
4223 element of a plain vector.  With a negative argument, @kbd{v r}
4224 and @kbd{v c} instead delete one row, column, or vector element.
4226 @cindex Divisor functions
4227 (@bullet{}) @strong{Exercise 4.}  The @cite{k}th @dfn{divisor function}
4228 @tex
4229 $\sigma_k(n)$
4230 @end tex
4231 is the sum of the @cite{k}th powers of all the divisors of an
4232 integer @cite{n}.  Figure out a method for computing the divisor
4233 function for reasonably small values of @cite{n}.  As a test,
4234 the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
4235 @xref{List Answer 4, 4}. (@bullet{})
4237 @cindex Square-free numbers
4238 @cindex Duplicate values in a list
4239 (@bullet{}) @strong{Exercise 5.}  The @kbd{k f} command produces a
4240 list of prime factors for a number.  Sometimes it is important to
4241 know that a number is @dfn{square-free}, i.e., that no prime occurs
4242 more than once in its list of prime factors.  Find a sequence of
4243 keystrokes to tell if a number is square-free; your method should
4244 leave 1 on the stack if it is, or 0 if it isn't.
4245 @xref{List Answer 5, 5}. (@bullet{})
4247 @cindex Triangular lists
4248 (@bullet{}) @strong{Exercise 6.}  Build a list of lists that looks
4249 like the following diagram.  (You may wish to use the @kbd{v /}
4250 command to enable multi-line display of vectors.)
4252 @smallexample
4253 @group
4254 1:  [ [1],
4255       [1, 2],
4256       [1, 2, 3],
4257       [1, 2, 3, 4],
4258       [1, 2, 3, 4, 5],
4259       [1, 2, 3, 4, 5, 6] ]
4260 @end group
4261 @end smallexample
4263 @noindent
4264 @xref{List Answer 6, 6}. (@bullet{})
4266 (@bullet{}) @strong{Exercise 7.}  Build the following list of lists.
4268 @smallexample
4269 @group
4270 1:  [ [0],
4271       [1, 2],
4272       [3, 4, 5],
4273       [6, 7, 8, 9],
4274       [10, 11, 12, 13, 14],
4275       [15, 16, 17, 18, 19, 20] ]
4276 @end group
4277 @end smallexample
4279 @noindent
4280 @xref{List Answer 7, 7}. (@bullet{})
4282 @cindex Maximizing a function over a list of values
4283 @c [fix-ref Numerical Solutions]
4284 (@bullet{}) @strong{Exercise 8.}  Compute a list of values of Bessel's
4285 @c{$J_1(x)$}
4286 @cite{J1} function @samp{besJ(1,x)} for @cite{x} from 0 to 5
4287 in steps of 0.25.
4288 Find the value of @cite{x} (from among the above set of values) for
4289 which @samp{besJ(1,x)} is a maximum.  Use an ``automatic'' method,
4290 i.e., just reading along the list by hand to find the largest value
4291 is not allowed!  (There is an @kbd{a X} command which does this kind
4292 of thing automatically; @pxref{Numerical Solutions}.)
4293 @xref{List Answer 8, 8}. (@bullet{})@refill
4295 @cindex Digits, vectors of
4296 (@bullet{}) @strong{Exercise 9.}  You are given an integer in the range
4297 @c{$0 \le N < 10^m$}
4298 @cite{0 <= N < 10^m} for @cite{m=12} (i.e., an integer of less than
4299 twelve digits).  Convert this integer into a vector of @cite{m}
4300 digits, each in the range from 0 to 9.  In vector-of-digits notation,
4301 add one to this integer to produce a vector of @cite{m+1} digits
4302 (since there could be a carry out of the most significant digit).
4303 Convert this vector back into a regular integer.  A good integer
4304 to try is 25129925999.  @xref{List Answer 9, 9}. (@bullet{})
4306 (@bullet{}) @strong{Exercise 10.}  Your friend Joe tried to use
4307 @kbd{V R a =} to test if all numbers in a list were equal.  What
4308 happened?  How would you do this test?  @xref{List Answer 10, 10}. (@bullet{})
4310 (@bullet{}) @strong{Exercise 11.}  The area of a circle of radius one
4311 is @c{$\pi$}
4312 @cite{pi}.  The area of the @c{$2\times2$}
4313 @asis{2x2} square that encloses that
4314 circle is 4.  So if we throw @var{n} darts at random points in the square,
4315 about @c{$\pi/4$}
4316 @cite{pi/4} of them will land inside the circle.  This gives us
4317 an entertaining way to estimate the value of @c{$\pi$}
4318 @cite{pi}.  The @w{@kbd{k r}}
4319 command picks a random number between zero and the value on the stack.
4320 We could get a random floating-point number between @i{-1} and 1 by typing
4321 @w{@kbd{2.0 k r 1 -}}.  Build a vector of 100 random @cite{(x,y)} points in
4322 this square, then use vector mapping and reduction to count how many
4323 points lie inside the unit circle.  Hint:  Use the @kbd{v b} command.
4324 @xref{List Answer 11, 11}. (@bullet{})
4326 @cindex Matchstick problem
4327 (@bullet{}) @strong{Exercise 12.}  The @dfn{matchstick problem} provides
4328 another way to calculate @c{$\pi$}
4329 @cite{pi}.  Say you have an infinite field
4330 of vertical lines with a spacing of one inch.  Toss a one-inch matchstick
4331 onto the field.  The probability that the matchstick will land crossing
4332 a line turns out to be @c{$2/\pi$}
4333 @cite{2/pi}.  Toss 100 matchsticks to estimate
4334 @c{$\pi$}
4335 @cite{pi}.  (If you want still more fun, the probability that the GCD
4336 (@w{@kbd{k g}}) of two large integers is one turns out to be @c{$6/\pi^2$}
4337 @cite{6/pi^2}.
4338 That provides yet another way to estimate @c{$\pi$}
4339 @cite{pi}.)
4340 @xref{List Answer 12, 12}. (@bullet{})
4342 (@bullet{}) @strong{Exercise 13.}  An algebraic entry of a string in
4343 double-quote marks, @samp{"hello"}, creates a vector of the numerical
4344 (ASCII) codes of the characters (here, @cite{[104, 101, 108, 108, 111]}).
4345 Sometimes it is convenient to compute a @dfn{hash code} of a string,
4346 which is just an integer that represents the value of that string.
4347 Two equal strings have the same hash code; two different strings
4348 @dfn{probably} have different hash codes.  (For example, Calc has
4349 over 400 function names, but Emacs can quickly find the definition for
4350 any given name because it has sorted the functions into ``buckets'' by
4351 their hash codes.  Sometimes a few names will hash into the same bucket,
4352 but it is easier to search among a few names than among all the names.)
4353 One popular hash function is computed as follows:  First set @cite{h = 0}.
4354 Then, for each character from the string in turn, set @cite{h = 3h + c_i}
4355 where @cite{c_i} is the character's ASCII code.  If we have 511 buckets,
4356 we then take the hash code modulo 511 to get the bucket number.  Develop a
4357 simple command or commands for converting string vectors into hash codes.
4358 The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
4359 511 is 121.  @xref{List Answer 13, 13}. (@bullet{})
4361 (@bullet{}) @strong{Exercise 14.}  The @kbd{H V R} and @kbd{H V U}
4362 commands do nested function evaluations.  @kbd{H V U} takes a starting
4363 value and a number of steps @var{n} from the stack; it then applies the
4364 function you give to the starting value 0, 1, 2, up to @var{n} times
4365 and returns a vector of the results.  Use this command to create a
4366 ``random walk'' of 50 steps.  Start with the two-dimensional point
4367 @cite{(0,0)}; then take one step a random distance between @i{-1} and 1
4368 in both @cite{x} and @cite{y}; then take another step, and so on.  Use the
4369 @kbd{g f} command to display this random walk.  Now modify your random
4370 walk to walk a unit distance, but in a random direction, at each step.
4371 (Hint:  The @code{sincos} function returns a vector of the cosine and
4372 sine of an angle.)  @xref{List Answer 14, 14}. (@bullet{})
4374 @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
4375 @section Types Tutorial
4377 @noindent
4378 Calc understands a variety of data types as well as simple numbers.
4379 In this section, we'll experiment with each of these types in turn.
4381 The numbers we've been using so far have mainly been either @dfn{integers}
4382 or @dfn{floats}.  We saw that floats are usually a good approximation to
4383 the mathematical concept of real numbers, but they are only approximations
4384 and are susceptible to roundoff error.  Calc also supports @dfn{fractions},
4385 which can exactly represent any rational number.
4387 @smallexample
4388 @group
4389 1:  3628800    2:  3628800    1:  518400:7   1:  518414:7   1:  7:518414
4390     .          1:  49             .              .              .
4391                    .
4393     10 !           49 @key{RET}         :              2 +            &
4394 @end group
4395 @end smallexample
4397 @noindent
4398 The @kbd{:} command divides two integers to get a fraction; @kbd{/}
4399 would normally divide integers to get a floating-point result.
4400 Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
4401 since the @kbd{:} would otherwise be interpreted as part of a
4402 fraction beginning with 49.
4404 You can convert between floating-point and fractional format using
4405 @kbd{c f} and @kbd{c F}:
4407 @smallexample
4408 @group
4409 1:  1.35027217629e-5    1:  7:518414
4410     .                       .
4412     c f                     c F
4413 @end group
4414 @end smallexample
4416 The @kbd{c F} command replaces a floating-point number with the
4417 ``simplest'' fraction whose floating-point representation is the
4418 same, to within the current precision.
4420 @smallexample
4421 @group
4422 1:  3.14159265359   1:  1146408:364913   1:  3.1416   1:  355:113
4423     .                   .                    .            .
4425     P                   c F      @key{DEL}       p 5 @key{RET} P      c F
4426 @end group
4427 @end smallexample
4429 (@bullet{}) @strong{Exercise 1.}  A calculation has produced the
4430 result 1.26508260337.  You suspect it is the square root of the
4431 product of @c{$\pi$}
4432 @cite{pi} and some rational number.  Is it?  (Be sure
4433 to allow for roundoff error!)  @xref{Types Answer 1, 1}. (@bullet{})
4435 @dfn{Complex numbers} can be stored in both rectangular and polar form.
4437 @smallexample
4438 @group
4439 1:  -9     1:  (0, 3)    1:  (3; 90.)   1:  (6; 90.)   1:  (2.4495; 45.)
4440     .          .             .              .              .
4442     9 n        Q             c p            2 *            Q
4443 @end group
4444 @end smallexample
4446 @noindent
4447 The square root of @i{-9} is by default rendered in rectangular form
4448 (@w{@cite{0 + 3i}}), but we can convert it to polar form (3 with a
4449 phase angle of 90 degrees).  All the usual arithmetic and scientific
4450 operations are defined on both types of complex numbers.
4452 Another generalized kind of number is @dfn{infinity}.  Infinity
4453 isn't really a number, but it can sometimes be treated like one.
4454 Calc uses the symbol @code{inf} to represent positive infinity,
4455 i.e., a value greater than any real number.  Naturally, you can
4456 also write @samp{-inf} for minus infinity, a value less than any
4457 real number.  The word @code{inf} can only be input using
4458 algebraic entry.
4460 @smallexample
4461 @group
4462 2:  inf        2:  -inf       2:  -inf       2:  -inf       1:  nan
4463 1:  -17        1:  -inf       1:  -inf       1:  inf            .
4464     .              .              .              .
4466 ' inf @key{RET} 17 n     *  @key{RET}         72 +           A              +
4467 @end group
4468 @end smallexample
4470 @noindent
4471 Since infinity is infinitely large, multiplying it by any finite
4472 number (like @i{-17}) has no effect, except that since @i{-17}
4473 is negative, it changes a plus infinity to a minus infinity.
4474 (``A huge positive number, multiplied by @i{-17}, yields a huge
4475 negative number.'')  Adding any finite number to infinity also
4476 leaves it unchanged.  Taking an absolute value gives us plus
4477 infinity again.  Finally, we add this plus infinity to the minus
4478 infinity we had earlier.  If you work it out, you might expect
4479 the answer to be @i{-72} for this.  But the 72 has been completely
4480 lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
4481 the finite difference between them, if any, is undetectable.
4482 So we say the result is @dfn{indeterminate}, which Calc writes
4483 with the symbol @code{nan} (for Not A Number).
4485 Dividing by zero is normally treated as an error, but you can get
4486 Calc to write an answer in terms of infinity by pressing @kbd{m i}
4487 to turn on ``infinite mode.''
4489 @smallexample
4490 @group
4491 3:  nan        2:  nan        2:  nan        2:  nan        1:  nan
4492 2:  1          1:  1 / 0      1:  uinf       1:  uinf           .
4493 1:  0              .              .              .
4494     .
4496   1 @key{RET} 0          /       m i    U /            17 n *         +
4497 @end group
4498 @end smallexample
4500 @noindent
4501 Dividing by zero normally is left unevaluated, but after @kbd{m i}
4502 it instead gives an infinite result.  The answer is actually
4503 @code{uinf}, ``undirected infinity.''  If you look at a graph of
4504 @cite{1 / x} around @w{@cite{x = 0}}, you'll see that it goes toward
4505 plus infinity as you approach zero from above, but toward minus
4506 infinity as you approach from below.  Since we said only @cite{1 / 0},
4507 Calc knows that the answer is infinite but not in which direction.
4508 That's what @code{uinf} means.  Notice that multiplying @code{uinf}
4509 by a negative number still leaves plain @code{uinf}; there's no
4510 point in saying @samp{-uinf} because the sign of @code{uinf} is
4511 unknown anyway.  Finally, we add @code{uinf} to our @code{nan},
4512 yielding @code{nan} again.  It's easy to see that, because
4513 @code{nan} means ``totally unknown'' while @code{uinf} means
4514 ``unknown sign but known to be infinite,'' the more mysterious
4515 @code{nan} wins out when it is combined with @code{uinf}, or, for
4516 that matter, with anything else.
4518 (@bullet{}) @strong{Exercise 2.}  Predict what Calc will answer
4519 for each of these formulas:  @samp{inf / inf}, @samp{exp(inf)},
4520 @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
4521 @samp{abs(uinf)}, @samp{ln(0)}.
4522 @xref{Types Answer 2, 2}. (@bullet{})
4524 (@bullet{}) @strong{Exercise 3.}  We saw that @samp{inf - inf = nan},
4525 which stands for an unknown value.  Can @code{nan} stand for
4526 a complex number?  Can it stand for infinity?
4527 @xref{Types Answer 3, 3}. (@bullet{})
4529 @dfn{HMS forms} represent a value in terms of hours, minutes, and
4530 seconds.
4532 @smallexample
4533 @group
4534 1:  2@@ 30' 0"     1:  3@@ 30' 0"     2:  3@@ 30' 0"     1:  2.
4535     .                 .             1:  1@@ 45' 0."        .
4536                                         .
4538   2@@ 30' @key{RET}          1 +               @key{RET} 2 /           /
4539 @end group
4540 @end smallexample
4542 HMS forms can also be used to hold angles in degrees, minutes, and
4543 seconds.
4545 @smallexample
4546 @group
4547 1:  0.5        1:  26.56505   1:  26@@ 33' 54.18"    1:  0.44721
4548     .              .              .                     .
4550     0.5            I T            c h                   S
4551 @end group
4552 @end smallexample
4554 @noindent
4555 First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
4556 form, then we take the sine of that angle.  Note that the trigonometric
4557 functions will accept HMS forms directly as input.
4559 @cindex Beatles
4560 (@bullet{}) @strong{Exercise 4.}  The Beatles' @emph{Abbey Road} is
4561 47 minutes and 26 seconds long, and contains 17 songs.  What is the
4562 average length of a song on @emph{Abbey Road}?  If the Extended Disco
4563 Version of @emph{Abbey Road} added 20 seconds to the length of each
4564 song, how long would the album be?  @xref{Types Answer 4, 4}. (@bullet{})
4566 A @dfn{date form} represents a date, or a date and time.  Dates must
4567 be entered using algebraic entry.  Date forms are surrounded by
4568 @samp{< >} symbols; most standard formats for dates are recognized.
4570 @smallexample
4571 @group
4572 2:  <Sun Jan 13, 1991>                    1:  2.25
4573 1:  <6:00pm Thu Jan 10, 1991>                 .
4574     .
4576 ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET}           -
4577 @end group
4578 @end smallexample
4580 @noindent
4581 In this example, we enter two dates, then subtract to find the
4582 number of days between them.  It is also possible to add an
4583 HMS form or a number (of days) to a date form to get another
4584 date form.
4586 @smallexample
4587 @group
4588 1:  <4:45:59pm Mon Jan 14, 1991>     1:  <2:50:59am Thu Jan 17, 1991>
4589     .                                    .
4591     t N                                  2 + 10@@ 5' +
4592 @end group
4593 @end smallexample
4595 @c [fix-ref Date Arithmetic]
4596 @noindent
4597 The @kbd{t N} (``now'') command pushes the current date and time on the
4598 stack; then we add two days, ten hours and five minutes to the date and
4599 time.  Other date-and-time related commands include @kbd{t J}, which
4600 does Julian day conversions, @kbd{t W}, which finds the beginning of
4601 the week in which a date form lies, and @kbd{t I}, which increments a
4602 date by one or several months.  @xref{Date Arithmetic}, for more.
4604 (@bullet{}) @strong{Exercise 5.}  How many days until the next
4605 Friday the 13th?  @xref{Types Answer 5, 5}. (@bullet{})
4607 (@bullet{}) @strong{Exercise 6.}  How many leap years will there be
4608 between now and the year 10001 A.D.?  @xref{Types Answer 6, 6}. (@bullet{})
4610 @cindex Slope and angle of a line
4611 @cindex Angle and slope of a line
4612 An @dfn{error form} represents a mean value with an attached standard
4613 deviation, or error estimate.  Suppose our measurements indicate that
4614 a certain telephone pole is about 30 meters away, with an estimated
4615 error of 1 meter, and 8 meters tall, with an estimated error of 0.2
4616 meters.  What is the slope of a line from here to the top of the
4617 pole, and what is the equivalent angle in degrees?
4619 @smallexample
4620 @group
4621 1:  8 +/- 0.2    2:  8 +/- 0.2   1:  0.266 +/- 0.011   1:  14.93 +/- 0.594
4622     .            1:  30 +/- 1        .                     .
4623                      .
4625     8 p .2 @key{RET}       30 p 1          /                     I T
4626 @end group
4627 @end smallexample
4629 @noindent
4630 This means that the angle is about 15 degrees, and, assuming our
4631 original error estimates were valid standard deviations, there is about
4632 a 60% chance that the result is correct within 0.59 degrees.
4634 @cindex Torus, volume of
4635 (@bullet{}) @strong{Exercise 7.}  The volume of a torus (a donut shape) is
4636 @c{$2 \pi^2 R r^2$}
4637 @w{@cite{2 pi^2 R r^2}} where @cite{R} is the radius of the circle that
4638 defines the center of the tube and @cite{r} is the radius of the tube
4639 itself.  Suppose @cite{R} is 20 cm and @cite{r} is 4 cm, each known to
4640 within 5 percent.  What is the volume and the relative uncertainty of
4641 the volume?  @xref{Types Answer 7, 7}. (@bullet{})
4643 An @dfn{interval form} represents a range of values.  While an
4644 error form is best for making statistical estimates, intervals give
4645 you exact bounds on an answer.  Suppose we additionally know that
4646 our telephone pole is definitely between 28 and 31 meters away,
4647 and that it is between 7.7 and 8.1 meters tall.
4649 @smallexample
4650 @group
4651 1:  [7.7 .. 8.1]  2:  [7.7 .. 8.1]  1:  [0.24 .. 0.28]  1:  [13.9 .. 16.1]
4652     .             1:  [28 .. 31]        .                   .
4653                       .
4655   [ 7.7 .. 8.1 ]    [ 28 .. 31 ]        /                   I T
4656 @end group
4657 @end smallexample
4659 @noindent
4660 If our bounds were correct, then the angle to the top of the pole
4661 is sure to lie in the range shown.
4663 The square brackets around these intervals indicate that the endpoints
4664 themselves are allowable values.  In other words, the distance to the
4665 telephone pole is between 28 and 31, @emph{inclusive}.  You can also
4666 make an interval that is exclusive of its endpoints by writing
4667 parentheses instead of square brackets.  You can even make an interval
4668 which is inclusive (``closed'') on one end and exclusive (``open'') on
4669 the other.
4671 @smallexample
4672 @group
4673 1:  [1 .. 10)    1:  (0.1 .. 1]   2:  (0.1 .. 1]   1:  (0.2 .. 3)
4674     .                .            1:  [2 .. 3)         .
4675                                       .
4677   [ 1 .. 10 )        &              [ 2 .. 3 )         *
4678 @end group
4679 @end smallexample
4681 @noindent
4682 The Calculator automatically keeps track of which end values should
4683 be open and which should be closed.  You can also make infinite or
4684 semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
4685 or both endpoints.
4687 (@bullet{}) @strong{Exercise 8.}  What answer would you expect from
4688 @samp{@w{1 /} @w{(0 .. 10)}}?  What about @samp{@w{1 /} @w{(-10 .. 0)}}?  What
4689 about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
4690 zero)?  What about @samp{@w{1 /} @w{(-10 .. 10)}}?
4691 @xref{Types Answer 8, 8}. (@bullet{})
4693 (@bullet{}) @strong{Exercise 9.}  Two easy ways of squaring a number
4694 are @kbd{@key{RET} *} and @w{@kbd{2 ^}}.  Normally these produce the same
4695 answer.  Would you expect this still to hold true for interval forms?
4696 If not, which of these will result in a larger interval?
4697 @xref{Types Answer 9, 9}. (@bullet{})
4699 A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
4700 For example, arithmetic involving time is generally done modulo 12
4701 or 24 hours.
4703 @smallexample
4704 @group
4705 1:  17 mod 24    1:  3 mod 24     1:  21 mod 24    1:  9 mod 24
4706     .                .                .                .
4708     17 M 24 @key{RET}      10 +             n                5 /
4709 @end group
4710 @end smallexample
4712 @noindent
4713 In this last step, Calc has found a new number which, when multiplied
4714 by 5 modulo 24, produces the original number, 21.  If @var{m} is prime
4715 it is always possible to find such a number.  For non-prime @var{m}
4716 like 24, it is only sometimes possible.
4718 @smallexample
4719 @group
4720 1:  10 mod 24    1:  16 mod 24    1:  1000000...   1:  16
4721     .                .                .                .
4723     10 M 24 @key{RET}      100 ^            10 @key{RET} 100 ^     24 %
4724 @end group
4725 @end smallexample
4727 @noindent
4728 These two calculations get the same answer, but the first one is
4729 much more efficient because it avoids the huge intermediate value
4730 that arises in the second one.
4732 @cindex Fermat, primality test of
4733 (@bullet{}) @strong{Exercise 10.}  A theorem of Pierre de Fermat
4734 says that @c{\w{$x^{n-1} \bmod n = 1$}}
4735 @cite{x^(n-1) mod n = 1} if @cite{n} is a prime number
4736 and @cite{x} is an integer less than @cite{n}.  If @cite{n} is
4737 @emph{not} a prime number, this will @emph{not} be true for most
4738 values of @cite{x}.  Thus we can test informally if a number is
4739 prime by trying this formula for several values of @cite{x}.
4740 Use this test to tell whether the following numbers are prime:
4741 811749613, 15485863.  @xref{Types Answer 10, 10}. (@bullet{})
4743 It is possible to use HMS forms as parts of error forms, intervals,
4744 modulo forms, or as the phase part of a polar complex number.
4745 For example, the @code{calc-time} command pushes the current time
4746 of day on the stack as an HMS/modulo form.
4748 @smallexample
4749 @group
4750 1:  17@@ 34' 45" mod 24@@ 0' 0"     1:  6@@ 22' 15" mod 24@@ 0' 0"
4751     .                                 .
4753     x time @key{RET}                        n
4754 @end group
4755 @end smallexample
4757 @noindent
4758 This calculation tells me it is six hours and 22 minutes until midnight.
4760 (@bullet{}) @strong{Exercise 11.}  A rule of thumb is that one year
4761 is about @c{$\pi \times 10^7$}
4762 @w{@cite{pi * 10^7}} seconds.  What time will it be that
4763 many seconds from right now?  @xref{Types Answer 11, 11}. (@bullet{})
4765 (@bullet{}) @strong{Exercise 12.}  You are preparing to order packaging
4766 for the CD release of the Extended Disco Version of @emph{Abbey Road}.
4767 You are told that the songs will actually be anywhere from 20 to 60
4768 seconds longer than the originals.  One CD can hold about 75 minutes
4769 of music.  Should you order single or double packages?
4770 @xref{Types Answer 12, 12}. (@bullet{})
4772 Another kind of data the Calculator can manipulate is numbers with
4773 @dfn{units}.  This isn't strictly a new data type; it's simply an
4774 application of algebraic expressions, where we use variables with
4775 suggestive names like @samp{cm} and @samp{in} to represent units
4776 like centimeters and inches.
4778 @smallexample
4779 @group
4780 1:  2 in        1:  5.08 cm      1:  0.027778 fath   1:  0.0508 m
4781     .               .                .                   .
4783     ' 2in @key{RET}       u c cm @key{RET}       u c fath @key{RET}        u b
4784 @end group
4785 @end smallexample
4787 @noindent
4788 We enter the quantity ``2 inches'' (actually an algebraic expression
4789 which means two times the variable @samp{in}), then we convert it
4790 first to centimeters, then to fathoms, then finally to ``base'' units,
4791 which in this case means meters.
4793 @smallexample
4794 @group
4795 1:  9 acre     1:  3 sqrt(acre)   1:  190.84 m   1:  190.84 m + 30 cm
4796     .              .                  .              .
4798  ' 9 acre @key{RET}      Q                  u s            ' $+30 cm @key{RET}
4800 @end group
4801 @end smallexample
4802 @noindent
4803 @smallexample
4804 @group
4805 1:  191.14 m     1:  36536.3046 m^2    1:  365363046 cm^2
4806     .                .                     .
4808     u s              2 ^                   u c cgs
4809 @end group
4810 @end smallexample
4812 @noindent
4813 Since units expressions are really just formulas, taking the square
4814 root of @samp{acre} is undefined.  After all, @code{acre} might be an
4815 algebraic variable that you will someday assign a value.  We use the
4816 ``units-simplify'' command to simplify the expression with variables
4817 being interpreted as unit names.
4819 In the final step, we have converted not to a particular unit, but to a
4820 units system.  The ``cgs'' system uses centimeters instead of meters
4821 as its standard unit of length.
4823 There is a wide variety of units defined in the Calculator.
4825 @smallexample
4826 @group
4827 1:  55 mph     1:  88.5139 kph   1:   88.5139 km / hr   1:  8.201407e-8 c
4828     .              .                  .                     .
4830  ' 55 mph @key{RET}      u c kph @key{RET}        u c km/hr @key{RET}         u c c @key{RET}
4831 @end group
4832 @end smallexample
4834 @noindent
4835 We express a speed first in miles per hour, then in kilometers per
4836 hour, then again using a slightly more explicit notation, then
4837 finally in terms of fractions of the speed of light.
4839 Temperature conversions are a bit more tricky.  There are two ways to
4840 interpret ``20 degrees Fahrenheit''---it could mean an actual
4841 temperature, or it could mean a change in temperature.  For normal
4842 units there is no difference, but temperature units have an offset
4843 as well as a scale factor and so there must be two explicit commands
4844 for them.
4846 @smallexample
4847 @group
4848 1:  20 degF       1:  11.1111 degC     1:  -20:3 degC    1:  -6.666 degC
4849     .                 .                    .                 .
4851   ' 20 degF @key{RET}       u c degC @key{RET}         U u t degC @key{RET}    c f
4852 @end group
4853 @end smallexample
4855 @noindent
4856 First we convert a change of 20 degrees Fahrenheit into an equivalent
4857 change in degrees Celsius (or Centigrade).  Then, we convert the
4858 absolute temperature 20 degrees Fahrenheit into Celsius.  Since
4859 this comes out as an exact fraction, we then convert to floating-point
4860 for easier comparison with the other result.
4862 For simple unit conversions, you can put a plain number on the stack.
4863 Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
4864 When you use this method, you're responsible for remembering which
4865 numbers are in which units:
4867 @smallexample
4868 @group
4869 1:  55         1:  88.5139              1:  8.201407e-8
4870     .              .                        .
4872     55             u c mph @key{RET} kph @key{RET}      u c km/hr @key{RET} c @key{RET}
4873 @end group
4874 @end smallexample
4876 To see a complete list of built-in units, type @kbd{u v}.  Press
4877 @w{@kbd{M-# c}} again to re-enter the Calculator when you're done looking
4878 at the units table.
4880 (@bullet{}) @strong{Exercise 13.}  How many seconds are there really
4881 in a year?  @xref{Types Answer 13, 13}. (@bullet{})
4883 @cindex Speed of light
4884 (@bullet{}) @strong{Exercise 14.}  Supercomputer designs are limited by
4885 the speed of light (and of electricity, which is nearly as fast).
4886 Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
4887 cabinet is one meter across.  Is speed of light going to be a
4888 significant factor in its design?  @xref{Types Answer 14, 14}. (@bullet{})
4890 (@bullet{}) @strong{Exercise 15.}  Sam the Slug normally travels about
4891 five yards in an hour.  He has obtained a supply of Power Pills; each
4892 Power Pill he eats doubles his speed.  How many Power Pills can he
4893 swallow and still travel legally on most US highways?
4894 @xref{Types Answer 15, 15}. (@bullet{})
4896 @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
4897 @section Algebra and Calculus Tutorial
4899 @noindent
4900 This section shows how to use Calc's algebra facilities to solve
4901 equations, do simple calculus problems, and manipulate algebraic
4902 formulas.
4904 @menu
4905 * Basic Algebra Tutorial::
4906 * Rewrites Tutorial::
4907 @end menu
4909 @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
4910 @subsection Basic Algebra
4912 @noindent
4913 If you enter a formula in algebraic mode that refers to variables,
4914 the formula itself is pushed onto the stack.  You can manipulate
4915 formulas as regular data objects.
4917 @smallexample
4918 @group
4919 1:  2 x^2 - 6       1:  6 - 2 x^2       1:  (6 - 2 x^2) (3 x^2 + y)
4920     .                   .                   .
4922     ' 2x^2-6 @key{RET}        n                   ' 3x^2+y @key{RET} *
4923 @end group
4924 @end smallexample
4926 (@bullet{}) @strong{Exercise 1.}  Do @kbd{' x @key{RET} Q 2 ^} and
4927 @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
4928 Why or why not?  @xref{Algebra Answer 1, 1}. (@bullet{})
4930 There are also commands for doing common algebraic operations on
4931 formulas.  Continuing with the formula from the last example,
4933 @smallexample
4934 @group
4935 1:  18 x^2 + 6 y - 6 x^4 - 2 x^2 y    1:  (18 - 2 y) x^2 - 6 x^4 + 6 y
4936     .                                     .
4938     a x                                   a c x @key{RET}
4939 @end group
4940 @end smallexample
4942 @noindent
4943 First we ``expand'' using the distributive law, then we ``collect''
4944 terms involving like powers of @cite{x}.
4946 Let's find the value of this expression when @cite{x} is 2 and @cite{y}
4947 is one-half.
4949 @smallexample
4950 @group
4951 1:  17 x^2 - 6 x^4 + 3      1:  -25
4952     .                           .
4954     1:2 s l y @key{RET}               2 s l x @key{RET}
4955 @end group
4956 @end smallexample
4958 @noindent
4959 The @kbd{s l} command means ``let''; it takes a number from the top of
4960 the stack and temporarily assigns it as the value of the variable
4961 you specify.  It then evaluates (as if by the @kbd{=} key) the
4962 next expression on the stack.  After this command, the variable goes
4963 back to its original value, if any.
4965 (An earlier exercise in this tutorial involved storing a value in the
4966 variable @code{x}; if this value is still there, you will have to
4967 unstore it with @kbd{s u x @key{RET}} before the above example will work
4968 properly.)
4970 @cindex Maximum of a function using Calculus
4971 Let's find the maximum value of our original expression when @cite{y}
4972 is one-half and @cite{x} ranges over all possible values.  We can
4973 do this by taking the derivative with respect to @cite{x} and examining
4974 values of @cite{x} for which the derivative is zero.  If the second
4975 derivative of the function at that value of @cite{x} is negative,
4976 the function has a local maximum there.
4978 @smallexample
4979 @group
4980 1:  17 x^2 - 6 x^4 + 3      1:  34 x - 24 x^3
4981     .                           .
4983     U @key{DEL}  s 1                  a d x @key{RET}   s 2
4984 @end group
4985 @end smallexample
4987 @noindent
4988 Well, the derivative is clearly zero when @cite{x} is zero.  To find
4989 the other root(s), let's divide through by @cite{x} and then solve:
4991 @smallexample
4992 @group
4993 1:  (34 x - 24 x^3) / x    1:  34 x / x - 24 x^3 / x    1:  34 - 24 x^2
4994     .                          .                            .
4996     ' x @key{RET} /                  a x                          a s
4998 @end group
4999 @end smallexample
5000 @noindent
5001 @smallexample
5002 @group
5003 1:  34 - 24 x^2 = 0        1:  x = 1.19023
5004     .                          .
5006     0 a =  s 3                 a S x @key{RET}
5007 @end group
5008 @end smallexample
5010 @noindent
5011 Notice the use of @kbd{a s} to ``simplify'' the formula.  When the
5012 default algebraic simplifications don't do enough, you can use
5013 @kbd{a s} to tell Calc to spend more time on the job.
5015 Now we compute the second derivative and plug in our values of @cite{x}:
5017 @smallexample
5018 @group
5019 1:  1.19023        2:  1.19023         2:  1.19023
5020     .              1:  34 x - 24 x^3   1:  34 - 72 x^2
5021                        .                   .
5023     a .                r 2                 a d x @key{RET} s 4
5024 @end group
5025 @end smallexample
5027 @noindent
5028 (The @kbd{a .} command extracts just the righthand side of an equation.
5029 Another method would have been to use @kbd{v u} to unpack the equation
5030 @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
5031 to delete the @samp{x}.)
5033 @smallexample
5034 @group
5035 2:  34 - 72 x^2   1:  -68.         2:  34 - 72 x^2     1:  34
5036 1:  1.19023           .            1:  0                   .
5037     .                                  .
5039     @key{TAB}               s l x @key{RET}        U @key{DEL} 0             s l x @key{RET}
5040 @end group
5041 @end smallexample
5043 @noindent
5044 The first of these second derivatives is negative, so we know the function
5045 has a maximum value at @cite{x = 1.19023}.  (The function also has a
5046 local @emph{minimum} at @cite{x = 0}.)
5048 When we solved for @cite{x}, we got only one value even though
5049 @cite{34 - 24 x^2 = 0} is a quadratic equation that ought to have
5050 two solutions.  The reason is that @w{@kbd{a S}} normally returns a
5051 single ``principal'' solution.  If it needs to come up with an
5052 arbitrary sign (as occurs in the quadratic formula) it picks @cite{+}.
5053 If it needs an arbitrary integer, it picks zero.  We can get a full
5054 solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
5056 @smallexample
5057 @group
5058 1:  34 - 24 x^2 = 0    1:  x = 1.19023 s1      1:  x = -1.19023
5059     .                      .                       .
5061     r 3                    H a S x @key{RET}  s 5        1 n  s l s1 @key{RET}
5062 @end group
5063 @end smallexample
5065 @noindent
5066 Calc has invented the variable @samp{s1} to represent an unknown sign;
5067 it is supposed to be either @i{+1} or @i{-1}.  Here we have used
5068 the ``let'' command to evaluate the expression when the sign is negative.
5069 If we plugged this into our second derivative we would get the same,
5070 negative, answer, so @cite{x = -1.19023} is also a maximum.
5072 To find the actual maximum value, we must plug our two values of @cite{x}
5073 into the original formula.
5075 @smallexample
5076 @group
5077 2:  17 x^2 - 6 x^4 + 3    1:  24.08333 s1^2 - 12.04166 s1^4 + 3
5078 1:  x = 1.19023 s1            .
5079     .
5081     r 1 r 5                   s l @key{RET}
5082 @end group
5083 @end smallexample
5085 @noindent
5086 (Here we see another way to use @kbd{s l}; if its input is an equation
5087 with a variable on the lefthand side, then @kbd{s l} treats the equation
5088 like an assignment to that variable if you don't give a variable name.)
5090 It's clear that this will have the same value for either sign of
5091 @code{s1}, but let's work it out anyway, just for the exercise:
5093 @smallexample
5094 @group
5095 2:  [-1, 1]              1:  [15.04166, 15.04166]
5096 1:  24.08333 s1^2 ...        .
5097     .
5099   [ 1 n , 1 ] @key{TAB}            V M $ @key{RET}
5100 @end group
5101 @end smallexample
5103 @noindent
5104 Here we have used a vector mapping operation to evaluate the function
5105 at several values of @samp{s1} at once.  @kbd{V M $} is like @kbd{V M '}
5106 except that it takes the formula from the top of the stack.  The
5107 formula is interpreted as a function to apply across the vector at the
5108 next-to-top stack level.  Since a formula on the stack can't contain
5109 @samp{$} signs, Calc assumes the variables in the formula stand for
5110 different arguments.  It prompts you for an @dfn{argument list}, giving
5111 the list of all variables in the formula in alphabetical order as the
5112 default list.  In this case the default is @samp{(s1)}, which is just
5113 what we want so we simply press @key{RET} at the prompt.
5115 If there had been several different values, we could have used
5116 @w{@kbd{V R X}} to find the global maximum.
5118 Calc has a built-in @kbd{a P} command that solves an equation using
5119 @w{@kbd{H a S}} and returns a vector of all the solutions.  It simply
5120 automates the job we just did by hand.  Applied to our original
5121 cubic polynomial, it would produce the vector of solutions
5122 @cite{[1.19023, -1.19023, 0]}.  (There is also an @kbd{a X} command
5123 which finds a local maximum of a function.  It uses a numerical search
5124 method rather than examining the derivatives, and thus requires you
5125 to provide some kind of initial guess to show it where to look.)
5127 (@bullet{}) @strong{Exercise 2.}  Given a vector of the roots of a
5128 polynomial (such as the output of an @kbd{a P} command), what
5129 sequence of commands would you use to reconstruct the original
5130 polynomial?  (The answer will be unique to within a constant
5131 multiple; choose the solution where the leading coefficient is one.)
5132 @xref{Algebra Answer 2, 2}. (@bullet{})
5134 The @kbd{m s} command enables ``symbolic mode,'' in which formulas
5135 like @samp{sqrt(5)} that can't be evaluated exactly are left in
5136 symbolic form rather than giving a floating-point approximate answer.
5137 Fraction mode (@kbd{m f}) is also useful when doing algebra.
5139 @smallexample
5140 @group
5141 2:  34 x - 24 x^3        2:  34 x - 24 x^3
5142 1:  34 x - 24 x^3        1:  [sqrt(51) / 6, sqrt(51) / -6, 0]
5143     .                        .
5145     r 2  @key{RET}     m s  m f    a P x @key{RET}
5146 @end group
5147 @end smallexample
5149 One more mode that makes reading formulas easier is ``Big mode.''
5151 @smallexample
5152 @group
5153                3
5154 2:  34 x - 24 x
5156       ____   ____
5157      V 51   V 51
5158 1:  [-----, -----, 0]
5159        6     -6
5161     .
5163     d B
5164 @end group
5165 @end smallexample
5167 Here things like powers, square roots, and quotients and fractions
5168 are displayed in a two-dimensional pictorial form.  Calc has other
5169 language modes as well, such as C mode, FORTRAN mode, and @TeX{} mode.
5171 @smallexample
5172 @group
5173 2:  34*x - 24*pow(x, 3)               2:  34*x - 24*x**3
5174 1:  @{sqrt(51) / 6, sqrt(51) / -6, 0@}  1:  /sqrt(51) / 6, sqrt(51) / -6, 0/
5175     .                                     .
5177     d C                                   d F
5179 @end group
5180 @end smallexample
5181 @noindent
5182 @smallexample
5183 @group
5184 3:  34 x - 24 x^3
5185 2:  [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
5186 1:  @{2 \over 3@} \sqrt@{5@}
5187     .
5189     d T   ' 2 \sqrt@{5@} \over 3 @key{RET}
5190 @end group
5191 @end smallexample
5193 @noindent
5194 As you can see, language modes affect both entry and display of
5195 formulas.  They affect such things as the names used for built-in
5196 functions, the set of arithmetic operators and their precedences,
5197 and notations for vectors and matrices.
5199 Notice that @samp{sqrt(51)} may cause problems with older
5200 implementations of C and FORTRAN, which would require something more
5201 like @samp{sqrt(51.0)}.  It is always wise to check over the formulas
5202 produced by the various language modes to make sure they are fully
5203 correct.
5205 Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes.  (You
5206 may prefer to remain in Big mode, but all the examples in the tutorial
5207 are shown in normal mode.)
5209 @cindex Area under a curve
5210 What is the area under the portion of this curve from @cite{x = 1} to @cite{2}?
5211 This is simply the integral of the function:
5213 @smallexample
5214 @group
5215 1:  17 x^2 - 6 x^4 + 3     1:  5.6666 x^3 - 1.2 x^5 + 3 x
5216     .                          .
5218     r 1                        a i x
5219 @end group
5220 @end smallexample
5222 @noindent
5223 We want to evaluate this at our two values for @cite{x} and subtract.
5224 One way to do it is again with vector mapping and reduction:
5226 @smallexample
5227 @group
5228 2:  [2, 1]            1:  [12.93333, 7.46666]    1:  5.46666
5229 1:  5.6666 x^3 ...        .                          .
5231    [ 2 , 1 ] @key{TAB}          V M $ @key{RET}                  V R -
5232 @end group
5233 @end smallexample
5235 (@bullet{}) @strong{Exercise 3.}  Find the integral from 1 to @cite{y}
5236 of @c{$x \sin \pi x$}
5237 @w{@cite{x sin(pi x)}} (where the sine is calculated in radians).
5238 Find the values of the integral for integers @cite{y} from 1 to 5.
5239 @xref{Algebra Answer 3, 3}. (@bullet{})
5241 Calc's integrator can do many simple integrals symbolically, but many
5242 others are beyond its capabilities.  Suppose we wish to find the area
5243 under the curve @c{$\sin x \ln x$}
5244 @cite{sin(x) ln(x)} over the same range of @cite{x}.  If
5245 you entered this formula and typed @kbd{a i x @key{RET}} (don't bother to try
5246 this), Calc would work for a long time but would be unable to find a
5247 solution.  In fact, there is no closed-form solution to this integral.
5248 Now what do we do?
5250 @cindex Integration, numerical
5251 @cindex Numerical integration
5252 One approach would be to do the integral numerically.  It is not hard
5253 to do this by hand using vector mapping and reduction.  It is rather
5254 slow, though, since the sine and logarithm functions take a long time.
5255 We can save some time by reducing the working precision.
5257 @smallexample
5258 @group
5259 3:  10                  1:  [1, 1.1, 1.2,  ...  , 1.8, 1.9]
5260 2:  1                       .
5261 1:  0.1
5262     .
5264  10 @key{RET} 1 @key{RET} .1 @key{RET}        C-u v x
5265 @end group
5266 @end smallexample
5268 @noindent
5269 (Note that we have used the extended version of @kbd{v x}; we could
5270 also have used plain @kbd{v x} as follows:  @kbd{v x 10 @key{RET} 9 + .1 *}.)
5272 @smallexample
5273 @group
5274 2:  [1, 1.1, ... ]              1:  [0., 0.084941, 0.16993, ... ]
5275 1:  sin(x) ln(x)                    .
5276     .
5278     ' sin(x) ln(x) @key{RET}  s 1    m r  p 5 @key{RET}   V M $ @key{RET}
5280 @end group
5281 @end smallexample
5282 @noindent
5283 @smallexample
5284 @group
5285 1:  3.4195     0.34195
5286     .          .
5288     V R +      0.1 *
5289 @end group
5290 @end smallexample
5292 @noindent
5293 (If you got wildly different results, did you remember to switch
5294 to radians mode?)
5296 Here we have divided the curve into ten segments of equal width;
5297 approximating these segments as rectangular boxes (i.e., assuming
5298 the curve is nearly flat at that resolution), we compute the areas
5299 of the boxes (height times width), then sum the areas.  (It is
5300 faster to sum first, then multiply by the width, since the width
5301 is the same for every box.)
5303 The true value of this integral turns out to be about 0.374, so
5304 we're not doing too well.  Let's try another approach.
5306 @smallexample
5307 @group
5308 1:  sin(x) ln(x)    1:  0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
5309     .                   .
5311     r 1                 a t x=1 @key{RET} 4 @key{RET}
5312 @end group
5313 @end smallexample
5315 @noindent
5316 Here we have computed the Taylor series expansion of the function
5317 about the point @cite{x=1}.  We can now integrate this polynomial
5318 approximation, since polynomials are easy to integrate.
5320 @smallexample
5321 @group
5322 1:  0.42074 x^2 + ...    1:  [-0.0446, -0.42073]      1:  0.3761
5323     .                        .                            .
5325     a i x @key{RET}            [ 2 , 1 ] @key{TAB}  V M $ @key{RET}         V R -
5326 @end group
5327 @end smallexample
5329 @noindent
5330 Better!  By increasing the precision and/or asking for more terms
5331 in the Taylor series, we can get a result as accurate as we like.
5332 (Taylor series converge better away from singularities in the
5333 function such as the one at @code{ln(0)}, so it would also help to
5334 expand the series about the points @cite{x=2} or @cite{x=1.5} instead
5335 of @cite{x=1}.)
5337 @cindex Simpson's rule
5338 @cindex Integration by Simpson's rule
5339 (@bullet{}) @strong{Exercise 4.}  Our first method approximated the
5340 curve by stairsteps of width 0.1; the total area was then the sum
5341 of the areas of the rectangles under these stairsteps.  Our second
5342 method approximated the function by a polynomial, which turned out
5343 to be a better approximation than stairsteps.  A third method is
5344 @dfn{Simpson's rule}, which is like the stairstep method except
5345 that the steps are not required to be flat.  Simpson's rule boils
5346 down to the formula,
5348 @ifinfo
5349 @example
5350 (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
5351               + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
5352 @end example
5353 @end ifinfo
5354 @tex
5355 \turnoffactive
5356 \beforedisplay
5357 $$ \displaylines{
5358       \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
5359    \hfill \cr \hfill    {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
5360 } $$
5361 \afterdisplay
5362 @end tex
5364 @noindent
5365 where @cite{n} (which must be even) is the number of slices and @cite{h}
5366 is the width of each slice.  These are 10 and 0.1 in our example.
5367 For reference, here is the corresponding formula for the stairstep
5368 method:
5370 @ifinfo
5371 @example
5372 h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
5373           + f(a+(n-2)*h) + f(a+(n-1)*h))
5374 @end example
5375 @end ifinfo
5376 @tex
5377 \turnoffactive
5378 \beforedisplay
5379 $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
5380            + f(a+(n-2)h) + f(a+(n-1)h)) $$
5381 \afterdisplay
5382 @end tex
5384 Compute the integral from 1 to 2 of @c{$\sin x \ln x$}
5385 @cite{sin(x) ln(x)} using
5386 Simpson's rule with 10 slices.  @xref{Algebra Answer 4, 4}. (@bullet{})
5388 Calc has a built-in @kbd{a I} command for doing numerical integration.
5389 It uses @dfn{Romberg's method}, which is a more sophisticated cousin
5390 of Simpson's rule.  In particular, it knows how to keep refining the
5391 result until the current precision is satisfied.
5393 @c [fix-ref Selecting Sub-Formulas]
5394 Aside from the commands we've seen so far, Calc also provides a
5395 large set of commands for operating on parts of formulas.  You
5396 indicate the desired sub-formula by placing the cursor on any part
5397 of the formula before giving a @dfn{selection} command.  Selections won't
5398 be covered in the tutorial; @pxref{Selecting Subformulas}, for
5399 details and examples.
5401 @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
5402 @c                to 2^((n-1)*(r-1)).
5404 @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
5405 @subsection Rewrite Rules
5407 @noindent
5408 No matter how many built-in commands Calc provided for doing algebra,
5409 there would always be something you wanted to do that Calc didn't have
5410 in its repertoire.  So Calc also provides a @dfn{rewrite rule} system
5411 that you can use to define your own algebraic manipulations.
5413 Suppose we want to simplify this trigonometric formula:
5415 @smallexample
5416 @group
5417 1:  1 / cos(x) - sin(x) tan(x)
5418     .
5420     ' 1/cos(x) - sin(x) tan(x) @key{RET}   s 1
5421 @end group
5422 @end smallexample
5424 @noindent
5425 If we were simplifying this by hand, we'd probably replace the
5426 @samp{tan} with a @samp{sin/cos} first, then combine over a common
5427 denominator.  There is no Calc command to do the former; the @kbd{a n}
5428 algebra command will do the latter but we'll do both with rewrite
5429 rules just for practice.
5431 Rewrite rules are written with the @samp{:=} symbol.
5433 @smallexample
5434 @group
5435 1:  1 / cos(x) - sin(x)^2 / cos(x)
5436     .
5438     a r tan(a) := sin(a)/cos(a) @key{RET}
5439 @end group
5440 @end smallexample
5442 @noindent
5443 (The ``assignment operator'' @samp{:=} has several uses in Calc.  All
5444 by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
5445 but when it is given to the @kbd{a r} command, that command interprets
5446 it as a rewrite rule.)
5448 The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
5449 rewrite rule.  Calc searches the formula on the stack for parts that
5450 match the pattern.  Variables in a rewrite pattern are called
5451 @dfn{meta-variables}, and when matching the pattern each meta-variable
5452 can match any sub-formula.  Here, the meta-variable @samp{a} matched
5453 the actual variable @samp{x}.
5455 When the pattern part of a rewrite rule matches a part of the formula,
5456 that part is replaced by the righthand side with all the meta-variables
5457 substituted with the things they matched.  So the result is
5458 @samp{sin(x) / cos(x)}.  Calc's normal algebraic simplifications then
5459 mix this in with the rest of the original formula.
5461 To merge over a common denominator, we can use another simple rule:
5463 @smallexample
5464 @group
5465 1:  (1 - sin(x)^2) / cos(x)
5466     .
5468     a r a/x + b/x := (a+b)/x @key{RET}
5469 @end group
5470 @end smallexample
5472 This rule points out several interesting features of rewrite patterns.
5473 First, if a meta-variable appears several times in a pattern, it must
5474 match the same thing everywhere.  This rule detects common denominators
5475 because the same meta-variable @samp{x} is used in both of the
5476 denominators.
5478 Second, meta-variable names are independent from variables in the
5479 target formula.  Notice that the meta-variable @samp{x} here matches
5480 the subformula @samp{cos(x)}; Calc never confuses the two meanings of
5481 @samp{x}.
5483 And third, rewrite patterns know a little bit about the algebraic
5484 properties of formulas.  The pattern called for a sum of two quotients;
5485 Calc was able to match a difference of two quotients by matching
5486 @samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}.
5488 @c [fix-ref Algebraic Properties of Rewrite Rules]
5489 We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
5490 the rule.  It would have worked just the same in all cases.  (If we
5491 really wanted the rule to apply only to @samp{+} or only to @samp{-},
5492 we could have used the @code{plain} symbol.  @xref{Algebraic Properties
5493 of Rewrite Rules}, for some examples of this.)
5495 One more rewrite will complete the job.  We want to use the identity
5496 @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
5497 the identity in a way that matches our formula.  The obvious rule
5498 would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows
5499 that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work.  The
5500 latter rule has a more general pattern so it will work in many other
5501 situations, too.
5503 @smallexample
5504 @group
5505 1:  (1 + cos(x)^2 - 1) / cos(x)           1:  cos(x)
5506     .                                         .
5508     a r sin(x)^2 := 1 - cos(x)^2 @key{RET}          a s
5509 @end group
5510 @end smallexample
5512 You may ask, what's the point of using the most general rule if you
5513 have to type it in every time anyway?  The answer is that Calc allows
5514 you to store a rewrite rule in a variable, then give the variable
5515 name in the @kbd{a r} command.  In fact, this is the preferred way to
5516 use rewrites.  For one, if you need a rule once you'll most likely
5517 need it again later.  Also, if the rule doesn't work quite right you
5518 can simply Undo, edit the variable, and run the rule again without
5519 having to retype it.
5521 @smallexample
5522 @group
5523 ' tan(x) := sin(x)/cos(x) @key{RET}      s t tsc @key{RET}
5524 ' a/x + b/x := (a+b)/x @key{RET}         s t merge @key{RET}
5525 ' sin(x)^2 := 1 - cos(x)^2 @key{RET}     s t sinsqr @key{RET}
5527 1:  1 / cos(x) - sin(x) tan(x)     1:  cos(x)
5528     .                                  .
5530     r 1                a r tsc @key{RET}  a r merge @key{RET}  a r sinsqr @key{RET}  a s
5531 @end group
5532 @end smallexample
5534 To edit a variable, type @kbd{s e} and the variable name, use regular
5535 Emacs editing commands as necessary, then type @kbd{M-# M-#} or
5536 @kbd{C-c C-c} to store the edited value back into the variable.
5537 You can also use @w{@kbd{s e}} to create a new variable if you wish.
5539 Notice that the first time you use each rule, Calc puts up a ``compiling''
5540 message briefly.  The pattern matcher converts rules into a special
5541 optimized pattern-matching language rather than using them directly.
5542 This allows @kbd{a r} to apply even rather complicated rules very
5543 efficiently.  If the rule is stored in a variable, Calc compiles it
5544 only once and stores the compiled form along with the variable.  That's
5545 another good reason to store your rules in variables rather than
5546 entering them on the fly.
5548 (@bullet{}) @strong{Exercise 1.}  Type @kbd{m s} to get symbolic
5549 mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
5550 Using a rewrite rule, simplify this formula by multiplying both
5551 sides by the conjugate @w{@samp{1 - sqrt(2)}}.  The result will have
5552 to be expanded by the distributive law; do this with another
5553 rewrite.  @xref{Rewrites Answer 1, 1}. (@bullet{})
5555 The @kbd{a r} command can also accept a vector of rewrite rules, or
5556 a variable containing a vector of rules.
5558 @smallexample
5559 @group
5560 1:  [tsc, merge, sinsqr]          1:  [tan(x) := sin(x) / cos(x), ... ]
5561     .                                 .
5563     ' [tsc,merge,sinsqr] @key{RET}          =
5565 @end group
5566 @end smallexample
5567 @noindent
5568 @smallexample
5569 @group
5570 1:  1 / cos(x) - sin(x) tan(x)    1:  cos(x)
5571     .                                 .
5573     s t trig @key{RET}  r 1                 a r trig @key{RET}  a s
5574 @end group
5575 @end smallexample
5577 @c [fix-ref Nested Formulas with Rewrite Rules]
5578 Calc tries all the rules you give against all parts of the formula,
5579 repeating until no further change is possible.  (The exact order in
5580 which things are tried is rather complex, but for simple rules like
5581 the ones we've used here the order doesn't really matter.
5582 @xref{Nested Formulas with Rewrite Rules}.)
5584 Calc actually repeats only up to 100 times, just in case your rule set
5585 has gotten into an infinite loop.  You can give a numeric prefix argument
5586 to @kbd{a r} to specify any limit.  In particular, @kbd{M-1 a r} does
5587 only one rewrite at a time.
5589 @smallexample
5590 @group
5591 1:  1 / cos(x) - sin(x)^2 / cos(x)    1:  (1 - sin(x)^2) / cos(x)
5592     .                                     .
5594     r 1  M-1 a r trig @key{RET}                 M-1 a r trig @key{RET}
5595 @end group
5596 @end smallexample
5598 You can type @kbd{M-0 a r} if you want no limit at all on the number
5599 of rewrites that occur.
5601 Rewrite rules can also be @dfn{conditional}.  Simply follow the rule
5602 with a @samp{::} symbol and the desired condition.  For example,
5604 @smallexample
5605 @group
5606 1:  exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
5607     .
5609     ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET}
5611 @end group
5612 @end smallexample
5613 @noindent
5614 @smallexample
5615 @group
5616 1:  1 + exp(3 pi i) + 1
5617     .
5619     a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET}
5620 @end group
5621 @end smallexample
5623 @noindent
5624 (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
5625 which will be zero only when @samp{k} is an even integer.)
5627 An interesting point is that the variables @samp{pi} and @samp{i}
5628 were matched literally rather than acting as meta-variables.
5629 This is because they are special-constant variables.  The special
5630 constants @samp{e}, @samp{phi}, and so on also match literally.
5631 A common error with rewrite
5632 rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
5633 to match any @samp{f} with five arguments but in fact matching
5634 only when the fifth argument is literally @samp{e}!@refill
5636 @cindex Fibonacci numbers
5637 @ignore
5638 @starindex
5639 @end ignore
5640 @tindex fib
5641 Rewrite rules provide an interesting way to define your own functions.
5642 Suppose we want to define @samp{fib(n)} to produce the @var{n}th
5643 Fibonacci number.  The first two Fibonacci numbers are each 1;
5644 later numbers are formed by summing the two preceding numbers in
5645 the sequence.  This is easy to express in a set of three rules:
5647 @smallexample
5648 @group
5649 ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET}  s t fib
5651 1:  fib(7)               1:  13
5652     .                        .
5654     ' fib(7) @key{RET}             a r fib @key{RET}
5655 @end group
5656 @end smallexample
5658 One thing that is guaranteed about the order that rewrites are tried
5659 is that, for any given subformula, earlier rules in the rule set will
5660 be tried for that subformula before later ones.  So even though the
5661 first and third rules both match @samp{fib(1)}, we know the first will
5662 be used preferentially.
5664 This rule set has one dangerous bug:  Suppose we apply it to the
5665 formula @samp{fib(x)}?  (Don't actually try this.)  The third rule
5666 will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
5667 Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
5668 fib(x-4)}, and so on, expanding forever.  What we really want is to apply
5669 the third rule only when @samp{n} is an integer greater than two.  Type
5670 @w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
5672 @smallexample
5673 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
5674 @end smallexample
5676 @noindent
5677 Now:
5679 @smallexample
5680 @group
5681 1:  fib(6) + fib(x) + fib(0)      1:  8 + fib(x) + fib(0)
5682     .                                 .
5684     ' fib(6)+fib(x)+fib(0) @key{RET}        a r fib @key{RET}
5685 @end group
5686 @end smallexample
5688 @noindent
5689 We've created a new function, @code{fib}, and a new command,
5690 @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
5691 this formula.''  To make things easier still, we can tell Calc to
5692 apply these rules automatically by storing them in the special
5693 variable @code{EvalRules}.
5695 @smallexample
5696 @group
5697 1:  [fib(1) := ...]    .                1:  [8, 13]
5698     .                                       .
5700     s r fib @key{RET}        s t EvalRules @key{RET}    ' [fib(6), fib(7)] @key{RET}
5701 @end group
5702 @end smallexample
5704 It turns out that this rule set has the problem that it does far
5705 more work than it needs to when @samp{n} is large.  Consider the
5706 first few steps of the computation of @samp{fib(6)}:
5708 @smallexample
5709 @group
5710 fib(6) =
5711 fib(5)              +               fib(4) =
5712 fib(4)     +      fib(3)     +      fib(3)     +      fib(2) =
5713 fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
5714 @end group
5715 @end smallexample
5717 @noindent
5718 Note that @samp{fib(3)} appears three times here.  Unless Calc's
5719 algebraic simplifier notices the multiple @samp{fib(3)}s and combines
5720 them (and, as it happens, it doesn't), this rule set does lots of
5721 needless recomputation.  To cure the problem, type @code{s e EvalRules}
5722 to edit the rules (or just @kbd{s E}, a shorthand command for editing
5723 @code{EvalRules}) and add another condition:
5725 @smallexample
5726 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
5727 @end smallexample
5729 @noindent
5730 If a @samp{:: remember} condition appears anywhere in a rule, then if
5731 that rule succeeds Calc will add another rule that describes that match
5732 to the front of the rule set.  (Remembering works in any rule set, but
5733 for technical reasons it is most effective in @code{EvalRules}.)  For
5734 example, if the rule rewrites @samp{fib(7)} to something that evaluates
5735 to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
5737 Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
5738 type @kbd{s E} again to see what has happened to the rule set.
5740 With the @code{remember} feature, our rule set can now compute
5741 @samp{fib(@var{n})} in just @var{n} steps.  In the process it builds
5742 up a table of all Fibonacci numbers up to @var{n}.  After we have
5743 computed the result for a particular @var{n}, we can get it back
5744 (and the results for all smaller @var{n}) later in just one step.
5746 All Calc operations will run somewhat slower whenever @code{EvalRules}
5747 contains any rules.  You should type @kbd{s u EvalRules @key{RET}} now to
5748 un-store the variable.
5750 (@bullet{}) @strong{Exercise 2.}  Sometimes it is possible to reformulate
5751 a problem to reduce the amount of recursion necessary to solve it.
5752 Create a rule that, in about @var{n} simple steps and without recourse
5753 to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
5754 @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
5755 @var{n}th and @var{n+1}st Fibonacci numbers, respectively.  This rule is
5756 rather clunky to use, so add a couple more rules to make the ``user
5757 interface'' the same as for our first version: enter @samp{fib(@var{n})},
5758 get back a plain number.  @xref{Rewrites Answer 2, 2}. (@bullet{})
5760 There are many more things that rewrites can do.  For example, there
5761 are @samp{&&&} and @samp{|||} pattern operators that create ``and''
5762 and ``or'' combinations of rules.  As one really simple example, we
5763 could combine our first two Fibonacci rules thusly:
5765 @example
5766 [fib(1 ||| 2) := 1, fib(n) := ... ]
5767 @end example
5769 @noindent
5770 That means ``@code{fib} of something matching either 1 or 2 rewrites
5771 to 1.''
5773 You can also make meta-variables optional by enclosing them in @code{opt}.
5774 For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
5775 @samp{2 + x} or @samp{3 x} or @samp{x}.  The pattern @samp{opt(a) + opt(b) x}
5776 matches all of these forms, filling in a default of zero for @samp{a}
5777 and one for @samp{b}.
5779 (@bullet{}) @strong{Exercise 3.}  Your friend Joe had @samp{2 + 3 x}
5780 on the stack and tried to use the rule
5781 @samp{opt(a) + opt(b) x := f(a, b, x)}.  What happened?
5782 @xref{Rewrites Answer 3, 3}. (@bullet{})
5784 (@bullet{}) @strong{Exercise 4.}  Starting with a positive integer @cite{a},
5785 divide @cite{a} by two if it is even, otherwise compute @cite{3 a + 1}.
5786 Now repeat this step over and over.  A famous unproved conjecture
5787 is that for any starting @cite{a}, the sequence always eventually
5788 reaches 1.  Given the formula @samp{seq(@var{a}, 0)}, write a set of
5789 rules that convert this into @samp{seq(1, @var{n})} where @var{n}
5790 is the number of steps it took the sequence to reach the value 1.
5791 Now enhance the rules to accept @samp{seq(@var{a})} as a starting
5792 configuration, and to stop with just the number @var{n} by itself.
5793 Now make the result be a vector of values in the sequence, from @var{a}
5794 to 1.  (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
5795 and @var{y}.)  For example, rewriting @samp{seq(6)} should yield the
5796 vector @cite{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
5797 @xref{Rewrites Answer 4, 4}. (@bullet{})
5799 (@bullet{}) @strong{Exercise 5.}  Define, using rewrite rules, a function
5800 @samp{nterms(@var{x})} that returns the number of terms in the sum
5801 @var{x}, or 1 if @var{x} is not a sum.  (A @dfn{sum} for our purposes
5802 is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
5803 so that @cite{2 - 3 (x + y) + x y} is a sum of three terms.)
5804 @xref{Rewrites Answer 5, 5}. (@bullet{})
5806 (@bullet{}) @strong{Exercise 6.}  Calc considers the form @cite{0^0}
5807 to be ``indeterminate,'' and leaves it unevaluated (assuming infinite
5808 mode is not enabled).  Some people prefer to define @cite{0^0 = 1},
5809 so that the identity @cite{x^0 = 1} can safely be used for all @cite{x}.
5810 Find a way to make Calc follow this convention.  What happens if you
5811 now type @kbd{m i} to turn on infinite mode?
5812 @xref{Rewrites Answer 6, 6}. (@bullet{})
5814 (@bullet{}) @strong{Exercise 7.}  A Taylor series for a function is an
5815 infinite series that exactly equals the value of that function at
5816 values of @cite{x} near zero.
5818 @ifinfo
5819 @example
5820 cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
5821 @end example
5822 @end ifinfo
5823 @tex
5824 \turnoffactive \let\rm\goodrm
5825 \beforedisplay
5826 $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
5827 \afterdisplay
5828 @end tex
5830 The @kbd{a t} command produces a @dfn{truncated Taylor series} which
5831 is obtained by dropping all the terms higher than, say, @cite{x^2}.
5832 Calc represents the truncated Taylor series as a polynomial in @cite{x}.
5833 Mathematicians often write a truncated series using a ``big-O'' notation
5834 that records what was the lowest term that was truncated.
5836 @ifinfo
5837 @example
5838 cos(x) = 1 - x^2 / 2! + O(x^3)
5839 @end example
5840 @end ifinfo
5841 @tex
5842 \turnoffactive \let\rm\goodrm
5843 \beforedisplay
5844 $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
5845 \afterdisplay
5846 @end tex
5848 @noindent
5849 The meaning of @cite{O(x^3)} is ``a quantity which is negligibly small
5850 if @cite{x^3} is considered negligibly small as @cite{x} goes to zero.''
5852 The exercise is to create rewrite rules that simplify sums and products of
5853 power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
5854 For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
5855 on the stack, we want to be able to type @kbd{*} and get the result
5856 @samp{x - 2:3 x^3 + O(x^4)}.  Don't worry if the terms of the sum are
5857 rearranged or if @kbd{a s} needs to be typed after rewriting.  (This one
5858 is rather tricky; the solution at the end of this chapter uses 6 rewrite
5859 rules.  Hint:  The @samp{constant(x)} condition tests whether @samp{x} is
5860 a number.)  @xref{Rewrites Answer 7, 7}. (@bullet{})
5862 @c [fix-ref Rewrite Rules]
5863 @xref{Rewrite Rules}, for the whole story on rewrite rules.
5865 @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
5866 @section Programming Tutorial
5868 @noindent
5869 The Calculator is written entirely in Emacs Lisp, a highly extensible
5870 language.  If you know Lisp, you can program the Calculator to do
5871 anything you like.  Rewrite rules also work as a powerful programming
5872 system.  But Lisp and rewrite rules take a while to master, and often
5873 all you want to do is define a new function or repeat a command a few
5874 times.  Calc has features that allow you to do these things easily.
5876 (Note that the programming commands relating to user-defined keys
5877 are not yet supported under Lucid Emacs 19.)
5879 One very limited form of programming is defining your own functions.
5880 Calc's @kbd{Z F} command allows you to define a function name and
5881 key sequence to correspond to any formula.  Programming commands use
5882 the shift-@kbd{Z} prefix; the user commands they create use the lower
5883 case @kbd{z} prefix.
5885 @smallexample
5886 @group
5887 1:  1 + x + x^2 / 2 + x^3 / 6         1:  1 + x + x^2 / 2 + x^3 / 6
5888     .                                     .
5890     ' 1 + x + x^2/2! + x^3/3! @key{RET}         Z F e myexp @key{RET} @key{RET} @key{RET} y
5891 @end group
5892 @end smallexample
5894 This polynomial is a Taylor series approximation to @samp{exp(x)}.
5895 The @kbd{Z F} command asks a number of questions.  The above answers
5896 say that the key sequence for our function should be @kbd{z e}; the
5897 @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
5898 function in algebraic formulas should also be @code{myexp}; the
5899 default argument list @samp{(x)} is acceptable; and finally @kbd{y}
5900 answers the question ``leave it in symbolic form for non-constant
5901 arguments?''
5903 @smallexample
5904 @group
5905 1:  1.3495     2:  1.3495     3:  1.3495
5906     .          1:  1.34986    2:  1.34986
5907                    .          1:  myexp(a + 1)
5908                                   .
5910     .3 z e         .3 E           ' a+1 @key{RET} z e
5911 @end group
5912 @end smallexample
5914 @noindent
5915 First we call our new @code{exp} approximation with 0.3 as an
5916 argument, and compare it with the true @code{exp} function.  Then
5917 we note that, as requested, if we try to give @kbd{z e} an
5918 argument that isn't a plain number, it leaves the @code{myexp}
5919 function call in symbolic form.  If we had answered @kbd{n} to the
5920 final question, @samp{myexp(a + 1)} would have evaluated by plugging
5921 in @samp{a + 1} for @samp{x} in the defining formula.
5923 @cindex Sine integral Si(x)
5924 @ignore
5925 @starindex
5926 @end ignore
5927 @tindex Si
5928 (@bullet{}) @strong{Exercise 1.}  The ``sine integral'' function
5929 @c{${\rm Si}(x)$}
5930 @cite{Si(x)} is defined as the integral of @samp{sin(t)/t} for
5931 @cite{t = 0} to @cite{x} in radians.  (It was invented because this
5932 integral has no solution in terms of basic functions; if you give it
5933 to Calc's @kbd{a i} command, it will ponder it for a long time and then
5934 give up.)  We can use the numerical integration command, however,
5935 which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
5936 with any integrand @samp{f(t)}.  Define a @kbd{z s} command and
5937 @code{Si} function that implement this.  You will need to edit the
5938 default argument list a bit.  As a test, @samp{Si(1)} should return
5939 0.946083.  (Hint:  @code{ninteg} will run a lot faster if you reduce
5940 the precision to, say, six digits beforehand.)
5941 @xref{Programming Answer 1, 1}. (@bullet{})
5943 The simplest way to do real ``programming'' of Emacs is to define a
5944 @dfn{keyboard macro}.  A keyboard macro is simply a sequence of
5945 keystrokes which Emacs has stored away and can play back on demand.
5946 For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
5947 you may wish to program a keyboard macro to type this for you.
5949 @smallexample
5950 @group
5951 1:  y = sqrt(x)          1:  x = y^2
5952     .                        .
5954     ' y=sqrt(x) @key{RET}       C-x ( H a S x @key{RET} C-x )
5956 1:  y = cos(x)           1:  x = s1 arccos(y) + 2 pi n1
5957     .                        .
5959     ' y=cos(x) @key{RET}           X
5960 @end group
5961 @end smallexample
5963 @noindent
5964 When you type @kbd{C-x (}, Emacs begins recording.  But it is also
5965 still ready to execute your keystrokes, so you're really ``training''
5966 Emacs by walking it through the procedure once.  When you type
5967 @w{@kbd{C-x )}}, the macro is recorded.  You can now type @kbd{X} to
5968 re-execute the same keystrokes.
5970 You can give a name to your macro by typing @kbd{Z K}.
5972 @smallexample
5973 @group
5974 1:  .              1:  y = x^4         1:  x = s2 sqrt(s1 sqrt(y))
5975                        .                   .
5977   Z K x @key{RET}            ' y=x^4 @key{RET}         z x
5978 @end group
5979 @end smallexample
5981 @noindent
5982 Notice that we use shift-@kbd{Z} to define the command, and lower-case
5983 @kbd{z} to call it up.
5985 Keyboard macros can call other macros.
5987 @smallexample
5988 @group
5989 1:  abs(x)        1:  x = s1 y                1:  2 / x    1:  x = 2 / y
5990     .                 .                           .            .
5992  ' abs(x) @key{RET}   C-x ( ' y @key{RET} a = z x C-x )    ' 2/x @key{RET}       X
5993 @end group
5994 @end smallexample
5996 (@bullet{}) @strong{Exercise 2.}  Define a keyboard macro to negate
5997 the item in level 3 of the stack, without disturbing the rest of
5998 the stack.  @xref{Programming Answer 2, 2}. (@bullet{})
6000 (@bullet{}) @strong{Exercise 3.}  Define keyboard macros to compute
6001 the following functions:
6003 @enumerate
6004 @item
6005 Compute @c{$\displaystyle{\sin x \over x}$}
6006 @cite{sin(x) / x}, where @cite{x} is the number on the
6007 top of the stack.
6009 @item
6010 Compute the base-@cite{b} logarithm, just like the @kbd{B} key except
6011 the arguments are taken in the opposite order.
6013 @item
6014 Produce a vector of integers from 1 to the integer on the top of
6015 the stack.
6016 @end enumerate
6017 @noindent
6018 @xref{Programming Answer 3, 3}. (@bullet{})
6020 (@bullet{}) @strong{Exercise 4.}  Define a keyboard macro to compute
6021 the average (mean) value of a list of numbers.
6022 @xref{Programming Answer 4, 4}. (@bullet{})
6024 In many programs, some of the steps must execute several times.
6025 Calc has @dfn{looping} commands that allow this.  Loops are useful
6026 inside keyboard macros, but actually work at any time.
6028 @smallexample
6029 @group
6030 1:  x^6          2:  x^6        1: 360 x^2
6031     .            1:  4             .
6032                      .
6034   ' x^6 @key{RET}          4         Z < a d x @key{RET} Z >
6035 @end group
6036 @end smallexample
6038 @noindent
6039 Here we have computed the fourth derivative of @cite{x^6} by
6040 enclosing a derivative command in a ``repeat loop'' structure.
6041 This structure pops a repeat count from the stack, then
6042 executes the body of the loop that many times.
6044 If you make a mistake while entering the body of the loop,
6045 type @w{@kbd{Z C-g}} to cancel the loop command.
6047 @cindex Fibonacci numbers
6048 Here's another example:
6050 @smallexample
6051 @group
6052 3:  1               2:  10946
6053 2:  1               1:  17711
6054 1:  20                  .
6055     .
6057 1 @key{RET} @key{RET} 20       Z < @key{TAB} C-j + Z >
6058 @end group
6059 @end smallexample
6061 @noindent
6062 The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
6063 numbers, respectively.  (To see what's going on, try a few repetitions
6064 of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
6065 key if you have one, makes a copy of the number in level 2.)
6067 @cindex Golden ratio
6068 @cindex Phi, golden ratio
6069 A fascinating property of the Fibonacci numbers is that the @cite{n}th
6070 Fibonacci number can be found directly by computing @c{$\phi^n / \sqrt{5}$}
6071 @cite{phi^n / sqrt(5)}
6072 and then rounding to the nearest integer, where @c{$\phi$ (``phi'')}
6073 @cite{phi}, the
6074 ``golden ratio,'' is @c{$(1 + \sqrt{5}) / 2$}
6075 @cite{(1 + sqrt(5)) / 2}.  (For convenience, this constant is available
6076 from the @code{phi} variable, or the @kbd{I H P} command.)
6078 @smallexample
6079 @group
6080 1:  1.61803         1:  24476.0000409    1:  10945.9999817    1:  10946
6081     .                   .                    .                    .
6083     I H P               21 ^                 5 Q /                R
6084 @end group
6085 @end smallexample
6087 @cindex Continued fractions
6088 (@bullet{}) @strong{Exercise 5.}  The @dfn{continued fraction}
6089 representation of @c{$\phi$}
6090 @cite{phi} is @c{$1 + 1/(1 + 1/(1 + 1/( \ldots )))$}
6091 @cite{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
6092 We can compute an approximate value by carrying this however far
6093 and then replacing the innermost @c{$1/( \ldots )$}
6094 @cite{1/( ...@: )} by 1.  Approximate
6095 @c{$\phi$}
6096 @cite{phi} using a twenty-term continued fraction.
6097 @xref{Programming Answer 5, 5}. (@bullet{})
6099 (@bullet{}) @strong{Exercise 6.}  Linear recurrences like the one for
6100 Fibonacci numbers can be expressed in terms of matrices.  Given a
6101 vector @w{@cite{[a, b]}} determine a matrix which, when multiplied by this
6102 vector, produces the vector @cite{[b, c]}, where @cite{a}, @cite{b} and
6103 @cite{c} are three successive Fibonacci numbers.  Now write a program
6104 that, given an integer @cite{n}, computes the @cite{n}th Fibonacci number
6105 using matrix arithmetic.  @xref{Programming Answer 6, 6}. (@bullet{})
6107 @cindex Harmonic numbers
6108 A more sophisticated kind of loop is the @dfn{for} loop.  Suppose
6109 we wish to compute the 20th ``harmonic'' number, which is equal to
6110 the sum of the reciprocals of the integers from 1 to 20.
6112 @smallexample
6113 @group
6114 3:  0               1:  3.597739
6115 2:  1                   .
6116 1:  20
6117     .
6119 0 @key{RET} 1 @key{RET} 20         Z ( & + 1 Z )
6120 @end group
6121 @end smallexample
6123 @noindent
6124 The ``for'' loop pops two numbers, the lower and upper limits, then
6125 repeats the body of the loop as an internal counter increases from
6126 the lower limit to the upper one.  Just before executing the loop
6127 body, it pushes the current loop counter.  When the loop body
6128 finishes, it pops the ``step,'' i.e., the amount by which to
6129 increment the loop counter.  As you can see, our loop always
6130 uses a step of one.
6132 This harmonic number function uses the stack to hold the running
6133 total as well as for the various loop housekeeping functions.  If
6134 you find this disorienting, you can sum in a variable instead:
6136 @smallexample
6137 @group
6138 1:  0         2:  1                  .            1:  3.597739
6139     .         1:  20                                  .
6140                   .
6142     0 t 7       1 @key{RET} 20      Z ( & s + 7 1 Z )       r 7
6143 @end group
6144 @end smallexample
6146 @noindent
6147 The @kbd{s +} command adds the top-of-stack into the value in a
6148 variable (and removes that value from the stack).
6150 It's worth noting that many jobs that call for a ``for'' loop can
6151 also be done more easily by Calc's high-level operations.  Two
6152 other ways to compute harmonic numbers are to use vector mapping
6153 and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
6154 or to use the summation command @kbd{a +}.  Both of these are
6155 probably easier than using loops.  However, there are some
6156 situations where loops really are the way to go:
6158 (@bullet{}) @strong{Exercise 7.}  Use a ``for'' loop to find the first
6159 harmonic number which is greater than 4.0.
6160 @xref{Programming Answer 7, 7}. (@bullet{})
6162 Of course, if we're going to be using variables in our programs,
6163 we have to worry about the programs clobbering values that the
6164 caller was keeping in those same variables.  This is easy to
6165 fix, though:
6167 @smallexample
6168 @group
6169     .        1:  0.6667       1:  0.6667     3:  0.6667
6170                  .                .          2:  3.597739
6171                                              1:  0.6667
6172                                                  .
6174    Z `    p 4 @key{RET} 2 @key{RET} 3 /   s 7 s s a @key{RET}    Z '  r 7 s r a @key{RET}
6175 @end group
6176 @end smallexample
6178 @noindent
6179 When we type @kbd{Z `} (that's a back-quote character), Calc saves
6180 its mode settings and the contents of the ten ``quick variables''
6181 for later reference.  When we type @kbd{Z '} (that's an apostrophe
6182 now), Calc restores those saved values.  Thus the @kbd{p 4} and
6183 @kbd{s 7} commands have no effect outside this sequence.  Wrapping
6184 this around the body of a keyboard macro ensures that it doesn't
6185 interfere with what the user of the macro was doing.  Notice that
6186 the contents of the stack, and the values of named variables,
6187 survive past the @kbd{Z '} command.
6189 @cindex Bernoulli numbers, approximate
6190 The @dfn{Bernoulli numbers} are a sequence with the interesting
6191 property that all of the odd Bernoulli numbers are zero, and the
6192 even ones, while difficult to compute, can be roughly approximated
6193 by the formula @c{$\displaystyle{2 n! \over (2 \pi)^n}$}
6194 @cite{2 n!@: / (2 pi)^n}.  Let's write a keyboard
6195 macro to compute (approximate) Bernoulli numbers.  (Calc has a
6196 command, @kbd{k b}, to compute exact Bernoulli numbers, but
6197 this command is very slow for large @cite{n} since the higher
6198 Bernoulli numbers are very large fractions.)
6200 @smallexample
6201 @group
6202 1:  10               1:  0.0756823
6203     .                    .
6205     10     C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
6206 @end group
6207 @end smallexample
6209 @noindent
6210 You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
6211 @kbd{Z ]} as ``end-if.''  There is no need for an explicit ``if''
6212 command.  For the purposes of @w{@kbd{Z [}}, the condition is ``true''
6213 if the value it pops from the stack is a nonzero number, or ``false''
6214 if it pops zero or something that is not a number (like a formula).
6215 Here we take our integer argument modulo 2; this will be nonzero
6216 if we're asking for an odd Bernoulli number.
6218 The actual tenth Bernoulli number is @cite{5/66}.
6220 @smallexample
6221 @group
6222 3:  0.0756823    1:  0          1:  0.25305    1:  0          1:  1.16659
6223 2:  5:66             .              .              .              .
6224 1:  0.0757575
6225     .
6227 10 k b @key{RET} c f   M-0 @key{DEL} 11 X   @key{DEL} 12 X       @key{DEL} 13 X       @key{DEL} 14 X
6228 @end group
6229 @end smallexample
6231 Just to exercise loops a bit more, let's compute a table of even
6232 Bernoulli numbers.
6234 @smallexample
6235 @group
6236 3:  []             1:  [0.10132, 0.03079, 0.02340, 0.033197, ...]
6237 2:  2                  .
6238 1:  30
6239     .
6241  [ ] 2 @key{RET} 30          Z ( X | 2 Z )
6242 @end group
6243 @end smallexample
6245 @noindent
6246 The vertical-bar @kbd{|} is the vector-concatenation command.  When
6247 we execute it, the list we are building will be in stack level 2
6248 (initially this is an empty list), and the next Bernoulli number
6249 will be in level 1.  The effect is to append the Bernoulli number
6250 onto the end of the list.  (To create a table of exact fractional
6251 Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
6252 sequence of keystrokes.)
6254 With loops and conditionals, you can program essentially anything
6255 in Calc.  One other command that makes looping easier is @kbd{Z /},
6256 which takes a condition from the stack and breaks out of the enclosing
6257 loop if the condition is true (non-zero).  You can use this to make
6258 ``while'' and ``until'' style loops.
6260 If you make a mistake when entering a keyboard macro, you can edit
6261 it using @kbd{Z E}.  First, you must attach it to a key with @kbd{Z K}.
6262 One technique is to enter a throwaway dummy definition for the macro,
6263 then enter the real one in the edit command.
6265 @smallexample
6266 @group
6267 1:  3                   1:  3           Keyboard Macro Editor.
6268     .                       .           Original keys: 1 @key{RET} 2 +
6270                                         type "1\r"
6271                                         type "2"
6272                                         calc-plus
6274 C-x ( 1 @key{RET} 2 + C-x )    Z K h @key{RET}      Z E h
6275 @end group
6276 @end smallexample
6278 @noindent
6279 This shows the screen display assuming you have the @file{macedit}
6280 keyboard macro editing package installed, which is usually the case
6281 since a copy of @file{macedit} comes bundled with Calc.
6283 A keyboard macro is stored as a pure keystroke sequence.  The
6284 @file{macedit} package (invoked by @kbd{Z E}) scans along the
6285 macro and tries to decode it back into human-readable steps.
6286 If a key or keys are simply shorthand for some command with a
6287 @kbd{M-x} name, that name is shown.  Anything that doesn't correspond
6288 to a @kbd{M-x} command is written as a @samp{type} command.
6290 Let's edit in a new definition, for computing harmonic numbers.
6291 First, erase the three lines of the old definition.  Then, type
6292 in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
6293 to copy it from this page of the Info file; you can skip typing
6294 the comments that begin with @samp{#}).
6296 @smallexample
6297 calc-kbd-push         # Save local values (Z `)
6298 type "0"              # Push a zero
6299 calc-store-into       # Store it in variable 1
6300 type "1"
6301 type "1"              # Initial value for loop
6302 calc-roll-down        # This is the @key{TAB} key; swap initial & final
6303 calc-kbd-for          # Begin "for" loop...
6304 calc-inv              #   Take reciprocal
6305 calc-store-plus       #   Add to accumulator
6306 type "1"
6307 type "1"              #   Loop step is 1
6308 calc-kbd-end-for      # End "for" loop
6309 calc-recall           # Now recall final accumulated value
6310 type "1"
6311 calc-kbd-pop          # Restore values (Z ')
6312 @end smallexample
6314 @noindent
6315 Press @kbd{M-# M-#} to finish editing and return to the Calculator.
6317 @smallexample
6318 @group
6319 1:  20         1:  3.597739
6320     .              .
6322     20             z h
6323 @end group
6324 @end smallexample
6326 If you don't know how to write a particular command in @file{macedit}
6327 format, you can always write it as keystrokes in a @code{type} command.
6328 There is also a @code{keys} command which interprets the rest of the
6329 line as standard Emacs keystroke names.  In fact, @file{macedit} defines
6330 a handy @code{read-kbd-macro} command which reads the current region
6331 of the current buffer as a sequence of keystroke names, and defines that
6332 sequence on the @kbd{X} (and @kbd{C-x e}) key.  Because this is so
6333 useful, Calc puts this command on the @kbd{M-# m} key.  Try reading in
6334 this macro in the following form:  Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
6335 one end of the text below, then type @kbd{M-# m} at the other.
6337 @example
6338 @group
6339 Z ` 0 t 1
6340     1 @key{TAB}
6341     Z (  & s + 1  1 Z )
6342     r 1
6343 Z '
6344 @end group
6345 @end example
6347 (@bullet{}) @strong{Exercise 8.}  A general algorithm for solving
6348 equations numerically is @dfn{Newton's Method}.  Given the equation
6349 @cite{f(x) = 0} for any function @cite{f}, and an initial guess
6350 @cite{x_0} which is reasonably close to the desired solution, apply
6351 this formula over and over:
6353 @ifinfo
6354 @example
6355 new_x = x - f(x)/f'(x)
6356 @end example
6357 @end ifinfo
6358 @tex
6359 \beforedisplay
6360 $$ x_{\goodrm new} = x - {f(x) \over f'(x)} $$
6361 \afterdisplay
6362 @end tex
6364 @noindent
6365 where @cite{f'(x)} is the derivative of @cite{f}.  The @cite{x}
6366 values will quickly converge to a solution, i.e., eventually
6367 @c{$x_{\rm new}$}
6368 @cite{new_x} and @cite{x} will be equal to within the limits
6369 of the current precision.  Write a program which takes a formula
6370 involving the variable @cite{x}, and an initial guess @cite{x_0},
6371 on the stack, and produces a value of @cite{x} for which the formula
6372 is zero.  Use it to find a solution of @c{$\sin(\cos x) = 0.5$}
6373 @cite{sin(cos(x)) = 0.5}
6374 near @cite{x = 4.5}.  (Use angles measured in radians.)  Note that
6375 the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
6376 method when it is able.  @xref{Programming Answer 8, 8}. (@bullet{})
6378 @cindex Digamma function
6379 @cindex Gamma constant, Euler's
6380 @cindex Euler's gamma constant
6381 (@bullet{}) @strong{Exercise 9.}  The @dfn{digamma} function @c{$\psi(z)$ (``psi'')}
6382 @cite{psi(z)}
6383 is defined as the derivative of @c{$\ln \Gamma(z)$}
6384 @cite{ln(gamma(z))}.  For large
6385 values of @cite{z}, it can be approximated by the infinite sum
6387 @ifinfo
6388 @example
6389 psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
6390 @end example
6391 @end ifinfo
6392 @tex
6393 \let\rm\goodrm
6394 \beforedisplay
6395 $$ \psi(z) \approx \ln z - {1\over2z} -
6396    \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
6398 \afterdisplay
6399 @end tex
6401 @noindent
6402 where @c{$\sum$}
6403 @cite{sum} represents the sum over @cite{n} from 1 to infinity
6404 (or to some limit high enough to give the desired accuracy), and
6405 the @code{bern} function produces (exact) Bernoulli numbers.
6406 While this sum is not guaranteed to converge, in practice it is safe.
6407 An interesting mathematical constant is Euler's gamma, which is equal
6408 to about 0.5772.  One way to compute it is by the formula,
6409 @c{$\gamma = -\psi(1)$}
6410 @cite{gamma = -psi(1)}.  Unfortunately, 1 isn't a large enough argument
6411 for the above formula to work (5 is a much safer value for @cite{z}).
6412 Fortunately, we can compute @c{$\psi(1)$}
6413 @cite{psi(1)} from @c{$\psi(5)$}
6414 @cite{psi(5)} using
6415 the recurrence @c{$\psi(z+1) = \psi(z) + {1 \over z}$}
6416 @cite{psi(z+1) = psi(z) + 1/z}.  Your task:  Develop
6417 a program to compute @c{$\psi(z)$}
6418 @cite{psi(z)}; it should ``pump up'' @cite{z}
6419 if necessary to be greater than 5, then use the above summation
6420 formula.  Use looping commands to compute the sum.  Use your function
6421 to compute @c{$\gamma$}
6422 @cite{gamma} to twelve decimal places.  (Calc has a built-in command
6423 for Euler's constant, @kbd{I P}, which you can use to check your answer.)
6424 @xref{Programming Answer 9, 9}. (@bullet{})
6426 @cindex Polynomial, list of coefficients
6427 (@bullet{}) @strong{Exercise 10.}  Given a polynomial in @cite{x} and
6428 a number @cite{m} on the stack, where the polynomial is of degree
6429 @cite{m} or less (i.e., does not have any terms higher than @cite{x^m}),
6430 write a program to convert the polynomial into a list-of-coefficients
6431 notation.  For example, @cite{5 x^4 + (x + 1)^2} with @cite{m = 6}
6432 should produce the list @cite{[1, 2, 1, 0, 5, 0, 0]}.  Also develop
6433 a way to convert from this form back to the standard algebraic form.
6434 @xref{Programming Answer 10, 10}. (@bullet{})
6436 @cindex Recursion
6437 (@bullet{}) @strong{Exercise 11.}  The @dfn{Stirling numbers of the
6438 first kind} are defined by the recurrences,
6440 @ifinfo
6441 @example
6442 s(n,n) = 1   for n >= 0,
6443 s(n,0) = 0   for n > 0,
6444 s(n+1,m) = s(n,m-1) - n s(n,m)   for n >= m >= 1.
6445 @end example
6446 @end ifinfo
6447 @tex
6448 \turnoffactive
6449 \beforedisplay
6450 $$ \eqalign{ s(n,n)   &= 1 \qquad \hbox{for } n \ge 0,  \cr
6451              s(n,0)   &= 0 \qquad \hbox{for } n > 0, \cr
6452              s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
6453                           \hbox{for } n \ge m \ge 1.}
6455 \afterdisplay
6456 \vskip5pt
6457 (These numbers are also sometimes written $\displaystyle{n \brack m}$.)
6458 @end tex
6460 This can be implemented using a @dfn{recursive} program in Calc; the
6461 program must invoke itself in order to calculate the two righthand
6462 terms in the general formula.  Since it always invokes itself with
6463 ``simpler'' arguments, it's easy to see that it must eventually finish
6464 the computation.  Recursion is a little difficult with Emacs keyboard
6465 macros since the macro is executed before its definition is complete.
6466 So here's the recommended strategy:  Create a ``dummy macro'' and assign
6467 it to a key with, e.g., @kbd{Z K s}.  Now enter the true definition,
6468 using the @kbd{z s} command to call itself recursively, then assign it
6469 to the same key with @kbd{Z K s}.  Now the @kbd{z s} command will run
6470 the complete recursive program.  (Another way is to use @w{@kbd{Z E}}
6471 or @kbd{M-# m} (@code{read-kbd-macro}) to read the whole macro at once,
6472 thus avoiding the ``training'' phase.)  The task:  Write a program
6473 that computes Stirling numbers of the first kind, given @cite{n} and
6474 @cite{m} on the stack.  Test it with @emph{small} inputs like
6475 @cite{s(4,2)}.  (There is a built-in command for Stirling numbers,
6476 @kbd{k s}, which you can use to check your answers.)
6477 @xref{Programming Answer 11, 11}. (@bullet{})
6479 The programming commands we've seen in this part of the tutorial
6480 are low-level, general-purpose operations.  Often you will find
6481 that a higher-level function, such as vector mapping or rewrite
6482 rules, will do the job much more easily than a detailed, step-by-step
6483 program can:
6485 (@bullet{}) @strong{Exercise 12.}  Write another program for
6486 computing Stirling numbers of the first kind, this time using
6487 rewrite rules.  Once again, @cite{n} and @cite{m} should be taken
6488 from the stack.  @xref{Programming Answer 12, 12}. (@bullet{})
6490 @example
6492 @end example
6493 This ends the tutorial section of the Calc manual.  Now you know enough
6494 about Calc to use it effectively for many kinds of calculations.  But
6495 Calc has many features that were not even touched upon in this tutorial.
6496 @c [not-split]
6497 The rest of this manual tells the whole story.
6498 @c [when-split]
6499 @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
6501 @page
6502 @node Answers to Exercises, , Programming Tutorial, Tutorial
6503 @section Answers to Exercises
6505 @noindent
6506 This section includes answers to all the exercises in the Calc tutorial.
6508 @menu
6509 * RPN Answer 1::           1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
6510 * RPN Answer 2::           2*4 + 7*9.5 + 5/4
6511 * RPN Answer 3::           Operating on levels 2 and 3
6512 * RPN Answer 4::           Joe's complex problems
6513 * Algebraic Answer 1::     Simulating Q command
6514 * Algebraic Answer 2::     Joe's algebraic woes
6515 * Algebraic Answer 3::     1 / 0
6516 * Modes Answer 1::         3#0.1 = 3#0.0222222?
6517 * Modes Answer 2::         16#f.e8fe15
6518 * Modes Answer 3::         Joe's rounding bug
6519 * Modes Answer 4::         Why floating point?
6520 * Arithmetic Answer 1::    Why the \ command?
6521 * Arithmetic Answer 2::    Tripping up the B command
6522 * Vector Answer 1::        Normalizing a vector
6523 * Vector Answer 2::        Average position
6524 * Matrix Answer 1::        Row and column sums
6525 * Matrix Answer 2::        Symbolic system of equations
6526 * Matrix Answer 3::        Over-determined system
6527 * List Answer 1::          Powers of two
6528 * List Answer 2::          Least-squares fit with matrices
6529 * List Answer 3::          Geometric mean
6530 * List Answer 4::          Divisor function
6531 * List Answer 5::          Duplicate factors
6532 * List Answer 6::          Triangular list
6533 * List Answer 7::          Another triangular list
6534 * List Answer 8::          Maximum of Bessel function
6535 * List Answer 9::          Integers the hard way
6536 * List Answer 10::         All elements equal
6537 * List Answer 11::         Estimating pi with darts
6538 * List Answer 12::         Estimating pi with matchsticks
6539 * List Answer 13::         Hash codes
6540 * List Answer 14::         Random walk
6541 * Types Answer 1::         Square root of pi times rational
6542 * Types Answer 2::         Infinities
6543 * Types Answer 3::         What can "nan" be?
6544 * Types Answer 4::         Abbey Road
6545 * Types Answer 5::         Friday the 13th
6546 * Types Answer 6::         Leap years
6547 * Types Answer 7::         Erroneous donut
6548 * Types Answer 8::         Dividing intervals
6549 * Types Answer 9::         Squaring intervals
6550 * Types Answer 10::        Fermat's primality test
6551 * Types Answer 11::        pi * 10^7 seconds
6552 * Types Answer 12::        Abbey Road on CD
6553 * Types Answer 13::        Not quite pi * 10^7 seconds
6554 * Types Answer 14::        Supercomputers and c
6555 * Types Answer 15::        Sam the Slug
6556 * Algebra Answer 1::       Squares and square roots
6557 * Algebra Answer 2::       Building polynomial from roots
6558 * Algebra Answer 3::       Integral of x sin(pi x)
6559 * Algebra Answer 4::       Simpson's rule
6560 * Rewrites Answer 1::      Multiplying by conjugate
6561 * Rewrites Answer 2::      Alternative fib rule
6562 * Rewrites Answer 3::      Rewriting opt(a) + opt(b) x
6563 * Rewrites Answer 4::      Sequence of integers
6564 * Rewrites Answer 5::      Number of terms in sum
6565 * Rewrites Answer 6::      Defining 0^0 = 1
6566 * Rewrites Answer 7::      Truncated Taylor series
6567 * Programming Answer 1::   Fresnel's C(x)
6568 * Programming Answer 2::   Negate third stack element
6569 * Programming Answer 3::   Compute sin(x) / x, etc.
6570 * Programming Answer 4::   Average value of a list
6571 * Programming Answer 5::   Continued fraction phi
6572 * Programming Answer 6::   Matrix Fibonacci numbers
6573 * Programming Answer 7::   Harmonic number greater than 4
6574 * Programming Answer 8::   Newton's method
6575 * Programming Answer 9::   Digamma function
6576 * Programming Answer 10::  Unpacking a polynomial
6577 * Programming Answer 11::  Recursive Stirling numbers
6578 * Programming Answer 12::  Stirling numbers with rewrites
6579 @end menu
6581 @c The following kludgery prevents the individual answers from
6582 @c being entered on the table of contents.
6583 @tex
6584 \global\let\oldwrite=\write
6585 \gdef\skipwrite#1#2{\let\write=\oldwrite}
6586 \global\let\oldchapternofonts=\chapternofonts
6587 \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
6588 @end tex
6590 @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
6591 @subsection RPN Tutorial Exercise 1
6593 @noindent
6594 @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
6596 The result is @c{$1 - (2 \times (3 + 4)) = -13$}
6597 @cite{1 - (2 * (3 + 4)) = -13}.
6599 @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
6600 @subsection RPN Tutorial Exercise 2
6602 @noindent
6603 @c{$2\times4 + 7\times9.5 + {5\over4} = 75.75$}
6604 @cite{2*4 + 7*9.5 + 5/4 = 75.75}
6606 After computing the intermediate term @c{$2\times4 = 8$}
6607 @cite{2*4 = 8}, you can leave
6608 that result on the stack while you compute the second term.  With
6609 both of these results waiting on the stack you can then compute the
6610 final term, then press @kbd{+ +} to add everything up.
6612 @smallexample
6613 @group
6614 2:  2          1:  8          3:  8          2:  8
6615 1:  4              .          2:  7          1:  66.5
6616     .                         1:  9.5            .
6617                                   .
6619   2 @key{RET} 4          *          7 @key{RET} 9.5          *
6621 @end group
6622 @end smallexample
6623 @noindent
6624 @smallexample
6625 @group
6626 4:  8          3:  8          2:  8          1:  75.75
6627 3:  66.5       2:  66.5       1:  67.75          .
6628 2:  5          1:  1.25           .
6629 1:  4              .
6630     .
6632   5 @key{RET} 4          /              +              +
6633 @end group
6634 @end smallexample
6636 Alternatively, you could add the first two terms before going on
6637 with the third term.
6639 @smallexample
6640 @group
6641 2:  8          1:  74.5       3:  74.5       2:  74.5       1:  75.75
6642 1:  66.5           .          2:  5          1:  1.25           .
6643     .                         1:  4              .
6644                                   .
6646    ...             +            5 @key{RET} 4          /              +
6647 @end group
6648 @end smallexample
6650 On an old-style RPN calculator this second method would have the
6651 advantage of using only three stack levels.  But since Calc's stack
6652 can grow arbitrarily large this isn't really an issue.  Which method
6653 you choose is purely a matter of taste.
6655 @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
6656 @subsection RPN Tutorial Exercise 3
6658 @noindent
6659 The @key{TAB} key provides a way to operate on the number in level 2.
6661 @smallexample
6662 @group
6663 3:  10         3:  10         4:  10         3:  10         3:  10
6664 2:  20         2:  30         3:  30         2:  30         2:  21
6665 1:  30         1:  20         2:  20         1:  21         1:  30
6666     .              .          1:  1              .              .
6667                                   .
6669                   @key{TAB}             1              +             @key{TAB}
6670 @end group
6671 @end smallexample
6673 Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
6675 @smallexample
6676 @group
6677 3:  10         3:  21         3:  21         3:  30         3:  11
6678 2:  21         2:  30         2:  30         2:  11         2:  21
6679 1:  30         1:  10         1:  11         1:  21         1:  30
6680     .              .              .              .              .
6682                   M-@key{TAB}           1 +           M-@key{TAB}          M-@key{TAB}
6683 @end group
6684 @end smallexample
6686 @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
6687 @subsection RPN Tutorial Exercise 4
6689 @noindent
6690 Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
6691 but using both the comma and the space at once yields:
6693 @smallexample
6694 @group
6695 1:  ( ...      2:  ( ...      1:  (2, ...    2:  (2, ...    2:  (2, ...
6696     .          1:  2              .          1:  (2, ...    1:  (2, 3)
6697                    .                             .              .
6699     (              2              ,             @key{SPC}            3 )
6700 @end group
6701 @end smallexample
6703 Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
6704 extra incomplete object to the top of the stack and delete it.
6705 But a feature of Calc is that @key{DEL} on an incomplete object
6706 deletes just one component out of that object, so he had to press
6707 @key{DEL} twice to finish the job.
6709 @smallexample
6710 @group
6711 2:  (2, ...    2:  (2, 3)     2:  (2, 3)     1:  (2, 3)
6712 1:  (2, 3)     1:  (2, ...    1:  ( ...          .
6713     .              .              .
6715                   @key{TAB}            @key{DEL}            @key{DEL}
6716 @end group
6717 @end smallexample
6719 (As it turns out, deleting the second-to-top stack entry happens often
6720 enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
6721 @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
6722 the ``feature'' that tripped poor Joe.)
6724 @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
6725 @subsection Algebraic Entry Tutorial Exercise 1
6727 @noindent
6728 Type @kbd{' sqrt($) @key{RET}}.
6730 If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
6731 Or, RPN style, @kbd{0.5 ^}.
6733 (Actually, @samp{$^1:2}, using the fraction one-half as the power, is
6734 a closer equivalent, since @samp{9^0.5} yields @cite{3.0} whereas
6735 @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @cite{3}.)
6737 @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
6738 @subsection Algebraic Entry Tutorial Exercise 2
6740 @noindent
6741 In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
6742 name with @samp{1+y} as its argument.  Assigning a value to a variable
6743 has no relation to a function by the same name.  Joe needed to use an
6744 explicit @samp{*} symbol here:  @samp{2 x*(1+y)}.
6746 @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
6747 @subsection Algebraic Entry Tutorial Exercise 3
6749 @noindent
6750 The result from @kbd{1 @key{RET} 0 /} will be the formula @cite{1 / 0}.
6751 The ``function'' @samp{/} cannot be evaluated when its second argument
6752 is zero, so it is left in symbolic form.  When you now type @kbd{0 *},
6753 the result will be zero because Calc uses the general rule that ``zero
6754 times anything is zero.''
6756 @c [fix-ref Infinities]
6757 The @kbd{m i} command enables an @dfn{infinite mode} in which @cite{1 / 0}
6758 results in a special symbol that represents ``infinity.''  If you
6759 multiply infinity by zero, Calc uses another special new symbol to
6760 show that the answer is ``indeterminate.''  @xref{Infinities}, for
6761 further discussion of infinite and indeterminate values.
6763 @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
6764 @subsection Modes Tutorial Exercise 1
6766 @noindent
6767 Calc always stores its numbers in decimal, so even though one-third has
6768 an exact base-3 representation (@samp{3#0.1}), it is still stored as
6769 0.3333333 (chopped off after 12 or however many decimal digits) inside
6770 the calculator's memory.  When this inexact number is converted back
6771 to base 3 for display, it may still be slightly inexact.  When we
6772 multiply this number by 3, we get 0.999999, also an inexact value.
6774 When Calc displays a number in base 3, it has to decide how many digits
6775 to show.  If the current precision is 12 (decimal) digits, that corresponds
6776 to @samp{12 / log10(3) = 25.15} base-3 digits.  Because 25.15 is not an
6777 exact integer, Calc shows only 25 digits, with the result that stored
6778 numbers carry a little bit of extra information that may not show up on
6779 the screen.  When Joe entered @samp{3#0.2}, the stored number 0.666666
6780 happened to round to a pleasing value when it lost that last 0.15 of a
6781 digit, but it was still inexact in Calc's memory.  When he divided by 2,
6782 he still got the dreaded inexact value 0.333333.  (Actually, he divided
6783 0.666667 by 2 to get 0.333334, which is why he got something a little
6784 higher than @code{3#0.1} instead of a little lower.)
6786 If Joe didn't want to be bothered with all this, he could have typed
6787 @kbd{M-24 d n} to display with one less digit than the default.  (If
6788 you give @kbd{d n} a negative argument, it uses default-minus-that,
6789 so @kbd{M-- d n} would be an easier way to get the same effect.)  Those
6790 inexact results would still be lurking there, but they would now be
6791 rounded to nice, natural-looking values for display purposes.  (Remember,
6792 @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
6793 off one digit will round the number up to @samp{0.1}.)  Depending on the
6794 nature of your work, this hiding of the inexactness may be a benefit or
6795 a danger.  With the @kbd{d n} command, Calc gives you the choice.
6797 Incidentally, another consequence of all this is that if you type
6798 @kbd{M-30 d n} to display more digits than are ``really there,''
6799 you'll see garbage digits at the end of the number.  (In decimal
6800 display mode, with decimally-stored numbers, these garbage digits are
6801 always zero so they vanish and you don't notice them.)  Because Calc
6802 rounds off that 0.15 digit, there is the danger that two numbers could
6803 be slightly different internally but still look the same.  If you feel
6804 uneasy about this, set the @kbd{d n} precision to be a little higher
6805 than normal; you'll get ugly garbage digits, but you'll always be able
6806 to tell two distinct numbers apart.
6808 An interesting side note is that most computers store their
6809 floating-point numbers in binary, and convert to decimal for display.
6810 Thus everyday programs have the same problem:  Decimal 0.1 cannot be
6811 represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
6812 comes out as an inexact approximation to 1 on some machines (though
6813 they generally arrange to hide it from you by rounding off one digit as
6814 we did above).  Because Calc works in decimal instead of binary, you can
6815 be sure that numbers that look exact @emph{are} exact as long as you stay
6816 in decimal display mode.
6818 It's not hard to show that any number that can be represented exactly
6819 in binary, octal, or hexadecimal is also exact in decimal, so the kinds
6820 of problems we saw in this exercise are likely to be severe only when
6821 you use a relatively unusual radix like 3.
6823 @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
6824 @subsection Modes Tutorial Exercise 2
6826 If the radix is 15 or higher, we can't use the letter @samp{e} to mark
6827 the exponent because @samp{e} is interpreted as a digit.  When Calc
6828 needs to display scientific notation in a high radix, it writes
6829 @samp{16#F.E8F*16.^15}.  You can enter a number like this as an
6830 algebraic entry.  Also, pressing @kbd{e} without any digits before it
6831 normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
6832 puts you in algebraic entry:  @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
6833 way to enter this number.
6835 The reason Calc puts a decimal point in the @samp{16.^} is to prevent
6836 huge integers from being generated if the exponent is large (consider
6837 @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
6838 exact integer and then throw away most of the digits when we multiply
6839 it by the floating-point @samp{16#1.23}).  While this wouldn't normally
6840 matter for display purposes, it could give you a nasty surprise if you
6841 copied that number into a file and later moved it back into Calc.
6843 @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
6844 @subsection Modes Tutorial Exercise 3
6846 @noindent
6847 The answer he got was @cite{0.5000000000006399}.
6849 The problem is not that the square operation is inexact, but that the
6850 sine of 45 that was already on the stack was accurate to only 12 places.
6851 Arbitrary-precision calculations still only give answers as good as
6852 their inputs.
6854 The real problem is that there is no 12-digit number which, when
6855 squared, comes out to 0.5 exactly.  The @kbd{f [} and @kbd{f ]}
6856 commands decrease or increase a number by one unit in the last
6857 place (according to the current precision).  They are useful for
6858 determining facts like this.
6860 @smallexample
6861 @group
6862 1:  0.707106781187      1:  0.500000000001
6863     .                       .
6865     45 S                    2 ^
6867 @end group
6868 @end smallexample
6869 @noindent
6870 @smallexample
6871 @group
6872 1:  0.707106781187      1:  0.707106781186      1:  0.499999999999
6873     .                       .                       .
6875     U  @key{DEL}                  f [                     2 ^
6876 @end group
6877 @end smallexample
6879 A high-precision calculation must be carried out in high precision
6880 all the way.  The only number in the original problem which was known
6881 exactly was the quantity 45 degrees, so the precision must be raised
6882 before anything is done after the number 45 has been entered in order
6883 for the higher precision to be meaningful.
6885 @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
6886 @subsection Modes Tutorial Exercise 4
6888 @noindent
6889 Many calculations involve real-world quantities, like the width and
6890 height of a piece of wood or the volume of a jar.  Such quantities
6891 can't be measured exactly anyway, and if the data that is input to
6892 a calculation is inexact, doing exact arithmetic on it is a waste
6893 of time.
6895 Fractions become unwieldy after too many calculations have been
6896 done with them.  For example, the sum of the reciprocals of the
6897 integers from 1 to 10 is 7381:2520.  The sum from 1 to 30 is
6898 9304682830147:2329089562800.  After a point it will take a long
6899 time to add even one more term to this sum, but a floating-point
6900 calculation of the sum will not have this problem.
6902 Also, rational numbers cannot express the results of all calculations.
6903 There is no fractional form for the square root of two, so if you type
6904 @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
6906 @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
6907 @subsection Arithmetic Tutorial Exercise 1
6909 @noindent
6910 Dividing two integers that are larger than the current precision may
6911 give a floating-point result that is inaccurate even when rounded
6912 down to an integer.  Consider @cite{123456789 / 2} when the current
6913 precision is 6 digits.  The true answer is @cite{61728394.5}, but
6914 with a precision of 6 this will be rounded to @c{$12345700.0/2.0 = 61728500.0$}
6915 @cite{12345700.@: / 2.@: = 61728500.}.
6916 The result, when converted to an integer, will be off by 106.
6918 Here are two solutions:  Raise the precision enough that the
6919 floating-point round-off error is strictly to the right of the
6920 decimal point.  Or, convert to fraction mode so that @cite{123456789 / 2}
6921 produces the exact fraction @cite{123456789:2}, which can be rounded
6922 down by the @kbd{F} command without ever switching to floating-point
6923 format.
6925 @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
6926 @subsection Arithmetic Tutorial Exercise 2
6928 @noindent
6929 @kbd{27 @key{RET} 9 B} could give the exact result @cite{3:2}, but it
6930 does a floating-point calculation instead and produces @cite{1.5}.
6932 Calc will find an exact result for a logarithm if the result is an integer
6933 or the reciprocal of an integer.  But there is no efficient way to search
6934 the space of all possible rational numbers for an exact answer, so Calc
6935 doesn't try.
6937 @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
6938 @subsection Vector Tutorial Exercise 1
6940 @noindent
6941 Duplicate the vector, compute its length, then divide the vector
6942 by its length:  @kbd{@key{RET} A /}.
6944 @smallexample
6945 @group
6946 1:  [1, 2, 3]  2:  [1, 2, 3]      1:  [0.27, 0.53, 0.80]  1:  1.
6947     .          1:  3.74165738677      .                       .
6948                    .
6950     r 1            @key{RET} A              /                       A
6951 @end group
6952 @end smallexample
6954 The final @kbd{A} command shows that the normalized vector does
6955 indeed have unit length.
6957 @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
6958 @subsection Vector Tutorial Exercise 2
6960 @noindent
6961 The average position is equal to the sum of the products of the
6962 positions times their corresponding probabilities.  This is the
6963 definition of the dot product operation.  So all you need to do
6964 is to put the two vectors on the stack and press @kbd{*}.
6966 @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
6967 @subsection Matrix Tutorial Exercise 1
6969 @noindent
6970 The trick is to multiply by a vector of ones.  Use @kbd{r 4 [1 1 1] *} to
6971 get the row sum.  Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
6973 @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
6974 @subsection Matrix Tutorial Exercise 2
6976 @ifinfo
6977 @example
6978 @group
6979    x + a y = 6
6980    x + b y = 10
6981 @end group
6982 @end example
6983 @end ifinfo
6984 @tex
6985 \turnoffactive
6986 \beforedisplay
6987 $$ \eqalign{ x &+ a y = 6 \cr
6988              x &+ b y = 10}
6990 \afterdisplay
6991 @end tex
6993 Just enter the righthand side vector, then divide by the lefthand side
6994 matrix as usual.
6996 @smallexample
6997 @group
6998 1:  [6, 10]    2:  [6, 10]         1:  [6 - 4 a / (b - a), 4 / (b - a) ]
6999     .          1:  [ [ 1, a ]          .
7000                      [ 1, b ] ]
7001                    .
7003 ' [6 10] @key{RET}     ' [1 a; 1 b] @key{RET}      /
7004 @end group
7005 @end smallexample
7007 This can be made more readable using @kbd{d B} to enable ``big'' display
7008 mode:
7010 @smallexample
7011 @group
7012           4 a     4
7013 1:  [6 - -----, -----]
7014          b - a  b - a
7015 @end group
7016 @end smallexample
7018 Type @kbd{d N} to return to ``normal'' display mode afterwards.
7020 @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
7021 @subsection Matrix Tutorial Exercise 3
7023 @noindent
7024 To solve @c{$A^T A \, X = A^T B$}
7025 @cite{trn(A) * A * X = trn(A) * B}, first we compute
7026 @c{$A' = A^T A$}
7027 @cite{A2 = trn(A) * A} and @c{$B' = A^T B$}
7028 @cite{B2 = trn(A) * B}; now, we have a
7029 system @c{$A' X = B'$}
7030 @cite{A2 * X = B2} which we can solve using Calc's @samp{/}
7031 command.
7033 @ifinfo
7034 @example
7035 @group
7036     a + 2b + 3c = 6
7037    4a + 5b + 6c = 2
7038    7a + 6b      = 3
7039    2a + 4b + 6c = 11
7040 @end group
7041 @end example
7042 @end ifinfo
7043 @tex
7044 \turnoffactive
7045 \beforedisplayh
7046 $$ \openup1\jot \tabskip=0pt plus1fil
7047 \halign to\displaywidth{\tabskip=0pt
7048    $\hfil#$&$\hfil{}#{}$&
7049    $\hfil#$&$\hfil{}#{}$&
7050    $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
7051   a&+&2b&+&3c&=6 \cr
7052  4a&+&5b&+&6c&=2 \cr
7053  7a&+&6b& &  &=3 \cr
7054  2a&+&4b&+&6c&=11 \cr}
7056 \afterdisplayh
7057 @end tex
7059 The first step is to enter the coefficient matrix.  We'll store it in
7060 quick variable number 7 for later reference.  Next, we compute the
7061 @c{$B'$}
7062 @cite{B2} vector.
7064 @smallexample
7065 @group
7066 1:  [ [ 1, 2, 3 ]             2:  [ [ 1, 4, 7, 2 ]     1:  [57, 84, 96]
7067       [ 4, 5, 6 ]                   [ 2, 5, 6, 4 ]         .
7068       [ 7, 6, 0 ]                   [ 3, 6, 0, 6 ] ]
7069       [ 2, 4, 6 ] ]           1:  [6, 2, 3, 11]
7070     .                             .
7072 ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET}  s 7  v t  [6 2 3 11]   *
7073 @end group
7074 @end smallexample
7076 @noindent
7077 Now we compute the matrix @c{$A'$}
7078 @cite{A2} and divide.
7080 @smallexample
7081 @group
7082 2:  [57, 84, 96]          1:  [-11.64, 14.08, -3.64]
7083 1:  [ [ 70, 72, 39 ]          .
7084       [ 72, 81, 60 ]
7085       [ 39, 60, 81 ] ]
7086     .
7088     r 7 v t r 7 *             /
7089 @end group
7090 @end smallexample
7092 @noindent
7093 (The actual computed answer will be slightly inexact due to
7094 round-off error.)
7096 Notice that the answers are similar to those for the @c{$3\times3$}
7097 @asis{3x3} system
7098 solved in the text.  That's because the fourth equation that was
7099 added to the system is almost identical to the first one multiplied
7100 by two.  (If it were identical, we would have gotten the exact same
7101 answer since the @c{$4\times3$}
7102 @asis{4x3} system would be equivalent to the original @c{$3\times3$}
7103 @asis{3x3}
7104 system.)
7106 Since the first and fourth equations aren't quite equivalent, they
7107 can't both be satisfied at once.  Let's plug our answers back into
7108 the original system of equations to see how well they match.
7110 @smallexample
7111 @group
7112 2:  [-11.64, 14.08, -3.64]     1:  [5.6, 2., 3., 11.2]
7113 1:  [ [ 1, 2, 3 ]                  .
7114       [ 4, 5, 6 ]
7115       [ 7, 6, 0 ]
7116       [ 2, 4, 6 ] ]
7117     .
7119     r 7                            @key{TAB} *
7120 @end group
7121 @end smallexample
7123 @noindent
7124 This is reasonably close to our original @cite{B} vector,
7125 @cite{[6, 2, 3, 11]}.
7127 @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
7128 @subsection List Tutorial Exercise 1
7130 @noindent
7131 We can use @kbd{v x} to build a vector of integers.  This needs to be
7132 adjusted to get the range of integers we desire.  Mapping @samp{-}
7133 across the vector will accomplish this, although it turns out the
7134 plain @samp{-} key will work just as well.
7136 @smallexample
7137 @group
7138 2:  2                              2:  2
7139 1:  [1, 2, 3, 4, 5, 6, 7, 8, 9]    1:  [-4, -3, -2, -1, 0, 1, 2, 3, 4]
7140     .                                  .
7142     2  v x 9 @key{RET}                       5 V M -   or   5 -
7143 @end group
7144 @end smallexample
7146 @noindent
7147 Now we use @kbd{V M ^} to map the exponentiation operator across the
7148 vector.
7150 @smallexample
7151 @group
7152 1:  [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
7153     .
7155     V M ^
7156 @end group
7157 @end smallexample
7159 @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
7160 @subsection List Tutorial Exercise 2
7162 @noindent
7163 Given @cite{x} and @cite{y} vectors in quick variables 1 and 2 as before,
7164 the first job is to form the matrix that describes the problem.
7166 @ifinfo
7167 @example
7168    m*x + b*1 = y
7169 @end example
7170 @end ifinfo
7171 @tex
7172 \turnoffactive
7173 \beforedisplay
7174 $$ m \times x + b \times 1 = y $$
7175 \afterdisplay
7176 @end tex
7178 Thus we want a @c{$19\times2$}
7179 @asis{19x2} matrix with our @cite{x} vector as one column and
7180 ones as the other column.  So, first we build the column of ones, then
7181 we combine the two columns to form our @cite{A} matrix.
7183 @smallexample
7184 @group
7185 2:  [1.34, 1.41, 1.49, ... ]    1:  [ [ 1.34, 1 ]
7186 1:  [1, 1, 1, ...]                    [ 1.41, 1 ]
7187     .                                 [ 1.49, 1 ]
7188                                       @dots{}
7190     r 1 1 v b 19 @key{RET}                M-2 v p v t   s 3
7191 @end group
7192 @end smallexample
7194 @noindent
7195 Now we compute @c{$A^T y$}
7196 @cite{trn(A) * y} and @c{$A^T A$}
7197 @cite{trn(A) * A} and divide.
7199 @smallexample
7200 @group
7201 1:  [33.36554, 13.613]    2:  [33.36554, 13.613]
7202     .                     1:  [ [ 98.0003, 41.63 ]
7203                                 [  41.63,   19   ] ]
7204                               .
7206  v t r 2 *                    r 3 v t r 3 *
7207 @end group
7208 @end smallexample
7210 @noindent
7211 (Hey, those numbers look familiar!)
7213 @smallexample
7214 @group
7215 1:  [0.52141679, -0.425978]
7216     .
7218     /
7219 @end group
7220 @end smallexample
7222 Since we were solving equations of the form @c{$m \times x + b \times 1 = y$}
7223 @cite{m*x + b*1 = y}, these
7224 numbers should be @cite{m} and @cite{b}, respectively.  Sure enough, they
7225 agree exactly with the result computed using @kbd{V M} and @kbd{V R}!
7227 The moral of this story:  @kbd{V M} and @kbd{V R} will probably solve
7228 your problem, but there is often an easier way using the higher-level
7229 arithmetic functions!
7231 @c [fix-ref Curve Fitting]
7232 In fact, there is a built-in @kbd{a F} command that does least-squares
7233 fits.  @xref{Curve Fitting}.
7235 @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
7236 @subsection List Tutorial Exercise 3
7238 @noindent
7239 Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
7240 whatever) to set the mark, then move to the other end of the list
7241 and type @w{@kbd{M-# g}}.
7243 @smallexample
7244 @group
7245 1:  [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
7246     .
7247 @end group
7248 @end smallexample
7250 To make things interesting, let's assume we don't know at a glance
7251 how many numbers are in this list.  Then we could type:
7253 @smallexample
7254 @group
7255 2:  [2.3, 6, 22, ... ]     2:  [2.3, 6, 22, ... ]
7256 1:  [2.3, 6, 22, ... ]     1:  126356422.5
7257     .                          .
7259     @key{RET}                        V R *
7261 @end group
7262 @end smallexample
7263 @noindent
7264 @smallexample
7265 @group
7266 2:  126356422.5            2:  126356422.5     1:  7.94652913734
7267 1:  [2.3, 6, 22, ... ]     1:  9                   .
7268     .                          .
7270     @key{TAB}                        v l                 I ^
7271 @end group
7272 @end smallexample
7274 @noindent
7275 (The @kbd{I ^} command computes the @var{n}th root of a number.
7276 You could also type @kbd{& ^} to take the reciprocal of 9 and
7277 then raise the number to that power.)
7279 @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
7280 @subsection List Tutorial Exercise 4
7282 @noindent
7283 A number @cite{j} is a divisor of @cite{n} if @c{$n \mathbin{\hbox{\code{\%}}} j = 0$}
7284 @samp{n % j = 0}.  The first
7285 step is to get a vector that identifies the divisors.
7287 @smallexample
7288 @group
7289 2:  30                  2:  [0, 0, 0, 2, ...]    1:  [1, 1, 1, 0, ...]
7290 1:  [1, 2, 3, 4, ...]   1:  0                        .
7291     .                       .
7293  30 @key{RET} v x 30 @key{RET}   s 1    V M %  0                 V M a =  s 2
7294 @end group
7295 @end smallexample
7297 @noindent
7298 This vector has 1's marking divisors of 30 and 0's marking non-divisors.
7300 The zeroth divisor function is just the total number of divisors.
7301 The first divisor function is the sum of the divisors.
7303 @smallexample
7304 @group
7305 1:  8      3:  8                    2:  8                    2:  8
7306            2:  [1, 2, 3, 4, ...]    1:  [1, 2, 3, 0, ...]    1:  72
7307            1:  [1, 1, 1, 0, ...]        .                        .
7308                .
7310    V R +       r 1 r 2                  V M *                  V R +
7311 @end group
7312 @end smallexample
7314 @noindent
7315 Once again, the last two steps just compute a dot product for which
7316 a simple @kbd{*} would have worked equally well.
7318 @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
7319 @subsection List Tutorial Exercise 5
7321 @noindent
7322 The obvious first step is to obtain the list of factors with @kbd{k f}.
7323 This list will always be in sorted order, so if there are duplicates
7324 they will be right next to each other.  A suitable method is to compare
7325 the list with a copy of itself shifted over by one.
7327 @smallexample
7328 @group
7329 1:  [3, 7, 7, 7, 19]   2:  [3, 7, 7, 7, 19]     2:  [3, 7, 7, 7, 19, 0]
7330     .                  1:  [3, 7, 7, 7, 19, 0]  1:  [0, 3, 7, 7, 7, 19]
7331                            .                        .
7333     19551 k f              @key{RET} 0 |                  @key{TAB} 0 @key{TAB} |
7335 @end group
7336 @end smallexample
7337 @noindent
7338 @smallexample
7339 @group
7340 1:  [0, 0, 1, 1, 0, 0]   1:  2          1:  0
7341     .                        .              .
7343     V M a =                  V R +          0 a =
7344 @end group
7345 @end smallexample
7347 @noindent
7348 Note that we have to arrange for both vectors to have the same length
7349 so that the mapping operation works; no prime factor will ever be
7350 zero, so adding zeros on the left and right is safe.  From then on
7351 the job is pretty straightforward.
7353 Incidentally, Calc provides the @c{\dfn{M\"obius} $\mu$}
7354 @dfn{Moebius mu} function which is
7355 zero if and only if its argument is square-free.  It would be a much
7356 more convenient way to do the above test in practice.
7358 @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
7359 @subsection List Tutorial Exercise 6
7361 @noindent
7362 First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
7363 to get a list of lists of integers!
7365 @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
7366 @subsection List Tutorial Exercise 7
7368 @noindent
7369 Here's one solution.  First, compute the triangular list from the previous
7370 exercise and type @kbd{1 -} to subtract one from all the elements.
7372 @smallexample
7373 @group
7374 1:  [ [0],
7375       [0, 1],
7376       [0, 1, 2],
7377       @dots{}
7379     1 -
7380 @end group
7381 @end smallexample
7383 The numbers down the lefthand edge of the list we desire are called
7384 the ``triangular numbers'' (now you know why!).  The @cite{n}th
7385 triangular number is the sum of the integers from 1 to @cite{n}, and
7386 can be computed directly by the formula @c{$n (n+1) \over 2$}
7387 @cite{n * (n+1) / 2}.
7389 @smallexample
7390 @group
7391 2:  [ [0], [0, 1], ... ]    2:  [ [0], [0, 1], ... ]
7392 1:  [0, 1, 2, 3, 4, 5]      1:  [0, 1, 3, 6, 10, 15]
7393     .                           .
7395     v x 6 @key{RET} 1 -               V M ' $ ($+1)/2 @key{RET}
7396 @end group
7397 @end smallexample
7399 @noindent
7400 Adding this list to the above list of lists produces the desired
7401 result:
7403 @smallexample
7404 @group
7405 1:  [ [0],
7406       [1, 2],
7407       [3, 4, 5],
7408       [6, 7, 8, 9],
7409       [10, 11, 12, 13, 14],
7410       [15, 16, 17, 18, 19, 20] ]
7411       .
7413       V M +
7414 @end group
7415 @end smallexample
7417 If we did not know the formula for triangular numbers, we could have
7418 computed them using a @kbd{V U +} command.  We could also have
7419 gotten them the hard way by mapping a reduction across the original
7420 triangular list.
7422 @smallexample
7423 @group
7424 2:  [ [0], [0, 1], ... ]    2:  [ [0], [0, 1], ... ]
7425 1:  [ [0], [0, 1], ... ]    1:  [0, 1, 3, 6, 10, 15]
7426     .                           .
7428     @key{RET}                         V M V R +
7429 @end group
7430 @end smallexample
7432 @noindent
7433 (This means ``map a @kbd{V R +} command across the vector,'' and
7434 since each element of the main vector is itself a small vector,
7435 @kbd{V R +} computes the sum of its elements.)
7437 @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
7438 @subsection List Tutorial Exercise 8
7440 @noindent
7441 The first step is to build a list of values of @cite{x}.
7443 @smallexample
7444 @group
7445 1:  [1, 2, 3, ..., 21]  1:  [0, 1, 2, ..., 20]  1:  [0, 0.25, 0.5, ..., 5]
7446     .                       .                       .
7448     v x 21 @key{RET}              1 -                     4 /  s 1
7449 @end group
7450 @end smallexample
7452 Next, we compute the Bessel function values.
7454 @smallexample
7455 @group
7456 1:  [0., 0.124, 0.242, ..., -0.328]
7457     .
7459     V M ' besJ(1,$) @key{RET}
7460 @end group
7461 @end smallexample
7463 @noindent
7464 (Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
7466 A way to isolate the maximum value is to compute the maximum using
7467 @kbd{V R X}, then compare all the Bessel values with that maximum.
7469 @smallexample
7470 @group
7471 2:  [0., 0.124, 0.242, ... ]   1:  [0, 0, 0, ... ]    2:  [0, 0, 0, ... ]
7472 1:  0.5801562                      .                  1:  1
7473     .                                                     .
7475     @key{RET} V R X                      V M a =                @key{RET} V R +    @key{DEL}
7476 @end group
7477 @end smallexample
7479 @noindent
7480 It's a good idea to verify, as in the last step above, that only
7481 one value is equal to the maximum.  (After all, a plot of @c{$\sin x$}
7482 @cite{sin(x)}
7483 might have many points all equal to the maximum value, 1.)
7485 The vector we have now has a single 1 in the position that indicates
7486 the maximum value of @cite{x}.  Now it is a simple matter to convert
7487 this back into the corresponding value itself.
7489 @smallexample
7490 @group
7491 2:  [0, 0, 0, ... ]         1:  [0, 0., 0., ... ]    1:  1.75
7492 1:  [0, 0.25, 0.5, ... ]        .                        .
7493     .
7495     r 1                         V M *                    V R +
7496 @end group
7497 @end smallexample
7499 If @kbd{a =} had produced more than one @cite{1} value, this method
7500 would have given the sum of all maximum @cite{x} values; not very
7501 useful!  In this case we could have used @kbd{v m} (@code{calc-mask-vector})
7502 instead.  This command deletes all elements of a ``data'' vector that
7503 correspond to zeros in a ``mask'' vector, leaving us with, in this
7504 example, a vector of maximum @cite{x} values.
7506 The built-in @kbd{a X} command maximizes a function using more
7507 efficient methods.  Just for illustration, let's use @kbd{a X}
7508 to maximize @samp{besJ(1,x)} over this same interval.
7510 @smallexample
7511 @group
7512 2:  besJ(1, x)                 1:  [1.84115, 0.581865]
7513 1:  [0 .. 5]                       .
7514     .
7516 ' besJ(1,x), [0..5] @key{RET}            a X x @key{RET}
7517 @end group
7518 @end smallexample
7520 @noindent
7521 The output from @kbd{a X} is a vector containing the value of @cite{x}
7522 that maximizes the function, and the function's value at that maximum.
7523 As you can see, our simple search got quite close to the right answer.
7525 @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
7526 @subsection List Tutorial Exercise 9
7528 @noindent
7529 Step one is to convert our integer into vector notation.
7531 @smallexample
7532 @group
7533 1:  25129925999           3:  25129925999
7534     .                     2:  10
7535                           1:  [11, 10, 9, ..., 1, 0]
7536                               .
7538     25129925999 @key{RET}           10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
7540 @end group
7541 @end smallexample
7542 @noindent
7543 @smallexample
7544 @group
7545 1:  25129925999              1:  [0, 2, 25, 251, 2512, ... ]
7546 2:  [100000000000, ... ]         .
7547     .
7549     V M ^   s 1                  V M \
7550 @end group
7551 @end smallexample
7553 @noindent
7554 (Recall, the @kbd{\} command computes an integer quotient.)
7556 @smallexample
7557 @group
7558 1:  [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
7559     .
7561     10 V M %   s 2
7562 @end group
7563 @end smallexample
7565 Next we must increment this number.  This involves adding one to
7566 the last digit, plus handling carries.  There is a carry to the
7567 left out of a digit if that digit is a nine and all the digits to
7568 the right of it are nines.
7570 @smallexample
7571 @group
7572 1:  [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1]   1:  [1, 1, 1, 0, 0, 1, ... ]
7573     .                                          .
7575     9 V M a =                                  v v
7577 @end group
7578 @end smallexample
7579 @noindent
7580 @smallexample
7581 @group
7582 1:  [1, 1, 1, 0, 0, 0, ... ]   1:  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
7583     .                              .
7585     V U *                          v v 1 |
7586 @end group
7587 @end smallexample
7589 @noindent
7590 Accumulating @kbd{*} across a vector of ones and zeros will preserve
7591 only the initial run of ones.  These are the carries into all digits
7592 except the rightmost digit.  Concatenating a one on the right takes
7593 care of aligning the carries properly, and also adding one to the
7594 rightmost digit.
7596 @smallexample
7597 @group
7598 2:  [0, 0, 0, 0, ... ]     1:  [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
7599 1:  [0, 0, 2, 5, ... ]         .
7600     .
7602     0 r 2 |                    V M +  10 V M %
7603 @end group
7604 @end smallexample
7606 @noindent
7607 Here we have concatenated 0 to the @emph{left} of the original number;
7608 this takes care of shifting the carries by one with respect to the
7609 digits that generated them.
7611 Finally, we must convert this list back into an integer.
7613 @smallexample
7614 @group
7615 3:  [0, 0, 2, 5, ... ]        2:  [0, 0, 2, 5, ... ]
7616 2:  1000000000000             1:  [1000000000000, 100000000000, ... ]
7617 1:  [100000000000, ... ]          .
7618     .
7620     10 @key{RET} 12 ^  r 1              |
7622 @end group
7623 @end smallexample
7624 @noindent
7625 @smallexample
7626 @group
7627 1:  [0, 0, 20000000000, 5000000000, ... ]    1:  25129926000
7628     .                                            .
7630     V M *                                        V R +
7631 @end group
7632 @end smallexample
7634 @noindent
7635 Another way to do this final step would be to reduce the formula
7636 @w{@samp{10 $$ + $}} across the vector of digits.
7638 @smallexample
7639 @group
7640 1:  [0, 0, 2, 5, ... ]        1:  25129926000
7641     .                             .
7643                                   V R ' 10 $$ + $ @key{RET}
7644 @end group
7645 @end smallexample
7647 @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
7648 @subsection List Tutorial Exercise 10
7650 @noindent
7651 For the list @cite{[a, b, c, d]}, the result is @cite{((a = b) = c) = d},
7652 which will compare @cite{a} and @cite{b} to produce a 1 or 0, which is
7653 then compared with @cite{c} to produce another 1 or 0, which is then
7654 compared with @cite{d}.  This is not at all what Joe wanted.
7656 Here's a more correct method:
7658 @smallexample
7659 @group
7660 1:  [7, 7, 7, 8, 7]      2:  [7, 7, 7, 8, 7]
7661     .                    1:  7
7662                              .
7664   ' [7,7,7,8,7] @key{RET}          @key{RET} v r 1 @key{RET}
7666 @end group
7667 @end smallexample
7668 @noindent
7669 @smallexample
7670 @group
7671 1:  [1, 1, 1, 0, 1]      1:  0
7672     .                        .
7674     V M a =                  V R *
7675 @end group
7676 @end smallexample
7678 @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
7679 @subsection List Tutorial Exercise 11
7681 @noindent
7682 The circle of unit radius consists of those points @cite{(x,y)} for which
7683 @cite{x^2 + y^2 < 1}.  We start by generating a vector of @cite{x^2}
7684 and a vector of @cite{y^2}.
7686 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7687 commands.
7689 @smallexample
7690 @group
7691 2:  [2., 2., ..., 2.]          2:  [2., 2., ..., 2.]
7692 1:  [2., 2., ..., 2.]          1:  [1.16, 1.98, ..., 0.81]
7693     .                              .
7695  v . t .  2. v b 100 @key{RET} @key{RET}       V M k r
7697 @end group
7698 @end smallexample
7699 @noindent
7700 @smallexample
7701 @group
7702 2:  [2., 2., ..., 2.]          1:  [0.026, 0.96, ..., 0.036]
7703 1:  [0.026, 0.96, ..., 0.036]  2:  [0.53, 0.81, ..., 0.094]
7704     .                              .
7706     1 -  2 V M ^                   @key{TAB}  V M k r  1 -  2 V M ^
7707 @end group
7708 @end smallexample
7710 Now we sum the @cite{x^2} and @cite{y^2} values, compare with 1 to
7711 get a vector of 1/0 truth values, then sum the truth values.
7713 @smallexample
7714 @group
7715 1:  [0.56, 1.78, ..., 0.13]    1:  [1, 0, ..., 1]    1:  84
7716     .                              .                     .
7718     +                              1 V M a <             V R +
7719 @end group
7720 @end smallexample
7722 @noindent
7723 The ratio @cite{84/100} should approximate the ratio @c{$\pi/4$}
7724 @cite{pi/4}.
7726 @smallexample
7727 @group
7728 1:  0.84       1:  3.36       2:  3.36       1:  1.0695
7729     .              .          1:  3.14159        .
7731     100 /          4 *            P              /
7732 @end group
7733 @end smallexample
7735 @noindent
7736 Our estimate, 3.36, is off by about 7%.  We could get a better estimate
7737 by taking more points (say, 1000), but it's clear that this method is
7738 not very efficient!
7740 (Naturally, since this example uses random numbers your own answer
7741 will be slightly different from the one shown here!)
7743 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7744 return to full-sized display of vectors.
7746 @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
7747 @subsection List Tutorial Exercise 12
7749 @noindent
7750 This problem can be made a lot easier by taking advantage of some
7751 symmetries.  First of all, after some thought it's clear that the
7752 @cite{y} axis can be ignored altogether.  Just pick a random @cite{x}
7753 component for one end of the match, pick a random direction @c{$\theta$}
7754 @cite{theta},
7755 and see if @cite{x} and @c{$x + \cos \theta$}
7756 @cite{x + cos(theta)} (which is the @cite{x}
7757 coordinate of the other endpoint) cross a line.  The lines are at
7758 integer coordinates, so this happens when the two numbers surround
7759 an integer.
7761 Since the two endpoints are equivalent, we may as well choose the leftmost
7762 of the two endpoints as @cite{x}.  Then @cite{theta} is an angle pointing
7763 to the right, in the range -90 to 90 degrees.  (We could use radians, but
7764 it would feel like cheating to refer to @c{$\pi/2$}
7765 @cite{pi/2} radians while trying
7766 to estimate @c{$\pi$}
7767 @cite{pi}!)
7769 In fact, since the field of lines is infinite we can choose the
7770 coordinates 0 and 1 for the lines on either side of the leftmost
7771 endpoint.  The rightmost endpoint will be between 0 and 1 if the
7772 match does not cross a line, or between 1 and 2 if it does.  So:
7773 Pick random @cite{x} and @c{$\theta$}
7774 @cite{theta}, compute @c{$x + \cos \theta$}
7775 @cite{x + cos(theta)},
7776 and count how many of the results are greater than one.  Simple!
7778 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7779 commands.
7781 @smallexample
7782 @group
7783 1:  [0.52, 0.71, ..., 0.72]    2:  [0.52, 0.71, ..., 0.72]
7784     .                          1:  [78.4, 64.5, ..., -42.9]
7785                                    .
7787 v . t . 1. v b 100 @key{RET}  V M k r    180. v b 100 @key{RET}  V M k r  90 -
7788 @end group
7789 @end smallexample
7791 @noindent
7792 (The next step may be slow, depending on the speed of your computer.)
7794 @smallexample
7795 @group
7796 2:  [0.52, 0.71, ..., 0.72]    1:  [0.72, 1.14, ..., 1.45]
7797 1:  [0.20, 0.43, ..., 0.73]        .
7798     .
7800     m d  V M C                     +
7802 @end group
7803 @end smallexample
7804 @noindent
7805 @smallexample
7806 @group
7807 1:  [0, 1, ..., 1]       1:  0.64            1:  3.125
7808     .                        .                   .
7810     1 V M a >                V R + 100 /         2 @key{TAB} /
7811 @end group
7812 @end smallexample
7814 Let's try the third method, too.  We'll use random integers up to
7815 one million.  The @kbd{k r} command with an integer argument picks
7816 a random integer.
7818 @smallexample
7819 @group
7820 2:  [1000000, 1000000, ..., 1000000]   2:  [78489, 527587, ..., 814975]
7821 1:  [1000000, 1000000, ..., 1000000]   1:  [324014, 358783, ..., 955450]
7822     .                                      .
7824     1000000 v b 100 @key{RET} @key{RET}                V M k r  @key{TAB}  V M k r
7826 @end group
7827 @end smallexample
7828 @noindent
7829 @smallexample
7830 @group
7831 1:  [1, 1, ..., 25]      1:  [1, 1, ..., 0]     1:  0.56
7832     .                        .                      .
7834     V M k g                  1 V M a =              V R + 100 /
7836 @end group
7837 @end smallexample
7838 @noindent
7839 @smallexample
7840 @group
7841 1:  10.714        1:  3.273
7842     .                 .
7844     6 @key{TAB} /           Q
7845 @end group
7846 @end smallexample
7848 For a proof of this property of the GCD function, see section 4.5.2,
7849 exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
7851 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7852 return to full-sized display of vectors.
7854 @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
7855 @subsection List Tutorial Exercise 13
7857 @noindent
7858 First, we put the string on the stack as a vector of ASCII codes.
7860 @smallexample
7861 @group
7862 1:  [84, 101, 115, ..., 51]
7863     .
7865     "Testing, 1, 2, 3 @key{RET}
7866 @end group
7867 @end smallexample
7869 @noindent
7870 Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
7871 there was no need to type an apostrophe.  Also, Calc didn't mind that
7872 we omitted the closing @kbd{"}.  (The same goes for all closing delimiters
7873 like @kbd{)} and @kbd{]} at the end of a formula.
7875 We'll show two different approaches here.  In the first, we note that
7876 if the input vector is @cite{[a, b, c, d]}, then the hash code is
7877 @cite{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}.  In other words,
7878 it's a sum of descending powers of three times the ASCII codes.
7880 @smallexample
7881 @group
7882 2:  [84, 101, 115, ..., 51]    2:  [84, 101, 115, ..., 51]
7883 1:  16                         1:  [15, 14, 13, ..., 0]
7884     .                              .
7886     @key{RET} v l                        v x 16 @key{RET} -
7888 @end group
7889 @end smallexample
7890 @noindent
7891 @smallexample
7892 @group
7893 2:  [84, 101, 115, ..., 51]    1:  1960915098    1:  121
7894 1:  [14348907, ..., 1]             .                 .
7895     .
7897     3 @key{TAB} V M ^                    *                 511 %
7898 @end group
7899 @end smallexample
7901 @noindent
7902 Once again, @kbd{*} elegantly summarizes most of the computation.
7903 But there's an even more elegant approach:  Reduce the formula
7904 @kbd{3 $$ + $} across the vector.  Recall that this represents a
7905 function of two arguments that computes its first argument times three
7906 plus its second argument.
7908 @smallexample
7909 @group
7910 1:  [84, 101, 115, ..., 51]    1:  1960915098
7911     .                              .
7913     "Testing, 1, 2, 3 @key{RET}          V R ' 3$$+$ @key{RET}
7914 @end group
7915 @end smallexample
7917 @noindent
7918 If you did the decimal arithmetic exercise, this will be familiar.
7919 Basically, we're turning a base-3 vector of digits into an integer,
7920 except that our ``digits'' are much larger than real digits.
7922 Instead of typing @kbd{511 %} again to reduce the result, we can be
7923 cleverer still and notice that rather than computing a huge integer
7924 and taking the modulo at the end, we can take the modulo at each step
7925 without affecting the result.  While this means there are more
7926 arithmetic operations, the numbers we operate on remain small so
7927 the operations are faster.
7929 @smallexample
7930 @group
7931 1:  [84, 101, 115, ..., 51]    1:  121
7932     .                              .
7934     "Testing, 1, 2, 3 @key{RET}          V R ' (3$$+$)%511 @key{RET}
7935 @end group
7936 @end smallexample
7938 Why does this work?  Think about a two-step computation:
7939 @w{@cite{3 (3a + b) + c}}.  Taking a result modulo 511 basically means
7940 subtracting off enough 511's to put the result in the desired range.
7941 So the result when we take the modulo after every step is,
7943 @ifinfo
7944 @example
7945 3 (3 a + b - 511 m) + c - 511 n
7946 @end example
7947 @end ifinfo
7948 @tex
7949 \turnoffactive
7950 \beforedisplay
7951 $$ 3 (3 a + b - 511 m) + c - 511 n $$
7952 \afterdisplay
7953 @end tex
7955 @noindent
7956 for some suitable integers @cite{m} and @cite{n}.  Expanding out by
7957 the distributive law yields
7959 @ifinfo
7960 @example
7961 9 a + 3 b + c - 511*3 m - 511 n
7962 @end example
7963 @end ifinfo
7964 @tex
7965 \turnoffactive
7966 \beforedisplay
7967 $$ 9 a + 3 b + c - 511\times3 m - 511 n $$
7968 \afterdisplay
7969 @end tex
7971 @noindent
7972 The @cite{m} term in the latter formula is redundant because any
7973 contribution it makes could just as easily be made by the @cite{n}
7974 term.  So we can take it out to get an equivalent formula with
7975 @cite{n' = 3m + n},
7977 @ifinfo
7978 @example
7979 9 a + 3 b + c - 511 n'
7980 @end example
7981 @end ifinfo
7982 @tex
7983 \turnoffactive
7984 \beforedisplay
7985 $$ 9 a + 3 b + c - 511 n' $$
7986 \afterdisplay
7987 @end tex
7989 @noindent
7990 which is just the formula for taking the modulo only at the end of
7991 the calculation.  Therefore the two methods are essentially the same.
7993 Later in the tutorial we will encounter @dfn{modulo forms}, which
7994 basically automate the idea of reducing every intermediate result
7995 modulo some value @var{m}.
7997 @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
7998 @subsection List Tutorial Exercise 14
8000 We want to use @kbd{H V U} to nest a function which adds a random
8001 step to an @cite{(x,y)} coordinate.  The function is a bit long, but
8002 otherwise the problem is quite straightforward.
8004 @smallexample
8005 @group
8006 2:  [0, 0]     1:  [ [    0,       0    ]
8007 1:  50               [  0.4288, -0.1695 ]
8008     .                [ -0.4787, -0.9027 ]
8009                      ...
8011     [0,0] 50       H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
8012 @end group
8013 @end smallexample
8015 Just as the text recommended, we used @samp{< >} nameless function
8016 notation to keep the two @code{random} calls from being evaluated
8017 before nesting even begins.
8019 We now have a vector of @cite{[x, y]} sub-vectors, which by Calc's
8020 rules acts like a matrix.  We can transpose this matrix and unpack
8021 to get a pair of vectors, @cite{x} and @cite{y}, suitable for graphing.
8023 @smallexample
8024 @group
8025 2:  [ 0, 0.4288, -0.4787, ... ]
8026 1:  [ 0, -0.1696, -0.9027, ... ]
8027     .
8029     v t  v u  g f
8030 @end group
8031 @end smallexample
8033 Incidentally, because the @cite{x} and @cite{y} are completely
8034 independent in this case, we could have done two separate commands
8035 to create our @cite{x} and @cite{y} vectors of numbers directly.
8037 To make a random walk of unit steps, we note that @code{sincos} of
8038 a random direction exactly gives us an @cite{[x, y]} step of unit
8039 length; in fact, the new nesting function is even briefer, though
8040 we might want to lower the precision a bit for it.
8042 @smallexample
8043 @group
8044 2:  [0, 0]     1:  [ [    0,      0    ]
8045 1:  50               [  0.1318, 0.9912 ]
8046     .                [ -0.5965, 0.3061 ]
8047                      ...
8049     [0,0] 50   m d  p 6 @key{RET}   H V U ' <# + sincos(random(360.0))> @key{RET}
8050 @end group
8051 @end smallexample
8053 Another @kbd{v t v u g f} sequence will graph this new random walk.
8055 An interesting twist on these random walk functions would be to use
8056 complex numbers instead of 2-vectors to represent points on the plane.
8057 In the first example, we'd use something like @samp{random + random*(0,1)},
8058 and in the second we could use polar complex numbers with random phase
8059 angles.  (This exercise was first suggested in this form by Randal
8060 Schwartz.)
8062 @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
8063 @subsection Types Tutorial Exercise 1
8065 @noindent
8066 If the number is the square root of @c{$\pi$}
8067 @cite{pi} times a rational number,
8068 then its square, divided by @c{$\pi$}
8069 @cite{pi}, should be a rational number.
8071 @smallexample
8072 @group
8073 1:  1.26508260337    1:  0.509433962268   1:  2486645810:4881193627
8074     .                    .                    .
8076                          2 ^ P /              c F
8077 @end group
8078 @end smallexample
8080 @noindent
8081 Technically speaking this is a rational number, but not one that is
8082 likely to have arisen in the original problem.  More likely, it just
8083 happens to be the fraction which most closely represents some
8084 irrational number to within 12 digits.
8086 But perhaps our result was not quite exact.  Let's reduce the
8087 precision slightly and try again:
8089 @smallexample
8090 @group
8091 1:  0.509433962268     1:  27:53
8092     .                      .
8094     U p 10 @key{RET}             c F
8095 @end group
8096 @end smallexample
8098 @noindent
8099 Aha!  It's unlikely that an irrational number would equal a fraction
8100 this simple to within ten digits, so our original number was probably
8101 @c{$\sqrt{27 \pi / 53}$}
8102 @cite{sqrt(27 pi / 53)}.
8104 Notice that we didn't need to re-round the number when we reduced the
8105 precision.  Remember, arithmetic operations always round their inputs
8106 to the current precision before they begin.
8108 @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
8109 @subsection Types Tutorial Exercise 2
8111 @noindent
8112 @samp{inf / inf = nan}.  Perhaps @samp{1} is the ``obvious'' answer.
8113 But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
8115 @samp{exp(inf) = inf}.  It's tempting to say that the exponential
8116 of infinity must be ``bigger'' than ``regular'' infinity, but as
8117 far as Calc is concerned all infinities are as just as big.
8118 In other words, as @cite{x} goes to infinity, @cite{e^x} also goes
8119 to infinity, but the fact the @cite{e^x} grows much faster than
8120 @cite{x} is not relevant here.
8122 @samp{exp(-inf) = 0}.  Here we have a finite answer even though
8123 the input is infinite.
8125 @samp{sqrt(-inf) = (0, 1) inf}.  Remember that @cite{(0, 1)}
8126 represents the imaginary number @cite{i}.  Here's a derivation:
8127 @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
8128 The first part is, by definition, @cite{i}; the second is @code{inf}
8129 because, once again, all infinities are the same size.
8131 @samp{sqrt(uinf) = uinf}.  In fact, we do know something about the
8132 direction because @code{sqrt} is defined to return a value in the
8133 right half of the complex plane.  But Calc has no notation for this,
8134 so it settles for the conservative answer @code{uinf}.
8136 @samp{abs(uinf) = inf}.  No matter which direction @cite{x} points,
8137 @samp{abs(x)} always points along the positive real axis.
8139 @samp{ln(0) = -inf}.  Here we have an infinite answer to a finite
8140 input.  As in the @cite{1 / 0} case, Calc will only use infinities
8141 here if you have turned on ``infinite'' mode.  Otherwise, it will
8142 treat @samp{ln(0)} as an error.
8144 @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
8145 @subsection Types Tutorial Exercise 3
8147 @noindent
8148 We can make @samp{inf - inf} be any real number we like, say,
8149 @cite{a}, just by claiming that we added @cite{a} to the first
8150 infinity but not to the second.  This is just as true for complex
8151 values of @cite{a}, so @code{nan} can stand for a complex number.
8152 (And, similarly, @code{uinf} can stand for an infinity that points
8153 in any direction in the complex plane, such as @samp{(0, 1) inf}).
8155 In fact, we can multiply the first @code{inf} by two.  Surely
8156 @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
8157 So @code{nan} can even stand for infinity.  Obviously it's just
8158 as easy to make it stand for minus infinity as for plus infinity.
8160 The moral of this story is that ``infinity'' is a slippery fish
8161 indeed, and Calc tries to handle it by having a very simple model
8162 for infinities (only the direction counts, not the ``size''); but
8163 Calc is careful to write @code{nan} any time this simple model is
8164 unable to tell what the true answer is.
8166 @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
8167 @subsection Types Tutorial Exercise 4
8169 @smallexample
8170 @group
8171 2:  0@@ 47' 26"              1:  0@@ 2' 47.411765"
8172 1:  17                          .
8173     .
8175     0@@ 47' 26" @key{RET} 17           /
8176 @end group
8177 @end smallexample
8179 @noindent
8180 The average song length is two minutes and 47.4 seconds.
8182 @smallexample
8183 @group
8184 2:  0@@ 2' 47.411765"     1:  0@@ 3' 7.411765"    1:  0@@ 53' 6.000005"
8185 1:  0@@ 0' 20"                .                      .
8186     .
8188     20"                      +                      17 *
8189 @end group
8190 @end smallexample
8192 @noindent
8193 The album would be 53 minutes and 6 seconds long.
8195 @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
8196 @subsection Types Tutorial Exercise 5
8198 @noindent
8199 Let's suppose it's January 14, 1991.  The easiest thing to do is
8200 to keep trying 13ths of months until Calc reports a Friday.
8201 We can do this by manually entering dates, or by using @kbd{t I}:
8203 @smallexample
8204 @group
8205 1:  <Wed Feb 13, 1991>    1:  <Wed Mar 13, 1991>   1:  <Sat Apr 13, 1991>
8206     .                         .                        .
8208     ' <2/13> @key{RET}       @key{DEL}    ' <3/13> @key{RET}             t I
8209 @end group
8210 @end smallexample
8212 @noindent
8213 (Calc assumes the current year if you don't say otherwise.)
8215 This is getting tedious---we can keep advancing the date by typing
8216 @kbd{t I} over and over again, but let's automate the job by using
8217 vector mapping.  The @kbd{t I} command actually takes a second
8218 ``how-many-months'' argument, which defaults to one.  This
8219 argument is exactly what we want to map over:
8221 @smallexample
8222 @group
8223 2:  <Sat Apr 13, 1991>     1:  [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
8224 1:  [1, 2, 3, 4, 5, 6]          <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
8225     .                           <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
8226                                .
8228     v x 6 @key{RET}                  V M t I
8229 @end group
8230 @end smallexample
8232 @noindent
8233 Et voil@`a, September 13, 1991 is a Friday.
8235 @smallexample
8236 @group
8237 1:  242
8238     .
8240 ' <sep 13> - <jan 14> @key{RET}
8241 @end group
8242 @end smallexample
8244 @noindent
8245 And the answer to our original question:  242 days to go.
8247 @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
8248 @subsection Types Tutorial Exercise 6
8250 @noindent
8251 The full rule for leap years is that they occur in every year divisible
8252 by four, except that they don't occur in years divisible by 100, except
8253 that they @emph{do} in years divisible by 400.  We could work out the
8254 answer by carefully counting the years divisible by four and the
8255 exceptions, but there is a much simpler way that works even if we
8256 don't know the leap year rule.
8258 Let's assume the present year is 1991.  Years have 365 days, except
8259 that leap years (whenever they occur) have 366 days.  So let's count
8260 the number of days between now and then, and compare that to the
8261 number of years times 365.  The number of extra days we find must be
8262 equal to the number of leap years there were.
8264 @smallexample
8265 @group
8266 1:  <Mon Jan 1, 10001>     2:  <Mon Jan 1, 10001>     1:  2925593
8267     .                      1:  <Tue Jan 1, 1991>          .
8268                                .
8270   ' <jan 1 10001> @key{RET}         ' <jan 1 1991> @key{RET}          -
8272 @end group
8273 @end smallexample
8274 @noindent
8275 @smallexample
8276 @group
8277 3:  2925593       2:  2925593     2:  2925593     1:  1943
8278 2:  10001         1:  8010        1:  2923650         .
8279 1:  1991              .               .
8280     .
8282   10001 @key{RET} 1991      -               365 *           -
8283 @end group
8284 @end smallexample
8286 @c [fix-ref Date Forms]
8287 @noindent
8288 There will be 1943 leap years before the year 10001.  (Assuming,
8289 of course, that the algorithm for computing leap years remains
8290 unchanged for that long.  @xref{Date Forms}, for some interesting
8291 background information in that regard.)
8293 @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
8294 @subsection Types Tutorial Exercise 7
8296 @noindent
8297 The relative errors must be converted to absolute errors so that
8298 @samp{+/-} notation may be used.
8300 @smallexample
8301 @group
8302 1:  1.              2:  1.
8303     .               1:  0.2
8304                         .
8306     20 @key{RET} .05 *        4 @key{RET} .05 *
8307 @end group
8308 @end smallexample
8310 Now we simply chug through the formula.
8312 @smallexample
8313 @group
8314 1:  19.7392088022    1:  394.78 +/- 19.739    1:  6316.5 +/- 706.21
8315     .                    .                        .
8317     2 P 2 ^ *            20 p 1 *                 4 p .2 @key{RET} 2 ^ *
8318 @end group
8319 @end smallexample
8321 It turns out the @kbd{v u} command will unpack an error form as
8322 well as a vector.  This saves us some retyping of numbers.
8324 @smallexample
8325 @group
8326 3:  6316.5 +/- 706.21     2:  6316.5 +/- 706.21
8327 2:  6316.5                1:  0.1118
8328 1:  706.21                    .
8329     .
8331     @key{RET} v u                   @key{TAB} /
8332 @end group
8333 @end smallexample
8335 @noindent
8336 Thus the volume is 6316 cubic centimeters, within about 11 percent.
8338 @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
8339 @subsection Types Tutorial Exercise 8
8341 @noindent
8342 The first answer is pretty simple:  @samp{1 / (0 .. 10) = (0.1 .. inf)}.
8343 Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
8344 close to zero, its reciprocal can get arbitrarily large, so the answer
8345 is an interval that effectively means, ``any number greater than 0.1''
8346 but with no upper bound.
8348 The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
8350 Calc normally treats division by zero as an error, so that the formula
8351 @w{@samp{1 / 0}} is left unsimplified.  Our third problem,
8352 @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
8353 is now a member of the interval.  So Calc leaves this one unevaluated, too.
8355 If you turn on ``infinite'' mode by pressing @kbd{m i}, you will
8356 instead get the answer @samp{[0.1 .. inf]}, which includes infinity
8357 as a possible value.
8359 The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
8360 Zero is buried inside the interval, but it's still a possible value.
8361 It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
8362 will be either greater than @i{0.1}, or less than @i{-0.1}.  Thus
8363 the interval goes from minus infinity to plus infinity, with a ``hole''
8364 in it from @i{-0.1} to @i{0.1}.  Calc doesn't have any way to
8365 represent this, so it just reports @samp{[-inf .. inf]} as the answer.
8366 It may be disappointing to hear ``the answer lies somewhere between
8367 minus infinity and plus infinity, inclusive,'' but that's the best
8368 that interval arithmetic can do in this case.
8370 @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
8371 @subsection Types Tutorial Exercise 9
8373 @smallexample
8374 @group
8375 1:  [-3 .. 3]       2:  [-3 .. 3]     2:  [0 .. 9]
8376     .               1:  [0 .. 9]      1:  [-9 .. 9]
8377                         .                 .
8379     [ 3 n .. 3 ]        @key{RET} 2 ^           @key{TAB} @key{RET} *
8380 @end group
8381 @end smallexample
8383 @noindent
8384 In the first case the result says, ``if a number is between @i{-3} and
8385 3, its square is between 0 and 9.''  The second case says, ``the product
8386 of two numbers each between @i{-3} and 3 is between @i{-9} and 9.''
8388 An interval form is not a number; it is a symbol that can stand for
8389 many different numbers.  Two identical-looking interval forms can stand
8390 for different numbers.
8392 The same issue arises when you try to square an error form.
8394 @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
8395 @subsection Types Tutorial Exercise 10
8397 @noindent
8398 Testing the first number, we might arbitrarily choose 17 for @cite{x}.
8400 @smallexample
8401 @group
8402 1:  17 mod 811749613   2:  17 mod 811749613   1:  533694123 mod 811749613
8403     .                      811749612              .
8404                            .
8406     17 M 811749613 @key{RET}     811749612              ^
8407 @end group
8408 @end smallexample
8410 @noindent
8411 Since 533694123 is (considerably) different from 1, the number 811749613
8412 must not be prime.
8414 It's awkward to type the number in twice as we did above.  There are
8415 various ways to avoid this, and algebraic entry is one.  In fact, using
8416 a vector mapping operation we can perform several tests at once.  Let's
8417 use this method to test the second number.
8419 @smallexample
8420 @group
8421 2:  [17, 42, 100000]               1:  [1 mod 15485863, 1 mod ... ]
8422 1:  15485863                           .
8423     .
8425  [17 42 100000] 15485863 @key{RET}           V M ' ($$ mod $)^($-1) @key{RET}
8426 @end group
8427 @end smallexample
8429 @noindent
8430 The result is three ones (modulo @cite{n}), so it's very probable that
8431 15485863 is prime.  (In fact, this number is the millionth prime.)
8433 Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
8434 would have been hopelessly inefficient, since they would have calculated
8435 the power using full integer arithmetic.
8437 Calc has a @kbd{k p} command that does primality testing.  For small
8438 numbers it does an exact test; for large numbers it uses a variant
8439 of the Fermat test we used here.  You can use @kbd{k p} repeatedly
8440 to prove that a large integer is prime with any desired probability.
8442 @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
8443 @subsection Types Tutorial Exercise 11
8445 @noindent
8446 There are several ways to insert a calculated number into an HMS form.
8447 One way to convert a number of seconds to an HMS form is simply to
8448 multiply the number by an HMS form representing one second:
8450 @smallexample
8451 @group
8452 1:  31415926.5359     2:  31415926.5359     1:  8726@@ 38' 46.5359"
8453     .                 1:  0@@ 0' 1"              .
8454                           .
8456     P 1e7 *               0@@ 0' 1"              *
8458 @end group
8459 @end smallexample
8460 @noindent
8461 @smallexample
8462 @group
8463 2:  8726@@ 38' 46.5359"             1:  6@@ 6' 2.5359" mod 24@@ 0' 0"
8464 1:  15@@ 27' 16" mod 24@@ 0' 0"          .
8465     .
8467     x time @key{RET}                         +
8468 @end group
8469 @end smallexample
8471 @noindent
8472 It will be just after six in the morning.
8474 The algebraic @code{hms} function can also be used to build an
8475 HMS form:
8477 @smallexample
8478 @group
8479 1:  hms(0, 0, 10000000. pi)       1:  8726@@ 38' 46.5359"
8480     .                                 .
8482   ' hms(0, 0, 1e7 pi) @key{RET}             =
8483 @end group
8484 @end smallexample
8486 @noindent
8487 The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
8488 the actual number 3.14159...
8490 @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
8491 @subsection Types Tutorial Exercise 12
8493 @noindent
8494 As we recall, there are 17 songs of about 2 minutes and 47 seconds
8495 each.
8497 @smallexample
8498 @group
8499 2:  0@@ 2' 47"                    1:  [0@@ 3' 7" .. 0@@ 3' 47"]
8500 1:  [0@@ 0' 20" .. 0@@ 1' 0"]          .
8501     .
8503     [ 0@@ 20" .. 0@@ 1' ]              +
8505 @end group
8506 @end smallexample
8507 @noindent
8508 @smallexample
8509 @group
8510 1:  [0@@ 52' 59." .. 1@@ 4' 19."]
8511     .
8513     17 *
8514 @end group
8515 @end smallexample
8517 @noindent
8518 No matter how long it is, the album will fit nicely on one CD.
8520 @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
8521 @subsection Types Tutorial Exercise 13
8523 @noindent
8524 Type @kbd{' 1 yr @key{RET} u c s @key{RET}}.  The answer is 31557600 seconds.
8526 @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
8527 @subsection Types Tutorial Exercise 14
8529 @noindent
8530 How long will it take for a signal to get from one end of the computer
8531 to the other?
8533 @smallexample
8534 @group
8535 1:  m / c         1:  3.3356 ns
8536     .                 .
8538  ' 1 m / c @key{RET}        u c ns @key{RET}
8539 @end group
8540 @end smallexample
8542 @noindent
8543 (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
8545 @smallexample
8546 @group
8547 1:  3.3356 ns     1:  0.81356 ns / ns     1:  0.81356
8548 2:  4.1 ns            .                       .
8549     .
8551   ' 4.1 ns @key{RET}        /                       u s
8552 @end group
8553 @end smallexample
8555 @noindent
8556 Thus a signal could take up to 81 percent of a clock cycle just to
8557 go from one place to another inside the computer, assuming the signal
8558 could actually attain the full speed of light.  Pretty tight!
8560 @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
8561 @subsection Types Tutorial Exercise 15
8563 @noindent
8564 The speed limit is 55 miles per hour on most highways.  We want to
8565 find the ratio of Sam's speed to the US speed limit.
8567 @smallexample
8568 @group
8569 1:  55 mph         2:  55 mph           3:  11 hr mph / yd
8570     .              1:  5 yd / hr            .
8571                        .
8573   ' 55 mph @key{RET}       ' 5 yd/hr @key{RET}          /
8574 @end group
8575 @end smallexample
8577 The @kbd{u s} command cancels out these units to get a plain
8578 number.  Now we take the logarithm base two to find the final
8579 answer, assuming that each successive pill doubles his speed.
8581 @smallexample
8582 @group
8583 1:  19360.       2:  19360.       1:  14.24
8584     .            1:  2                .
8585                      .
8587     u s              2                B
8588 @end group
8589 @end smallexample
8591 @noindent
8592 Thus Sam can take up to 14 pills without a worry.
8594 @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
8595 @subsection Algebra Tutorial Exercise 1
8597 @noindent
8598 @c [fix-ref Declarations]
8599 The result @samp{sqrt(x)^2} is simplified back to @cite{x} by the
8600 Calculator, but @samp{sqrt(x^2)} is not.  (Consider what happens
8601 if @w{@cite{x = -4}}.)  If @cite{x} is real, this formula could be
8602 simplified to @samp{abs(x)}, but for general complex arguments even
8603 that is not safe.  (@xref{Declarations}, for a way to tell Calc
8604 that @cite{x} is known to be real.)
8606 @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
8607 @subsection Algebra Tutorial Exercise 2
8609 @noindent
8610 Suppose our roots are @cite{[a, b, c]}.  We want a polynomial which
8611 is zero when @cite{x} is any of these values.  The trivial polynomial
8612 @cite{x-a} is zero when @cite{x=a}, so the product @cite{(x-a)(x-b)(x-c)}
8613 will do the job.  We can use @kbd{a c x} to write this in a more
8614 familiar form.
8616 @smallexample
8617 @group
8618 1:  34 x - 24 x^3          1:  [1.19023, -1.19023, 0]
8619     .                          .
8621     r 2                        a P x @key{RET}
8623 @end group
8624 @end smallexample
8625 @noindent
8626 @smallexample
8627 @group
8628 1:  [x - 1.19023, x + 1.19023, x]     1:  (x - 1.19023) (x + 1.19023) x
8629     .                                     .
8631     V M ' x-$ @key{RET}                         V R *
8633 @end group
8634 @end smallexample
8635 @noindent
8636 @smallexample
8637 @group
8638 1:  x^3 - 1.41666 x        1:  34 x - 24 x^3
8639     .                          .
8641     a c x @key{RET}                  24 n *  a x
8642 @end group
8643 @end smallexample
8645 @noindent
8646 Sure enough, our answer (multiplied by a suitable constant) is the
8647 same as the original polynomial.
8649 @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
8650 @subsection Algebra Tutorial Exercise 3
8652 @smallexample
8653 @group
8654 1:  x sin(pi x)         1:  (sin(pi x) - pi x cos(pi x)) / pi^2
8655     .                       .
8657   ' x sin(pi x) @key{RET}   m r   a i x @key{RET}
8659 @end group
8660 @end smallexample
8661 @noindent
8662 @smallexample
8663 @group
8664 1:  [y, 1]
8665 2:  (sin(pi x) - pi x cos(pi x)) / pi^2
8666     .
8668   ' [y,1] @key{RET} @key{TAB}
8670 @end group
8671 @end smallexample
8672 @noindent
8673 @smallexample
8674 @group
8675 1:  [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
8676     .
8678     V M $ @key{RET}
8680 @end group
8681 @end smallexample
8682 @noindent
8683 @smallexample
8684 @group
8685 1:  (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
8686     .
8688     V R -
8690 @end group
8691 @end smallexample
8692 @noindent
8693 @smallexample
8694 @group
8695 1:  (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
8696     .
8698     =
8700 @end group
8701 @end smallexample
8702 @noindent
8703 @smallexample
8704 @group
8705 1:  [0., -0.95493, 0.63662, -1.5915, 1.2732]
8706     .
8708     v x 5 @key{RET}  @key{TAB}  V M $ @key{RET}
8709 @end group
8710 @end smallexample
8712 @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
8713 @subsection Algebra Tutorial Exercise 4
8715 @noindent
8716 The hard part is that @kbd{V R +} is no longer sufficient to add up all
8717 the contributions from the slices, since the slices have varying
8718 coefficients.  So first we must come up with a vector of these
8719 coefficients.  Here's one way:
8721 @smallexample
8722 @group
8723 2:  -1                 2:  3                    1:  [4, 2, ..., 4]
8724 1:  [1, 2, ..., 9]     1:  [-1, 1, ..., -1]         .
8725     .                      .
8727     1 n v x 9 @key{RET}          V M ^  3 @key{TAB}             -
8729 @end group
8730 @end smallexample
8731 @noindent
8732 @smallexample
8733 @group
8734 1:  [4, 2, ..., 4, 1]      1:  [1, 4, 2, ..., 4, 1]
8735     .                          .
8737     1 |                        1 @key{TAB} |
8738 @end group
8739 @end smallexample
8741 @noindent
8742 Now we compute the function values.  Note that for this method we need
8743 eleven values, including both endpoints of the desired interval.
8745 @smallexample
8746 @group
8747 2:  [1, 4, 2, ..., 4, 1]
8748 1:  [1, 1.1, 1.2,  ...  , 1.8, 1.9, 2.]
8749     .
8751  11 @key{RET} 1 @key{RET} .1 @key{RET}  C-u v x
8753 @end group
8754 @end smallexample
8755 @noindent
8756 @smallexample
8757 @group
8758 2:  [1, 4, 2, ..., 4, 1]
8759 1:  [0., 0.084941, 0.16993, ... ]
8760     .
8762     ' sin(x) ln(x) @key{RET}   m r  p 5 @key{RET}   V M $ @key{RET}
8763 @end group
8764 @end smallexample
8766 @noindent
8767 Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
8768 same thing.
8770 @smallexample
8771 @group
8772 1:  11.22      1:  1.122      1:  0.374
8773     .              .              .
8775     *              .1 *           3 /
8776 @end group
8777 @end smallexample
8779 @noindent
8780 Wow!  That's even better than the result from the Taylor series method.
8782 @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
8783 @subsection Rewrites Tutorial Exercise 1
8785 @noindent
8786 We'll use Big mode to make the formulas more readable.
8788 @smallexample
8789 @group
8790                                                ___
8791                                           2 + V 2
8792 1:  (2 + sqrt(2)) / (1 + sqrt(2))     1:  --------
8793     .                                          ___
8794                                           1 + V 2
8796                                           .
8798   ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET}         d B
8799 @end group
8800 @end smallexample
8802 @noindent
8803 Multiplying by the conjugate helps because @cite{(a+b) (a-b) = a^2 - b^2}.
8805 @smallexample
8806 @group
8807           ___    ___
8808 1:  (2 + V 2 ) (V 2  - 1)
8809     .
8811   a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
8813 @end group
8814 @end smallexample
8815 @noindent
8816 @smallexample
8817 @group
8818          ___                         ___
8819 1:  2 + V 2  - 2                1:  V 2
8820     .                               .
8822   a r a*(b+c) := a*b + a*c          a s
8823 @end group
8824 @end smallexample
8826 @noindent
8827 (We could have used @kbd{a x} instead of a rewrite rule for the
8828 second step.)
8830 The multiply-by-conjugate rule turns out to be useful in many
8831 different circumstances, such as when the denominator involves
8832 sines and cosines or the imaginary constant @code{i}.
8834 @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
8835 @subsection Rewrites Tutorial Exercise 2
8837 @noindent
8838 Here is the rule set:
8840 @smallexample
8841 @group
8842 [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
8843   fib(1, x, y) := x,
8844   fib(n, x, y) := fib(n-1, y, x+y) ]
8845 @end group
8846 @end smallexample
8848 @noindent
8849 The first rule turns a one-argument @code{fib} that people like to write
8850 into a three-argument @code{fib} that makes computation easier.  The
8851 second rule converts back from three-argument form once the computation
8852 is done.  The third rule does the computation itself.  It basically
8853 says that if @cite{x} and @cite{y} are two consecutive Fibonacci numbers,
8854 then @cite{y} and @cite{x+y} are the next (overlapping) pair of Fibonacci
8855 numbers.
8857 Notice that because the number @cite{n} was ``validated'' by the
8858 conditions on the first rule, there is no need to put conditions on
8859 the other rules because the rule set would never get that far unless
8860 the input were valid.  That further speeds computation, since no
8861 extra conditions need to be checked at every step.
8863 Actually, a user with a nasty sense of humor could enter a bad
8864 three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
8865 which would get the rules into an infinite loop.  One thing that would
8866 help keep this from happening by accident would be to use something like
8867 @samp{ZzFib} instead of @code{fib} as the name of the three-argument
8868 function.
8870 @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
8871 @subsection Rewrites Tutorial Exercise 3
8873 @noindent
8874 He got an infinite loop.  First, Calc did as expected and rewrote
8875 @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}.  Then it looked for ways to
8876 apply the rule again, and found that @samp{f(2, 3, x)} looks like
8877 @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
8878 @samp{f(0, 1, f(2, 3, x))}.  It then wrapped another @samp{f(0, 1, ...)}
8879 around that, and so on, ad infinitum.  Joe should have used @kbd{M-1 a r}
8880 to make sure the rule applied only once.
8882 (Actually, even the first step didn't work as he expected.  What Calc
8883 really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
8884 treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
8885 to it.  While this may seem odd, it's just as valid a solution as the
8886 ``obvious'' one.  One way to fix this would be to add the condition
8887 @samp{:: variable(x)} to the rule, to make sure the thing that matches
8888 @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
8889 on the lefthand side, so that the rule matches the actual variable
8890 @samp{x} rather than letting @samp{x} stand for something else.)
8892 @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
8893 @subsection Rewrites Tutorial Exercise 4
8895 @noindent
8896 @ignore
8897 @starindex
8898 @end ignore
8899 @tindex seq
8900 Here is a suitable set of rules to solve the first part of the problem:
8902 @smallexample
8903 @group
8904 [ seq(n, c) := seq(n/2,  c+1) :: n%2 = 0,
8905   seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
8906 @end group
8907 @end smallexample
8909 Given the initial formula @samp{seq(6, 0)}, application of these
8910 rules produces the following sequence of formulas:
8912 @example
8913 seq( 3, 1)
8914 seq(10, 2)
8915 seq( 5, 3)
8916 seq(16, 4)
8917 seq( 8, 5)
8918 seq( 4, 6)
8919 seq( 2, 7)
8920 seq( 1, 8)
8921 @end example
8923 @noindent
8924 whereupon neither of the rules match, and rewriting stops.
8926 We can pretty this up a bit with a couple more rules:
8928 @smallexample
8929 @group
8930 [ seq(n) := seq(n, 0),
8931   seq(1, c) := c,
8932   ... ]
8933 @end group
8934 @end smallexample
8936 @noindent
8937 Now, given @samp{seq(6)} as the starting configuration, we get 8
8938 as the result.
8940 The change to return a vector is quite simple:
8942 @smallexample
8943 @group
8944 [ seq(n) := seq(n, []) :: integer(n) :: n > 0,
8945   seq(1, v) := v | 1,
8946   seq(n, v) := seq(n/2,  v | n) :: n%2 = 0,
8947   seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
8948 @end group
8949 @end smallexample
8951 @noindent
8952 Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
8954 Notice that the @cite{n > 1} guard is no longer necessary on the last
8955 rule since the @cite{n = 1} case is now detected by another rule.
8956 But a guard has been added to the initial rule to make sure the
8957 initial value is suitable before the computation begins.
8959 While still a good idea, this guard is not as vitally important as it
8960 was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
8961 will not get into an infinite loop.  Calc will not be able to prove
8962 the symbol @samp{x} is either even or odd, so none of the rules will
8963 apply and the rewrites will stop right away.
8965 @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
8966 @subsection Rewrites Tutorial Exercise 5
8968 @noindent
8969 @ignore
8970 @starindex
8971 @end ignore
8972 @tindex nterms
8973 If @cite{x} is the sum @cite{a + b}, then `@t{nterms(}@var{x}@t{)}' must
8974 be `@t{nterms(}@var{a}@t{)}' plus `@t{nterms(}@var{b}@t{)}'.  If @cite{x}
8975 is not a sum, then `@t{nterms(}@var{x}@t{)}' = 1.
8977 @smallexample
8978 @group
8979 [ nterms(a + b) := nterms(a) + nterms(b),
8980   nterms(x)     := 1 ]
8981 @end group
8982 @end smallexample
8984 @noindent
8985 Here we have taken advantage of the fact that earlier rules always
8986 match before later rules; @samp{nterms(x)} will only be tried if we
8987 already know that @samp{x} is not a sum.
8989 @node Rewrites Answer 6, Rewrites Answer 7, Rewrites Answer 5, Answers to Exercises
8990 @subsection Rewrites Tutorial Exercise 6
8992 Just put the rule @samp{0^0 := 1} into @code{EvalRules}.  For example,
8993 before making this definition we have:
8995 @smallexample
8996 @group
8997 2:  [-2, -1, 0, 1, 2]                1:  [1, 1, 0^0, 1, 1]
8998 1:  0                                    .
8999     .
9001     v x 5 @key{RET}  3 -  0                    V M ^
9002 @end group
9003 @end smallexample
9005 @noindent
9006 But then:
9008 @smallexample
9009 @group
9010 2:  [-2, -1, 0, 1, 2]                1:  [1, 1, 1, 1, 1]
9011 1:  0                                    .
9012     .
9014     U  ' 0^0:=1 @key{RET} s t EvalRules @key{RET}    V M ^
9015 @end group
9016 @end smallexample
9018 Perhaps more surprisingly, this rule still works with infinite mode
9019 turned on.  Calc tries @code{EvalRules} before any built-in rules for
9020 a function.  This allows you to override the default behavior of any
9021 Calc feature:  Even though Calc now wants to evaluate @cite{0^0} to
9022 @code{nan}, your rule gets there first and evaluates it to 1 instead.
9024 Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
9025 What happens?  (Be sure to remove this rule afterward, or you might get
9026 a nasty surprise when you use Calc to balance your checkbook!)
9028 @node Rewrites Answer 7, Programming Answer 1, Rewrites Answer 6, Answers to Exercises
9029 @subsection Rewrites Tutorial Exercise 7
9031 @noindent
9032 Here is a rule set that will do the job:
9034 @smallexample
9035 @group
9036 [ a*(b + c) := a*b + a*c,
9037   opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
9038      :: constant(a) :: constant(b),
9039   opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
9040      :: constant(a) :: constant(b),
9041   a O(x^n) := O(x^n) :: constant(a),
9042   x^opt(m) O(x^n) := O(x^(n+m)),
9043   O(x^n) O(x^m) := O(x^(n+m)) ]
9044 @end group
9045 @end smallexample
9047 If we really want the @kbd{+} and @kbd{*} keys to operate naturally
9048 on power series, we should put these rules in @code{EvalRules}.  For
9049 testing purposes, it is better to put them in a different variable,
9050 say, @code{O}, first.
9052 The first rule just expands products of sums so that the rest of the
9053 rules can assume they have an expanded-out polynomial to work with.
9054 Note that this rule does not mention @samp{O} at all, so it will
9055 apply to any product-of-sum it encounters---this rule may surprise
9056 you if you put it into @code{EvalRules}!
9058 In the second rule, the sum of two O's is changed to the smaller O.
9059 The optional constant coefficients are there mostly so that
9060 @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
9061 as well as @samp{O(x^2) + O(x^3)}.
9063 The third rule absorbs higher powers of @samp{x} into O's.
9065 The fourth rule says that a constant times a negligible quantity
9066 is still negligible.  (This rule will also match @samp{O(x^3) / 4},
9067 with @samp{a = 1/4}.)
9069 The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
9070 (It is easy to see that if one of these forms is negligible, the other
9071 is, too.)  Notice the @samp{x^opt(m)} to pick up terms like
9072 @w{@samp{x O(x^3)}}.  Optional powers will match @samp{x} as @samp{x^1}
9073 but not 1 as @samp{x^0}.  This turns out to be exactly what we want here.
9075 The sixth rule is the corresponding rule for products of two O's.
9077 Another way to solve this problem would be to create a new ``data type''
9078 that represents truncated power series.  We might represent these as
9079 function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
9080 a vector of coefficients for @cite{x^0}, @cite{x^1}, @cite{x^2}, and so
9081 on.  Rules would exist for sums and products of such @code{series}
9082 objects, and as an optional convenience could also know how to combine a
9083 @code{series} object with a normal polynomial.  (With this, and with a
9084 rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
9085 you could still enter power series in exactly the same notation as
9086 before.)  Operations on such objects would probably be more efficient,
9087 although the objects would be a bit harder to read.
9089 @c [fix-ref Compositions]
9090 Some other symbolic math programs provide a power series data type
9091 similar to this.  Mathematica, for example, has an object that looks
9092 like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
9093 @var{nmax}, @var{den}]}, where @var{x0} is the point about which the
9094 power series is taken (we've been assuming this was always zero),
9095 and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
9096 with fractional or negative powers.  Also, the @code{PowerSeries}
9097 objects have a special display format that makes them look like
9098 @samp{2 x^2 + O(x^4)} when they are printed out.  (@xref{Compositions},
9099 for a way to do this in Calc, although for something as involved as
9100 this it would probably be better to write the formatting routine
9101 in Lisp.)
9103 @node Programming Answer 1, Programming Answer 2, Rewrites Answer 7, Answers to Exercises
9104 @subsection Programming Tutorial Exercise 1
9106 @noindent
9107 Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
9108 @kbd{Z F}, and answer the questions.  Since this formula contains two
9109 variables, the default argument list will be @samp{(t x)}.  We want to
9110 change this to @samp{(x)} since @cite{t} is really a dummy variable
9111 to be used within @code{ninteg}.
9113 The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
9114 (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
9116 @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
9117 @subsection Programming Tutorial Exercise 2
9119 @noindent
9120 One way is to move the number to the top of the stack, operate on
9121 it, then move it back:  @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
9123 Another way is to negate the top three stack entries, then negate
9124 again the top two stack entries:  @kbd{C-x ( M-3 n M-2 n C-x )}.
9126 Finally, it turns out that a negative prefix argument causes a
9127 command like @kbd{n} to operate on the specified stack entry only,
9128 which is just what we want:  @kbd{C-x ( M-- 3 n C-x )}.
9130 Just for kicks, let's also do it algebraically:
9131 @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
9133 @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
9134 @subsection Programming Tutorial Exercise 3
9136 @noindent
9137 Each of these functions can be computed using the stack, or using
9138 algebraic entry, whichever way you prefer:
9140 @noindent
9141 Computing @c{$\displaystyle{\sin x \over x}$}
9142 @cite{sin(x) / x}:
9144 Using the stack:  @kbd{C-x (  @key{RET} S @key{TAB} /  C-x )}.
9146 Using algebraic entry:  @kbd{C-x (  ' sin($)/$ @key{RET}  C-x )}.
9148 @noindent
9149 Computing the logarithm:
9151 Using the stack:  @kbd{C-x (  @key{TAB} B  C-x )}
9153 Using algebraic entry:  @kbd{C-x (  ' log($,$$) @key{RET}  C-x )}.
9155 @noindent
9156 Computing the vector of integers:
9158 Using the stack:  @kbd{C-x (  1 @key{RET} 1  C-u v x  C-x )}.  (Recall that
9159 @kbd{C-u v x} takes the vector size, starting value, and increment
9160 from the stack.)
9162 Alternatively:  @kbd{C-x (  ~ v x  C-x )}.  (The @kbd{~} key pops a
9163 number from the stack and uses it as the prefix argument for the
9164 next command.)
9166 Using algebraic entry:  @kbd{C-x (  ' index($) @key{RET}  C-x )}.
9168 @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
9169 @subsection Programming Tutorial Exercise 4
9171 @noindent
9172 Here's one way:  @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
9174 @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
9175 @subsection Programming Tutorial Exercise 5
9177 @smallexample
9178 @group
9179 2:  1              1:  1.61803398502         2:  1.61803398502
9180 1:  20                 .                     1:  1.61803398875
9181     .                                            .
9183    1 @key{RET} 20         Z < & 1 + Z >                I H P
9184 @end group
9185 @end smallexample
9187 @noindent
9188 This answer is quite accurate.
9190 @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
9191 @subsection Programming Tutorial Exercise 6
9193 @noindent
9194 Here is the matrix:
9196 @example
9197 [ [ 0, 1 ]   * [a, b] = [b, a + b]
9198   [ 1, 1 ] ]
9199 @end example
9201 @noindent
9202 Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @cite{n+1}
9203 and @cite{n+2}.  Here's one program that does the job:
9205 @example
9206 C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
9207 @end example
9209 @noindent
9210 This program is quite efficient because Calc knows how to raise a
9211 matrix (or other value) to the power @cite{n} in only @c{$\log_2 n$}
9212 @cite{log(n,2)}
9213 steps.  For example, this program can compute the 1000th Fibonacci
9214 number (a 209-digit integer!) in about 10 steps; even though the
9215 @kbd{Z < ... Z >} solution had much simpler steps, it would have
9216 required so many steps that it would not have been practical.
9218 @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
9219 @subsection Programming Tutorial Exercise 7
9221 @noindent
9222 The trick here is to compute the harmonic numbers differently, so that
9223 the loop counter itself accumulates the sum of reciprocals.  We use
9224 a separate variable to hold the integer counter.
9226 @smallexample
9227 @group
9228 1:  1          2:  1       1:  .
9229     .          1:  4
9230                    .
9232     1 t 1       1 @key{RET} 4      Z ( t 2 r 1 1 + s 1 & Z )
9233 @end group
9234 @end smallexample
9236 @noindent
9237 The body of the loop goes as follows:  First save the harmonic sum
9238 so far in variable 2.  Then delete it from the stack; the for loop
9239 itself will take care of remembering it for us.  Next, recall the
9240 count from variable 1, add one to it, and feed its reciprocal to
9241 the for loop to use as the step value.  The for loop will increase
9242 the ``loop counter'' by that amount and keep going until the
9243 loop counter exceeds 4.
9245 @smallexample
9246 @group
9247 2:  31                  3:  31
9248 1:  3.99498713092       2:  3.99498713092
9249     .                   1:  4.02724519544
9250                             .
9252     r 1 r 2                 @key{RET} 31 & +
9253 @end group
9254 @end smallexample
9256 Thus we find that the 30th harmonic number is 3.99, and the 31st
9257 harmonic number is 4.02.
9259 @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
9260 @subsection Programming Tutorial Exercise 8
9262 @noindent
9263 The first step is to compute the derivative @cite{f'(x)} and thus
9264 the formula @c{$\displaystyle{x - {f(x) \over f'(x)}}$}
9265 @cite{x - f(x)/f'(x)}.
9267 (Because this definition is long, it will be repeated in concise form
9268 below.  You can use @w{@kbd{M-# m}} to load it from there.  While you are
9269 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9270 keystrokes without executing them.  In the following diagrams we'll
9271 pretend Calc actually executed the keystrokes as you typed them,
9272 just for purposes of illustration.)
9274 @smallexample
9275 @group
9276 2:  sin(cos(x)) - 0.5            3:  4.5
9277 1:  4.5                          2:  sin(cos(x)) - 0.5
9278     .                            1:  -(sin(x) cos(cos(x)))
9279                                      .
9281 ' sin(cos(x))-0.5 @key{RET} 4.5  m r  C-x ( Z `  @key{TAB} @key{RET} a d x @key{RET}
9283 @end group
9284 @end smallexample
9285 @noindent
9286 @smallexample
9287 @group
9288 2:  4.5
9289 1:  x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
9290     .
9292     /  ' x @key{RET} @key{TAB} -   t 1
9293 @end group
9294 @end smallexample
9296 Now, we enter the loop.  We'll use a repeat loop with a 20-repetition
9297 limit just in case the method fails to converge for some reason.
9298 (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
9299 repetitions are done.)
9301 @smallexample
9302 @group
9303 1:  4.5         3:  4.5                     2:  4.5
9304     .           2:  x + (sin(cos(x)) ...    1:  5.24196456928
9305                 1:  4.5                         .
9306                     .
9308   20 Z <          @key{RET} r 1 @key{TAB}                 s l x @key{RET}
9309 @end group
9310 @end smallexample
9312 This is the new guess for @cite{x}.  Now we compare it with the
9313 old one to see if we've converged.
9315 @smallexample
9316 @group
9317 3:  5.24196     2:  5.24196     1:  5.24196     1:  5.26345856348
9318 2:  5.24196     1:  0               .               .
9319 1:  4.5             .
9320     .
9322   @key{RET} M-@key{TAB}         a =             Z /             Z > Z ' C-x )
9323 @end group
9324 @end smallexample
9326 The loop converges in just a few steps to this value.  To check
9327 the result, we can simply substitute it back into the equation.
9329 @smallexample
9330 @group
9331 2:  5.26345856348
9332 1:  0.499999999997
9333     .
9335  @key{RET} ' sin(cos($)) @key{RET}
9336 @end group
9337 @end smallexample
9339 Let's test the new definition again:
9341 @smallexample
9342 @group
9343 2:  x^2 - 9           1:  3.
9344 1:  1                     .
9345     .
9347   ' x^2-9 @key{RET} 1           X
9348 @end group
9349 @end smallexample
9351 Once again, here's the full Newton's Method definition:
9353 @example
9354 @group
9355 C-x ( Z `  @key{TAB} @key{RET} a d x @key{RET}  /  ' x @key{RET} @key{TAB} -  t 1
9356            20 Z <  @key{RET} r 1 @key{TAB}  s l x @key{RET}
9357                    @key{RET} M-@key{TAB}  a =  Z /
9358               Z >
9359       Z '
9360 C-x )
9361 @end group
9362 @end example
9364 @c [fix-ref Nesting and Fixed Points]
9365 It turns out that Calc has a built-in command for applying a formula
9366 repeatedly until it converges to a number.  @xref{Nesting and Fixed Points},
9367 to see how to use it.
9369 @c [fix-ref Root Finding]
9370 Also, of course, @kbd{a R} is a built-in command that uses Newton's
9371 method (among others) to look for numerical solutions to any equation.
9372 @xref{Root Finding}.
9374 @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
9375 @subsection Programming Tutorial Exercise 9
9377 @noindent
9378 The first step is to adjust @cite{z} to be greater than 5.  A simple
9379 ``for'' loop will do the job here.  If @cite{z} is less than 5, we
9380 reduce the problem using @c{$\psi(z) = \psi(z+1) - 1/z$}
9381 @cite{psi(z) = psi(z+1) - 1/z}.  We go
9382 on to compute @c{$\psi(z+1)$}
9383 @cite{psi(z+1)}, and remember to add back a factor of
9384 @cite{-1/z} when we're done.  This step is repeated until @cite{z > 5}.
9386 (Because this definition is long, it will be repeated in concise form
9387 below.  You can use @w{@kbd{M-# m}} to load it from there.  While you are
9388 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9389 keystrokes without executing them.  In the following diagrams we'll
9390 pretend Calc actually executed the keystrokes as you typed them,
9391 just for purposes of illustration.)
9393 @smallexample
9394 @group
9395 1:  1.             1:  1.
9396     .                  .
9398  1.0 @key{RET}       C-x ( Z `  s 1  0 t 2
9399 @end group
9400 @end smallexample
9402 Here, variable 1 holds @cite{z} and variable 2 holds the adjustment
9403 factor.  If @cite{z < 5}, we use a loop to increase it.
9405 (By the way, we started with @samp{1.0} instead of the integer 1 because
9406 otherwise the calculation below will try to do exact fractional arithmetic,
9407 and will never converge because fractions compare equal only if they
9408 are exactly equal, not just equal to within the current precision.)
9410 @smallexample
9411 @group
9412 3:  1.      2:  1.       1:  6.
9413 2:  1.      1:  1            .
9414 1:  5           .
9415     .
9417   @key{RET} 5        a <    Z [  5 Z (  & s + 2  1 s + 1  1 Z ) r 1  Z ]
9418 @end group
9419 @end smallexample
9421 Now we compute the initial part of the sum:  @c{$\ln z - {1 \over 2z}$}
9422 @cite{ln(z) - 1/2z}
9423 minus the adjustment factor.
9425 @smallexample
9426 @group
9427 2:  1.79175946923      2:  1.7084261359      1:  -0.57490719743
9428 1:  0.0833333333333    1:  2.28333333333         .
9429     .                      .
9431     L  r 1 2 * &           -  r 2                -
9432 @end group
9433 @end smallexample
9435 Now we evaluate the series.  We'll use another ``for'' loop counting
9436 up the value of @cite{2 n}.  (Calc does have a summation command,
9437 @kbd{a +}, but we'll use loops just to get more practice with them.)
9439 @smallexample
9440 @group
9441 3:  -0.5749       3:  -0.5749        4:  -0.5749      2:  -0.5749
9442 2:  2             2:  1:6            3:  1:6          1:  2.3148e-3
9443 1:  40            1:  2              2:  2                .
9444     .                 .              1:  36.
9445                                          .
9447    2 @key{RET} 40        Z ( @key{RET} k b @key{TAB}     @key{RET} r 1 @key{TAB} ^      * /
9449 @end group
9450 @end smallexample
9451 @noindent
9452 @smallexample
9453 @group
9454 3:  -0.5749       3:  -0.5772      2:  -0.5772     1:  -0.577215664892
9455 2:  -0.5749       2:  -0.5772      1:  0               .
9456 1:  2.3148e-3     1:  -0.5749          .
9457     .                 .
9459   @key{TAB} @key{RET} M-@key{TAB}       - @key{RET} M-@key{TAB}      a =     Z /    2  Z )  Z ' C-x )
9460 @end group
9461 @end smallexample
9463 This is the value of @c{$-\gamma$}
9464 @cite{- gamma}, with a slight bit of roundoff error.
9465 To get a full 12 digits, let's use a higher precision:
9467 @smallexample
9468 @group
9469 2:  -0.577215664892      2:  -0.577215664892
9470 1:  1.                   1:  -0.577215664901532
9472     1. @key{RET}                   p 16 @key{RET} X
9473 @end group
9474 @end smallexample
9476 Here's the complete sequence of keystrokes:
9478 @example
9479 @group
9480 C-x ( Z `  s 1  0 t 2
9481            @key{RET} 5 a <  Z [  5 Z (  & s + 2  1 s + 1  1 Z ) r 1  Z ]
9482            L r 1 2 * & - r 2 -
9483            2 @key{RET} 40  Z (  @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9484                           @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
9485                   2  Z )
9486       Z '
9487 C-x )
9488 @end group
9489 @end example
9491 @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
9492 @subsection Programming Tutorial Exercise 10
9494 @noindent
9495 Taking the derivative of a term of the form @cite{x^n} will produce
9496 a term like @c{$n x^{n-1}$}
9497 @cite{n x^(n-1)}.  Taking the derivative of a constant
9498 produces zero.  From this it is easy to see that the @cite{n}th
9499 derivative of a polynomial, evaluated at @cite{x = 0}, will equal the
9500 coefficient on the @cite{x^n} term times @cite{n!}.
9502 (Because this definition is long, it will be repeated in concise form
9503 below.  You can use @w{@kbd{M-# m}} to load it from there.  While you are
9504 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9505 keystrokes without executing them.  In the following diagrams we'll
9506 pretend Calc actually executed the keystrokes as you typed them,
9507 just for purposes of illustration.)
9509 @smallexample
9510 @group
9511 2:  5 x^4 + (x + 1)^2          3:  5 x^4 + (x + 1)^2
9512 1:  6                          2:  0
9513     .                          1:  6
9514                                    .
9516   ' 5 x^4 + (x+1)^2 @key{RET} 6        C-x ( Z `  [ ] t 1  0 @key{TAB}
9517 @end group
9518 @end smallexample
9520 @noindent
9521 Variable 1 will accumulate the vector of coefficients.
9523 @smallexample
9524 @group
9525 2:  0              3:  0                  2:  5 x^4 + ...
9526 1:  5 x^4 + ...    2:  5 x^4 + ...        1:  1
9527     .              1:  1                      .
9528                        .
9530    Z ( @key{TAB}         @key{RET} 0 s l x @key{RET}            M-@key{TAB} ! /  s | 1
9531 @end group
9532 @end smallexample
9534 @noindent
9535 Note that @kbd{s | 1} appends the top-of-stack value to the vector
9536 in a variable; it is completely analogous to @kbd{s + 1}.  We could
9537 have written instead, @kbd{r 1 @key{TAB} | t 1}.
9539 @smallexample
9540 @group
9541 1:  20 x^3 + 2 x + 2      1:  0         1:  [1, 2, 1, 0, 5, 0, 0]
9542     .                         .             .
9544     a d x @key{RET}                 1 Z )         @key{DEL} r 1  Z ' C-x )
9545 @end group
9546 @end smallexample
9548 To convert back, a simple method is just to map the coefficients
9549 against a table of powers of @cite{x}.
9551 @smallexample
9552 @group
9553 2:  [1, 2, 1, 0, 5, 0, 0]    2:  [1, 2, 1, 0, 5, 0, 0]
9554 1:  6                        1:  [0, 1, 2, 3, 4, 5, 6]
9555     .                            .
9557     6 @key{RET}                        1 + 0 @key{RET} 1 C-u v x
9559 @end group
9560 @end smallexample
9561 @noindent
9562 @smallexample
9563 @group
9564 2:  [1, 2, 1, 0, 5, 0, 0]    2:  1 + 2 x + x^2 + 5 x^4
9565 1:  [1, x, x^2, x^3, ... ]       .
9566     .
9568     ' x @key{RET} @key{TAB} V M ^            *
9569 @end group
9570 @end smallexample
9572 Once again, here are the whole polynomial to/from vector programs:
9574 @example
9575 @group
9576 C-x ( Z `  [ ] t 1  0 @key{TAB}
9577            Z (  @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! /  s | 1
9578                 a d x @key{RET}
9579          1 Z ) r 1
9580       Z '
9581 C-x )
9583 C-x (  1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ *  C-x )
9584 @end group
9585 @end example
9587 @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
9588 @subsection Programming Tutorial Exercise 11
9590 @noindent
9591 First we define a dummy program to go on the @kbd{z s} key.  The true
9592 @w{@kbd{z s}} key is supposed to take two numbers from the stack and
9593 return one number, so @key{DEL} as a dummy definition will make
9594 sure the stack comes out right.
9596 @smallexample
9597 @group
9598 2:  4          1:  4                         2:  4
9599 1:  2              .                         1:  2
9600     .                                            .
9602   4 @key{RET} 2       C-x ( @key{DEL} C-x )  Z K s @key{RET}       2
9603 @end group
9604 @end smallexample
9606 The last step replaces the 2 that was eaten during the creation
9607 of the dummy @kbd{z s} command.  Now we move on to the real
9608 definition.  The recurrence needs to be rewritten slightly,
9609 to the form @cite{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
9611 (Because this definition is long, it will be repeated in concise form
9612 below.  You can use @kbd{M-# m} to load it from there.)
9614 @smallexample
9615 @group
9616 2:  4        4:  4       3:  4       2:  4
9617 1:  2        3:  2       2:  2       1:  2
9618     .        2:  4       1:  0           .
9619              1:  2           .
9620                  .
9622   C-x (       M-2 @key{RET}        a =         Z [  @key{DEL} @key{DEL} 1  Z :
9624 @end group
9625 @end smallexample
9626 @noindent
9627 @smallexample
9628 @group
9629 4:  4       2:  4                     2:  3      4:  3    4:  3    3:  3
9630 3:  2       1:  2                     1:  2      3:  2    3:  2    2:  2
9631 2:  2           .                         .      2:  3    2:  3    1:  3
9632 1:  0                                            1:  2    1:  1        .
9633     .                                                .        .
9635   @key{RET} 0   a = Z [  @key{DEL} @key{DEL} 0  Z :  @key{TAB} 1 - @key{TAB}   M-2 @key{RET}     1 -      z s
9636 @end group
9637 @end smallexample
9639 @noindent
9640 (Note that the value 3 that our dummy @kbd{z s} produces is not correct;
9641 it is merely a placeholder that will do just as well for now.)
9643 @smallexample
9644 @group
9645 3:  3               4:  3           3:  3       2:  3      1:  -6
9646 2:  3               3:  3           2:  3       1:  9          .
9647 1:  2               2:  3           1:  3           .
9648     .               1:  2               .
9649                         .
9651  M-@key{TAB} M-@key{TAB}     @key{TAB} @key{RET} M-@key{TAB}         z s          *          -
9653 @end group
9654 @end smallexample
9655 @noindent
9656 @smallexample
9657 @group
9658 1:  -6                          2:  4          1:  11      2:  11
9659     .                           1:  2              .       1:  11
9660                                     .                          .
9662   Z ] Z ] C-x )   Z K s @key{RET}      @key{DEL} 4 @key{RET} 2       z s      M-@key{RET} k s
9663 @end group
9664 @end smallexample
9666 Even though the result that we got during the definition was highly
9667 bogus, once the definition is complete the @kbd{z s} command gets
9668 the right answers.
9670 Here's the full program once again:
9672 @example
9673 @group
9674 C-x (  M-2 @key{RET} a =
9675        Z [  @key{DEL} @key{DEL} 1
9676        Z :  @key{RET} 0 a =
9677             Z [  @key{DEL} @key{DEL} 0
9678             Z :  @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9679                  M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9680             Z ]
9681        Z ]
9682 C-x )
9683 @end group
9684 @end example
9686 You can read this definition using @kbd{M-# m} (@code{read-kbd-macro})
9687 followed by @kbd{Z K s}, without having to make a dummy definition
9688 first, because @code{read-kbd-macro} doesn't need to execute the
9689 definition as it reads it in.  For this reason, @code{M-# m} is often
9690 the easiest way to create recursive programs in Calc.
9692 @node Programming Answer 12, , Programming Answer 11, Answers to Exercises
9693 @subsection Programming Tutorial Exercise 12
9695 @noindent
9696 This turns out to be a much easier way to solve the problem.  Let's
9697 denote Stirling numbers as calls of the function @samp{s}.
9699 First, we store the rewrite rules corresponding to the definition of
9700 Stirling numbers in a convenient variable:
9702 @smallexample
9703 s e StirlingRules @key{RET}
9704 [ s(n,n) := 1  :: n >= 0,
9705   s(n,0) := 0  :: n > 0,
9706   s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
9707 C-c C-c
9708 @end smallexample
9710 Now, it's just a matter of applying the rules:
9712 @smallexample
9713 @group
9714 2:  4          1:  s(4, 2)              1:  11
9715 1:  2              .                        .
9716     .
9718   4 @key{RET} 2       C-x (  ' s($$,$) @key{RET}     a r StirlingRules @key{RET}  C-x )
9719 @end group
9720 @end smallexample
9722 As in the case of the @code{fib} rules, it would be useful to put these
9723 rules in @code{EvalRules} and to add a @samp{:: remember} condition to
9724 the last rule.
9726 @c This ends the table-of-contents kludge from above:
9727 @tex
9728 \global\let\chapternofonts=\oldchapternofonts
9729 @end tex
9731 @c [reference]
9733 @node Introduction, Data Types, Tutorial, Top
9734 @chapter Introduction
9736 @noindent
9737 This chapter is the beginning of the Calc reference manual.
9738 It covers basic concepts such as the stack, algebraic and
9739 numeric entry, undo, numeric prefix arguments, etc.
9741 @c [when-split]
9742 @c (Chapter 2, the Tutorial, has been printed in a separate volume.)
9744 @menu
9745 * Basic Commands::
9746 * Help Commands::
9747 * Stack Basics::
9748 * Numeric Entry::
9749 * Algebraic Entry::
9750 * Quick Calculator::
9751 * Keypad Mode::
9752 * Prefix Arguments::
9753 * Undo::
9754 * Error Messages::
9755 * Multiple Calculators::
9756 * Troubleshooting Commands::
9757 @end menu
9759 @node Basic Commands, Help Commands, Introduction, Introduction
9760 @section Basic Commands
9762 @noindent
9763 @pindex calc
9764 @pindex calc-mode
9765 @cindex Starting the Calculator
9766 @cindex Running the Calculator
9767 To start the Calculator in its standard interface, type @kbd{M-x calc}.
9768 By default this creates a pair of small windows, @samp{*Calculator*}
9769 and @samp{*Calc Trail*}.  The former displays the contents of the
9770 Calculator stack and is manipulated exclusively through Calc commands.
9771 It is possible (though not usually necessary) to create several Calc
9772 Mode buffers each of which has an independent stack, undo list, and
9773 mode settings.  There is exactly one Calc Trail buffer; it records a
9774 list of the results of all calculations that have been done.  The
9775 Calc Trail buffer uses a variant of Calc Mode, so Calculator commands
9776 still work when the trail buffer's window is selected.  It is possible
9777 to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
9778 still exists and is updated silently.  @xref{Trail Commands}.@refill
9780 @kindex M-# c
9781 @kindex M-# M-#
9782 @ignore
9783 @mindex @null
9784 @end ignore
9785 @kindex M-# #
9786 In most installations, the @kbd{M-# c} key sequence is a more
9787 convenient way to start the Calculator.  Also, @kbd{M-# M-#} and
9788 @kbd{M-# #} are synonyms for @kbd{M-# c} unless you last used Calc
9789 in its ``keypad'' mode.
9791 @kindex x
9792 @kindex M-x
9793 @pindex calc-execute-extended-command
9794 Most Calc commands use one or two keystrokes.  Lower- and upper-case
9795 letters are distinct.  Commands may also be entered in full @kbd{M-x} form;
9796 for some commands this is the only form.  As a convenience, the @kbd{x}
9797 key (@code{calc-execute-extended-command})
9798 is like @kbd{M-x} except that it enters the initial string @samp{calc-}
9799 for you.  For example, the following key sequences are equivalent:
9800 @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.@refill
9802 @cindex Extensions module
9803 @cindex @file{calc-ext} module
9804 The Calculator exists in many parts.  When you type @kbd{M-# c}, the
9805 Emacs ``auto-load'' mechanism will bring in only the first part, which
9806 contains the basic arithmetic functions.  The other parts will be
9807 auto-loaded the first time you use the more advanced commands like trig
9808 functions or matrix operations.  This is done to improve the response time
9809 of the Calculator in the common case when all you need to do is a
9810 little arithmetic.  If for some reason the Calculator fails to load an
9811 extension module automatically, you can force it to load all the
9812 extensions by using the @kbd{M-# L} (@code{calc-load-everything})
9813 command.  @xref{Mode Settings}.@refill
9815 If you type @kbd{M-x calc} or @kbd{M-# c} with any numeric prefix argument,
9816 the Calculator is loaded if necessary, but it is not actually started.
9817 If the argument is positive, the @file{calc-ext} extensions are also
9818 loaded if necessary.  User-written Lisp code that wishes to make use
9819 of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
9820 to auto-load the Calculator.@refill
9822 @kindex M-# b
9823 @pindex full-calc
9824 If you type @kbd{M-# b}, then next time you use @kbd{M-# c} you
9825 will get a Calculator that uses the full height of the Emacs screen.
9826 When full-screen mode is on, @kbd{M-# c} runs the @code{full-calc}
9827 command instead of @code{calc}.  From the Unix shell you can type
9828 @samp{emacs -f full-calc} to start a new Emacs specifically for use
9829 as a calculator.  When Calc is started from the Emacs command line
9830 like this, Calc's normal ``quit'' commands actually quit Emacs itself.
9832 @kindex M-# o
9833 @pindex calc-other-window
9834 The @kbd{M-# o} command is like @kbd{M-# c} except that the Calc
9835 window is not actually selected.  If you are already in the Calc
9836 window, @kbd{M-# o} switches you out of it.  (The regular Emacs
9837 @kbd{C-x o} command would also work for this, but it has a
9838 tendency to drop you into the Calc Trail window instead, which
9839 @kbd{M-# o} takes care not to do.)
9841 @ignore
9842 @mindex M-# q
9843 @end ignore
9844 For one quick calculation, you can type @kbd{M-# q} (@code{quick-calc})
9845 which prompts you for a formula (like @samp{2+3/4}).  The result is
9846 displayed at the bottom of the Emacs screen without ever creating
9847 any special Calculator windows.  @xref{Quick Calculator}.
9849 @ignore
9850 @mindex M-# k
9851 @end ignore
9852 Finally, if you are using the X window system you may want to try
9853 @kbd{M-# k} (@code{calc-keypad}) which runs Calc with a
9854 ``calculator keypad'' picture as well as a stack display.  Click on
9855 the keys with the mouse to operate the calculator.  @xref{Keypad Mode}.
9857 @kindex q
9858 @pindex calc-quit
9859 @cindex Quitting the Calculator
9860 @cindex Exiting the Calculator
9861 The @kbd{q} key (@code{calc-quit}) exits Calc Mode and closes the
9862 Calculator's window(s).  It does not delete the Calculator buffers.
9863 If you type @kbd{M-x calc} again, the Calculator will reappear with the
9864 contents of the stack intact.  Typing @kbd{M-# c} or @kbd{M-# M-#}
9865 again from inside the Calculator buffer is equivalent to executing
9866 @code{calc-quit}; you can think of @kbd{M-# M-#} as toggling the
9867 Calculator on and off.@refill
9869 @kindex M-# x
9870 The @kbd{M-# x} command also turns the Calculator off, no matter which
9871 user interface (standard, Keypad, or Embedded) is currently active.
9872 It also cancels @code{calc-edit} mode if used from there.
9874 @kindex d @key{SPC}
9875 @pindex calc-refresh
9876 @cindex Refreshing a garbled display
9877 @cindex Garbled displays, refreshing
9878 The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
9879 of the Calculator buffer from memory.  Use this if the contents of the
9880 buffer have been damaged somehow.
9882 @ignore
9883 @mindex o
9884 @end ignore
9885 The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
9886 ``home'' position at the bottom of the Calculator buffer.
9888 @kindex <
9889 @kindex >
9890 @pindex calc-scroll-left
9891 @pindex calc-scroll-right
9892 @cindex Horizontal scrolling
9893 @cindex Scrolling
9894 @cindex Wide text, scrolling
9895 The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
9896 @code{calc-scroll-right}.  These are just like the normal horizontal
9897 scrolling commands except that they scroll one half-screen at a time by
9898 default.  (Calc formats its output to fit within the bounds of the
9899 window whenever it can.)@refill
9901 @kindex @{
9902 @kindex @}
9903 @pindex calc-scroll-down
9904 @pindex calc-scroll-up
9905 @cindex Vertical scrolling
9906 The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
9907 and @code{calc-scroll-up}.  They scroll up or down by one-half the
9908 height of the Calc window.@refill
9910 @kindex M-# 0
9911 @pindex calc-reset
9912 The @kbd{M-# 0} command (@code{calc-reset}; that's @kbd{M-#} followed
9913 by a zero) resets the Calculator to its default state.  This clears
9914 the stack, resets all the modes, clears the caches (@pxref{Caches}),
9915 and so on.  (It does @emph{not} erase the values of any variables.)
9916 With a numeric prefix argument, @kbd{M-# 0} preserves the contents
9917 of the stack but resets everything else.
9919 @pindex calc-version
9920 The @kbd{M-x calc-version} command displays the current version number
9921 of Calc and the name of the person who installed it on your system.
9922 (This information is also present in the @samp{*Calc Trail*} buffer,
9923 and in the output of the @kbd{h h} command.)
9925 @node Help Commands, Stack Basics, Basic Commands, Introduction
9926 @section Help Commands
9928 @noindent
9929 @cindex Help commands
9930 @kindex ?
9931 @pindex calc-help
9932 The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
9933 Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
9934 @key{ESC} and @kbd{C-x} prefixes.  You can type
9935 @kbd{?} after a prefix to see a list of commands beginning with that
9936 prefix.  (If the message includes @samp{[MORE]}, press @kbd{?} again
9937 to see additional commands for that prefix.)
9939 @kindex h h
9940 @pindex calc-full-help
9941 The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
9942 responses at once.  When printed, this makes a nice, compact (three pages)
9943 summary of Calc keystrokes.
9945 In general, the @kbd{h} key prefix introduces various commands that
9946 provide help within Calc.  Many of the @kbd{h} key functions are
9947 Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
9949 @kindex h i
9950 @kindex M-# i
9951 @kindex i
9952 @pindex calc-info
9953 The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
9954 to read this manual on-line.  This is basically the same as typing
9955 @kbd{C-h i} (the regular way to run the Info system), then, if Info
9956 is not already in the Calc manual, selecting the beginning of the
9957 manual.  The @kbd{M-# i} command is another way to read the Calc
9958 manual; it is different from @kbd{h i} in that it works any time,
9959 not just inside Calc.  The plain @kbd{i} key is also equivalent to
9960 @kbd{h i}, though this key is obsolete and may be replaced with a
9961 different command in a future version of Calc.
9963 @kindex h t
9964 @kindex M-# t
9965 @pindex calc-tutorial
9966 The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
9967 the Tutorial section of the Calc manual.  It is like @kbd{h i},
9968 except that it selects the starting node of the tutorial rather
9969 than the beginning of the whole manual.  (It actually selects the
9970 node ``Interactive Tutorial'' which tells a few things about
9971 using the Info system before going on to the actual tutorial.)
9972 The @kbd{M-# t} key is equivalent to @kbd{h t} (but it works at
9973 all times).
9975 @kindex h s
9976 @kindex M-# s
9977 @pindex calc-info-summary
9978 The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
9979 on the Summary node of the Calc manual.  @xref{Summary}.  The @kbd{M-# s}
9980 key is equivalent to @kbd{h s}.
9982 @kindex h k
9983 @pindex calc-describe-key
9984 The @kbd{h k} (@code{calc-describe-key}) command looks up a key
9985 sequence in the Calc manual.  For example, @kbd{h k H a S} looks
9986 up the documentation on the @kbd{H a S} (@code{calc-solve-for})
9987 command.  This works by looking up the textual description of
9988 the key(s) in the Key Index of the manual, then jumping to the
9989 node indicated by the index.
9991 Most Calc commands do not have traditional Emacs documentation
9992 strings, since the @kbd{h k} command is both more convenient and
9993 more instructive.  This means the regular Emacs @kbd{C-h k}
9994 (@code{describe-key}) command will not be useful for Calc keystrokes.
9996 @kindex h c
9997 @pindex calc-describe-key-briefly
9998 The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
9999 key sequence and displays a brief one-line description of it at
10000 the bottom of the screen.  It looks for the key sequence in the
10001 Summary node of the Calc manual; if it doesn't find the sequence
10002 there, it acts just like its regular Emacs counterpart @kbd{C-h c}
10003 (@code{describe-key-briefly}).  For example, @kbd{h c H a S}
10004 gives the description:
10006 @smallexample
10007 H a S runs calc-solve-for:  a `H a S' v  => fsolve(a,v)  (?=notes)
10008 @end smallexample
10010 @noindent
10011 which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
10012 takes a value @cite{a} from the stack, prompts for a value @cite{v},
10013 then applies the algebraic function @code{fsolve} to these values.
10014 The @samp{?=notes} message means you can now type @kbd{?} to see
10015 additional notes from the summary that apply to this command.
10017 @kindex h f
10018 @pindex calc-describe-function
10019 The @kbd{h f} (@code{calc-describe-function}) command looks up an
10020 algebraic function or a command name in the Calc manual.  The
10021 prompt initially contains @samp{calcFunc-}; follow this with an
10022 algebraic function name to look up that function in the Function
10023 Index.  Or, backspace and enter a command name beginning with
10024 @samp{calc-} to look it up in the Command Index.  This command
10025 will also look up operator symbols that can appear in algebraic
10026 formulas, like @samp{%} and @samp{=>}.
10028 @kindex h v
10029 @pindex calc-describe-variable
10030 The @kbd{h v} (@code{calc-describe-variable}) command looks up a
10031 variable in the Calc manual.  The prompt initially contains the
10032 @samp{var-} prefix; just add a variable name like @code{pi} or
10033 @code{PlotRejects}.
10035 @kindex h b
10036 @pindex describe-bindings
10037 The @kbd{h b} (@code{calc-describe-bindings}) command is just like
10038 @kbd{C-h b}, except that only local (Calc-related) key bindings are
10039 listed.
10041 @kindex h n
10042 The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
10043 the ``news'' or change history of Calc.  This is kept in the file
10044 @file{README}, which Calc looks for in the same directory as the Calc
10045 source files.
10047 @kindex h C-c
10048 @kindex h C-d
10049 @kindex h C-w
10050 The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
10051 distribution, and warranty information about Calc.  These work by
10052 pulling up the appropriate parts of the ``Copying'' or ``Reporting
10053 Bugs'' sections of the manual.
10055 @node Stack Basics, Numeric Entry, Help Commands, Introduction
10056 @section Stack Basics
10058 @noindent
10059 @cindex Stack basics
10060 @c [fix-tut RPN Calculations and the Stack]
10061 Calc uses RPN notation.  If you are not familiar with RPN, @pxref{RPN
10062 Tutorial}.
10064 To add the numbers 1 and 2 in Calc you would type the keys:
10065 @kbd{1 @key{RET} 2 +}.
10066 (@key{RET} corresponds to the @key{ENTER} key on most calculators.)
10067 The first three keystrokes ``push'' the numbers 1 and 2 onto the stack.  The
10068 @kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
10069 and pushes the result (3) back onto the stack.  This number is ready for
10070 further calculations:  @kbd{5 -} pushes 5 onto the stack, then pops the
10071 3 and 5, subtracts them, and pushes the result (@i{-2}).@refill
10073 Note that the ``top'' of the stack actually appears at the @emph{bottom}
10074 of the buffer.  A line containing a single @samp{.} character signifies
10075 the end of the buffer; Calculator commands operate on the number(s)
10076 directly above this line.  The @kbd{d t} (@code{calc-truncate-stack})
10077 command allows you to move the @samp{.} marker up and down in the stack;
10078 @pxref{Truncating the Stack}.
10080 @kindex d l
10081 @pindex calc-line-numbering
10082 Stack elements are numbered consecutively, with number 1 being the top of
10083 the stack.  These line numbers are ordinarily displayed on the lefthand side
10084 of the window.  The @kbd{d l} (@code{calc-line-numbering}) command controls
10085 whether these numbers appear.  (Line numbers may be turned off since they
10086 slow the Calculator down a bit and also clutter the display.)
10088 @kindex o
10089 @pindex calc-realign
10090 The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
10091 the cursor to its top-of-stack ``home'' position.  It also undoes any
10092 horizontal scrolling in the window.  If you give it a numeric prefix
10093 argument, it instead moves the cursor to the specified stack element.
10095 The @key{RET} (or equivalent @key{SPC}) key is only required to separate
10096 two consecutive numbers.
10097 (After all, if you typed @kbd{1 2} by themselves the Calculator
10098 would enter the number 12.)  If you press @key{RET} or @key{SPC} @emph{not}
10099 right after typing a number, the key duplicates the number on the top of
10100 the stack.  @kbd{@key{RET} *} is thus a handy way to square a number.@refill
10102 The @key{DEL} key pops and throws away the top number on the stack.
10103 The @key{TAB} key swaps the top two objects on the stack.
10104 @xref{Stack and Trail}, for descriptions of these and other stack-related
10105 commands.@refill
10107 @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
10108 @section Numeric Entry
10110 @noindent
10111 @kindex 0-9
10112 @kindex .
10113 @kindex e
10114 @cindex Numeric entry
10115 @cindex Entering numbers
10116 Pressing a digit or other numeric key begins numeric entry using the
10117 minibuffer.  The number is pushed on the stack when you press the @key{RET}
10118 or @key{SPC} keys.  If you press any other non-numeric key, the number is
10119 pushed onto the stack and the appropriate operation is performed.  If
10120 you press a numeric key which is not valid, the key is ignored.
10122 @cindex Minus signs
10123 @cindex Negative numbers, entering
10124 @kindex _
10125 There are three different concepts corresponding to the word ``minus,''
10126 typified by @cite{a-b} (subtraction), @cite{-x}
10127 (change-sign), and @cite{-5} (negative number).  Calc uses three
10128 different keys for these operations, respectively:
10129 @kbd{-}, @kbd{n}, and @kbd{_} (the underscore).  The @kbd{-} key subtracts
10130 the two numbers on the top of the stack.  The @kbd{n} key changes the sign
10131 of the number on the top of the stack or the number currently being entered.
10132 The @kbd{_} key begins entry of a negative number or changes the sign of
10133 the number currently being entered.  The following sequences all enter the
10134 number @i{-5} onto the stack:  @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
10135 @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.@refill
10137 Some other keys are active during numeric entry, such as @kbd{#} for
10138 non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
10139 These notations are described later in this manual with the corresponding
10140 data types.  @xref{Data Types}.
10142 During numeric entry, the only editing key available is @key{DEL}.
10144 @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
10145 @section Algebraic Entry
10147 @noindent
10148 @kindex '
10149 @pindex calc-algebraic-entry
10150 @cindex Algebraic notation
10151 @cindex Formulas, entering
10152 Calculations can also be entered in algebraic form.  This is accomplished
10153 by typing the apostrophe key, @kbd{'}, followed by the expression in
10154 standard format:  @kbd{@key{'} 2+3*4 @key{RET}} computes
10155 @c{$2+(3\times4) = 14$}
10156 @cite{2+(3*4) = 14} and pushes that on the stack.  If you wish you can
10157 ignore the RPN aspect of Calc altogether and simply enter algebraic
10158 expressions in this way.  You may want to use @key{DEL} every so often to
10159 clear previous results off the stack.@refill
10161 You can press the apostrophe key during normal numeric entry to switch
10162 the half-entered number into algebraic entry mode.  One reason to do this
10163 would be to use the full Emacs cursor motion and editing keys, which are
10164 available during algebraic entry but not during numeric entry.
10166 In the same vein, during either numeric or algebraic entry you can
10167 press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
10168 you complete your half-finished entry in a separate buffer.
10169 @xref{Editing Stack Entries}.
10171 @kindex m a
10172 @pindex calc-algebraic-mode
10173 @cindex Algebraic mode
10174 If you prefer algebraic entry, you can use the command @kbd{m a}
10175 (@code{calc-algebraic-mode}) to set Algebraic mode.  In this mode,
10176 digits and other keys that would normally start numeric entry instead
10177 start full algebraic entry; as long as your formula begins with a digit
10178 you can omit the apostrophe.  Open parentheses and square brackets also
10179 begin algebraic entry.  You can still do RPN calculations in this mode,
10180 but you will have to press @key{RET} to terminate every number:
10181 @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
10182 thing as @kbd{2*3+4 @key{RET}}.@refill
10184 @cindex Incomplete algebraic mode
10185 If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
10186 command, it enables Incomplete Algebraic mode; this is like regular
10187 Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
10188 only.  Numeric keys still begin a numeric entry in this mode.
10190 @kindex m t
10191 @pindex calc-total-algebraic-mode
10192 @cindex Total algebraic mode
10193 The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
10194 stronger algebraic-entry mode, in which @emph{all} regular letter and
10195 punctuation keys begin algebraic entry.  Use this if you prefer typing
10196 @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
10197 @kbd{a f}, and so on.  To type regular Calc commands when you are in
10198 ``total'' algebraic mode, hold down the @key{META} key.  Thus @kbd{M-q}
10199 is the command to quit Calc, @kbd{M-p} sets the precision, and
10200 @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns total algebraic
10201 mode back off again.  Meta keys also terminate algebraic entry, so
10202 that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}.  The symbol
10203 @samp{Alg*} will appear in the mode line whenever you are in this mode.
10205 Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
10206 algebraic formula.  You can then use the normal Emacs editing keys to
10207 modify this formula to your liking before pressing @key{RET}.
10209 @kindex $
10210 @cindex Formulas, referring to stack
10211 Within a formula entered from the keyboard, the symbol @kbd{$}
10212 represents the number on the top of the stack.  If an entered formula
10213 contains any @kbd{$} characters, the Calculator replaces the top of
10214 stack with that formula rather than simply pushing the formula onto the
10215 stack.  Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
10216 @key{RET}} replaces it with 6.  Note that the @kbd{$} key always
10217 initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
10218 first character in the new formula.@refill
10220 Higher stack elements can be accessed from an entered formula with the
10221 symbols @kbd{$$}, @kbd{$$$}, and so on.  The number of stack elements
10222 removed (to be replaced by the entered values) equals the number of dollar
10223 signs in the longest such symbol in the formula.  For example, @samp{$$+$$$}
10224 adds the second and third stack elements, replacing the top three elements
10225 with the answer.  (All information about the top stack element is thus lost
10226 since no single @samp{$} appears in this formula.)@refill
10228 A slightly different way to refer to stack elements is with a dollar
10229 sign followed by a number:  @samp{$1}, @samp{$2}, and so on are much
10230 like @samp{$}, @samp{$$}, etc., except that stack entries referred
10231 to numerically are not replaced by the algebraic entry.  That is, while
10232 @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
10233 on the stack and pushes an additional 6.
10235 If a sequence of formulas are entered separated by commas, each formula
10236 is pushed onto the stack in turn.  For example, @samp{1,2,3} pushes
10237 those three numbers onto the stack (leaving the 3 at the top), and
10238 @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6.  Also,
10239 @samp{$,$$} exchanges the top two elements of the stack, just like the
10240 @key{TAB} key.
10242 You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
10243 of @key{RET}.  This uses @kbd{=} to evaluate the variables in each
10244 formula that goes onto the stack.  (Thus @kbd{' pi @key{RET}} pushes
10245 the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
10247 If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
10248 instead of @key{RET}, Calc disables the default simplifications
10249 (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
10250 is being pushed on the stack.  Thus @kbd{' 1+2 @key{RET}} pushes 3
10251 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @cite{1+2};
10252 you might then press @kbd{=} when it is time to evaluate this formula.
10254 @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
10255 @section ``Quick Calculator'' Mode
10257 @noindent
10258 @kindex M-# q
10259 @pindex quick-calc
10260 @cindex Quick Calculator
10261 There is another way to invoke the Calculator if all you need to do
10262 is make one or two quick calculations.  Type @kbd{M-# q} (or
10263 @kbd{M-x quick-calc}), then type any formula as an algebraic entry.
10264 The Calculator will compute the result and display it in the echo
10265 area, without ever actually putting up a Calc window.
10267 You can use the @kbd{$} character in a Quick Calculator formula to
10268 refer to the previous Quick Calculator result.  Older results are
10269 not retained; the Quick Calculator has no effect on the full
10270 Calculator's stack or trail.  If you compute a result and then
10271 forget what it was, just run @code{M-# q} again and enter
10272 @samp{$} as the formula.
10274 If this is the first time you have used the Calculator in this Emacs
10275 session, the @kbd{M-# q} command will create the @code{*Calculator*}
10276 buffer and perform all the usual initializations; it simply will
10277 refrain from putting that buffer up in a new window.  The Quick
10278 Calculator refers to the @code{*Calculator*} buffer for all mode
10279 settings.  Thus, for example, to set the precision that the Quick
10280 Calculator uses, simply run the full Calculator momentarily and use
10281 the regular @kbd{p} command.
10283 If you use @code{M-# q} from inside the Calculator buffer, the
10284 effect is the same as pressing the apostrophe key (algebraic entry).
10286 The result of a Quick calculation is placed in the Emacs ``kill ring''
10287 as well as being displayed.  A subsequent @kbd{C-y} command will
10288 yank the result into the editing buffer.  You can also use this
10289 to yank the result into the next @kbd{M-# q} input line as a more
10290 explicit alternative to @kbd{$} notation, or to yank the result
10291 into the Calculator stack after typing @kbd{M-# c}.
10293 If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
10294 of @key{RET}, the result is inserted immediately into the current
10295 buffer rather than going into the kill ring.
10297 Quick Calculator results are actually evaluated as if by the @kbd{=}
10298 key (which replaces variable names by their stored values, if any).
10299 If the formula you enter is an assignment to a variable using the
10300 @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
10301 then the result of the evaluation is stored in that Calc variable.
10302 @xref{Store and Recall}.
10304 If the result is an integer and the current display radix is decimal,
10305 the number will also be displayed in hex and octal formats.  If the
10306 integer is in the range from 1 to 126, it will also be displayed as
10307 an ASCII character.
10309 For example, the quoted character @samp{"x"} produces the vector
10310 result @samp{[120]} (because 120 is the ASCII code of the lower-case
10311 `x'; @pxref{Strings}).  Since this is a vector, not an integer, it
10312 is displayed only according to the current mode settings.  But
10313 running Quick Calc again and entering @samp{120} will produce the
10314 result @samp{120 (16#78, 8#170, x)} which shows the number in its
10315 decimal, hexadecimal, octal, and ASCII forms.
10317 Please note that the Quick Calculator is not any faster at loading
10318 or computing the answer than the full Calculator; the name ``quick''
10319 merely refers to the fact that it's much less hassle to use for
10320 small calculations.
10322 @node Prefix Arguments, Undo, Quick Calculator, Introduction
10323 @section Numeric Prefix Arguments
10325 @noindent
10326 Many Calculator commands use numeric prefix arguments.  Some, such as
10327 @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
10328 the prefix argument or use a default if you don't use a prefix.
10329 Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
10330 and prompt for a number if you don't give one as a prefix.@refill
10332 As a rule, stack-manipulation commands accept a numeric prefix argument
10333 which is interpreted as an index into the stack.  A positive argument
10334 operates on the top @var{n} stack entries; a negative argument operates
10335 on the @var{n}th stack entry in isolation; and a zero argument operates
10336 on the entire stack.
10338 Most commands that perform computations (such as the arithmetic and
10339 scientific functions) accept a numeric prefix argument that allows the
10340 operation to be applied across many stack elements.  For unary operations
10341 (that is, functions of one argument like absolute value or complex
10342 conjugate), a positive prefix argument applies that function to the top
10343 @var{n} stack entries simultaneously, and a negative argument applies it
10344 to the @var{n}th stack entry only.  For binary operations (functions of
10345 two arguments like addition, GCD, and vector concatenation), a positive
10346 prefix argument ``reduces'' the function across the top @var{n}
10347 stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
10348 @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
10349 @var{n} stack elements with the top stack element as a second argument
10350 (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
10351 This feature is not available for operations which use the numeric prefix
10352 argument for some other purpose.
10354 Numeric prefixes are specified the same way as always in Emacs:  Press
10355 a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
10356 or press @kbd{C-u} followed by digits.  Some commands treat plain
10357 @kbd{C-u} (without any actual digits) specially.@refill
10359 @kindex ~
10360 @pindex calc-num-prefix
10361 You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
10362 top of the stack and enter it as the numeric prefix for the next command.
10363 For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
10364 (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
10365 to the fourth power and set the precision to that value.@refill
10367 Conversely, if you have typed a numeric prefix argument the @kbd{~} key
10368 pushes it onto the stack in the form of an integer.
10370 @node Undo, Error Messages, Prefix Arguments, Introduction
10371 @section Undoing Mistakes
10373 @noindent
10374 @kindex U
10375 @kindex C-_
10376 @pindex calc-undo
10377 @cindex Mistakes, undoing
10378 @cindex Undoing mistakes
10379 @cindex Errors, undoing
10380 The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
10381 If that operation added or dropped objects from the stack, those objects
10382 are removed or restored.  If it was a ``store'' operation, you are
10383 queried whether or not to restore the variable to its original value.
10384 The @kbd{U} key may be pressed any number of times to undo successively
10385 farther back in time; with a numeric prefix argument it undoes a
10386 specified number of operations.  The undo history is cleared only by the
10387 @kbd{q} (@code{calc-quit}) command.  (Recall that @kbd{M-# c} is
10388 synonymous with @code{calc-quit} while inside the Calculator; this
10389 also clears the undo history.)
10391 Currently the mode-setting commands (like @code{calc-precision}) are not
10392 undoable.  You can undo past a point where you changed a mode, but you
10393 will need to reset the mode yourself.
10395 @kindex D
10396 @pindex calc-redo
10397 @cindex Redoing after an Undo
10398 The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
10399 mistakenly undone.  Pressing @kbd{U} with a negative prefix argument is
10400 equivalent to executing @code{calc-redo}.  You can redo any number of
10401 times, up to the number of recent consecutive undo commands.  Redo
10402 information is cleared whenever you give any command that adds new undo
10403 information, i.e., if you undo, then enter a number on the stack or make
10404 any other change, then it will be too late to redo.
10406 @kindex M-@key{RET}
10407 @pindex calc-last-args
10408 @cindex Last-arguments feature
10409 @cindex Arguments, restoring
10410 The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
10411 it restores the arguments of the most recent command onto the stack;
10412 however, it does not remove the result of that command.  Given a numeric
10413 prefix argument, this command applies to the @cite{n}th most recent
10414 command which removed items from the stack; it pushes those items back
10415 onto the stack.
10417 The @kbd{K} (@code{calc-keep-args}) command provides a related function
10418 to @kbd{M-@key{RET}}.  @xref{Stack and Trail}.
10420 It is also possible to recall previous results or inputs using the trail.
10421 @xref{Trail Commands}.
10423 The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
10425 @node Error Messages, Multiple Calculators, Undo, Introduction
10426 @section Error Messages
10428 @noindent
10429 @kindex w
10430 @pindex calc-why
10431 @cindex Errors, messages
10432 @cindex Why did an error occur?
10433 Many situations that would produce an error message in other calculators
10434 simply create unsimplified formulas in the Emacs Calculator.  For example,
10435 @kbd{1 @key{RET} 0 /} pushes the formula @cite{1 / 0}; @w{@kbd{0 L}} pushes
10436 the formula @samp{ln(0)}.  Floating-point overflow and underflow are also
10437 reasons for this to happen.
10439 When a function call must be left in symbolic form, Calc usually
10440 produces a message explaining why.  Messages that are probably
10441 surprising or indicative of user errors are displayed automatically.
10442 Other messages are simply kept in Calc's memory and are displayed only
10443 if you type @kbd{w} (@code{calc-why}).  You can also press @kbd{w} if
10444 the same computation results in several messages.  (The first message
10445 will end with @samp{[w=more]} in this case.)
10447 @kindex d w
10448 @pindex calc-auto-why
10449 The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
10450 are displayed automatically.  (Calc effectively presses @kbd{w} for you
10451 after your computation finishes.)  By default, this occurs only for
10452 ``important'' messages.  The other possible modes are to report
10453 @emph{all} messages automatically, or to report none automatically (so
10454 that you must always press @kbd{w} yourself to see the messages).
10456 @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
10457 @section Multiple Calculators
10459 @noindent
10460 @pindex another-calc
10461 It is possible to have any number of Calc Mode buffers at once.
10462 Usually this is done by executing @kbd{M-x another-calc}, which
10463 is similar to @kbd{M-# c} except that if a @samp{*Calculator*}
10464 buffer already exists, a new, independent one with a name of the
10465 form @samp{*Calculator*<@var{n}>} is created.  You can also use the
10466 command @code{calc-mode} to put any buffer into Calculator mode, but
10467 this would ordinarily never be done.
10469 The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
10470 it only closes its window.  Use @kbd{M-x kill-buffer} to destroy a
10471 Calculator buffer.
10473 Each Calculator buffer keeps its own stack, undo list, and mode settings
10474 such as precision, angular mode, and display formats.  In Emacs terms,
10475 variables such as @code{calc-stack} are buffer-local variables.  The
10476 global default values of these variables are used only when a new
10477 Calculator buffer is created.  The @code{calc-quit} command saves
10478 the stack and mode settings of the buffer being quit as the new defaults.
10480 There is only one trail buffer, @samp{*Calc Trail*}, used by all
10481 Calculator buffers.
10483 @node Troubleshooting Commands, , Multiple Calculators, Introduction
10484 @section Troubleshooting Commands
10486 @noindent
10487 This section describes commands you can use in case a computation
10488 incorrectly fails or gives the wrong answer.
10490 @xref{Reporting Bugs}, if you find a problem that appears to be due
10491 to a bug or deficiency in Calc.
10493 @menu
10494 * Autoloading Problems::
10495 * Recursion Depth::
10496 * Caches::
10497 * Debugging Calc::
10498 @end menu
10500 @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
10501 @subsection Autoloading Problems
10503 @noindent
10504 The Calc program is split into many component files; components are
10505 loaded automatically as you use various commands that require them.
10506 Occasionally Calc may lose track of when a certain component is
10507 necessary; typically this means you will type a command and it won't
10508 work because some function you've never heard of was undefined.
10510 @kindex M-# L
10511 @pindex calc-load-everything
10512 If this happens, the easiest workaround is to type @kbd{M-# L}
10513 (@code{calc-load-everything}) to force all the parts of Calc to be
10514 loaded right away.  This will cause Emacs to take up a lot more
10515 memory than it would otherwise, but it's guaranteed to fix the problem.
10517 If you seem to run into this problem no matter what you do, or if
10518 even the @kbd{M-# L} command crashes, Calc may have been improperly
10519 installed.  @xref{Installation}, for details of the installation
10520 process.
10522 @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
10523 @subsection Recursion Depth
10525 @noindent
10526 @kindex M
10527 @kindex I M
10528 @pindex calc-more-recursion-depth
10529 @pindex calc-less-recursion-depth
10530 @cindex Recursion depth
10531 @cindex ``Computation got stuck'' message
10532 @cindex @code{max-lisp-eval-depth}
10533 @cindex @code{max-specpdl-size}
10534 Calc uses recursion in many of its calculations.  Emacs Lisp keeps a
10535 variable @code{max-lisp-eval-depth} which limits the amount of recursion
10536 possible in an attempt to recover from program bugs.  If a calculation
10537 ever halts incorrectly with the message ``Computation got stuck or
10538 ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
10539 to increase this limit.  (Of course, this will not help if the
10540 calculation really did get stuck due to some problem inside Calc.)@refill
10542 The limit is always increased (multiplied) by a factor of two.  There
10543 is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
10544 decreases this limit by a factor of two, down to a minimum value of 200.
10545 The default value is 1000.
10547 These commands also double or halve @code{max-specpdl-size}, another
10548 internal Lisp recursion limit.  The minimum value for this limit is 600.
10550 @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
10551 @subsection Caches
10553 @noindent
10554 @cindex Caches
10555 @cindex Flushing caches
10556 Calc saves certain values after they have been computed once.  For
10557 example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
10558 constant @c{$\pi$}
10559 @cite{pi} to about 20 decimal places; if the current precision
10560 is greater than this, it will recompute @c{$\pi$}
10561 @cite{pi} using a series
10562 approximation.  This value will not need to be recomputed ever again
10563 unless you raise the precision still further.  Many operations such as
10564 logarithms and sines make use of similarly cached values such as
10565 @c{$\pi \over 4$}
10566 @cite{pi/4} and @c{$\ln 2$}
10567 @cite{ln(2)}.  The visible effect of caching is that
10568 high-precision computations may seem to do extra work the first time.
10569 Other things cached include powers of two (for the binary arithmetic
10570 functions), matrix inverses and determinants, symbolic integrals, and
10571 data points computed by the graphing commands.
10573 @pindex calc-flush-caches
10574 If you suspect a Calculator cache has become corrupt, you can use the
10575 @code{calc-flush-caches} command to reset all caches to the empty state.
10576 (This should only be necessary in the event of bugs in the Calculator.)
10577 The @kbd{M-# 0} (with the zero key) command also resets caches along
10578 with all other aspects of the Calculator's state.
10580 @node Debugging Calc, , Caches, Troubleshooting Commands
10581 @subsection Debugging Calc
10583 @noindent
10584 A few commands exist to help in the debugging of Calc commands.
10585 @xref{Programming}, to see the various ways that you can write
10586 your own Calc commands.
10588 @kindex Z T
10589 @pindex calc-timing
10590 The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
10591 in which the timing of slow commands is reported in the Trail.
10592 Any Calc command that takes two seconds or longer writes a line
10593 to the Trail showing how many seconds it took.  This value is
10594 accurate only to within one second.
10596 All steps of executing a command are included; in particular, time
10597 taken to format the result for display in the stack and trail is
10598 counted.  Some prompts also count time taken waiting for them to
10599 be answered, while others do not; this depends on the exact
10600 implementation of the command.  For best results, if you are timing
10601 a sequence that includes prompts or multiple commands, define a
10602 keyboard macro to run the whole sequence at once.  Calc's @kbd{X}
10603 command (@pxref{Keyboard Macros}) will then report the time taken
10604 to execute the whole macro.
10606 Another advantage of the @kbd{X} command is that while it is
10607 executing, the stack and trail are not updated from step to step.
10608 So if you expect the output of your test sequence to leave a result
10609 that may take a long time to format and you don't wish to count
10610 this formatting time, end your sequence with a @key{DEL} keystroke
10611 to clear the result from the stack.  When you run the sequence with
10612 @kbd{X}, Calc will never bother to format the large result.
10614 Another thing @kbd{Z T} does is to increase the Emacs variable
10615 @code{gc-cons-threshold} to a much higher value (two million; the
10616 usual default in Calc is 250,000) for the duration of each command.
10617 This generally prevents garbage collection during the timing of
10618 the command, though it may cause your Emacs process to grow
10619 abnormally large.  (Garbage collection time is a major unpredictable
10620 factor in the timing of Emacs operations.)
10622 Another command that is useful when debugging your own Lisp
10623 extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
10624 the error handler that changes the ``@code{max-lisp-eval-depth}
10625 exceeded'' message to the much more friendly ``Computation got
10626 stuck or ran too long.''  This handler interferes with the Emacs
10627 Lisp debugger's @code{debug-on-error} mode.  Errors are reported
10628 in the handler itself rather than at the true location of the
10629 error.  After you have executed @code{calc-pass-errors}, Lisp
10630 errors will be reported correctly but the user-friendly message
10631 will be lost.
10633 @node Data Types, Stack and Trail, Introduction, Top
10634 @chapter Data Types
10636 @noindent
10637 This chapter discusses the various types of objects that can be placed
10638 on the Calculator stack, how they are displayed, and how they are
10639 entered.  (@xref{Data Type Formats}, for information on how these data
10640 types are represented as underlying Lisp objects.)@refill
10642 Integers, fractions, and floats are various ways of describing real
10643 numbers.  HMS forms also for many purposes act as real numbers.  These
10644 types can be combined to form complex numbers, modulo forms, error forms,
10645 or interval forms.  (But these last four types cannot be combined
10646 arbitrarily:@: error forms may not contain modulo forms, for example.)
10647 Finally, all these types of numbers may be combined into vectors,
10648 matrices, or algebraic formulas.
10650 @menu
10651 * Integers::                The most basic data type.
10652 * Fractions::               This and above are called @dfn{rationals}.
10653 * Floats::                  This and above are called @dfn{reals}.
10654 * Complex Numbers::         This and above are called @dfn{numbers}.
10655 * Infinities::
10656 * Vectors and Matrices::
10657 * Strings::
10658 * HMS Forms::
10659 * Date Forms::
10660 * Modulo Forms::
10661 * Error Forms::
10662 * Interval Forms::
10663 * Incomplete Objects::
10664 * Variables::
10665 * Formulas::
10666 @end menu
10668 @node Integers, Fractions, Data Types, Data Types
10669 @section Integers
10671 @noindent
10672 @cindex Integers
10673 The Calculator stores integers to arbitrary precision.  Addition,
10674 subtraction, and multiplication of integers always yields an exact
10675 integer result.  (If the result of a division or exponentiation of
10676 integers is not an integer, it is expressed in fractional or
10677 floating-point form according to the current Fraction Mode.
10678 @xref{Fraction Mode}.)
10680 A decimal integer is represented as an optional sign followed by a
10681 sequence of digits.  Grouping (@pxref{Grouping Digits}) can be used to
10682 insert a comma at every third digit for display purposes, but you
10683 must not type commas during the entry of numbers.@refill
10685 @kindex #
10686 A non-decimal integer is represented as an optional sign, a radix
10687 between 2 and 36, a @samp{#} symbol, and one or more digits.  For radix 11
10688 and above, the letters A through Z (upper- or lower-case) count as
10689 digits and do not terminate numeric entry mode.  @xref{Radix Modes}, for how
10690 to set the default radix for display of integers.  Numbers of any radix
10691 may be entered at any time.  If you press @kbd{#} at the beginning of a
10692 number, the current display radix is used.@refill
10694 @node Fractions, Floats, Integers, Data Types
10695 @section Fractions
10697 @noindent
10698 @cindex Fractions
10699 A @dfn{fraction} is a ratio of two integers.  Fractions are traditionally
10700 written ``2/3'' but Calc uses the notation @samp{2:3}.  (The @kbd{/} key
10701 performs RPN division; the following two sequences push the number
10702 @samp{2:3} on the stack:  @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
10703 assuming Fraction Mode has been enabled.)
10704 When the Calculator produces a fractional result it always reduces it to
10705 simplest form, which may in fact be an integer.@refill
10707 Fractions may also be entered in a three-part form, where @samp{2:3:4}
10708 represents two-and-three-quarters.  @xref{Fraction Formats}, for fraction
10709 display formats.@refill
10711 Non-decimal fractions are entered and displayed as
10712 @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
10713 form).  The numerator and denominator always use the same radix.@refill
10715 @node Floats, Complex Numbers, Fractions, Data Types
10716 @section Floats
10718 @noindent
10719 @cindex Floating-point numbers
10720 A floating-point number or @dfn{float} is a number stored in scientific
10721 notation.  The number of significant digits in the fractional part is
10722 governed by the current floating precision (@pxref{Precision}).  The
10723 range of acceptable values is from @c{$10^{-3999999}$}
10724 @cite{10^-3999999} (inclusive)
10725 to @c{$10^{4000000}$}
10726 @cite{10^4000000}
10727 (exclusive), plus the corresponding negative
10728 values and zero.
10730 Calculations that would exceed the allowable range of values (such
10731 as @samp{exp(exp(20))}) are left in symbolic form by Calc.  The
10732 messages ``floating-point overflow'' or ``floating-point underflow''
10733 indicate that during the calculation a number would have been produced
10734 that was too large or too close to zero, respectively, to be represented
10735 by Calc.  This does not necessarily mean the final result would have
10736 overflowed, just that an overflow occurred while computing the result.
10737 (In fact, it could report an underflow even though the final result
10738 would have overflowed!)
10740 If a rational number and a float are mixed in a calculation, the result
10741 will in general be expressed as a float.  Commands that require an integer
10742 value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
10743 floats, i.e., floating-point numbers with nothing after the decimal point.
10745 Floats are identified by the presence of a decimal point and/or an
10746 exponent.  In general a float consists of an optional sign, digits
10747 including an optional decimal point, and an optional exponent consisting
10748 of an @samp{e}, an optional sign, and up to seven exponent digits.
10749 For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
10750 or 0.235.
10752 Floating-point numbers are normally displayed in decimal notation with
10753 all significant figures shown.  Exceedingly large or small numbers are
10754 displayed in scientific notation.  Various other display options are
10755 available.  @xref{Float Formats}.
10757 @cindex Accuracy of calculations
10758 Floating-point numbers are stored in decimal, not binary.  The result
10759 of each operation is rounded to the nearest value representable in the
10760 number of significant digits specified by the current precision,
10761 rounding away from zero in the case of a tie.  Thus (in the default
10762 display mode) what you see is exactly what you get.  Some operations such
10763 as square roots and transcendental functions are performed with several
10764 digits of extra precision and then rounded down, in an effort to make the
10765 final result accurate to the full requested precision.  However,
10766 accuracy is not rigorously guaranteed.  If you suspect the validity of a
10767 result, try doing the same calculation in a higher precision.  The
10768 Calculator's arithmetic is not intended to be IEEE-conformant in any
10769 way.@refill
10771 While floats are always @emph{stored} in decimal, they can be entered
10772 and displayed in any radix just like integers and fractions.  The
10773 notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point
10774 number whose digits are in the specified radix.  Note that the @samp{.}
10775 is more aptly referred to as a ``radix point'' than as a decimal
10776 point in this case.  The number @samp{8#123.4567} is defined as
10777 @samp{8#1234567 * 8^-4}.  If the radix is 14 or less, you can use
10778 @samp{e} notation to write a non-decimal number in scientific notation.
10779 The exponent is written in decimal, and is considered to be a power
10780 of the radix: @samp{8#1234567e-4}.  If the radix is 15 or above, the
10781 letter @samp{e} is a digit, so scientific notation must be written
10782 out, e.g., @samp{16#123.4567*16^2}.  The first two exercises of the
10783 Modes Tutorial explore some of the properties of non-decimal floats.
10785 @node Complex Numbers, Infinities, Floats, Data Types
10786 @section Complex Numbers
10788 @noindent
10789 @cindex Complex numbers
10790 There are two supported formats for complex numbers: rectangular and
10791 polar.  The default format is rectangular, displayed in the form
10792 @samp{(@var{real},@var{imag})} where @var{real} is the real part and
10793 @var{imag} is the imaginary part, each of which may be any real number.
10794 Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
10795 notation; @pxref{Complex Formats}.@refill
10797 Polar complex numbers are displayed in the form `@t{(}@var{r}@t{;}@c{$\theta$}
10798 @var{theta}@t{)}'
10799 where @var{r} is the nonnegative magnitude and @c{$\theta$}
10800 @var{theta} is the argument
10801 or phase angle.  The range of @c{$\theta$}
10802 @var{theta} depends on the current angular
10803 mode (@pxref{Angular Modes}); it is generally between @i{-180} and
10804 @i{+180} degrees or the equivalent range in radians.@refill
10806 Complex numbers are entered in stages using incomplete objects.
10807 @xref{Incomplete Objects}.
10809 Operations on rectangular complex numbers yield rectangular complex
10810 results, and similarly for polar complex numbers.  Where the two types
10811 are mixed, or where new complex numbers arise (as for the square root of
10812 a negative real), the current @dfn{Polar Mode} is used to determine the
10813 type.  @xref{Polar Mode}.
10815 A complex result in which the imaginary part is zero (or the phase angle
10816 is 0 or 180 degrees or @c{$\pi$}
10817 @cite{pi} radians) is automatically converted to a real
10818 number.
10820 @node Infinities, Vectors and Matrices, Complex Numbers, Data Types
10821 @section Infinities
10823 @noindent
10824 @cindex Infinity
10825 @cindex @code{inf} variable
10826 @cindex @code{uinf} variable
10827 @cindex @code{nan} variable
10828 @vindex inf
10829 @vindex uinf
10830 @vindex nan
10831 The word @code{inf} represents the mathematical concept of @dfn{infinity}.
10832 Calc actually has three slightly different infinity-like values:
10833 @code{inf}, @code{uinf}, and @code{nan}.  These are just regular
10834 variable names (@pxref{Variables}); you should avoid using these
10835 names for your own variables because Calc gives them special
10836 treatment.  Infinities, like all variable names, are normally
10837 entered using algebraic entry.
10839 Mathematically speaking, it is not rigorously correct to treat
10840 ``infinity'' as if it were a number, but mathematicians often do
10841 so informally.  When they say that @samp{1 / inf = 0}, what they
10842 really mean is that @cite{1 / x}, as @cite{x} becomes larger and
10843 larger, becomes arbitrarily close to zero.  So you can imagine
10844 that if @cite{x} got ``all the way to infinity,'' then @cite{1 / x}
10845 would go all the way to zero.  Similarly, when they say that
10846 @samp{exp(inf) = inf}, they mean that @c{$e^x$}
10847 @cite{exp(x)} grows without
10848 bound as @cite{x} grows.  The symbol @samp{-inf} likewise stands
10849 for an infinitely negative real value; for example, we say that
10850 @samp{exp(-inf) = 0}.  You can have an infinity pointing in any
10851 direction on the complex plane:  @samp{sqrt(-inf) = i inf}.
10853 The same concept of limits can be used to define @cite{1 / 0}.  We
10854 really want the value that @cite{1 / x} approaches as @cite{x}
10855 approaches zero.  But if all we have is @cite{1 / 0}, we can't
10856 tell which direction @cite{x} was coming from.  If @cite{x} was
10857 positive and decreasing toward zero, then we should say that
10858 @samp{1 / 0 = inf}.  But if @cite{x} was negative and increasing
10859 toward zero, the answer is @samp{1 / 0 = -inf}.  In fact, @cite{x}
10860 could be an imaginary number, giving the answer @samp{i inf} or
10861 @samp{-i inf}.  Calc uses the special symbol @samp{uinf} to mean
10862 @dfn{undirected infinity}, i.e., a value which is infinitely
10863 large but with an unknown sign (or direction on the complex plane).
10865 Calc actually has three modes that say how infinities are handled.
10866 Normally, infinities never arise from calculations that didn't
10867 already have them.  Thus, @cite{1 / 0} is treated simply as an
10868 error and left unevaluated.  The @kbd{m i} (@code{calc-infinite-mode})
10869 command (@pxref{Infinite Mode}) enables a mode in which
10870 @cite{1 / 0} evaluates to @code{uinf} instead.  There is also
10871 an alternative type of infinite mode which says to treat zeros
10872 as if they were positive, so that @samp{1 / 0 = inf}.  While this
10873 is less mathematically correct, it may be the answer you want in
10874 some cases.
10876 Since all infinities are ``as large'' as all others, Calc simplifies,
10877 e.g., @samp{5 inf} to @samp{inf}.  Another example is
10878 @samp{5 - inf = -inf}, where the @samp{-inf} is so large that
10879 adding a finite number like five to it does not affect it.
10880 Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
10881 that variables like @code{a} always stand for finite quantities.
10882 Just to show that infinities really are all the same size,
10883 note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
10884 notation.
10886 It's not so easy to define certain formulas like @samp{0 * inf} and
10887 @samp{inf / inf}.  Depending on where these zeros and infinities
10888 came from, the answer could be literally anything.  The latter
10889 formula could be the limit of @cite{x / x} (giving a result of one),
10890 or @cite{2 x / x} (giving two), or @cite{x^2 / x} (giving @code{inf}),
10891 or @cite{x / x^2} (giving zero).  Calc uses the symbol @code{nan}
10892 to represent such an @dfn{indeterminate} value.  (The name ``nan''
10893 comes from analogy with the ``NAN'' concept of IEEE standard
10894 arithmetic; it stands for ``Not A Number.''  This is somewhat of a
10895 misnomer, since @code{nan} @emph{does} stand for some number or
10896 infinity, it's just that @emph{which} number it stands for
10897 cannot be determined.)  In Calc's notation, @samp{0 * inf = nan}
10898 and @samp{inf / inf = nan}.  A few other common indeterminate
10899 expressions are @samp{inf - inf} and @samp{inf ^ 0}.  Also,
10900 @samp{0 / 0 = nan} if you have turned on ``infinite mode''
10901 (as described above).
10903 Infinities are especially useful as parts of @dfn{intervals}.
10904 @xref{Interval Forms}.
10906 @node Vectors and Matrices, Strings, Infinities, Data Types
10907 @section Vectors and Matrices
10909 @noindent
10910 @cindex Vectors
10911 @cindex Plain vectors
10912 @cindex Matrices
10913 The @dfn{vector} data type is flexible and general.  A vector is simply a
10914 list of zero or more data objects.  When these objects are numbers, the
10915 whole is a vector in the mathematical sense.  When these objects are
10916 themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
10917 A vector which is not a matrix is referred to here as a @dfn{plain vector}.
10919 A vector is displayed as a list of values separated by commas and enclosed
10920 in square brackets:  @samp{[1, 2, 3]}.  Thus the following is a 2 row by
10921 3 column matrix:  @samp{[[1, 2, 3], [4, 5, 6]]}.  Vectors, like complex
10922 numbers, are entered as incomplete objects.  @xref{Incomplete Objects}.
10923 During algebraic entry, vectors are entered all at once in the usual
10924 brackets-and-commas form.  Matrices may be entered algebraically as nested
10925 vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
10926 with rows separated by semicolons.  The commas may usually be omitted
10927 when entering vectors:  @samp{[1 2 3]}.  Curly braces may be used in
10928 place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
10929 this case.
10931 Traditional vector and matrix arithmetic is also supported;
10932 @pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
10933 Many other operations are applied to vectors element-wise.  For example,
10934 the complex conjugate of a vector is a vector of the complex conjugates
10935 of its elements.@refill
10937 @ignore
10938 @starindex
10939 @end ignore
10940 @tindex vec
10941 Algebraic functions for building vectors include @samp{vec(a, b, c)}
10942 to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an @c{$n\times m$}
10943 @asis{@var{n}x@var{m}}
10944 matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
10945 from 1 to @samp{n}.
10947 @node Strings, HMS Forms, Vectors and Matrices, Data Types
10948 @section Strings
10950 @noindent
10951 @kindex "
10952 @cindex Strings
10953 @cindex Character strings
10954 Character strings are not a special data type in the Calculator.
10955 Rather, a string is represented simply as a vector all of whose
10956 elements are integers in the range 0 to 255 (ASCII codes).  You can
10957 enter a string at any time by pressing the @kbd{"} key.  Quotation
10958 marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
10959 inside strings.  Other notations introduced by backslashes are:
10961 @example
10962 @group
10963 \a     7          \^@@    0
10964 \b     8          \^a-z  1-26
10965 \e     27         \^[    27
10966 \f     12         \^\\   28
10967 \n     10         \^]    29
10968 \r     13         \^^    30
10969 \t     9          \^_    31
10970                   \^?    127
10971 @end group
10972 @end example
10974 @noindent
10975 Finally, a backslash followed by three octal digits produces any
10976 character from its ASCII code.
10978 @kindex d "
10979 @pindex calc-display-strings
10980 Strings are normally displayed in vector-of-integers form.  The
10981 @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
10982 which any vectors of small integers are displayed as quoted strings
10983 instead.
10985 The backslash notations shown above are also used for displaying
10986 strings.  Characters 128 and above are not translated by Calc; unless
10987 you have an Emacs modified for 8-bit fonts, these will show up in
10988 backslash-octal-digits notation.  For characters below 32, and
10989 for character 127, Calc uses the backslash-letter combination if
10990 there is one, or otherwise uses a @samp{\^} sequence.
10992 The only Calc feature that uses strings is @dfn{compositions};
10993 @pxref{Compositions}.  Strings also provide a convenient
10994 way to do conversions between ASCII characters and integers.
10996 @ignore
10997 @starindex
10998 @end ignore
10999 @tindex string
11000 There is a @code{string} function which provides a different display
11001 format for strings.  Basically, @samp{string(@var{s})}, where @var{s}
11002 is a vector of integers in the proper range, is displayed as the
11003 corresponding string of characters with no surrounding quotation
11004 marks or other modifications.  Thus @samp{string("ABC")} (or
11005 @samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
11006 This happens regardless of whether @w{@kbd{d "}} has been used.  The
11007 only way to turn it off is to use @kbd{d U} (unformatted language
11008 mode) which will display @samp{string("ABC")} instead.
11010 Control characters are displayed somewhat differently by @code{string}.
11011 Characters below 32, and character 127, are shown using @samp{^} notation
11012 (same as shown above, but without the backslash).  The quote and
11013 backslash characters are left alone, as are characters 128 and above.
11015 @ignore
11016 @starindex
11017 @end ignore
11018 @tindex bstring
11019 The @code{bstring} function is just like @code{string} except that
11020 the resulting string is breakable across multiple lines if it doesn't
11021 fit all on one line.  Potential break points occur at every space
11022 character in the string.
11024 @node HMS Forms, Date Forms, Strings, Data Types
11025 @section HMS Forms
11027 @noindent
11028 @cindex Hours-minutes-seconds forms
11029 @cindex Degrees-minutes-seconds forms
11030 @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
11031 argument, the interpretation is Degrees-Minutes-Seconds.  All functions
11032 that operate on angles accept HMS forms.  These are interpreted as
11033 degrees regardless of the current angular mode.  It is also possible to
11034 use HMS as the angular mode so that calculated angles are expressed in
11035 degrees, minutes, and seconds.
11037 @kindex @@
11038 @ignore
11039 @mindex @null
11040 @end ignore
11041 @kindex ' (HMS forms)
11042 @ignore
11043 @mindex @null
11044 @end ignore
11045 @kindex " (HMS forms)
11046 @ignore
11047 @mindex @null
11048 @end ignore
11049 @kindex h (HMS forms)
11050 @ignore
11051 @mindex @null
11052 @end ignore
11053 @kindex o (HMS forms)
11054 @ignore
11055 @mindex @null
11056 @end ignore
11057 @kindex m (HMS forms)
11058 @ignore
11059 @mindex @null
11060 @end ignore
11061 @kindex s (HMS forms)
11062 The default format for HMS values is
11063 @samp{@var{hours}@@ @var{mins}' @var{secs}"}.  During entry, the letters
11064 @samp{h} (for ``hours'') or
11065 @samp{o} (approximating the ``degrees'' symbol) are accepted as well as
11066 @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
11067 accepted in place of @samp{"}.
11068 The @var{hours} value is an integer (or integer-valued float).
11069 The @var{mins} value is an integer or integer-valued float between 0 and 59.
11070 The @var{secs} value is a real number between 0 (inclusive) and 60
11071 (exclusive).  A positive HMS form is interpreted as @var{hours} +
11072 @var{mins}/60 + @var{secs}/3600.  A negative HMS form is interpreted
11073 as @i{- @var{hours}} @i{-} @var{mins}/60 @i{-} @var{secs}/3600.
11074 Display format for HMS forms is quite flexible.  @xref{HMS Formats}.@refill
11076 HMS forms can be added and subtracted.  When they are added to numbers,
11077 the numbers are interpreted according to the current angular mode.  HMS
11078 forms can also be multiplied and divided by real numbers.  Dividing
11079 two HMS forms produces a real-valued ratio of the two angles.
11081 @pindex calc-time
11082 @cindex Time of day
11083 Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
11084 the stack as an HMS form.
11086 @node Date Forms, Modulo Forms, HMS Forms, Data Types
11087 @section Date Forms
11089 @noindent
11090 @cindex Date forms
11091 A @dfn{date form} represents a date and possibly an associated time.
11092 Simple date arithmetic is supported:  Adding a number to a date
11093 produces a new date shifted by that many days; adding an HMS form to
11094 a date shifts it by that many hours.  Subtracting two date forms
11095 computes the number of days between them (represented as a simple
11096 number).  Many other operations, such as multiplying two date forms,
11097 are nonsensical and are not allowed by Calc.
11099 Date forms are entered and displayed enclosed in @samp{< >} brackets.
11100 The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
11101 or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
11102 Input is flexible; date forms can be entered in any of the usual
11103 notations for dates and times.  @xref{Date Formats}.
11105 Date forms are stored internally as numbers, specifically the number
11106 of days since midnight on the morning of January 1 of the year 1 AD.
11107 If the internal number is an integer, the form represents a date only;
11108 if the internal number is a fraction or float, the form represents
11109 a date and time.  For example, @samp{<6:00am Wed Jan 9, 1991>}
11110 is represented by the number 726842.25.  The standard precision of
11111 12 decimal digits is enough to ensure that a (reasonable) date and
11112 time can be stored without roundoff error.
11114 If the current precision is greater than 12, date forms will keep
11115 additional digits in the seconds position.  For example, if the
11116 precision is 15, the seconds will keep three digits after the
11117 decimal point.  Decreasing the precision below 12 may cause the
11118 time part of a date form to become inaccurate.  This can also happen
11119 if astronomically high years are used, though this will not be an
11120 issue in everyday (or even everymillennium) use.  Note that date
11121 forms without times are stored as exact integers, so roundoff is
11122 never an issue for them.
11124 You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
11125 (@code{calc-unpack}) commands to get at the numerical representation
11126 of a date form.  @xref{Packing and Unpacking}.
11128 Date forms can go arbitrarily far into the future or past.  Negative
11129 year numbers represent years BC.  Calc uses a combination of the
11130 Gregorian and Julian calendars, following the history of Great
11131 Britain and the British colonies.  This is the same calendar that
11132 is used by the @code{cal} program in most Unix implementations.
11134 @cindex Julian calendar
11135 @cindex Gregorian calendar
11136 Some historical background:  The Julian calendar was created by
11137 Julius Caesar in the year 46 BC as an attempt to fix the gradual
11138 drift caused by the lack of leap years in the calendar used
11139 until that time.  The Julian calendar introduced an extra day in
11140 all years divisible by four.  After some initial confusion, the
11141 calendar was adopted around the year we call 8 AD.  Some centuries
11142 later it became apparent that the Julian year of 365.25 days was
11143 itself not quite right.  In 1582 Pope Gregory XIII introduced the
11144 Gregorian calendar, which added the new rule that years divisible
11145 by 100, but not by 400, were not to be considered leap years
11146 despite being divisible by four.  Many countries delayed adoption
11147 of the Gregorian calendar because of religious differences;
11148 in Britain it was put off until the year 1752, by which time
11149 the Julian calendar had fallen eleven days behind the true
11150 seasons.  So the switch to the Gregorian calendar in early
11151 September 1752 introduced a discontinuity:  The day after
11152 Sep 2, 1752 is Sep 14, 1752.  Calc follows this convention.
11153 To take another example, Russia waited until 1918 before
11154 adopting the new calendar, and thus needed to remove thirteen
11155 days (between Feb 1, 1918 and Feb 14, 1918).  This means that
11156 Calc's reckoning will be inconsistent with Russian history between
11157 1752 and 1918, and similarly for various other countries.
11159 Today's timekeepers introduce an occasional ``leap second'' as
11160 well, but Calc does not take these minor effects into account.
11161 (If it did, it would have to report a non-integer number of days
11162 between, say, @samp{<12:00am Mon Jan 1, 1900>} and
11163 @samp{<12:00am Sat Jan 1, 2000>}.)
11165 Calc uses the Julian calendar for all dates before the year 1752,
11166 including dates BC when the Julian calendar technically had not
11167 yet been invented.  Thus the claim that day number @i{-10000} is
11168 called ``August 16, 28 BC'' should be taken with a grain of salt.
11170 Please note that there is no ``year 0''; the day before
11171 @samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}.  These are
11172 days 0 and @i{-1} respectively in Calc's internal numbering scheme.
11174 @cindex Julian day counting
11175 Another day counting system in common use is, confusingly, also
11176 called ``Julian.''  It was invented in 1583 by Joseph Justus
11177 Scaliger, who named it in honor of his father Julius Caesar
11178 Scaliger.  For obscure reasons he chose to start his day
11179 numbering on Jan 1, 4713 BC at noon, which in Calc's scheme
11180 is @i{-1721423.5} (recall that Calc starts at midnight instead
11181 of noon).  Thus to convert a Calc date code obtained by
11182 unpacking a date form into a Julian day number, simply add
11183 1721423.5.  The Julian code for @samp{6:00am Jan 9, 1991}
11184 is 2448265.75.  The built-in @kbd{t J} command performs
11185 this conversion for you.
11187 @cindex Unix time format
11188 The Unix operating system measures time as an integer number of
11189 seconds since midnight, Jan 1, 1970.  To convert a Calc date
11190 value into a Unix time stamp, first subtract 719164 (the code
11191 for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
11192 seconds in a day) and press @kbd{R} to round to the nearest
11193 integer.  If you have a date form, you can simply subtract the
11194 day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
11195 719164.  Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
11196 to convert from Unix time to a Calc date form.  (Note that
11197 Unix normally maintains the time in the GMT time zone; you may
11198 need to subtract five hours to get New York time, or eight hours
11199 for California time.  The same is usually true of Julian day
11200 counts.)  The built-in @kbd{t U} command performs these
11201 conversions.
11203 @node Modulo Forms, Error Forms, Date Forms, Data Types
11204 @section Modulo Forms
11206 @noindent
11207 @cindex Modulo forms
11208 A @dfn{modulo form} is a real number which is taken modulo (i.e., within
11209 an integer multiple of) some value @var{M}.  Arithmetic modulo @var{M}
11210 often arises in number theory.  Modulo forms are written
11211 `@var{a} @t{mod} @var{M}',
11212 where @var{a} and @var{M} are real numbers or HMS forms, and
11213 @c{$0 \le a < M$}
11214 @cite{0 <= a < @var{M}}.
11215 In many applications @cite{a} and @cite{M} will be
11216 integers but this is not required.@refill
11218 Modulo forms are not to be confused with the modulo operator @samp{%}.
11219 The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
11220 the result 7.  Further computations treat this 7 as just a regular integer.
11221 The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
11222 further computations with this value are again reduced modulo 10 so that
11223 the result always lies in the desired range.
11225 When two modulo forms with identical @cite{M}'s are added or multiplied,
11226 the Calculator simply adds or multiplies the values, then reduces modulo
11227 @cite{M}.  If one argument is a modulo form and the other a plain number,
11228 the plain number is treated like a compatible modulo form.  It is also
11229 possible to raise modulo forms to powers; the result is the value raised
11230 to the power, then reduced modulo @cite{M}.  (When all values involved
11231 are integers, this calculation is done much more efficiently than
11232 actually computing the power and then reducing.)
11234 @cindex Modulo division
11235 Two modulo forms `@var{a} @t{mod} @var{M}' and `@var{b} @t{mod} @var{M}'
11236 can be divided if @cite{a}, @cite{b}, and @cite{M} are all
11237 integers.  The result is the modulo form which, when multiplied by
11238 `@var{b} @t{mod} @var{M}', produces `@var{a} @t{mod} @var{M}'.  If
11239 there is no solution to this equation (which can happen only when
11240 @cite{M} is non-prime), or if any of the arguments are non-integers, the
11241 division is left in symbolic form.  Other operations, such as square
11242 roots, are not yet supported for modulo forms.  (Note that, although
11243 @w{`@t{(}@var{a} @t{mod} @var{M}@t{)^.5}'} will compute a ``modulo square root''
11244 in the sense of reducing @c{$\sqrt a$}
11245 @cite{sqrt(a)} modulo @cite{M}, this is not a
11246 useful definition from the number-theoretical point of view.)@refill
11248 @ignore
11249 @mindex M
11250 @end ignore
11251 @kindex M (modulo forms)
11252 @ignore
11253 @mindex mod
11254 @end ignore
11255 @tindex mod (operator)
11256 To create a modulo form during numeric entry, press the shift-@kbd{M}
11257 key to enter the word @samp{mod}.  As a special convenience, pressing
11258 shift-@kbd{M} a second time automatically enters the value of @cite{M}
11259 that was most recently used before.  During algebraic entry, either
11260 type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
11261 Once again, pressing this a second time enters the current modulo.@refill
11263 You can also use @kbd{v p} and @kbd{%} to modify modulo forms.
11264 @xref{Building Vectors}.  @xref{Basic Arithmetic}.
11266 It is possible to mix HMS forms and modulo forms.  For example, an
11267 HMS form modulo 24 could be used to manipulate clock times; an HMS
11268 form modulo 360 would be suitable for angles.  Making the modulo @cite{M}
11269 also be an HMS form eliminates troubles that would arise if the angular
11270 mode were inadvertently set to Radians, in which case
11271 @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
11272 24 radians!
11274 Modulo forms cannot have variables or formulas for components.  If you
11275 enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
11276 to each of the coefficients:  @samp{(1 mod 5) x + (2 mod 5)}.
11278 @ignore
11279 @starindex
11280 @end ignore
11281 @tindex makemod
11282 The algebraic function @samp{makemod(a, m)} builds the modulo form
11283 @w{@samp{a mod m}}.
11285 @node Error Forms, Interval Forms, Modulo Forms, Data Types
11286 @section Error Forms
11288 @noindent
11289 @cindex Error forms
11290 @cindex Standard deviations
11291 An @dfn{error form} is a number with an associated standard
11292 deviation, as in @samp{2.3 +/- 0.12}.  The notation
11293 `@var{x} @t{+/-} @c{$\sigma$}
11294 @asis{sigma}' stands for an uncertain value which follows a normal or
11295 Gaussian distribution of mean @cite{x} and standard deviation or
11296 ``error'' @c{$\sigma$}
11297 @cite{sigma}.  Both the mean and the error can be either numbers or
11298 formulas.  Generally these are real numbers but the mean may also be
11299 complex.  If the error is negative or complex, it is changed to its
11300 absolute value.  An error form with zero error is converted to a
11301 regular number by the Calculator.@refill
11303 All arithmetic and transcendental functions accept error forms as input.
11304 Operations on the mean-value part work just like operations on regular
11305 numbers.  The error part for any function @cite{f(x)} (such as @c{$\sin x$}
11306 @cite{sin(x)})
11307 is defined by the error of @cite{x} times the derivative of @cite{f}
11308 evaluated at the mean value of @cite{x}.  For a two-argument function
11309 @cite{f(x,y)} (such as addition) the error is the square root of the sum
11310 of the squares of the errors due to @cite{x} and @cite{y}.
11311 @tex
11312 $$ \eqalign{
11313   f(x \hbox{\code{ +/- }} \sigma)
11314     &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
11315   f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
11316     &= f(x,y) \hbox{\code{ +/- }}
11317         \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
11318                              \right| \right)^2
11319              +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
11320                              \right| \right)^2 } \cr
11321 } $$
11322 @end tex
11323 Note that this
11324 definition assumes the errors in @cite{x} and @cite{y} are uncorrelated.
11325 A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
11326 is not the same as @samp{(2 +/- 1)^2}; the former represents the product
11327 of two independent values which happen to have the same probability
11328 distributions, and the latter is the product of one random value with itself.
11329 The former will produce an answer with less error, since on the average
11330 the two independent errors can be expected to cancel out.@refill
11332 Consult a good text on error analysis for a discussion of the proper use
11333 of standard deviations.  Actual errors often are neither Gaussian-distributed
11334 nor uncorrelated, and the above formulas are valid only when errors
11335 are small.  As an example, the error arising from
11336 `@t{sin(}@var{x} @t{+/-} @c{$\sigma$}
11337 @var{sigma}@t{)}' is
11338 `@c{$\sigma$\nobreak}
11339 @var{sigma} @t{abs(cos(}@var{x}@t{))}'.  When @cite{x} is close to zero,
11340 @c{$\cos x$}
11341 @cite{cos(x)} is
11342 close to one so the error in the sine is close to @c{$\sigma$}
11343 @cite{sigma}; this makes sense, since @c{$\sin x$}
11344 @cite{sin(x)} is approximately @cite{x} near zero, so a given
11345 error in @cite{x} will produce about the same error in the sine.  Likewise,
11346 near 90 degrees @c{$\cos x$}
11347 @cite{cos(x)} is nearly zero and so the computed error is
11348 small:  The sine curve is nearly flat in that region, so an error in @cite{x}
11349 has relatively little effect on the value of @c{$\sin x$}
11350 @cite{sin(x)}.  However, consider
11351 @samp{sin(90 +/- 1000)}.  The cosine of 90 is zero, so Calc will report
11352 zero error!  We get an obviously wrong result because we have violated
11353 the small-error approximation underlying the error analysis.  If the error
11354 in @cite{x} had been small, the error in @c{$\sin x$}
11355 @cite{sin(x)} would indeed have been negligible.@refill
11357 @ignore
11358 @mindex p
11359 @end ignore
11360 @kindex p (error forms)
11361 @tindex +/-
11362 To enter an error form during regular numeric entry, use the @kbd{p}
11363 (``plus-or-minus'') key to type the @samp{+/-} symbol.  (If you try actually
11364 typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
11365 @kbd{+} command!)  Within an algebraic formula, you can press @kbd{M-p} to
11366 type the @samp{+/-} symbol, or type it out by hand.
11368 Error forms and complex numbers can be mixed; the formulas shown above
11369 are used for complex numbers, too; note that if the error part evaluates
11370 to a complex number its absolute value (or the square root of the sum of
11371 the squares of the absolute values of the two error contributions) is
11372 used.  Mathematically, this corresponds to a radially symmetric Gaussian
11373 distribution of numbers on the complex plane.  However, note that Calc
11374 considers an error form with real components to represent a real number,
11375 not a complex distribution around a real mean.
11377 Error forms may also be composed of HMS forms.  For best results, both
11378 the mean and the error should be HMS forms if either one is.
11380 @ignore
11381 @starindex
11382 @end ignore
11383 @tindex sdev
11384 The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
11386 @node Interval Forms, Incomplete Objects, Error Forms, Data Types
11387 @section Interval Forms
11389 @noindent
11390 @cindex Interval forms
11391 An @dfn{interval} is a subset of consecutive real numbers.  For example,
11392 the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
11393 inclusive.  If you multiply it by the interval @samp{[0.5 ..@: 2]} you
11394 obtain @samp{[1 ..@: 8]}.  This calculation represents the fact that if
11395 you multiply some number in the range @samp{[2 ..@: 4]} by some other
11396 number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
11397 from 1 to 8.  Interval arithmetic is used to get a worst-case estimate
11398 of the possible range of values a computation will produce, given the
11399 set of possible values of the input.
11401 @ifinfo
11402 Calc supports several varieties of intervals, including @dfn{closed}
11403 intervals of the type shown above, @dfn{open} intervals such as
11404 @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
11405 @emph{exclusive}, and @dfn{semi-open} intervals in which one end
11406 uses a round parenthesis and the other a square bracket.  In mathematical
11407 terms,
11408 @samp{[2 ..@: 4]} means @cite{2 <= x <= 4}, whereas
11409 @samp{[2 ..@: 4)} represents @cite{2 <= x < 4},
11410 @samp{(2 ..@: 4]} represents @cite{2 < x <= 4}, and
11411 @samp{(2 ..@: 4)} represents @cite{2 < x < 4}.@refill
11412 @end ifinfo
11413 @tex
11414 Calc supports several varieties of intervals, including \dfn{closed}
11415 intervals of the type shown above, \dfn{open} intervals such as
11416 \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
11417 \emph{exclusive}, and \dfn{semi-open} intervals in which one end
11418 uses a round parenthesis and the other a square bracket.  In mathematical
11419 terms,
11420 $$ \eqalign{
11421    [2 \hbox{\cite{..}} 4]  &\quad\hbox{means}\quad  2 \le x \le 4  \cr
11422    [2 \hbox{\cite{..}} 4)  &\quad\hbox{means}\quad  2 \le x  <  4  \cr
11423    (2 \hbox{\cite{..}} 4]  &\quad\hbox{means}\quad  2  <  x \le 4  \cr
11424    (2 \hbox{\cite{..}} 4)  &\quad\hbox{means}\quad  2  <  x  <  4  \cr
11425 } $$
11426 @end tex
11428 The lower and upper limits of an interval must be either real numbers
11429 (or HMS or date forms), or symbolic expressions which are assumed to be
11430 real-valued, or @samp{-inf} and @samp{inf}.  In general the lower limit
11431 must be less than the upper limit.  A closed interval containing only
11432 one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
11433 automatically.  An interval containing no values at all (such as
11434 @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
11435 guaranteed to behave well when used in arithmetic.  Note that the
11436 interval @samp{[3 .. inf)} represents all real numbers greater than
11437 or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
11438 In fact, @samp{[-inf .. inf]} represents all real numbers including
11439 the real infinities.
11441 Intervals are entered in the notation shown here, either as algebraic
11442 formulas, or using incomplete forms.  (@xref{Incomplete Objects}.)
11443 In algebraic formulas, multiple periods in a row are collected from
11444 left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
11445 rather than @samp{1 ..@: 0.1e2}.  Add spaces or zeros if you want to
11446 get the other interpretation.  If you omit the lower or upper limit,
11447 a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
11449 ``Infinite mode'' also affects operations on intervals
11450 (@pxref{Infinities}).  Calc will always introduce an open infinity,
11451 as in @samp{1 / (0 .. 2] = [0.5 .. inf)}.  But closed infinities,
11452 @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in infinite mode;
11453 otherwise they are left unevaluated.  Note that the ``direction'' of
11454 a zero is not an issue in this case since the zero is always assumed
11455 to be continuous with the rest of the interval.  For intervals that
11456 contain zero inside them Calc is forced to give the result,
11457 @samp{1 / (-2 .. 2) = [-inf .. inf]}.
11459 While it may seem that intervals and error forms are similar, they are
11460 based on entirely different concepts of inexact quantities.  An error
11461 form `@var{x} @t{+/-} @c{$\sigma$}
11462 @var{sigma}' means a variable is random, and its value could
11463 be anything but is ``probably'' within one @c{$\sigma$}
11464 @var{sigma} of the mean value @cite{x}.
11465 An interval `@t{[}@var{a} @t{..@:} @var{b}@t{]}' means a variable's value
11466 is unknown, but guaranteed to lie in the specified range.  Error forms
11467 are statistical or ``average case'' approximations; interval arithmetic
11468 tends to produce ``worst case'' bounds on an answer.@refill
11470 Intervals may not contain complex numbers, but they may contain
11471 HMS forms or date forms.
11473 @xref{Set Operations}, for commands that interpret interval forms
11474 as subsets of the set of real numbers.
11476 @ignore
11477 @starindex
11478 @end ignore
11479 @tindex intv
11480 The algebraic function @samp{intv(n, a, b)} builds an interval form
11481 from @samp{a} to @samp{b}; @samp{n} is an integer code which must
11482 be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
11483 3 for @samp{[..]}.
11485 Please note that in fully rigorous interval arithmetic, care would be
11486 taken to make sure that the computation of the lower bound rounds toward
11487 minus infinity, while upper bound computations round toward plus
11488 infinity.  Calc's arithmetic always uses a round-to-nearest mode,
11489 which means that roundoff errors could creep into an interval
11490 calculation to produce intervals slightly smaller than they ought to
11491 be.  For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
11492 should yield the interval @samp{[1..2]} again, but in fact it yields the
11493 (slightly too small) interval @samp{[1..1.9999999]} due to roundoff
11494 error.
11496 @node Incomplete Objects, Variables, Interval Forms, Data Types
11497 @section Incomplete Objects
11499 @noindent
11500 @ignore
11501 @mindex [ ]
11502 @end ignore
11503 @kindex [
11504 @ignore
11505 @mindex ( )
11506 @end ignore
11507 @kindex (
11508 @kindex ,
11509 @ignore
11510 @mindex @null
11511 @end ignore
11512 @kindex ]
11513 @ignore
11514 @mindex @null
11515 @end ignore
11516 @kindex )
11517 @cindex Incomplete vectors
11518 @cindex Incomplete complex numbers
11519 @cindex Incomplete interval forms
11520 When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
11521 vector, respectively, the effect is to push an @dfn{incomplete} complex
11522 number or vector onto the stack.  The @kbd{,} key adds the value(s) at
11523 the top of the stack onto the current incomplete object.  The @kbd{)}
11524 and @kbd{]} keys ``close'' the incomplete object after adding any values
11525 on the top of the stack in front of the incomplete object.
11527 As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
11528 pushes the vector @samp{[2, 6, 9]} onto the stack.  Likewise, @kbd{( 1 , 2 Q )}
11529 pushes the complex number @samp{(1, 1.414)} (approximately).
11531 If several values lie on the stack in front of the incomplete object,
11532 all are collected and appended to the object.  Thus the @kbd{,} key
11533 is redundant:  @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}.  Some people
11534 prefer the equivalent @key{SPC} key to @key{RET}.@refill
11536 As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
11537 @kbd{,} adds a zero or duplicates the preceding value in the list being
11538 formed.  Typing @key{DEL} during incomplete entry removes the last item
11539 from the list.
11541 @kindex ;
11542 The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
11543 numbers:  @kbd{( 1 ; 2 )}.  When entering a vector, @kbd{;} is useful for
11544 creating a matrix.  In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
11545 equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
11547 @kindex ..
11548 @pindex calc-dots
11549 Incomplete entry is also used to enter intervals.  For example,
11550 @kbd{[ 2 ..@: 4 )} enters a semi-open interval.  Note that when you type
11551 the first period, it will be interpreted as a decimal point, but when
11552 you type a second period immediately afterward, it is re-interpreted as
11553 part of the interval symbol.  Typing @kbd{..} corresponds to executing
11554 the @code{calc-dots} command.
11556 If you find incomplete entry distracting, you may wish to enter vectors
11557 and complex numbers as algebraic formulas by pressing the apostrophe key.
11559 @node Variables, Formulas, Incomplete Objects, Data Types
11560 @section Variables
11562 @noindent
11563 @cindex Variables, in formulas
11564 A @dfn{variable} is somewhere between a storage register on a conventional
11565 calculator, and a variable in a programming language.  (In fact, a Calc
11566 variable is really just an Emacs Lisp variable that contains a Calc number
11567 or formula.)  A variable's name is normally composed of letters and digits.
11568 Calc also allows apostrophes and @code{#} signs in variable names.
11569 The Calc variable @code{foo} corresponds to the Emacs Lisp variable
11570 @code{var-foo}.  Commands like @kbd{s s} (@code{calc-store}) that operate
11571 on variables can be made to use any arbitrary Lisp variable simply by
11572 backspacing over the @samp{var-} prefix in the minibuffer.@refill
11574 In a command that takes a variable name, you can either type the full
11575 name of a variable, or type a single digit to use one of the special
11576 convenience variables @code{var-q0} through @code{var-q9}.  For example,
11577 @kbd{3 s s 2} stores the number 3 in variable @code{var-q2}, and
11578 @w{@kbd{3 s s foo @key{RET}}} stores that number in variable
11579 @code{var-foo}.@refill
11581 To push a variable itself (as opposed to the variable's value) on the
11582 stack, enter its name as an algebraic expression using the apostrophe
11583 (@key{'}) key.  Variable names in algebraic formulas implicitly have
11584 @samp{var-} prefixed to their names.  The @samp{#} character in variable
11585 names used in algebraic formulas corresponds to a dash @samp{-} in the
11586 Lisp variable name.  If the name contains any dashes, the prefix @samp{var-}
11587 is @emph{not} automatically added.  Thus the two formulas @samp{foo + 1}
11588 and @samp{var#foo + 1} both refer to the same variable.
11590 @kindex =
11591 @pindex calc-evaluate
11592 @cindex Evaluation of variables in a formula
11593 @cindex Variables, evaluation
11594 @cindex Formulas, evaluation
11595 The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
11596 replacing all variables in the formula which have been given values by a
11597 @code{calc-store} or @code{calc-let} command by their stored values.
11598 Other variables are left alone.  Thus a variable that has not been
11599 stored acts like an abstract variable in algebra; a variable that has
11600 been stored acts more like a register in a traditional calculator.
11601 With a positive numeric prefix argument, @kbd{=} evaluates the top
11602 @var{n} stack entries; with a negative argument, @kbd{=} evaluates
11603 the @var{n}th stack entry.
11605 @cindex @code{e} variable
11606 @cindex @code{pi} variable
11607 @cindex @code{i} variable
11608 @cindex @code{phi} variable
11609 @cindex @code{gamma} variable
11610 @vindex e
11611 @vindex pi
11612 @vindex i
11613 @vindex phi
11614 @vindex gamma
11615 A few variables are called @dfn{special constants}.  Their names are
11616 @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
11617 (@xref{Scientific Functions}.)  When they are evaluated with @kbd{=},
11618 their values are calculated if necessary according to the current precision
11619 or complex polar mode.  If you wish to use these symbols for other purposes,
11620 simply undefine or redefine them using @code{calc-store}.@refill
11622 The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
11623 infinite or indeterminate values.  It's best not to use them as
11624 regular variables, since Calc uses special algebraic rules when
11625 it manipulates them.  Calc displays a warning message if you store
11626 a value into any of these special variables.
11628 @xref{Store and Recall}, for a discussion of commands dealing with variables.
11630 @node Formulas, , Variables, Data Types
11631 @section Formulas
11633 @noindent
11634 @cindex Formulas
11635 @cindex Expressions
11636 @cindex Operators in formulas
11637 @cindex Precedence of operators
11638 When you press the apostrophe key you may enter any expression or formula
11639 in algebraic form.  (Calc uses the terms ``expression'' and ``formula''
11640 interchangeably.)  An expression is built up of numbers, variable names,
11641 and function calls, combined with various arithmetic operators.
11642 Parentheses may
11643 be used to indicate grouping.  Spaces are ignored within formulas, except
11644 that spaces are not permitted within variable names or numbers.
11645 Arithmetic operators, in order from highest to lowest precedence, and
11646 with their equivalent function names, are:
11648 @samp{_} [@code{subscr}] (subscripts);
11650 postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
11652 prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x})
11653 and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
11655 @samp{+/-} [@code{sdev}] (the standard deviation symbol) and
11656 @samp{mod} [@code{makemod}] (the symbol for modulo forms);
11658 postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
11659 and postfix @samp{!!} [@code{dfact}] (double factorial);
11661 @samp{^} [@code{pow}] (raised-to-the-power-of);
11663 @samp{*} [@code{mul}];
11665 @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
11666 @samp{\} [@code{idiv}] (integer division);
11668 infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
11670 @samp{|} [@code{vconcat}] (vector concatenation);
11672 relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
11673 @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
11675 @samp{&&} [@code{land}] (logical ``and'');
11677 @samp{||} [@code{lor}] (logical ``or'');
11679 the C-style ``if'' operator @samp{a?b:c} [@code{if}];
11681 @samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
11683 @samp{&&&} [@code{pand}] (rewrite pattern ``and'');
11685 @samp{|||} [@code{por}] (rewrite pattern ``or'');
11687 @samp{:=} [@code{assign}] (for assignments and rewrite rules);
11689 @samp{::} [@code{condition}] (rewrite pattern condition);
11691 @samp{=>} [@code{evalto}].
11693 Note that, unlike in usual computer notation, multiplication binds more
11694 strongly than division:  @samp{a*b/c*d} is equivalent to @c{$a b \over c d$}
11695 @cite{(a*b)/(c*d)}.
11697 @cindex Multiplication, implicit
11698 @cindex Implicit multiplication
11699 The multiplication sign @samp{*} may be omitted in many cases.  In particular,
11700 if the righthand side is a number, variable name, or parenthesized
11701 expression, the @samp{*} may be omitted.  Implicit multiplication has the
11702 same precedence as the explicit @samp{*} operator.  The one exception to
11703 the rule is that a variable name followed by a parenthesized expression,
11704 as in @samp{f(x)},
11705 is interpreted as a function call, not an implicit @samp{*}.  In many
11706 cases you must use a space if you omit the @samp{*}:  @samp{2a} is the
11707 same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
11708 is a variable called @code{ab}, @emph{not} the product of @samp{a} and
11709 @samp{b}!  Also note that @samp{f (x)} is still a function call.@refill
11711 @cindex Implicit comma in vectors
11712 The rules are slightly different for vectors written with square brackets.
11713 In vectors, the space character is interpreted (like the comma) as a
11714 separator of elements of the vector.  Thus @w{@samp{[ 2a b+c d ]}} is
11715 equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
11716 to @samp{2*a*b + c*d}.
11717 Note that spaces around the brackets, and around explicit commas, are
11718 ignored.  To force spaces to be interpreted as multiplication you can
11719 enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
11720 interpreted as @samp{[a*b, 2*c*d]}.  An implicit comma is also inserted
11721 between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.@refill
11723 Vectors that contain commas (not embedded within nested parentheses or
11724 brackets) do not treat spaces specially:  @samp{[a b, 2 c d]} is a vector
11725 of two elements.  Also, if it would be an error to treat spaces as
11726 separators, but not otherwise, then Calc will ignore spaces:
11727 @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
11728 a vector of two elements.  Finally, vectors entered with curly braces
11729 instead of square brackets do not give spaces any special treatment.
11730 When Calc displays a vector that does not contain any commas, it will
11731 insert parentheses if necessary to make the meaning clear:
11732 @w{@samp{[(a b)]}}.
11734 The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
11735 or five modulo minus-two?  Calc always interprets the leftmost symbol as
11736 an infix operator preferentially (modulo, in this case), so you would
11737 need to write @samp{(5%)-2} to get the former interpretation.
11739 @cindex Function call notation
11740 A function call is, e.g., @samp{sin(1+x)}.  Function names follow the same
11741 rules as variable names except that the default prefix @samp{calcFunc-} is
11742 used (instead of @samp{var-}) for the internal Lisp form.
11743 Most mathematical Calculator commands like
11744 @code{calc-sin} have function equivalents like @code{sin}.
11745 If no Lisp function is defined for a function called by a formula, the
11746 call is left as it is during algebraic manipulation: @samp{f(x+y)} is
11747 left alone.  Beware that many innocent-looking short names like @code{in}
11748 and @code{re} have predefined meanings which could surprise you; however,
11749 single letters or single letters followed by digits are always safe to
11750 use for your own function names.  @xref{Function Index}.@refill
11752 In the documentation for particular commands, the notation @kbd{H S}
11753 (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
11754 command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
11755 represent the same operation.@refill
11757 Commands that interpret (``parse'') text as algebraic formulas include
11758 algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
11759 the contents of the editing buffer when you finish, the @kbd{M-# g}
11760 and @w{@kbd{M-# r}} commands, the @kbd{C-y} command, the X window system
11761 ``paste'' mouse operation, and Embedded Mode.  All of these operations
11762 use the same rules for parsing formulas; in particular, language modes
11763 (@pxref{Language Modes}) affect them all in the same way.
11765 When you read a large amount of text into the Calculator (say a vector
11766 which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
11767 you may wish to include comments in the text.  Calc's formula parser
11768 ignores the symbol @samp{%%} and anything following it on a line:
11770 @example
11771 [ a + b,   %% the sum of "a" and "b"
11772   c + d,
11773   %% last line is coming up:
11774   e + f ]
11775 @end example
11777 @noindent
11778 This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
11780 @xref{Syntax Tables}, for a way to create your own operators and other
11781 input notations.  @xref{Compositions}, for a way to create new display
11782 formats.
11784 @xref{Algebra}, for commands for manipulating formulas symbolically.
11786 @node Stack and Trail, Mode Settings, Data Types, Top
11787 @chapter Stack and Trail Commands
11789 @noindent
11790 This chapter describes the Calc commands for manipulating objects on the
11791 stack and in the trail buffer.  (These commands operate on objects of any
11792 type, such as numbers, vectors, formulas, and incomplete objects.)
11794 @menu
11795 * Stack Manipulation::
11796 * Editing Stack Entries::
11797 * Trail Commands::
11798 * Keep Arguments::
11799 @end menu
11801 @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
11802 @section Stack Manipulation Commands
11804 @noindent
11805 @kindex @key{RET}
11806 @kindex @key{SPC}
11807 @pindex calc-enter
11808 @cindex Duplicating stack entries
11809 To duplicate the top object on the stack, press @key{RET} or @key{SPC}
11810 (two equivalent keys for the @code{calc-enter} command).
11811 Given a positive numeric prefix argument, these commands duplicate
11812 several elements at the top of the stack.
11813 Given a negative argument,
11814 these commands duplicate the specified element of the stack.
11815 Given an argument of zero, they duplicate the entire stack.
11816 For example, with @samp{10 20 30} on the stack,
11817 @key{RET} creates @samp{10 20 30 30},
11818 @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
11819 @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
11820 @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.@refill
11822 @kindex @key{LFD}
11823 @pindex calc-over
11824 The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
11825 have it, else on @kbd{C-j}) is like @code{calc-enter}
11826 except that the sign of the numeric prefix argument is interpreted
11827 oppositely.  Also, with no prefix argument the default argument is 2.
11828 Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
11829 are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
11830 @samp{10 20 30 20}.@refill
11832 @kindex @key{DEL}
11833 @kindex C-d
11834 @pindex calc-pop
11835 @cindex Removing stack entries
11836 @cindex Deleting stack entries
11837 To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
11838 The @kbd{C-d} key is a synonym for @key{DEL}.
11839 (If the top element is an incomplete object with at least one element, the
11840 last element is removed from it.)  Given a positive numeric prefix argument,
11841 several elements are removed.  Given a negative argument, the specified
11842 element of the stack is deleted.  Given an argument of zero, the entire
11843 stack is emptied.
11844 For example, with @samp{10 20 30} on the stack,
11845 @key{DEL} leaves @samp{10 20},
11846 @kbd{C-u 2 @key{DEL}} leaves @samp{10},
11847 @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
11848 @kbd{C-u 0 @key{DEL}} leaves an empty stack.@refill
11850 @kindex M-@key{DEL}
11851 @pindex calc-pop-above
11852 The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
11853 @key{LFD} is to @key{RET}:  It interprets the sign of the numeric
11854 prefix argument in the opposite way, and the default argument is 2.
11855 Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
11856 leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
11857 the third stack element.
11859 @kindex @key{TAB}
11860 @pindex calc-roll-down
11861 To exchange the top two elements of the stack, press @key{TAB}
11862 (@code{calc-roll-down}).  Given a positive numeric prefix argument, the
11863 specified number of elements at the top of the stack are rotated downward.
11864 Given a negative argument, the entire stack is rotated downward the specified
11865 number of times.  Given an argument of zero, the entire stack is reversed
11866 top-for-bottom.
11867 For example, with @samp{10 20 30 40 50} on the stack,
11868 @key{TAB} creates @samp{10 20 30 50 40},
11869 @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
11870 @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
11871 @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.@refill
11873 @kindex M-@key{TAB}
11874 @pindex calc-roll-up
11875 The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
11876 except that it rotates upward instead of downward.  Also, the default
11877 with no prefix argument is to rotate the top 3 elements.
11878 For example, with @samp{10 20 30 40 50} on the stack,
11879 @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
11880 @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
11881 @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
11882 @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.@refill
11884 A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
11885 terms of moving a particular element to a new position in the stack.
11886 With a positive argument @var{n}, @key{TAB} moves the top stack
11887 element down to level @var{n}, making room for it by pulling all the
11888 intervening stack elements toward the top.  @kbd{M-@key{TAB}} moves the
11889 element at level @var{n} up to the top.  (Compare with @key{LFD},
11890 which copies instead of moving the element in level @var{n}.)
11892 With a negative argument @i{-@var{n}}, @key{TAB} rotates the stack
11893 to move the object in level @var{n} to the deepest place in the
11894 stack, and the object in level @i{@var{n}+1} to the top.  @kbd{M-@key{TAB}}
11895 rotates the deepest stack element to be in level @i{n}, also
11896 putting the top stack element in level @i{@var{n}+1}.
11898 @xref{Selecting Subformulas}, for a way to apply these commands to
11899 any portion of a vector or formula on the stack.
11901 @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
11902 @section Editing Stack Entries
11904 @noindent
11905 @kindex `
11906 @pindex calc-edit
11907 @pindex calc-edit-finish
11908 @cindex Editing the stack with Emacs
11909 The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary
11910 buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using
11911 regular Emacs commands.  With a numeric prefix argument, it edits the
11912 specified number of stack entries at once.  (An argument of zero edits
11913 the entire stack; a negative argument edits one specific stack entry.)
11915 When you are done editing, press @kbd{M-# M-#} to finish and return
11916 to Calc.  The @key{RET} and @key{LFD} keys also work to finish most
11917 sorts of editing, though in some cases Calc leaves @key{RET} with its
11918 usual meaning (``insert a newline'') if it's a situation where you
11919 might want to insert new lines into the editing buffer.  The traditional
11920 Emacs ``finish'' key sequence, @kbd{C-c C-c}, also works to finish
11921 editing and may be easier to type, depending on your keyboard.
11923 When you finish editing, the Calculator parses the lines of text in
11924 the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
11925 original stack elements in the original buffer with these new values,
11926 then kills the @samp{*Calc Edit*} buffer.  The original Calculator buffer
11927 continues to exist during editing, but for best results you should be
11928 careful not to change it until you have finished the edit.  You can
11929 also cancel the edit by pressing @kbd{M-# x}.
11931 The formula is normally reevaluated as it is put onto the stack.
11932 For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
11933 @kbd{M-# M-#} will push 5 on the stack.  If you use @key{LFD} to
11934 finish, Calc will put the result on the stack without evaluating it.
11936 If you give a prefix argument to @kbd{M-# M-#} (or @kbd{C-c C-c}),
11937 Calc will not kill the @samp{*Calc Edit*} buffer.  You can switch
11938 back to that buffer and continue editing if you wish.  However, you
11939 should understand that if you initiated the edit with @kbd{`}, the
11940 @kbd{M-# M-#} operation will be programmed to replace the top of the
11941 stack with the new edited value, and it will do this even if you have
11942 rearranged the stack in the meanwhile.  This is not so much of a problem
11943 with other editing commands, though, such as @kbd{s e}
11944 (@code{calc-edit-variable}; @pxref{Operations on Variables}).
11946 If the @code{calc-edit} command involves more than one stack entry,
11947 each line of the @samp{*Calc Edit*} buffer is interpreted as a
11948 separate formula.  Otherwise, the entire buffer is interpreted as
11949 one formula, with line breaks ignored.  (You can use @kbd{C-o} or
11950 @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
11952 The @kbd{`} key also works during numeric or algebraic entry.  The
11953 text entered so far is moved to the @code{*Calc Edit*} buffer for
11954 more extensive editing than is convenient in the minibuffer.
11956 @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
11957 @section Trail Commands
11959 @noindent
11960 @cindex Trail buffer
11961 The commands for manipulating the Calc Trail buffer are two-key sequences
11962 beginning with the @kbd{t} prefix.
11964 @kindex t d
11965 @pindex calc-trail-display
11966 The @kbd{t d} (@code{calc-trail-display}) command turns display of the
11967 trail on and off.  Normally the trail display is toggled on if it was off,
11968 off if it was on.  With a numeric prefix of zero, this command always
11969 turns the trail off; with a prefix of one, it always turns the trail on.
11970 The other trail-manipulation commands described here automatically turn
11971 the trail on.  Note that when the trail is off values are still recorded
11972 there; they are simply not displayed.  To set Emacs to turn the trail
11973 off by default, type @kbd{t d} and then save the mode settings with
11974 @kbd{m m} (@code{calc-save-modes}).
11976 @kindex t i
11977 @pindex calc-trail-in
11978 @kindex t o
11979 @pindex calc-trail-out
11980 The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
11981 (@code{calc-trail-out}) commands switch the cursor into and out of the
11982 Calc Trail window.  In practice they are rarely used, since the commands
11983 shown below are a more convenient way to move around in the
11984 trail, and they work ``by remote control'' when the cursor is still
11985 in the Calculator window.@refill
11987 @cindex Trail pointer
11988 There is a @dfn{trail pointer} which selects some entry of the trail at
11989 any given time.  The trail pointer looks like a @samp{>} symbol right
11990 before the selected number.  The following commands operate on the
11991 trail pointer in various ways.
11993 @kindex t y
11994 @pindex calc-trail-yank
11995 @cindex Retrieving previous results
11996 The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
11997 the trail and pushes it onto the Calculator stack.  It allows you to
11998 re-use any previously computed value without retyping.  With a numeric
11999 prefix argument @var{n}, it yanks the value @var{n} lines above the current
12000 trail pointer.
12002 @kindex t <
12003 @pindex calc-trail-scroll-left
12004 @kindex t >
12005 @pindex calc-trail-scroll-right
12006 The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
12007 (@code{calc-trail-scroll-right}) commands horizontally scroll the trail
12008 window left or right by one half of its width.@refill
12010 @kindex t n
12011 @pindex calc-trail-next
12012 @kindex t p
12013 @pindex calc-trail-previous
12014 @kindex t f
12015 @pindex calc-trail-forward
12016 @kindex t b
12017 @pindex calc-trail-backward
12018 The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
12019 (@code{calc-trail-previous)} commands move the trail pointer down or up
12020 one line.  The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
12021 (@code{calc-trail-backward}) commands move the trail pointer down or up
12022 one screenful at a time.  All of these commands accept numeric prefix
12023 arguments to move several lines or screenfuls at a time.@refill
12025 @kindex t [
12026 @pindex calc-trail-first
12027 @kindex t ]
12028 @pindex calc-trail-last
12029 @kindex t h
12030 @pindex calc-trail-here
12031 The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
12032 (@code{calc-trail-last}) commands move the trail pointer to the first or
12033 last line of the trail.  The @kbd{t h} (@code{calc-trail-here}) command
12034 moves the trail pointer to the cursor position; unlike the other trail
12035 commands, @kbd{t h} works only when Calc Trail is the selected window.@refill
12037 @kindex t s
12038 @pindex calc-trail-isearch-forward
12039 @kindex t r
12040 @pindex calc-trail-isearch-backward
12041 @ifinfo
12042 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12043 (@code{calc-trail-isearch-backward}) commands perform an incremental
12044 search forward or backward through the trail.  You can press @key{RET}
12045 to terminate the search; the trail pointer moves to the current line.
12046 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12047 it was when the search began.@refill
12048 @end ifinfo
12049 @tex
12050 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12051 (@code{calc-trail-isearch-backward}) com\-mands perform an incremental
12052 search forward or backward through the trail.  You can press @key{RET}
12053 to terminate the search; the trail pointer moves to the current line.
12054 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12055 it was when the search began.
12056 @end tex
12058 @kindex t m
12059 @pindex calc-trail-marker
12060 The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
12061 line of text of your own choosing into the trail.  The text is inserted
12062 after the line containing the trail pointer; this usually means it is
12063 added to the end of the trail.  Trail markers are useful mainly as the
12064 targets for later incremental searches in the trail.
12066 @kindex t k
12067 @pindex calc-trail-kill
12068 The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
12069 from the trail.  The line is saved in the Emacs kill ring suitable for
12070 yanking into another buffer, but it is not easy to yank the text back
12071 into the trail buffer.  With a numeric prefix argument, this command
12072 kills the @var{n} lines below or above the selected one.
12074 The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
12075 elsewhere; @pxref{Vector and Matrix Formats}.
12077 @node Keep Arguments, , Trail Commands, Stack and Trail
12078 @section Keep Arguments
12080 @noindent
12081 @kindex K
12082 @pindex calc-keep-args
12083 The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
12084 the following command.  It prevents that command from removing its
12085 arguments from the stack.  For example, after @kbd{2 @key{RET} 3 +},
12086 the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
12087 the stack contains the arguments and the result: @samp{2 3 5}.
12089 This works for all commands that take arguments off the stack.  As
12090 another example, @kbd{K a s} simplifies a formula, pushing the
12091 simplified version of the formula onto the stack after the original
12092 formula (rather than replacing the original formula).
12094 Note that you could get the same effect by typing @kbd{@key{RET} a s},
12095 copying the formula and then simplifying the copy.  One difference
12096 is that for a very large formula the time taken to format the
12097 intermediate copy in @kbd{@key{RET} a s} could be noticeable; @kbd{K a s}
12098 would avoid this extra work.
12100 Even stack manipulation commands are affected.  @key{TAB} works by
12101 popping two values and pushing them back in the opposite order,
12102 so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
12104 A few Calc commands provide other ways of doing the same thing.
12105 For example, @kbd{' sin($)} replaces the number on the stack with
12106 its sine using algebraic entry; to push the sine and keep the
12107 original argument you could use either @kbd{' sin($1)} or
12108 @kbd{K ' sin($)}.  @xref{Algebraic Entry}.  Also, the @kbd{s s}
12109 command is effectively the same as @kbd{K s t}.  @xref{Storing Variables}.
12111 Keyboard macros may interact surprisingly with the @kbd{K} prefix.
12112 If you have defined a keyboard macro to be, say, @samp{Q +} to add
12113 one number to the square root of another, then typing @kbd{K X} will
12114 execute @kbd{K Q +}, probably not what you expected.  The @kbd{K}
12115 prefix will apply to just the first command in the macro rather than
12116 the whole macro.
12118 If you execute a command and then decide you really wanted to keep
12119 the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
12120 This command pushes the last arguments that were popped by any command
12121 onto the stack.  Note that the order of things on the stack will be
12122 different than with @kbd{K}:  @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
12123 @samp{5 2 3} on the stack instead of @samp{2 3 5}.  @xref{Undo}.
12125 @node Mode Settings, Arithmetic, Stack and Trail, Top
12126 @chapter Mode Settings
12128 @noindent
12129 This chapter describes commands that set modes in the Calculator.
12130 They do not affect the contents of the stack, although they may change
12131 the @emph{appearance} or @emph{interpretation} of the stack's contents.
12133 @menu
12134 * General Mode Commands::
12135 * Precision::
12136 * Inverse and Hyperbolic::
12137 * Calculation Modes::
12138 * Simplification Modes::
12139 * Declarations::
12140 * Display Modes::
12141 * Language Modes::
12142 * Modes Variable::
12143 * Calc Mode Line::
12144 @end menu
12146 @node General Mode Commands, Precision, Mode Settings, Mode Settings
12147 @section General Mode Commands
12149 @noindent
12150 @kindex m m
12151 @pindex calc-save-modes
12152 @cindex Continuous memory
12153 @cindex Saving mode settings
12154 @cindex Permanent mode settings
12155 @cindex @file{.emacs} file, mode settings
12156 You can save all of the current mode settings in your @file{.emacs} file
12157 with the @kbd{m m} (@code{calc-save-modes}) command.  This will cause
12158 Emacs to reestablish these modes each time it starts up.  The modes saved
12159 in the file include everything controlled by the @kbd{m} and @kbd{d}
12160 prefix keys, the current precision and binary word size, whether or not
12161 the trail is displayed, the current height of the Calc window, and more.
12162 The current interface (used when you type @kbd{M-# M-#}) is also saved.
12163 If there were already saved mode settings in the file, they are replaced.
12164 Otherwise, the new mode information is appended to the end of the file.
12166 @kindex m R
12167 @pindex calc-mode-record-mode
12168 The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
12169 record the new mode settings (as if by pressing @kbd{m m}) every
12170 time a mode setting changes.  If Embedded Mode is enabled, other
12171 options are available; @pxref{Mode Settings in Embedded Mode}.
12173 @kindex m F
12174 @pindex calc-settings-file-name
12175 The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
12176 choose a different place than your @file{.emacs} file for @kbd{m m},
12177 @kbd{Z P}, and similar commands to save permanent information.
12178 You are prompted for a file name.  All Calc modes are then reset to
12179 their default values, then settings from the file you named are loaded
12180 if this file exists, and this file becomes the one that Calc will
12181 use in the future for commands like @kbd{m m}.  The default settings
12182 file name is @file{~/.emacs}.  You can see the current file name by
12183 giving a blank response to the @kbd{m F} prompt.  See also the
12184 discussion of the @code{calc-settings-file} variable; @pxref{Installation}.
12186 If the file name you give contains the string @samp{.emacs} anywhere
12187 inside it, @kbd{m F} will not automatically load the new file.  This
12188 is because you are presumably switching to your @file{~/.emacs} file,
12189 which may contain other things you don't want to reread.  You can give
12190 a numeric prefix argument of 1 to @kbd{m F} to force it to read the
12191 file no matter what its name.  Conversely, an argument of @i{-1} tells
12192 @kbd{m F} @emph{not} to read the new file.  An argument of 2 or @i{-2}
12193 tells @kbd{m F} not to reset the modes to their defaults beforehand,
12194 which is useful if you intend your new file to have a variant of the
12195 modes present in the file you were using before.
12197 @kindex m x
12198 @pindex calc-always-load-extensions
12199 The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
12200 in which the first use of Calc loads the entire program, including all
12201 extensions modules.  Otherwise, the extensions modules will not be loaded
12202 until the various advanced Calc features are used.  Since this mode only
12203 has effect when Calc is first loaded, @kbd{m x} is usually followed by
12204 @kbd{m m} to make the mode-setting permanent.  To load all of Calc just
12205 once, rather than always in the future, you can press @kbd{M-# L}.
12207 @kindex m S
12208 @pindex calc-shift-prefix
12209 The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
12210 all of Calc's letter prefix keys may be typed shifted as well as unshifted.
12211 If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
12212 you might find it easier to turn this mode on so that you can type
12213 @kbd{A S} instead.  When this mode is enabled, the commands that used to
12214 be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
12215 now be invoked by pressing the shifted letter twice: @kbd{A A}.  Note
12216 that the @kbd{v} prefix key always works both shifted and unshifted, and
12217 the @kbd{z} and @kbd{Z} prefix keys are always distinct.  Also, the @kbd{h}
12218 prefix is not affected by this mode.  Press @kbd{m S} again to disable
12219 shifted-prefix mode.
12221 @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
12222 @section Precision
12224 @noindent
12225 @kindex p
12226 @pindex calc-precision
12227 @cindex Precision of calculations
12228 The @kbd{p} (@code{calc-precision}) command controls the precision to
12229 which floating-point calculations are carried.  The precision must be
12230 at least 3 digits and may be arbitrarily high, within the limits of
12231 memory and time.  This affects only floats:  Integer and rational
12232 calculations are always carried out with as many digits as necessary.
12234 The @kbd{p} key prompts for the current precision.  If you wish you
12235 can instead give the precision as a numeric prefix argument.
12237 Many internal calculations are carried to one or two digits higher
12238 precision than normal.  Results are rounded down afterward to the
12239 current precision.  Unless a special display mode has been selected,
12240 floats are always displayed with their full stored precision, i.e.,
12241 what you see is what you get.  Reducing the current precision does not
12242 round values already on the stack, but those values will be rounded
12243 down before being used in any calculation.  The @kbd{c 0} through
12244 @kbd{c 9} commands (@pxref{Conversions}) can be used to round an
12245 existing value to a new precision.@refill
12247 @cindex Accuracy of calculations
12248 It is important to distinguish the concepts of @dfn{precision} and
12249 @dfn{accuracy}.  In the normal usage of these words, the number
12250 123.4567 has a precision of 7 digits but an accuracy of 4 digits.
12251 The precision is the total number of digits not counting leading
12252 or trailing zeros (regardless of the position of the decimal point).
12253 The accuracy is simply the number of digits after the decimal point
12254 (again not counting trailing zeros).  In Calc you control the precision,
12255 not the accuracy of computations.  If you were to set the accuracy
12256 instead, then calculations like @samp{exp(100)} would generate many
12257 more digits than you would typically need, while @samp{exp(-100)} would
12258 probably round to zero!  In Calc, both these computations give you
12259 exactly 12 (or the requested number of) significant digits.
12261 The only Calc features that deal with accuracy instead of precision
12262 are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
12263 and the rounding functions like @code{floor} and @code{round}
12264 (@pxref{Integer Truncation}).  Also, @kbd{c 0} through @kbd{c 9}
12265 deal with both precision and accuracy depending on the magnitudes
12266 of the numbers involved.
12268 If you need to work with a particular fixed accuracy (say, dollars and
12269 cents with two digits after the decimal point), one solution is to work
12270 with integers and an ``implied'' decimal point.  For example, $8.99
12271 divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
12272 (actually $1.49833 with our implied decimal point); pressing @kbd{R}
12273 would round this to 150 cents, i.e., $1.50.
12275 @xref{Floats}, for still more on floating-point precision and related
12276 issues.
12278 @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
12279 @section Inverse and Hyperbolic Flags
12281 @noindent
12282 @kindex I
12283 @pindex calc-inverse
12284 There is no single-key equivalent to the @code{calc-arcsin} function.
12285 Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
12286 the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
12287 The @kbd{I} key actually toggles the Inverse Flag.  When this flag
12288 is set, the word @samp{Inv} appears in the mode line.@refill
12290 @kindex H
12291 @pindex calc-hyperbolic
12292 Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
12293 Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
12294 If both of these flags are set at once, the effect will be
12295 @code{calc-arcsinh}.  (The Hyperbolic flag is also used by some
12296 non-trigonometric commands; for example @kbd{H L} computes a base-10,
12297 instead of base-@i{e}, logarithm.)@refill
12299 Command names like @code{calc-arcsin} are provided for completeness, and
12300 may be executed with @kbd{x} or @kbd{M-x}.  Their effect is simply to
12301 toggle the Inverse and/or Hyperbolic flags and then execute the
12302 corresponding base command (@code{calc-sin} in this case).
12304 The Inverse and Hyperbolic flags apply only to the next Calculator
12305 command, after which they are automatically cleared.  (They are also
12306 cleared if the next keystroke is not a Calc command.)  Digits you
12307 type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix
12308 arguments for the next command, not as numeric entries.  The same
12309 is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to
12310 subtract and keep arguments).
12312 The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed
12313 elsewhere.  @xref{Keep Arguments}.
12315 @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
12316 @section Calculation Modes
12318 @noindent
12319 The commands in this section are two-key sequences beginning with
12320 the @kbd{m} prefix.  (That's the letter @kbd{m}, not the @key{META} key.)
12321 The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
12322 (@pxref{Algebraic Entry}).
12324 @menu
12325 * Angular Modes::
12326 * Polar Mode::
12327 * Fraction Mode::
12328 * Infinite Mode::
12329 * Symbolic Mode::
12330 * Matrix Mode::
12331 * Automatic Recomputation::
12332 * Working Message::
12333 @end menu
12335 @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
12336 @subsection Angular Modes
12338 @noindent
12339 @cindex Angular mode
12340 The Calculator supports three notations for angles: radians, degrees,
12341 and degrees-minutes-seconds.  When a number is presented to a function
12342 like @code{sin} that requires an angle, the current angular mode is
12343 used to interpret the number as either radians or degrees.  If an HMS
12344 form is presented to @code{sin}, it is always interpreted as
12345 degrees-minutes-seconds.
12347 Functions that compute angles produce a number in radians, a number in
12348 degrees, or an HMS form depending on the current angular mode.  If the
12349 result is a complex number and the current mode is HMS, the number is
12350 instead expressed in degrees.  (Complex-number calculations would
12351 normally be done in radians mode, though.  Complex numbers are converted
12352 to degrees by calculating the complex result in radians and then
12353 multiplying by 180 over @c{$\pi$}
12354 @cite{pi}.)
12356 @kindex m r
12357 @pindex calc-radians-mode
12358 @kindex m d
12359 @pindex calc-degrees-mode
12360 @kindex m h
12361 @pindex calc-hms-mode
12362 The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
12363 and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
12364 The current angular mode is displayed on the Emacs mode line.
12365 The default angular mode is degrees.@refill
12367 @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
12368 @subsection Polar Mode
12370 @noindent
12371 @cindex Polar mode
12372 The Calculator normally ``prefers'' rectangular complex numbers in the
12373 sense that rectangular form is used when the proper form can not be
12374 decided from the input.  This might happen by multiplying a rectangular
12375 number by a polar one, by taking the square root of a negative real
12376 number, or by entering @kbd{( 2 @key{SPC} 3 )}.
12378 @kindex m p
12379 @pindex calc-polar-mode
12380 The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
12381 preference between rectangular and polar forms.  In polar mode, all
12382 of the above example situations would produce polar complex numbers.
12384 @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
12385 @subsection Fraction Mode
12387 @noindent
12388 @cindex Fraction mode
12389 @cindex Division of integers
12390 Division of two integers normally yields a floating-point number if the
12391 result cannot be expressed as an integer.  In some cases you would
12392 rather get an exact fractional answer.  One way to accomplish this is
12393 to multiply fractions instead:  @kbd{6 @key{RET} 1:4 *} produces @cite{3:2}
12394 even though @kbd{6 @key{RET} 4 /} produces @cite{1.5}.
12396 @kindex m f
12397 @pindex calc-frac-mode
12398 To set the Calculator to produce fractional results for normal integer
12399 divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
12400 For example, @cite{8/4} produces @cite{2} in either mode,
12401 but @cite{6/4} produces @cite{3:2} in Fraction Mode, @cite{1.5} in
12402 Float Mode.@refill
12404 At any time you can use @kbd{c f} (@code{calc-float}) to convert a
12405 fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
12406 float to a fraction.  @xref{Conversions}.
12408 @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
12409 @subsection Infinite Mode
12411 @noindent
12412 @cindex Infinite mode
12413 The Calculator normally treats results like @cite{1 / 0} as errors;
12414 formulas like this are left in unsimplified form.  But Calc can be
12415 put into a mode where such calculations instead produce ``infinite''
12416 results.
12418 @kindex m i
12419 @pindex calc-infinite-mode
12420 The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
12421 on and off.  When the mode is off, infinities do not arise except
12422 in calculations that already had infinities as inputs.  (One exception
12423 is that infinite open intervals like @samp{[0 .. inf)} can be
12424 generated; however, intervals closed at infinity (@samp{[0 .. inf]})
12425 will not be generated when infinite mode is off.)
12427 With infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
12428 an undirected infinity.  @xref{Infinities}, for a discussion of the
12429 difference between @code{inf} and @code{uinf}.  Also, @cite{0 / 0}
12430 evaluates to @code{nan}, the ``indeterminate'' symbol.  Various other
12431 functions can also return infinities in this mode; for example,
12432 @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}.  Once again,
12433 note that @samp{exp(inf) = inf} regardless of infinite mode because
12434 this calculation has infinity as an input.
12436 @cindex Positive infinite mode
12437 The @kbd{m i} command with a numeric prefix argument of zero,
12438 i.e., @kbd{C-u 0 m i}, turns on a ``positive infinite mode'' in
12439 which zero is treated as positive instead of being directionless.
12440 Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
12441 Note that zero never actually has a sign in Calc; there are no
12442 separate representations for @i{+0} and @i{-0}.  Positive
12443 infinite mode merely changes the interpretation given to the
12444 single symbol, @samp{0}.  One consequence of this is that, while
12445 you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
12446 is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
12448 @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
12449 @subsection Symbolic Mode
12451 @noindent
12452 @cindex Symbolic mode
12453 @cindex Inexact results
12454 Calculations are normally performed numerically wherever possible.
12455 For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
12456 algebraic expression, produces a numeric answer if the argument is a
12457 number or a symbolic expression if the argument is an expression:
12458 @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
12460 @kindex m s
12461 @pindex calc-symbolic-mode
12462 In @dfn{symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
12463 command, functions which would produce inexact, irrational results are
12464 left in symbolic form.  Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
12465 @samp{sqrt(2)}.
12467 @kindex N
12468 @pindex calc-eval-num
12469 The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
12470 the expression at the top of the stack, by temporarily disabling
12471 @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
12472 Given a numeric prefix argument, it also
12473 sets the floating-point precision to the specified value for the duration
12474 of the command.@refill
12476 To evaluate a formula numerically without expanding the variables it
12477 contains, you can use the key sequence @kbd{m s a v m s} (this uses
12478 @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
12479 variables.)
12481 @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
12482 @subsection Matrix and Scalar Modes
12484 @noindent
12485 @cindex Matrix mode
12486 @cindex Scalar mode
12487 Calc sometimes makes assumptions during algebraic manipulation that
12488 are awkward or incorrect when vectors and matrices are involved.
12489 Calc has two modes, @dfn{matrix mode} and @dfn{scalar mode}, which
12490 modify its behavior around vectors in useful ways.
12492 @kindex m v
12493 @pindex calc-matrix-mode
12494 Press @kbd{m v} (@code{calc-matrix-mode}) once to enter matrix mode.
12495 In this mode, all objects are assumed to be matrices unless provably
12496 otherwise.  One major effect is that Calc will no longer consider
12497 multiplication to be commutative.  (Recall that in matrix arithmetic,
12498 @samp{A*B} is not the same as @samp{B*A}.)  This assumption affects
12499 rewrite rules and algebraic simplification.  Another effect of this
12500 mode is that calculations that would normally produce constants like
12501 0 and 1 (e.g., @cite{a - a} and @cite{a / a}, respectively) will now
12502 produce function calls that represent ``generic'' zero or identity
12503 matrices: @samp{idn(0)}, @samp{idn(1)}.  The @code{idn} function
12504 @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
12505 identity matrix; if @var{n} is omitted, it doesn't know what
12506 dimension to use and so the @code{idn} call remains in symbolic
12507 form.  However, if this generic identity matrix is later combined
12508 with a matrix whose size is known, it will be converted into
12509 a true identity matrix of the appropriate size.  On the other hand,
12510 if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
12511 will assume it really was a scalar after all and produce, e.g., 3.
12513 Press @kbd{m v} a second time to get scalar mode.  Here, objects are
12514 assumed @emph{not} to be vectors or matrices unless provably so.
12515 For example, normally adding a variable to a vector, as in
12516 @samp{[x, y, z] + a}, will leave the sum in symbolic form because
12517 as far as Calc knows, @samp{a} could represent either a number or
12518 another 3-vector.  In scalar mode, @samp{a} is assumed to be a
12519 non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
12521 Press @kbd{m v} a third time to return to the normal mode of operation.
12523 If you press @kbd{m v} with a numeric prefix argument @var{n}, you
12524 get a special ``dimensioned matrix mode'' in which matrices of
12525 unknown size are assumed to be @var{n}x@var{n} square matrices.
12526 Then, the function call @samp{idn(1)} will expand into an actual
12527 matrix rather than representing a ``generic'' matrix.
12529 @cindex Declaring scalar variables
12530 Of course these modes are approximations to the true state of
12531 affairs, which is probably that some quantities will be matrices
12532 and others will be scalars.  One solution is to ``declare''
12533 certain variables or functions to be scalar-valued.
12534 @xref{Declarations}, to see how to make declarations in Calc.
12536 There is nothing stopping you from declaring a variable to be
12537 scalar and then storing a matrix in it; however, if you do, the
12538 results you get from Calc may not be valid.  Suppose you let Calc
12539 get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
12540 @samp{[1, 2, 3]} in @samp{a}.  The result would not be the same as
12541 for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
12542 your earlier promise to Calc that @samp{a} would be scalar.
12544 Another way to mix scalars and matrices is to use selections
12545 (@pxref{Selecting Subformulas}).  Use matrix mode when operating on
12546 your formula normally; then, to apply scalar mode to a certain part
12547 of the formula without affecting the rest just select that part,
12548 change into scalar mode and press @kbd{=} to resimplify the part
12549 under this mode, then change back to matrix mode before deselecting.
12551 @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
12552 @subsection Automatic Recomputation
12554 @noindent
12555 The @dfn{evaluates-to} operator, @samp{=>}, has the special
12556 property that any @samp{=>} formulas on the stack are recomputed
12557 whenever variable values or mode settings that might affect them
12558 are changed.  @xref{Evaluates-To Operator}.
12560 @kindex m C
12561 @pindex calc-auto-recompute
12562 The @kbd{m C} (@code{calc-auto-recompute}) command turns this
12563 automatic recomputation on and off.  If you turn it off, Calc will
12564 not update @samp{=>} operators on the stack (nor those in the
12565 attached Embedded Mode buffer, if there is one).  They will not
12566 be updated unless you explicitly do so by pressing @kbd{=} or until
12567 you press @kbd{m C} to turn recomputation back on.  (While automatic
12568 recomputation is off, you can think of @kbd{m C m C} as a command
12569 to update all @samp{=>} operators while leaving recomputation off.)
12571 To update @samp{=>} operators in an Embedded buffer while
12572 automatic recomputation is off, use @w{@kbd{M-# u}}.
12573 @xref{Embedded Mode}.
12575 @node Working Message, , Automatic Recomputation, Calculation Modes
12576 @subsection Working Messages
12578 @noindent
12579 @cindex Performance
12580 @cindex Working messages
12581 Since the Calculator is written entirely in Emacs Lisp, which is not
12582 designed for heavy numerical work, many operations are quite slow.
12583 The Calculator normally displays the message @samp{Working...} in the
12584 echo area during any command that may be slow.  In addition, iterative
12585 operations such as square roots and trigonometric functions display the
12586 intermediate result at each step.  Both of these types of messages can
12587 be disabled if you find them distracting.
12589 @kindex m w
12590 @pindex calc-working
12591 Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
12592 disable all ``working'' messages.  Use a numeric prefix of 1 to enable
12593 only the plain @samp{Working...} message.  Use a numeric prefix of 2 to
12594 see intermediate results as well.  With no numeric prefix this displays
12595 the current mode.@refill
12597 While it may seem that the ``working'' messages will slow Calc down
12598 considerably, experiments have shown that their impact is actually
12599 quite small.  But if your terminal is slow you may find that it helps
12600 to turn the messages off.
12602 @node Simplification Modes, Declarations, Calculation Modes, Mode Settings
12603 @section Simplification Modes
12605 @noindent
12606 The current @dfn{simplification mode} controls how numbers and formulas
12607 are ``normalized'' when being taken from or pushed onto the stack.
12608 Some normalizations are unavoidable, such as rounding floating-point
12609 results to the current precision, and reducing fractions to simplest
12610 form.  Others, such as simplifying a formula like @cite{a+a} (or @cite{2+3}),
12611 are done by default but can be turned off when necessary.
12613 When you press a key like @kbd{+} when @cite{2} and @cite{3} are on the
12614 stack, Calc pops these numbers, normalizes them, creates the formula
12615 @cite{2+3}, normalizes it, and pushes the result.  Of course the standard
12616 rules for normalizing @cite{2+3} will produce the result @cite{5}.
12618 Simplification mode commands consist of the lower-case @kbd{m} prefix key
12619 followed by a shifted letter.
12621 @kindex m O
12622 @pindex calc-no-simplify-mode
12623 The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
12624 simplifications.  These would leave a formula like @cite{2+3} alone.  In
12625 fact, nothing except simple numbers are ever affected by normalization
12626 in this mode.
12628 @kindex m N
12629 @pindex calc-num-simplify-mode
12630 The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
12631 of any formulas except those for which all arguments are constants.  For
12632 example, @cite{1+2} is simplified to @cite{3}, and @cite{a+(2-2)} is
12633 simplified to @cite{a+0} but no further, since one argument of the sum
12634 is not a constant.  Unfortunately, @cite{(a+2)-2} is @emph{not} simplified
12635 because the top-level @samp{-} operator's arguments are not both
12636 constant numbers (one of them is the formula @cite{a+2}).
12637 A constant is a number or other numeric object (such as a constant
12638 error form or modulo form), or a vector all of whose
12639 elements are constant.@refill
12641 @kindex m D
12642 @pindex calc-default-simplify-mode
12643 The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
12644 default simplifications for all formulas.  This includes many easy and
12645 fast algebraic simplifications such as @cite{a+0} to @cite{a}, and
12646 @cite{a + 2 a} to @cite{3 a}, as well as evaluating functions like
12647 @cite{@t{deriv}(x^2, x)} to @cite{2 x}.
12649 @kindex m B
12650 @pindex calc-bin-simplify-mode
12651 The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
12652 simplifications to a result and then, if the result is an integer,
12653 uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
12654 to the current binary word size.  @xref{Binary Functions}.  Real numbers
12655 are rounded to the nearest integer and then clipped; other kinds of
12656 results (after the default simplifications) are left alone.
12658 @kindex m A
12659 @pindex calc-alg-simplify-mode
12660 The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
12661 simplification; it applies all the default simplifications, and also
12662 the more powerful (and slower) simplifications made by @kbd{a s}
12663 (@code{calc-simplify}).  @xref{Algebraic Simplifications}.
12665 @kindex m E
12666 @pindex calc-ext-simplify-mode
12667 The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
12668 algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
12669 command.  @xref{Unsafe Simplifications}.
12671 @kindex m U
12672 @pindex calc-units-simplify-mode
12673 The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
12674 simplification; it applies the command @kbd{u s}
12675 (@code{calc-simplify-units}), which in turn
12676 is a superset of @kbd{a s}.  In this mode, variable names which
12677 are identifiable as unit names (like @samp{mm} for ``millimeters'')
12678 are simplified with their unit definitions in mind.@refill
12680 A common technique is to set the simplification mode down to the lowest
12681 amount of simplification you will allow to be applied automatically, then
12682 use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
12683 perform higher types of simplifications on demand.  @xref{Algebraic
12684 Definitions}, for another sample use of no-simplification mode.@refill
12686 @node Declarations, Display Modes, Simplification Modes, Mode Settings
12687 @section Declarations
12689 @noindent
12690 A @dfn{declaration} is a statement you make that promises you will
12691 use a certain variable or function in a restricted way.  This may
12692 give Calc the freedom to do things that it couldn't do if it had to
12693 take the fully general situation into account.
12695 @menu
12696 * Declaration Basics::
12697 * Kinds of Declarations::
12698 * Functions for Declarations::
12699 @end menu
12701 @node Declaration Basics, Kinds of Declarations, Declarations, Declarations
12702 @subsection Declaration Basics
12704 @noindent
12705 @kindex s d
12706 @pindex calc-declare-variable
12707 The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
12708 way to make a declaration for a variable.  This command prompts for
12709 the variable name, then prompts for the declaration.  The default
12710 at the declaration prompt is the previous declaration, if any.
12711 You can edit this declaration, or press @kbd{C-k} to erase it and
12712 type a new declaration.  (Or, erase it and press @key{RET} to clear
12713 the declaration, effectively ``undeclaring'' the variable.)
12715 A declaration is in general a vector of @dfn{type symbols} and
12716 @dfn{range} values.  If there is only one type symbol or range value,
12717 you can write it directly rather than enclosing it in a vector.
12718 For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
12719 be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
12720 declares @code{bar} to be a constant integer between 1 and 6.
12721 (Actually, you can omit the outermost brackets and Calc will
12722 provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
12724 @cindex @code{Decls} variable
12725 @vindex Decls
12726 Declarations in Calc are kept in a special variable called @code{Decls}.
12727 This variable encodes the set of all outstanding declarations in
12728 the form of a matrix.  Each row has two elements:  A variable or
12729 vector of variables declared by that row, and the declaration
12730 specifier as described above.  You can use the @kbd{s D} command to
12731 edit this variable if you wish to see all the declarations at once.
12732 @xref{Operations on Variables}, for a description of this command
12733 and the @kbd{s p} command that allows you to save your declarations
12734 permanently if you wish.
12736 Items being declared can also be function calls.  The arguments in
12737 the call are ignored; the effect is to say that this function returns
12738 values of the declared type for any valid arguments.  The @kbd{s d}
12739 command declares only variables, so if you wish to make a function
12740 declaration you will have to edit the @code{Decls} matrix yourself.
12742 For example, the declaration matrix
12744 @smallexample
12745 @group
12746 [ [ foo,       real       ]
12747   [ [j, k, n], int        ]
12748   [ f(1,2,3),  [0 .. inf) ] ]
12749 @end group
12750 @end smallexample
12752 @noindent
12753 declares that @code{foo} represents a real number, @code{j}, @code{k}
12754 and @code{n} represent integers, and the function @code{f} always
12755 returns a real number in the interval shown.
12757 @vindex All
12758 If there is a declaration for the variable @code{All}, then that
12759 declaration applies to all variables that are not otherwise declared.
12760 It does not apply to function names.  For example, using the row
12761 @samp{[All, real]} says that all your variables are real unless they
12762 are explicitly declared without @code{real} in some other row.
12763 The @kbd{s d} command declares @code{All} if you give a blank
12764 response to the variable-name prompt.
12766 @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
12767 @subsection Kinds of Declarations
12769 @noindent
12770 The type-specifier part of a declaration (that is, the second prompt
12771 in the @kbd{s d} command) can be a type symbol, an interval, or a
12772 vector consisting of zero or more type symbols followed by zero or
12773 more intervals or numbers that represent the set of possible values
12774 for the variable.
12776 @smallexample
12777 @group
12778 [ [ a, [1, 2, 3, 4, 5] ]
12779   [ b, [1 .. 5]        ]
12780   [ c, [int, 1 .. 5]   ] ]
12781 @end group
12782 @end smallexample
12784 Here @code{a} is declared to contain one of the five integers shown;
12785 @code{b} is any number in the interval from 1 to 5 (any real number
12786 since we haven't specified), and @code{c} is any integer in that
12787 interval.  Thus the declarations for @code{a} and @code{c} are
12788 nearly equivalent (see below).
12790 The type-specifier can be the empty vector @samp{[]} to say that
12791 nothing is known about a given variable's value.  This is the same
12792 as not declaring the variable at all except that it overrides any
12793 @code{All} declaration which would otherwise apply.
12795 The initial value of @code{Decls} is the empty vector @samp{[]}.
12796 If @code{Decls} has no stored value or if the value stored in it
12797 is not valid, it is ignored and there are no declarations as far
12798 as Calc is concerned.  (The @kbd{s d} command will replace such a
12799 malformed value with a fresh empty matrix, @samp{[]}, before recording
12800 the new declaration.)  Unrecognized type symbols are ignored.
12802 The following type symbols describe what sorts of numbers will be
12803 stored in a variable:
12805 @table @code
12806 @item int
12807 Integers.
12808 @item numint
12809 Numerical integers.  (Integers or integer-valued floats.)
12810 @item frac
12811 Fractions.  (Rational numbers which are not integers.)
12812 @item rat
12813 Rational numbers.  (Either integers or fractions.)
12814 @item float
12815 Floating-point numbers.
12816 @item real
12817 Real numbers.  (Integers, fractions, or floats.  Actually,
12818 intervals and error forms with real components also count as
12819 reals here.)
12820 @item pos
12821 Positive real numbers.  (Strictly greater than zero.)
12822 @item nonneg
12823 Nonnegative real numbers.  (Greater than or equal to zero.)
12824 @item number
12825 Numbers.  (Real or complex.)
12826 @end table
12828 Calc uses this information to determine when certain simplifications
12829 of formulas are safe.  For example, @samp{(x^y)^z} cannot be
12830 simplified to @samp{x^(y z)} in general; for example,
12831 @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @i{-3}.
12832 However, this simplification @emph{is} safe if @code{z} is known
12833 to be an integer, or if @code{x} is known to be a nonnegative
12834 real number.  If you have given declarations that allow Calc to
12835 deduce either of these facts, Calc will perform this simplification
12836 of the formula.
12838 Calc can apply a certain amount of logic when using declarations.
12839 For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
12840 has been declared @code{int}; Calc knows that an integer times an
12841 integer, plus an integer, must always be an integer.  (In fact,
12842 Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
12843 it is able to determine that @samp{2n+1} must be an odd integer.)
12845 Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
12846 because Calc knows that the @code{abs} function always returns a
12847 nonnegative real.  If you had a @code{myabs} function that also had
12848 this property, you could get Calc to recognize it by adding the row
12849 @samp{[myabs(), nonneg]} to the @code{Decls} matrix.
12851 One instance of this simplification is @samp{sqrt(x^2)} (since the
12852 @code{sqrt} function is effectively a one-half power).  Normally
12853 Calc leaves this formula alone.  After the command
12854 @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
12855 @samp{abs(x)}.  And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
12856 simplify this formula all the way to @samp{x}.
12858 If there are any intervals or real numbers in the type specifier,
12859 they comprise the set of possible values that the variable or
12860 function being declared can have.  In particular, the type symbol
12861 @code{real} is effectively the same as the range @samp{[-inf .. inf]}
12862 (note that infinity is included in the range of possible values);
12863 @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
12864 the same as @samp{[0 .. inf]}.  Saying @samp{[real, [-5 .. 5]]} is
12865 redundant because the fact that the variable is real can be
12866 deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
12867 @samp{[rat, [-5 .. 5]]} are useful combinations.
12869 Note that the vector of intervals or numbers is in the same format
12870 used by Calc's set-manipulation commands.  @xref{Set Operations}.
12872 The type specifier @samp{[1, 2, 3]} is equivalent to
12873 @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
12874 In other words, the range of possible values means only that
12875 the variable's value must be numerically equal to a number in
12876 that range, but not that it must be equal in type as well.
12877 Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
12878 and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
12880 If you use a conflicting combination of type specifiers, the
12881 results are unpredictable.  An example is @samp{[pos, [0 .. 5]]},
12882 where the interval does not lie in the range described by the
12883 type symbol.
12885 ``Real'' declarations mostly affect simplifications involving powers
12886 like the one described above.  Another case where they are used
12887 is in the @kbd{a P} command which returns a list of all roots of a
12888 polynomial; if the variable has been declared real, only the real
12889 roots (if any) will be included in the list.
12891 ``Integer'' declarations are used for simplifications which are valid
12892 only when certain values are integers (such as @samp{(x^y)^z}
12893 shown above).
12895 Another command that makes use of declarations is @kbd{a s}, when
12896 simplifying equations and inequalities.  It will cancel @code{x}
12897 from both sides of @samp{a x = b x} only if it is sure @code{x}
12898 is non-zero, say, because it has a @code{pos} declaration.
12899 To declare specifically that @code{x} is real and non-zero,
12900 use @samp{[[-inf .. 0), (0 .. inf]]}.  (There is no way in the
12901 current notation to say that @code{x} is nonzero but not necessarily
12902 real.)  The @kbd{a e} command does ``unsafe'' simplifications,
12903 including cancelling @samp{x} from the equation when @samp{x} is
12904 not known to be nonzero.
12906 Another set of type symbols distinguish between scalars and vectors.
12908 @table @code
12909 @item scalar
12910 The value is not a vector.
12911 @item vector
12912 The value is a vector.
12913 @item matrix
12914 The value is a matrix (a rectangular vector of vectors).
12915 @end table
12917 These type symbols can be combined with the other type symbols
12918 described above; @samp{[int, matrix]} describes an object which
12919 is a matrix of integers.
12921 Scalar/vector declarations are used to determine whether certain
12922 algebraic operations are safe.  For example, @samp{[a, b, c] + x}
12923 is normally not simplified to @samp{[a + x, b + x, c + x]}, but
12924 it will be if @code{x} has been declared @code{scalar}.  On the
12925 other hand, multiplication is usually assumed to be commutative,
12926 but the terms in @samp{x y} will never be exchanged if both @code{x}
12927 and @code{y} are known to be vectors or matrices.  (Calc currently
12928 never distinguishes between @code{vector} and @code{matrix}
12929 declarations.)
12931 @xref{Matrix Mode}, for a discussion of ``matrix mode'' and
12932 ``scalar mode,'' which are similar to declaring @samp{[All, matrix]}
12933 or @samp{[All, scalar]} but much more convenient.
12935 One more type symbol that is recognized is used with the @kbd{H a d}
12936 command for taking total derivatives of a formula.  @xref{Calculus}.
12938 @table @code
12939 @item const
12940 The value is a constant with respect to other variables.
12941 @end table
12943 Calc does not check the declarations for a variable when you store
12944 a value in it.  However, storing @i{-3.5} in a variable that has
12945 been declared @code{pos}, @code{int}, or @code{matrix} may have
12946 unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @cite{3.5}
12947 if it substitutes the value first, or to @cite{-3.5} if @code{x}
12948 was declared @code{pos} and the formula @samp{sqrt(x^2)} is
12949 simplified to @samp{x} before the value is substituted.  Before
12950 using a variable for a new purpose, it is best to use @kbd{s d}
12951 or @kbd{s D} to check to make sure you don't still have an old
12952 declaration for the variable that will conflict with its new meaning.
12954 @node Functions for Declarations, , Kinds of Declarations, Declarations
12955 @subsection Functions for Declarations
12957 @noindent
12958 Calc has a set of functions for accessing the current declarations
12959 in a convenient manner.  These functions return 1 if the argument
12960 can be shown to have the specified property, or 0 if the argument
12961 can be shown @emph{not} to have that property; otherwise they are
12962 left unevaluated.  These functions are suitable for use with rewrite
12963 rules (@pxref{Conditional Rewrite Rules}) or programming constructs
12964 (@pxref{Conditionals in Macros}).  They can be entered only using
12965 algebraic notation.  @xref{Logical Operations}, for functions
12966 that perform other tests not related to declarations.
12968 For example, @samp{dint(17)} returns 1 because 17 is an integer, as
12969 do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
12970 @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
12971 Calc consults knowledge of its own built-in functions as well as your
12972 own declarations: @samp{dint(floor(x))} returns 1.
12974 @ignore
12975 @starindex
12976 @end ignore
12977 @tindex dint
12978 @ignore
12979 @starindex
12980 @end ignore
12981 @tindex dnumint
12982 @ignore
12983 @starindex
12984 @end ignore
12985 @tindex dnatnum
12986 The @code{dint} function checks if its argument is an integer.
12987 The @code{dnatnum} function checks if its argument is a natural
12988 number, i.e., a nonnegative integer.  The @code{dnumint} function
12989 checks if its argument is numerically an integer, i.e., either an
12990 integer or an integer-valued float.  Note that these and the other
12991 data type functions also accept vectors or matrices composed of
12992 suitable elements, and that real infinities @samp{inf} and @samp{-inf}
12993 are considered to be integers for the purposes of these functions.
12995 @ignore
12996 @starindex
12997 @end ignore
12998 @tindex drat
12999 The @code{drat} function checks if its argument is rational, i.e.,
13000 an integer or fraction.  Infinities count as rational, but intervals
13001 and error forms do not.
13003 @ignore
13004 @starindex
13005 @end ignore
13006 @tindex dreal
13007 The @code{dreal} function checks if its argument is real.  This
13008 includes integers, fractions, floats, real error forms, and intervals.
13010 @ignore
13011 @starindex
13012 @end ignore
13013 @tindex dimag
13014 The @code{dimag} function checks if its argument is imaginary,
13015 i.e., is mathematically equal to a real number times @cite{i}.
13017 @ignore
13018 @starindex
13019 @end ignore
13020 @tindex dpos
13021 @ignore
13022 @starindex
13023 @end ignore
13024 @tindex dneg
13025 @ignore
13026 @starindex
13027 @end ignore
13028 @tindex dnonneg
13029 The @code{dpos} function checks for positive (but nonzero) reals.
13030 The @code{dneg} function checks for negative reals.  The @code{dnonneg}
13031 function checks for nonnegative reals, i.e., reals greater than or
13032 equal to zero.  Note that the @kbd{a s} command can simplify an
13033 expression like @cite{x > 0} to 1 or 0 using @code{dpos}, and that
13034 @kbd{a s} is effectively applied to all conditions in rewrite rules,
13035 so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
13036 are rarely necessary.
13038 @ignore
13039 @starindex
13040 @end ignore
13041 @tindex dnonzero
13042 The @code{dnonzero} function checks that its argument is nonzero.
13043 This includes all nonzero real or complex numbers, all intervals that
13044 do not include zero, all nonzero modulo forms, vectors all of whose
13045 elements are nonzero, and variables or formulas whose values can be
13046 deduced to be nonzero.  It does not include error forms, since they
13047 represent values which could be anything including zero.  (This is
13048 also the set of objects considered ``true'' in conditional contexts.)
13050 @ignore
13051 @starindex
13052 @end ignore
13053 @tindex deven
13054 @ignore
13055 @starindex
13056 @end ignore
13057 @tindex dodd
13058 The @code{deven} function returns 1 if its argument is known to be
13059 an even integer (or integer-valued float); it returns 0 if its argument
13060 is known not to be even (because it is known to be odd or a non-integer).
13061 The @kbd{a s} command uses this to simplify a test of the form
13062 @samp{x % 2 = 0}.  There is also an analogous @code{dodd} function.
13064 @ignore
13065 @starindex
13066 @end ignore
13067 @tindex drange
13068 The @code{drange} function returns a set (an interval or a vector
13069 of intervals and/or numbers; @pxref{Set Operations}) that describes
13070 the set of possible values of its argument.  If the argument is
13071 a variable or a function with a declaration, the range is copied
13072 from the declaration.  Otherwise, the possible signs of the
13073 expression are determined using a method similar to @code{dpos},
13074 etc., and a suitable set like @samp{[0 .. inf]} is returned.  If
13075 the expression is not provably real, the @code{drange} function
13076 remains unevaluated.
13078 @ignore
13079 @starindex
13080 @end ignore
13081 @tindex dscalar
13082 The @code{dscalar} function returns 1 if its argument is provably
13083 scalar, or 0 if its argument is provably non-scalar.  It is left
13084 unevaluated if this cannot be determined.  (If matrix mode or scalar
13085 mode are in effect, this function returns 1 or 0, respectively,
13086 if it has no other information.)  When Calc interprets a condition
13087 (say, in a rewrite rule) it considers an unevaluated formula to be
13088 ``false.''  Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
13089 provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
13090 is provably non-scalar; both are ``false'' if there is insufficient
13091 information to tell.
13093 @node Display Modes, Language Modes, Declarations, Mode Settings
13094 @section Display Modes
13096 @noindent
13097 The commands in this section are two-key sequences beginning with the
13098 @kbd{d} prefix.  The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
13099 (@code{calc-line-breaking}) commands are described elsewhere;
13100 @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
13101 Display formats for vectors and matrices are also covered elsewhere;
13102 @pxref{Vector and Matrix Formats}.@refill
13104 One thing all display modes have in common is their treatment of the
13105 @kbd{H} prefix.  This prefix causes any mode command that would normally
13106 refresh the stack to leave the stack display alone.  The word ``Dirty''
13107 will appear in the mode line when Calc thinks the stack display may not
13108 reflect the latest mode settings.
13110 @kindex d @key{RET}
13111 @pindex calc-refresh-top
13112 The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
13113 top stack entry according to all the current modes.  Positive prefix
13114 arguments reformat the top @var{n} entries; negative prefix arguments
13115 reformat the specified entry, and a prefix of zero is equivalent to
13116 @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
13117 For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
13118 but reformats only the top two stack entries in the new mode.
13120 The @kbd{I} prefix has another effect on the display modes.  The mode
13121 is set only temporarily; the top stack entry is reformatted according
13122 to that mode, then the original mode setting is restored.  In other
13123 words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
13125 @menu
13126 * Radix Modes::
13127 * Grouping Digits::
13128 * Float Formats::
13129 * Complex Formats::
13130 * Fraction Formats::
13131 * HMS Formats::
13132 * Date Formats::
13133 * Truncating the Stack::
13134 * Justification::
13135 * Labels::
13136 @end menu
13138 @node Radix Modes, Grouping Digits, Display Modes, Display Modes
13139 @subsection Radix Modes
13141 @noindent
13142 @cindex Radix display
13143 @cindex Non-decimal numbers
13144 @cindex Decimal and non-decimal numbers
13145 Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
13146 notation.  Calc can actually display in any radix from two (binary) to 36.
13147 When the radix is above 10, the letters @code{A} to @code{Z} are used as
13148 digits.  When entering such a number, letter keys are interpreted as
13149 potential digits rather than terminating numeric entry mode.
13151 @kindex d 2
13152 @kindex d 8
13153 @kindex d 6
13154 @kindex d 0
13155 @cindex Hexadecimal integers
13156 @cindex Octal integers
13157 The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
13158 binary, octal, hexadecimal, and decimal as the current display radix,
13159 respectively.  Numbers can always be entered in any radix, though the
13160 current radix is used as a default if you press @kbd{#} without any initial
13161 digits.  A number entered without a @kbd{#} is @emph{always} interpreted
13162 as decimal.@refill
13164 @kindex d r
13165 @pindex calc-radix
13166 To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
13167 an integer from 2 to 36.  You can specify the radix as a numeric prefix
13168 argument; otherwise you will be prompted for it.
13170 @kindex d z
13171 @pindex calc-leading-zeros
13172 @cindex Leading zeros
13173 Integers normally are displayed with however many digits are necessary to
13174 represent the integer and no more.  The @kbd{d z} (@code{calc-leading-zeros})
13175 command causes integers to be padded out with leading zeros according to the
13176 current binary word size.  (@xref{Binary Functions}, for a discussion of
13177 word size.)  If the absolute value of the word size is @cite{w}, all integers
13178 are displayed with at least enough digits to represent @c{$2^w-1$}
13179 @cite{(2^w)-1} in the
13180 current radix.  (Larger integers will still be displayed in their entirety.)
13182 @node Grouping Digits, Float Formats, Radix Modes, Display Modes
13183 @subsection Grouping Digits
13185 @noindent
13186 @kindex d g
13187 @pindex calc-group-digits
13188 @cindex Grouping digits
13189 @cindex Digit grouping
13190 Long numbers can be hard to read if they have too many digits.  For
13191 example, the factorial of 30 is 33 digits long!  Press @kbd{d g}
13192 (@code{calc-group-digits}) to enable @dfn{grouping} mode, in which digits
13193 are displayed in clumps of 3 or 4 (depending on the current radix)
13194 separated by commas.
13196 The @kbd{d g} command toggles grouping on and off.
13197 With a numerix prefix of 0, this command displays the current state of
13198 the grouping flag; with an argument of minus one it disables grouping;
13199 with a positive argument @cite{N} it enables grouping on every @cite{N}
13200 digits.  For floating-point numbers, grouping normally occurs only
13201 before the decimal point.  A negative prefix argument @cite{-N} enables
13202 grouping every @cite{N} digits both before and after the decimal point.@refill
13204 @kindex d ,
13205 @pindex calc-group-char
13206 The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
13207 character as the grouping separator.  The default is the comma character.
13208 If you find it difficult to read vectors of large integers grouped with
13209 commas, you may wish to use spaces or some other character instead.
13210 This command takes the next character you type, whatever it is, and
13211 uses it as the digit separator.  As a special case, @kbd{d , \} selects
13212 @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
13214 Please note that grouped numbers will not generally be parsed correctly
13215 if re-read in textual form, say by the use of @kbd{M-# y} and @kbd{M-# g}.
13216 (@xref{Kill and Yank}, for details on these commands.)  One exception is
13217 the @samp{\,} separator, which doesn't interfere with parsing because it
13218 is ignored by @TeX{} language mode.
13220 @node Float Formats, Complex Formats, Grouping Digits, Display Modes
13221 @subsection Float Formats
13223 @noindent
13224 Floating-point quantities are normally displayed in standard decimal
13225 form, with scientific notation used if the exponent is especially high
13226 or low.  All significant digits are normally displayed.  The commands
13227 in this section allow you to choose among several alternative display
13228 formats for floats.
13230 @kindex d n
13231 @pindex calc-normal-notation
13232 The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
13233 display format.  All significant figures in a number are displayed.
13234 With a positive numeric prefix, numbers are rounded if necessary to
13235 that number of significant digits.  With a negative numerix prefix,
13236 the specified number of significant digits less than the current
13237 precision is used.  (Thus @kbd{C-u -2 d n} displays 10 digits if the
13238 current precision is 12.)
13240 @kindex d f
13241 @pindex calc-fix-notation
13242 The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
13243 notation.  The numeric argument is the number of digits after the
13244 decimal point, zero or more.  This format will relax into scientific
13245 notation if a nonzero number would otherwise have been rounded all the
13246 way to zero.  Specifying a negative number of digits is the same as
13247 for a positive number, except that small nonzero numbers will be rounded
13248 to zero rather than switching to scientific notation.
13250 @kindex d s
13251 @pindex calc-sci-notation
13252 @cindex Scientific notation, display of
13253 The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
13254 notation.  A positive argument sets the number of significant figures
13255 displayed, of which one will be before and the rest after the decimal
13256 point.  A negative argument works the same as for @kbd{d n} format.
13257 The default is to display all significant digits.
13259 @kindex d e
13260 @pindex calc-eng-notation
13261 @cindex Engineering notation, display of
13262 The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
13263 notation.  This is similar to scientific notation except that the
13264 exponent is rounded down to a multiple of three, with from one to three
13265 digits before the decimal point.  An optional numeric prefix sets the
13266 number of significant digits to display, as for @kbd{d s}.
13268 It is important to distinguish between the current @emph{precision} and
13269 the current @emph{display format}.  After the commands @kbd{C-u 10 p}
13270 and @kbd{C-u 6 d n} the Calculator computes all results to ten
13271 significant figures but displays only six.  (In fact, intermediate
13272 calculations are often carried to one or two more significant figures,
13273 but values placed on the stack will be rounded down to ten figures.)
13274 Numbers are never actually rounded to the display precision for storage,
13275 except by commands like @kbd{C-k} and @kbd{M-# y} which operate on the
13276 actual displayed text in the Calculator buffer.
13278 @kindex d .
13279 @pindex calc-point-char
13280 The @kbd{d .} (@code{calc-point-char}) command selects the character used
13281 as a decimal point.  Normally this is a period; users in some countries
13282 may wish to change this to a comma.  Note that this is only a display
13283 style; on entry, periods must always be used to denote floating-point
13284 numbers, and commas to separate elements in a list.
13286 @node Complex Formats, Fraction Formats, Float Formats, Display Modes
13287 @subsection Complex Formats
13289 @noindent
13290 @kindex d c
13291 @pindex calc-complex-notation
13292 There are three supported notations for complex numbers in rectangular
13293 form.  The default is as a pair of real numbers enclosed in parentheses
13294 and separated by a comma: @samp{(a,b)}.  The @kbd{d c}
13295 (@code{calc-complex-notation}) command selects this style.@refill
13297 @kindex d i
13298 @pindex calc-i-notation
13299 @kindex d j
13300 @pindex calc-j-notation
13301 The other notations are @kbd{d i} (@code{calc-i-notation}), in which
13302 numbers are displayed in @samp{a+bi} form, and @kbd{d j}
13303 (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
13304 in some disciplines.@refill
13306 @cindex @code{i} variable
13307 @vindex i
13308 Complex numbers are normally entered in @samp{(a,b)} format.
13309 If you enter @samp{2+3i} as an algebraic formula, it will be stored as
13310 the formula @samp{2 + 3 * i}.  However, if you use @kbd{=} to evaluate
13311 this formula and you have not changed the variable @samp{i}, the @samp{i}
13312 will be interpreted as @samp{(0,1)} and the formula will be simplified
13313 to @samp{(2,3)}.  Other commands (like @code{calc-sin}) will @emph{not}
13314 interpret the formula @samp{2 + 3 * i} as a complex number.
13315 @xref{Variables}, under ``special constants.''@refill
13317 @node Fraction Formats, HMS Formats, Complex Formats, Display Modes
13318 @subsection Fraction Formats
13320 @noindent
13321 @kindex d o
13322 @pindex calc-over-notation
13323 Display of fractional numbers is controlled by the @kbd{d o}
13324 (@code{calc-over-notation}) command.  By default, a number like
13325 eight thirds is displayed in the form @samp{8:3}.  The @kbd{d o} command
13326 prompts for a one- or two-character format.  If you give one character,
13327 that character is used as the fraction separator.  Common separators are
13328 @samp{:} and @samp{/}.  (During input of numbers, the @kbd{:} key must be
13329 used regardless of the display format; in particular, the @kbd{/} is used
13330 for RPN-style division, @emph{not} for entering fractions.)
13332 If you give two characters, fractions use ``integer-plus-fractional-part''
13333 notation.  For example, the format @samp{+/} would display eight thirds
13334 as @samp{2+2/3}.  If two colons are present in a number being entered,
13335 the number is interpreted in this form (so that the entries @kbd{2:2:3}
13336 and @kbd{8:3} are equivalent).
13338 It is also possible to follow the one- or two-character format with
13339 a number.  For example:  @samp{:10} or @samp{+/3}.  In this case,
13340 Calc adjusts all fractions that are displayed to have the specified
13341 denominator, if possible.  Otherwise it adjusts the denominator to
13342 be a multiple of the specified value.  For example, in @samp{:6} mode
13343 the fraction @cite{1:6} will be unaffected, but @cite{2:3} will be
13344 displayed as @cite{4:6}, @cite{1:2} will be displayed as @cite{3:6},
13345 and @cite{1:8} will be displayed as @cite{3:24}.  Integers are also
13346 affected by this mode:  3 is displayed as @cite{18:6}.  Note that the
13347 format @samp{:1} writes fractions the same as @samp{:}, but it writes
13348 integers as @cite{n:1}.
13350 The fraction format does not affect the way fractions or integers are
13351 stored, only the way they appear on the screen.  The fraction format
13352 never affects floats.
13354 @node HMS Formats, Date Formats, Fraction Formats, Display Modes
13355 @subsection HMS Formats
13357 @noindent
13358 @kindex d h
13359 @pindex calc-hms-notation
13360 The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
13361 HMS (hours-minutes-seconds) forms.  It prompts for a string which
13362 consists basically of an ``hours'' marker, optional punctuation, a
13363 ``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
13364 Punctuation is zero or more spaces, commas, or semicolons.  The hours
13365 marker is one or more non-punctuation characters.  The minutes and
13366 seconds markers must be single non-punctuation characters.
13368 The default HMS format is @samp{@@ ' "}, producing HMS values of the form
13369 @samp{23@@ 30' 15.75"}.  The format @samp{deg, ms} would display this same
13370 value as @samp{23deg, 30m15.75s}.  During numeric entry, the @kbd{h} or @kbd{o}
13371 keys are recognized as synonyms for @kbd{@@} regardless of display format.
13372 The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
13373 @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
13374 already been typed; otherwise, they have their usual meanings
13375 (@kbd{m-} prefix and @kbd{s-} prefix).  Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
13376 @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
13377 The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
13378 @kbd{o}) has already been pressed; otherwise it means to switch to algebraic
13379 entry.
13381 @node Date Formats, Truncating the Stack, HMS Formats, Display Modes
13382 @subsection Date Formats
13384 @noindent
13385 @kindex d d
13386 @pindex calc-date-notation
13387 The @kbd{d d} (@code{calc-date-notation}) command controls the display
13388 of date forms (@pxref{Date Forms}).  It prompts for a string which
13389 contains letters that represent the various parts of a date and time.
13390 To show which parts should be omitted when the form represents a pure
13391 date with no time, parts of the string can be enclosed in @samp{< >}
13392 marks.  If you don't include @samp{< >} markers in the format, Calc
13393 guesses at which parts, if any, should be omitted when formatting
13394 pure dates.
13396 The default format is:  @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
13397 An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
13398 If you enter a blank format string, this default format is
13399 reestablished.
13401 Calc uses @samp{< >} notation for nameless functions as well as for
13402 dates.  @xref{Specifying Operators}.  To avoid confusion with nameless
13403 functions, your date formats should avoid using the @samp{#} character.
13405 @menu
13406 * Date Formatting Codes::
13407 * Free-Form Dates::
13408 * Standard Date Formats::
13409 @end menu
13411 @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
13412 @subsubsection Date Formatting Codes
13414 @noindent
13415 When displaying a date, the current date format is used.  All
13416 characters except for letters and @samp{<} and @samp{>} are
13417 copied literally when dates are formatted.  The portion between
13418 @samp{< >} markers is omitted for pure dates, or included for
13419 date/time forms.  Letters are interpreted according to the table
13420 below.
13422 When dates are read in during algebraic entry, Calc first tries to
13423 match the input string to the current format either with or without
13424 the time part.  The punctuation characters (including spaces) must
13425 match exactly; letter fields must correspond to suitable text in
13426 the input.  If this doesn't work, Calc checks if the input is a
13427 simple number; if so, the number is interpreted as a number of days
13428 since Jan 1, 1 AD.  Otherwise, Calc tries a much more relaxed and
13429 flexible algorithm which is described in the next section.
13431 Weekday names are ignored during reading.
13433 Two-digit year numbers are interpreted as lying in the range
13434 from 1941 to 2039.  Years outside that range are always
13435 entered and displayed in full.  Year numbers with a leading
13436 @samp{+} sign are always interpreted exactly, allowing the
13437 entry and display of the years 1 through 99 AD.
13439 Here is a complete list of the formatting codes for dates:
13441 @table @asis
13442 @item Y
13443 Year:  ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
13444 @item YY
13445 Year:  ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
13446 @item BY
13447 Year:  ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
13448 @item YYY
13449 Year:  ``1991'' for 1991, ``23'' for 23 AD.
13450 @item YYYY
13451 Year:  ``1991'' for 1991, ``+23'' for 23 AD.
13452 @item aa
13453 Year:  ``ad'' or blank.
13454 @item AA
13455 Year:  ``AD'' or blank.
13456 @item aaa
13457 Year:  ``ad '' or blank.  (Note trailing space.)
13458 @item AAA
13459 Year:  ``AD '' or blank.
13460 @item aaaa
13461 Year:  ``a.d.'' or blank.
13462 @item AAAA
13463 Year:  ``A.D.'' or blank.
13464 @item bb
13465 Year:  ``bc'' or blank.
13466 @item BB
13467 Year:  ``BC'' or blank.
13468 @item bbb
13469 Year:  `` bc'' or blank.  (Note leading space.)
13470 @item BBB
13471 Year:  `` BC'' or blank.
13472 @item bbbb
13473 Year:  ``b.c.'' or blank.
13474 @item BBBB
13475 Year:  ``B.C.'' or blank.
13476 @item M
13477 Month:  ``8'' for August.
13478 @item MM
13479 Month:  ``08'' for August.
13480 @item BM
13481 Month:  `` 8'' for August.
13482 @item MMM
13483 Month:  ``AUG'' for August.
13484 @item Mmm
13485 Month:  ``Aug'' for August.
13486 @item mmm
13487 Month:  ``aug'' for August.
13488 @item MMMM
13489 Month:  ``AUGUST'' for August.
13490 @item Mmmm
13491 Month:  ``August'' for August.
13492 @item D
13493 Day:  ``7'' for 7th day of month.
13494 @item DD
13495 Day:  ``07'' for 7th day of month.
13496 @item BD
13497 Day:  `` 7'' for 7th day of month.
13498 @item W
13499 Weekday:  ``0'' for Sunday, ``6'' for Saturday.
13500 @item WWW
13501 Weekday:  ``SUN'' for Sunday.
13502 @item Www
13503 Weekday:  ``Sun'' for Sunday.
13504 @item www
13505 Weekday:  ``sun'' for Sunday.
13506 @item WWWW
13507 Weekday:  ``SUNDAY'' for Sunday.
13508 @item Wwww
13509 Weekday:  ``Sunday'' for Sunday.
13510 @item d
13511 Day of year:  ``34'' for Feb. 3.
13512 @item ddd
13513 Day of year:  ``034'' for Feb. 3.
13514 @item bdd
13515 Day of year:  `` 34'' for Feb. 3.
13516 @item h
13517 Hour:  ``5'' for 5 AM; ``17'' for 5 PM.
13518 @item hh
13519 Hour:  ``05'' for 5 AM; ``17'' for 5 PM.
13520 @item bh
13521 Hour:  `` 5'' for 5 AM; ``17'' for 5 PM.
13522 @item H
13523 Hour:  ``5'' for 5 AM and 5 PM.
13524 @item HH
13525 Hour:  ``05'' for 5 AM and 5 PM.
13526 @item BH
13527 Hour:  `` 5'' for 5 AM and 5 PM.
13528 @item p
13529 AM/PM:  ``a'' or ``p''.
13530 @item P
13531 AM/PM:  ``A'' or ``P''.
13532 @item pp
13533 AM/PM:  ``am'' or ``pm''.
13534 @item PP
13535 AM/PM:  ``AM'' or ``PM''.
13536 @item pppp
13537 AM/PM:  ``a.m.'' or ``p.m.''.
13538 @item PPPP
13539 AM/PM:  ``A.M.'' or ``P.M.''.
13540 @item m
13541 Minutes:  ``7'' for 7.
13542 @item mm
13543 Minutes:  ``07'' for 7.
13544 @item bm
13545 Minutes:  `` 7'' for 7.
13546 @item s
13547 Seconds:  ``7'' for 7;  ``7.23'' for 7.23.
13548 @item ss
13549 Seconds:  ``07'' for 7;  ``07.23'' for 7.23.
13550 @item bs
13551 Seconds:  `` 7'' for 7;  `` 7.23'' for 7.23.
13552 @item SS
13553 Optional seconds:  ``07'' for 7;  blank for 0.
13554 @item BS
13555 Optional seconds:  `` 7'' for 7;  blank for 0.
13556 @item N
13557 Numeric date/time:  ``726842.25'' for 6:00am Wed Jan 9, 1991.
13558 @item n
13559 Numeric date:  ``726842'' for any time on Wed Jan 9, 1991.
13560 @item J
13561 Julian date/time:  ``2448265.75'' for 6:00am Wed Jan 9, 1991.
13562 @item j
13563 Julian date:  ``2448266'' for any time on Wed Jan 9, 1991.
13564 @item U
13565 Unix time:  ``663400800'' for 6:00am Wed Jan 9, 1991.
13566 @item X
13567 Brackets suppression.  An ``X'' at the front of the format
13568 causes the surrounding @w{@samp{< >}} delimiters to be omitted
13569 when formatting dates.  Note that the brackets are still
13570 required for algebraic entry.
13571 @end table
13573 If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
13574 colon is also omitted if the seconds part is zero.
13576 If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
13577 appear in the format, then negative year numbers are displayed
13578 without a minus sign.  Note that ``aa'' and ``bb'' are mutually
13579 exclusive.  Some typical usages would be @samp{YYYY AABB};
13580 @samp{AAAYYYYBBB}; @samp{YYYYBBB}.
13582 The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
13583 ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
13584 reading unless several of these codes are strung together with no
13585 punctuation in between, in which case the input must have exactly as
13586 many digits as there are letters in the format.
13588 The ``j,'' ``J,'' and ``U'' formats do not make any time zone
13589 adjustment.  They effectively use @samp{julian(x,0)} and
13590 @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
13592 @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
13593 @subsubsection Free-Form Dates
13595 @noindent
13596 When reading a date form during algebraic entry, Calc falls back
13597 on the algorithm described here if the input does not exactly
13598 match the current date format.  This algorithm generally
13599 ``does the right thing'' and you don't have to worry about it,
13600 but it is described here in full detail for the curious.
13602 Calc does not distinguish between upper- and lower-case letters
13603 while interpreting dates.
13605 First, the time portion, if present, is located somewhere in the
13606 text and then removed.  The remaining text is then interpreted as
13607 the date.
13609 A time is of the form @samp{hh:mm:ss}, possibly with the seconds
13610 part omitted and possibly with an AM/PM indicator added to indicate
13611 12-hour time.  If the AM/PM is present, the minutes may also be
13612 omitted.  The AM/PM part may be any of the words @samp{am},
13613 @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
13614 abbreviated to one letter, and the alternate forms @samp{a.m.},
13615 @samp{p.m.}, and @samp{mid} are also understood.  Obviously
13616 @samp{noon} and @samp{midnight} are allowed only on 12:00:00.
13617 The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
13618 recognized with no number attached.
13620 If there is no AM/PM indicator, the time is interpreted in 24-hour
13621 format.
13623 To read the date portion, all words and numbers are isolated
13624 from the string; other characters are ignored.  All words must
13625 be either month names or day-of-week names (the latter of which
13626 are ignored).  Names can be written in full or as three-letter
13627 abbreviations.
13629 Large numbers, or numbers with @samp{+} or @samp{-} signs,
13630 are interpreted as years.  If one of the other numbers is
13631 greater than 12, then that must be the day and the remaining
13632 number in the input is therefore the month.  Otherwise, Calc
13633 assumes the month, day and year are in the same order that they
13634 appear in the current date format.  If the year is omitted, the
13635 current year is taken from the system clock.
13637 If there are too many or too few numbers, or any unrecognizable
13638 words, then the input is rejected.
13640 If there are any large numbers (of five digits or more) other than
13641 the year, they are ignored on the assumption that they are something
13642 like Julian dates that were included along with the traditional
13643 date components when the date was formatted.
13645 One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
13646 may optionally be used; the latter two are equivalent to a
13647 minus sign on the year value.
13649 If you always enter a four-digit year, and use a name instead
13650 of a number for the month, there is no danger of ambiguity.
13652 @node Standard Date Formats, , Free-Form Dates, Date Formats
13653 @subsubsection Standard Date Formats
13655 @noindent
13656 There are actually ten standard date formats, numbered 0 through 9.
13657 Entering a blank line at the @kbd{d d} command's prompt gives
13658 you format number 1, Calc's usual format.  You can enter any digit
13659 to select the other formats.
13661 To create your own standard date formats, give a numeric prefix
13662 argument from 0 to 9 to the @w{@kbd{d d}} command.  The format you
13663 enter will be recorded as the new standard format of that
13664 number, as well as becoming the new current date format.
13665 You can save your formats permanently with the @w{@kbd{m m}}
13666 command (@pxref{Mode Settings}).
13668 @table @asis
13669 @item 0
13670 @samp{N}  (Numerical format)
13671 @item 1
13672 @samp{<H:mm:SSpp >Www Mmm D, YYYY}  (American format)
13673 @item 2
13674 @samp{D Mmm YYYY<, h:mm:SS>}  (European format)
13675 @item 3
13676 @samp{Www Mmm BD< hh:mm:ss> YYYY}  (Unix written date format)
13677 @item 4
13678 @samp{M/D/Y< H:mm:SSpp>}  (American slashed format)
13679 @item 5
13680 @samp{D.M.Y< h:mm:SS>}  (European dotted format)
13681 @item 6
13682 @samp{M-D-Y< H:mm:SSpp>}  (American dashed format)
13683 @item 7
13684 @samp{D-M-Y< h:mm:SS>}  (European dashed format)
13685 @item 8
13686 @samp{j<, h:mm:ss>}  (Julian day plus time)
13687 @item 9
13688 @samp{YYddd< hh:mm:ss>}  (Year-day format)
13689 @end table
13691 @node Truncating the Stack, Justification, Date Formats, Display Modes
13692 @subsection Truncating the Stack
13694 @noindent
13695 @kindex d t
13696 @pindex calc-truncate-stack
13697 @cindex Truncating the stack
13698 @cindex Narrowing the stack
13699 The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
13700 line that marks the top-of-stack up or down in the Calculator buffer.
13701 The number right above that line is considered to the be at the top of
13702 the stack.  Any numbers below that line are ``hidden'' from all stack
13703 operations.  This is similar to the Emacs ``narrowing'' feature, except
13704 that the values below the @samp{.} are @emph{visible}, just temporarily
13705 frozen.  This feature allows you to keep several independent calculations
13706 running at once in different parts of the stack, or to apply a certain
13707 command to an element buried deep in the stack.@refill
13709 Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
13710 is on.  Thus, this line and all those below it become hidden.  To un-hide
13711 these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
13712 With a positive numeric prefix argument @cite{n}, @kbd{d t} hides the
13713 bottom @cite{n} values in the buffer.  With a negative argument, it hides
13714 all but the top @cite{n} values.  With an argument of zero, it hides zero
13715 values, i.e., moves the @samp{.} all the way down to the bottom.@refill
13717 @kindex d [
13718 @pindex calc-truncate-up
13719 @kindex d ]
13720 @pindex calc-truncate-down
13721 The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
13722 (@code{calc-truncate-down}) commands move the @samp{.} up or down one
13723 line at a time (or several lines with a prefix argument).@refill
13725 @node Justification, Labels, Truncating the Stack, Display Modes
13726 @subsection Justification
13728 @noindent
13729 @kindex d <
13730 @pindex calc-left-justify
13731 @kindex d =
13732 @pindex calc-center-justify
13733 @kindex d >
13734 @pindex calc-right-justify
13735 Values on the stack are normally left-justified in the window.  You can
13736 control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
13737 @kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
13738 (@code{calc-center-justify}).  For example, in right-justification mode,
13739 stack entries are displayed flush-right against the right edge of the
13740 window.@refill
13742 If you change the width of the Calculator window you may have to type
13743 @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
13744 text.
13746 Right-justification is especially useful together with fixed-point
13747 notation (see @code{d f}; @code{calc-fix-notation}).  With these modes
13748 together, the decimal points on numbers will always line up.
13750 With a numeric prefix argument, the justification commands give you
13751 a little extra control over the display.  The argument specifies the
13752 horizontal ``origin'' of a display line.  It is also possible to
13753 specify a maximum line width using the @kbd{d b} command (@pxref{Normal
13754 Language Modes}).  For reference, the precise rules for formatting and
13755 breaking lines are given below.  Notice that the interaction between
13756 origin and line width is slightly different in each justification
13757 mode.
13759 In left-justified mode, the line is indented by a number of spaces
13760 given by the origin (default zero).  If the result is longer than the
13761 maximum line width, if given, or too wide to fit in the Calc window
13762 otherwise, then it is broken into lines which will fit; each broken
13763 line is indented to the origin.
13765 In right-justified mode, lines are shifted right so that the rightmost
13766 character is just before the origin, or just before the current
13767 window width if no origin was specified.  If the line is too long
13768 for this, then it is broken; the current line width is used, if
13769 specified, or else the origin is used as a width if that is
13770 specified, or else the line is broken to fit in the window.
13772 In centering mode, the origin is the column number of the center of
13773 each stack entry.  If a line width is specified, lines will not be
13774 allowed to go past that width; Calc will either indent less or
13775 break the lines if necessary.  If no origin is specified, half the
13776 line width or Calc window width is used.
13778 Note that, in each case, if line numbering is enabled the display
13779 is indented an additional four spaces to make room for the line
13780 number.  The width of the line number is taken into account when
13781 positioning according to the current Calc window width, but not
13782 when positioning by explicit origins and widths.  In the latter
13783 case, the display is formatted as specified, and then uniformly
13784 shifted over four spaces to fit the line numbers.
13786 @node Labels, , Justification, Display Modes
13787 @subsection Labels
13789 @noindent
13790 @kindex d @{
13791 @pindex calc-left-label
13792 The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
13793 then displays that string to the left of every stack entry.  If the
13794 entries are left-justified (@pxref{Justification}), then they will
13795 appear immediately after the label (unless you specified an origin
13796 greater than the length of the label).  If the entries are centered
13797 or right-justified, the label appears on the far left and does not
13798 affect the horizontal position of the stack entry.
13800 Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
13802 @kindex d @}
13803 @pindex calc-right-label
13804 The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
13805 label on the righthand side.  It does not affect positioning of
13806 the stack entries unless they are right-justified.  Also, if both
13807 a line width and an origin are given in right-justified mode, the
13808 stack entry is justified to the origin and the righthand label is
13809 justified to the line width.
13811 One application of labels would be to add equation numbers to
13812 formulas you are manipulating in Calc and then copying into a
13813 document (possibly using Embedded Mode).  The equations would
13814 typically be centered, and the equation numbers would be on the
13815 left or right as you prefer.
13817 @node Language Modes, Modes Variable, Display Modes, Mode Settings
13818 @section Language Modes
13820 @noindent
13821 The commands in this section change Calc to use a different notation for
13822 entry and display of formulas, corresponding to the conventions of some
13823 other common language such as Pascal or @TeX{}.  Objects displayed on the
13824 stack or yanked from the Calculator to an editing buffer will be formatted
13825 in the current language; objects entered in algebraic entry or yanked from
13826 another buffer will be interpreted according to the current language.
13828 The current language has no effect on things written to or read from the
13829 trail buffer, nor does it affect numeric entry.  Only algebraic entry is
13830 affected.  You can make even algebraic entry ignore the current language
13831 and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
13833 For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
13834 program; elsewhere in the program you need the derivatives of this formula
13835 with respect to @samp{a[1]} and @samp{a[2]}.  First, type @kbd{d C}
13836 to switch to C notation.  Now use @code{C-u M-# g} to grab the formula
13837 into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
13838 to the first variable, and @kbd{M-# y} to yank the formula for the derivative
13839 back into your C program.  Press @kbd{U} to undo the differentiation and
13840 repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
13842 Without being switched into C mode first, Calc would have misinterpreted
13843 the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
13844 @code{atan} was equivalent to Calc's built-in @code{arctan} function,
13845 and would have written the formula back with notations (like implicit
13846 multiplication) which would not have been legal for a C program.
13848 As another example, suppose you are maintaining a C program and a @TeX{}
13849 document, each of which needs a copy of the same formula.  You can grab the
13850 formula from the program in C mode, switch to @TeX{} mode, and yank the
13851 formula into the document in @TeX{} math-mode format.
13853 Language modes are selected by typing the letter @kbd{d} followed by a
13854 shifted letter key.
13856 @menu
13857 * Normal Language Modes::
13858 * C FORTRAN Pascal::
13859 * TeX Language Mode::
13860 * Eqn Language Mode::
13861 * Mathematica Language Mode::
13862 * Maple Language Mode::
13863 * Compositions::
13864 * Syntax Tables::
13865 @end menu
13867 @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
13868 @subsection Normal Language Modes
13870 @noindent
13871 @kindex d N
13872 @pindex calc-normal-language
13873 The @kbd{d N} (@code{calc-normal-language}) command selects the usual
13874 notation for Calc formulas, as described in the rest of this manual.
13875 Matrices are displayed in a multi-line tabular format, but all other
13876 objects are written in linear form, as they would be typed from the
13877 keyboard.
13879 @kindex d O
13880 @pindex calc-flat-language
13881 @cindex Matrix display
13882 The @kbd{d O} (@code{calc-flat-language}) command selects a language
13883 identical with the normal one, except that matrices are written in
13884 one-line form along with everything else.  In some applications this
13885 form may be more suitable for yanking data into other buffers.
13887 @kindex d b
13888 @pindex calc-line-breaking
13889 @cindex Line breaking
13890 @cindex Breaking up long lines
13891 Even in one-line mode, long formulas or vectors will still be split
13892 across multiple lines if they exceed the width of the Calculator window.
13893 The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
13894 feature on and off.  (It works independently of the current language.)
13895 If you give a numeric prefix argument of five or greater to the @kbd{d b}
13896 command, that argument will specify the line width used when breaking
13897 long lines.
13899 @kindex d B
13900 @pindex calc-big-language
13901 The @kbd{d B} (@code{calc-big-language}) command selects a language
13902 which uses textual approximations to various mathematical notations,
13903 such as powers, quotients, and square roots:
13905 @example
13906   ____________
13907  | a + 1    2
13908  | ----- + c
13909 \|   b
13910 @end example
13912 @noindent
13913 in place of @samp{sqrt((a+1)/b + c^2)}.
13915 Subscripts like @samp{a_i} are displayed as actual subscripts in ``big''
13916 mode.  Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
13917 are displayed as @samp{a} with subscripts separated by commas:
13918 @samp{i, j}.  They must still be entered in the usual underscore
13919 notation.
13921 One slight ambiguity of Big notation is that
13923 @example
13924   3
13925 - -
13926   4
13927 @end example
13929 @noindent
13930 can represent either the negative rational number @cite{-3:4}, or the
13931 actual expression @samp{-(3/4)}; but the latter formula would normally
13932 never be displayed because it would immediately be evaluated to
13933 @cite{-3:4} or @cite{-0.75}, so this ambiguity is not a problem in
13934 typical use.
13936 Non-decimal numbers are displayed with subscripts.  Thus there is no
13937 way to tell the difference between @samp{16#C2} and @samp{C2_16},
13938 though generally you will know which interpretation is correct.
13939 Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
13940 in Big mode.
13942 In Big mode, stack entries often take up several lines.  To aid
13943 readability, stack entries are separated by a blank line in this mode.
13944 You may find it useful to expand the Calc window's height using
13945 @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
13946 one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
13948 Long lines are currently not rearranged to fit the window width in
13949 Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
13950 to scroll across a wide formula.  For really big formulas, you may
13951 even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
13953 @kindex d U
13954 @pindex calc-unformatted-language
13955 The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
13956 the use of operator notation in formulas.  In this mode, the formula
13957 shown above would be displayed:
13959 @example
13960 sqrt(add(div(add(a, 1), b), pow(c, 2)))
13961 @end example
13963 These four modes differ only in display format, not in the format
13964 expected for algebraic entry.  The standard Calc operators work in
13965 all four modes, and unformatted notation works in any language mode
13966 (except that Mathematica mode expects square brackets instead of
13967 parentheses).
13969 @node C FORTRAN Pascal, TeX Language Mode, Normal Language Modes, Language Modes
13970 @subsection C, FORTRAN, and Pascal Modes
13972 @noindent
13973 @kindex d C
13974 @pindex calc-c-language
13975 @cindex C language
13976 The @kbd{d C} (@code{calc-c-language}) command selects the conventions
13977 of the C language for display and entry of formulas.  This differs from
13978 the normal language mode in a variety of (mostly minor) ways.  In
13979 particular, C language operators and operator precedences are used in
13980 place of Calc's usual ones.  For example, @samp{a^b} means @samp{xor(a,b)}
13981 in C mode; a value raised to a power is written as a function call,
13982 @samp{pow(a,b)}.
13984 In C mode, vectors and matrices use curly braces instead of brackets.
13985 Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
13986 rather than using the @samp{#} symbol.  Array subscripting is
13987 translated into @code{subscr} calls, so that @samp{a[i]} in C
13988 mode is the same as @samp{a_i} in normal mode.  Assignments
13989 turn into the @code{assign} function, which Calc normally displays
13990 using the @samp{:=} symbol.
13992 The variables @code{var-pi} and @code{var-e} would be displayed @samp{pi}
13993 and @samp{e} in normal mode, but in C mode they are displayed as
13994 @samp{M_PI} and @samp{M_E}, corresponding to the names of constants
13995 typically provided in the @file{<math.h>} header.  Functions whose
13996 names are different in C are translated automatically for entry and
13997 display purposes.  For example, entering @samp{asin(x)} will push the
13998 formula @samp{arcsin(x)} onto the stack; this formula will be displayed
13999 as @samp{asin(x)} as long as C mode is in effect.
14001 @kindex d P
14002 @pindex calc-pascal-language
14003 @cindex Pascal language
14004 The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
14005 conventions.  Like C mode, Pascal mode interprets array brackets and uses
14006 a different table of operators.  Hexadecimal numbers are entered and
14007 displayed with a preceding dollar sign.  (Thus the regular meaning of
14008 @kbd{$2} during algebraic entry does not work in Pascal mode, though
14009 @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
14010 always.)  No special provisions are made for other non-decimal numbers,
14011 vectors, and so on, since there is no universally accepted standard way
14012 of handling these in Pascal.
14014 @kindex d F
14015 @pindex calc-fortran-language
14016 @cindex FORTRAN language
14017 The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
14018 conventions.  Various function names are transformed into FORTRAN
14019 equivalents.  Vectors are written as @samp{/1, 2, 3/}, and may be
14020 entered this way or using square brackets.  Since FORTRAN uses round
14021 parentheses for both function calls and array subscripts, Calc displays
14022 both in the same way; @samp{a(i)} is interpreted as a function call
14023 upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
14024 Also, if the variable @code{a} has been declared to have type
14025 @code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
14026 subscript.  (@xref{Declarations}.)  Usually it doesn't matter, though;
14027 if you enter the subscript expression @samp{a(i)} and Calc interprets
14028 it as a function call, you'll never know the difference unless you
14029 switch to another language mode or replace @code{a} with an actual
14030 vector (or unless @code{a} happens to be the name of a built-in
14031 function!).
14033 Underscores are allowed in variable and function names in all of these
14034 language modes.  The underscore here is equivalent to the @samp{#} in
14035 normal mode, or to hyphens in the underlying Emacs Lisp variable names.
14037 FORTRAN and Pascal modes normally do not adjust the case of letters in
14038 formulas.  Most built-in Calc names use lower-case letters.  If you use a
14039 positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
14040 modes will use upper-case letters exclusively for display, and will
14041 convert to lower-case on input.  With a negative prefix, these modes
14042 convert to lower-case for display and input.
14044 @node TeX Language Mode, Eqn Language Mode, C FORTRAN Pascal, Language Modes
14045 @subsection @TeX{} Language Mode
14047 @noindent
14048 @kindex d T
14049 @pindex calc-tex-language
14050 @cindex TeX language
14051 The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
14052 of ``math mode'' in the @TeX{} typesetting language, by Donald Knuth.
14053 Formulas are entered
14054 and displayed in @TeX{} notation, as in @samp{\sin\left( a \over b \right)}.
14055 Math formulas are usually enclosed by @samp{$ $} signs in @TeX{}; these
14056 should be omitted when interfacing with Calc.  To Calc, the @samp{$} sign
14057 has the same meaning it always does in algebraic formulas (a reference to
14058 an existing entry on the stack).@refill
14060 Complex numbers are displayed as in @samp{3 + 4i}.  Fractions and
14061 quotients are written using @code{\over};
14062 binomial coefficients are written with @code{\choose}.
14063 Interval forms are written with @code{\ldots}, and
14064 error forms are written with @code{\pm}.
14065 Absolute values are written as in @samp{|x + 1|}, and the floor and
14066 ceiling functions are written with @code{\lfloor}, @code{\rfloor}, etc.
14067 The words @code{\left} and @code{\right} are ignored when reading
14068 formulas in @TeX{} mode.  Both @code{inf} and @code{uinf} are written
14069 as @code{\infty}; when read, @code{\infty} always translates to
14070 @code{inf}.@refill
14072 Function calls are written the usual way, with the function name followed
14073 by the arguments in parentheses.  However, functions for which @TeX{} has
14074 special names (like @code{\sin}) will use curly braces instead of
14075 parentheses for very simple arguments.  During input, curly braces and
14076 parentheses work equally well for grouping, but when the document is
14077 formatted the curly braces will be invisible.  Thus the printed result is
14078 @c{$\sin{2 x}$}
14079 @cite{sin 2x} but @c{$\sin(2 + x)$}
14080 @cite{sin(2 + x)}.
14082 Function and variable names not treated specially by @TeX{} are simply
14083 written out as-is, which will cause them to come out in italic letters
14084 in the printed document.  If you invoke @kbd{d T} with a positive numeric
14085 prefix argument, names of more than one character will instead be written
14086 @samp{\hbox@{@var{name}@}}.  The @samp{\hbox@{ @}} notation is ignored
14087 during reading.  If you use a negative prefix argument, such function
14088 names are written @samp{\@var{name}}, and function names that begin
14089 with @code{\} during reading have the @code{\} removed.  (Note that
14090 in this mode, long variable names are still written with @code{\hbox}.
14091 However, you can always make an actual variable name like @code{\bar}
14092 in any @TeX{} mode.)
14094 During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
14095 by @samp{[ ...@: ]}.  The same also applies to @code{\pmatrix} and
14096 @code{\bmatrix}.  The symbol @samp{&} is interpreted as a comma,
14097 and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
14098 During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
14099 format; you may need to edit this afterwards to change @code{\matrix}
14100 to @code{\pmatrix} or @code{\\} to @code{\cr}.
14102 Accents like @code{\tilde} and @code{\bar} translate into function
14103 calls internally (@samp{tilde(x)}, @samp{bar(x)}).  The @code{\underline}
14104 sequence is treated as an accent.  The @code{\vec} accent corresponds
14105 to the function name @code{Vec}, because @code{vec} is the name of
14106 a built-in Calc function.  The following table shows the accents
14107 in Calc, @TeX{}, and @dfn{eqn} (described in the next section):
14109 @iftex
14110 @begingroup
14111 @let@calcindexershow=@calcindexernoshow  @c Suppress marginal notes
14112 @let@calcindexersh=@calcindexernoshow
14113 @end iftex
14114 @ignore
14115 @starindex
14116 @end ignore
14117 @tindex acute
14118 @ignore
14119 @starindex
14120 @end ignore
14121 @tindex bar
14122 @ignore
14123 @starindex
14124 @end ignore
14125 @tindex breve
14126 @ignore
14127 @starindex
14128 @end ignore
14129 @tindex check
14130 @ignore
14131 @starindex
14132 @end ignore
14133 @tindex dot
14134 @ignore
14135 @starindex
14136 @end ignore
14137 @tindex dotdot
14138 @ignore
14139 @starindex
14140 @end ignore
14141 @tindex dyad
14142 @ignore
14143 @starindex
14144 @end ignore
14145 @tindex grave
14146 @ignore
14147 @starindex
14148 @end ignore
14149 @tindex hat
14150 @ignore
14151 @starindex
14152 @end ignore
14153 @tindex Prime
14154 @ignore
14155 @starindex
14156 @end ignore
14157 @tindex tilde
14158 @ignore
14159 @starindex
14160 @end ignore
14161 @tindex under
14162 @ignore
14163 @starindex
14164 @end ignore
14165 @tindex Vec
14166 @iftex
14167 @endgroup
14168 @end iftex
14169 @example
14170 Calc      TeX           eqn
14171 ----      ---           ---
14172 acute     \acute
14173 bar       \bar          bar
14174 breve     \breve
14175 check     \check
14176 dot       \dot          dot
14177 dotdot    \ddot         dotdot
14178 dyad                    dyad
14179 grave     \grave
14180 hat       \hat          hat
14181 Prime                   prime
14182 tilde     \tilde        tilde
14183 under     \underline    under
14184 Vec       \vec          vec
14185 @end example
14187 The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
14188 @samp{@{@var{a} \to @var{b}@}}.  @TeX{} defines @code{\to} as an
14189 alias for @code{\rightarrow}.  However, if the @samp{=>} is the
14190 top-level expression being formatted, a slightly different notation
14191 is used:  @samp{\evalto @var{a} \to @var{b}}.  The @code{\evalto}
14192 word is ignored by Calc's input routines, and is undefined in @TeX{}.
14193 You will typically want to include one of the following definitions
14194 at the top of a @TeX{} file that uses @code{\evalto}:
14196 @example
14197 \def\evalto@{@}
14198 \def\evalto#1\to@{@}
14199 @end example
14201 The first definition formats evaluates-to operators in the usual
14202 way.  The second causes only the @var{b} part to appear in the
14203 printed document; the @var{a} part and the arrow are hidden.
14204 Another definition you may wish to use is @samp{\let\to=\Rightarrow}
14205 which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
14206 @xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
14208 The complete set of @TeX{} control sequences that are ignored during
14209 reading is:
14211 @example
14212 \hbox  \mbox  \text  \left  \right
14213 \,  \>  \:  \;  \!  \quad  \qquad  \hfil  \hfill
14214 \displaystyle  \textstyle  \dsize  \tsize
14215 \scriptstyle  \scriptscriptstyle  \ssize  \ssize
14216 \rm  \bf  \it  \sl  \roman  \bold  \italic  \slanted
14217 \cal  \mit  \Cal  \Bbb  \frak  \goth
14218 \evalto
14219 @end example
14221 Note that, because these symbols are ignored, reading a @TeX{} formula
14222 into Calc and writing it back out may lose spacing and font information.
14224 Also, the ``discretionary multiplication sign'' @samp{\*} is read
14225 the same as @samp{*}.
14227 @ifinfo
14228 The @TeX{} version of this manual includes some printed examples at the
14229 end of this section.
14230 @end ifinfo
14231 @iftex
14232 Here are some examples of how various Calc formulas are formatted in @TeX{}:
14234 @example
14235 @group
14236 sin(a^2 / b_i)
14237 \sin\left( {a^2 \over b_i} \right)
14238 @end group
14239 @end example
14240 @tex
14241 \let\rm\goodrm
14242 $$ \sin\left( a^2 \over b_i \right) $$
14243 @end tex
14244 @sp 1
14246 @example
14247 @group
14248 [(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
14249 [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
14250 @end group
14251 @end example
14252 @tex
14253 \turnoffactive
14254 $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
14255 @end tex
14256 @sp 1
14258 @example
14259 @group
14260 [abs(a), abs(a / b), floor(a), ceil(a / b)]
14261 [|a|, \left| a \over b \right|,
14262  \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
14263 @end group
14264 @end example
14265 @tex
14266 $$ [|a|, \left| a \over b \right|,
14267     \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
14268 @end tex
14269 @sp 1
14271 @example
14272 @group
14273 [sin(a), sin(2 a), sin(2 + a), sin(a / b)]
14274 [\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
14275  \sin\left( @{a \over b@} \right)]
14276 @end group
14277 @end example
14278 @tex
14279 \turnoffactive\let\rm\goodrm
14280 $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
14281 @end tex
14282 @sp 2
14284 First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
14285 @kbd{C-u - d T} (using the example definition
14286 @samp{\def\foo#1@{\tilde F(#1)@}}:
14288 @example
14289 @group
14290 [f(a), foo(bar), sin(pi)]
14291 [f(a), foo(bar), \sin{\pi}]
14292 [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
14293 [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
14294 @end group
14295 @end example
14296 @tex
14297 \let\rm\goodrm
14298 $$ [f(a), foo(bar), \sin{\pi}] $$
14299 $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
14300 $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
14301 @end tex
14302 @sp 2
14304 First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
14306 @example
14307 @group
14308 2 + 3 => 5
14309 \evalto 2 + 3 \to 5
14310 @end group
14311 @end example
14312 @tex
14313 \turnoffactive
14314 $$ 2 + 3 \to 5 $$
14315 $$ 5 $$
14316 @end tex
14317 @sp 2
14319 First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
14321 @example
14322 @group
14323 [2 + 3 => 5, a / 2 => (b + c) / 2]
14324 [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
14325 @end group
14326 @end example
14327 @tex
14328 \turnoffactive
14329 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
14330 {\let\to\Rightarrow
14331 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
14332 @end tex
14333 @sp 2
14335 Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
14337 @example
14338 @group
14339 [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
14340 \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14341 \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14342 @end group
14343 @end example
14344 @tex
14345 \turnoffactive
14346 $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14347 $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14348 @end tex
14349 @sp 2
14350 @end iftex
14352 @node Eqn Language Mode, Mathematica Language Mode, TeX Language Mode, Language Modes
14353 @subsection Eqn Language Mode
14355 @noindent
14356 @kindex d E
14357 @pindex calc-eqn-language
14358 @dfn{Eqn} is another popular formatter for math formulas.  It is
14359 designed for use with the TROFF text formatter, and comes standard
14360 with many versions of Unix.  The @kbd{d E} (@code{calc-eqn-language})
14361 command selects @dfn{eqn} notation.
14363 The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
14364 a significant part in the parsing of the language.  For example,
14365 @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
14366 @code{sqrt} operator.  @dfn{Eqn} also understands more conventional
14367 grouping using curly braces:  @samp{sqrt@{x+1@} + y}.  Braces are
14368 required only when the argument contains spaces.
14370 In Calc's @dfn{eqn} mode, however, curly braces are required to
14371 delimit arguments of operators like @code{sqrt}.  The first of the
14372 above examples would treat only the @samp{x} as the argument of
14373 @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
14374 @samp{sin * x + 1}, because @code{sin} is not a special operator
14375 in the @dfn{eqn} language.  If you always surround the argument
14376 with curly braces, Calc will never misunderstand.
14378 Calc also understands parentheses as grouping characters.  Another
14379 peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
14380 words with spaces from any surrounding characters that aren't curly
14381 braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
14382 (The spaces around @code{sin} are important to make @dfn{eqn}
14383 recognize that @code{sin} should be typeset in a roman font, and
14384 the spaces around @code{x} and @code{y} are a good idea just in
14385 case the @dfn{eqn} document has defined special meanings for these
14386 names, too.)
14388 Powers and subscripts are written with the @code{sub} and @code{sup}
14389 operators, respectively.  Note that the caret symbol @samp{^} is
14390 treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
14391 symbol (these are used to introduce spaces of various widths into
14392 the typeset output of @dfn{eqn}).
14394 As in @TeX{} mode, Calc's formatter omits parentheses around the
14395 arguments of functions like @code{ln} and @code{sin} if they are
14396 ``simple-looking''; in this case Calc surrounds the argument with
14397 braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
14399 Font change codes (like @samp{roman @var{x}}) and positioning codes
14400 (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
14401 @dfn{eqn} reader.  Also ignored are the words @code{left}, @code{right},
14402 @code{mark}, and @code{lineup}.  Quotation marks in @dfn{eqn} mode input
14403 are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
14404 @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
14405 of quotes in @dfn{eqn}, but it is good enough for most uses.
14407 Accent codes (@samp{@var{x} dot}) are handled by treating them as
14408 function calls (@samp{dot(@var{x})}) internally.  @xref{TeX Language
14409 Mode}, for a table of these accent functions.  The @code{prime} accent
14410 is treated specially if it occurs on a variable or function name:
14411 @samp{f prime prime @w{( x prime )}} is stored internally as
14412 @samp{f'@w{'}(x')}.  For example, taking the derivative of @samp{f(2 x)}
14413 with @kbd{a d x} will produce @samp{2 f'(2 x)}, which @dfn{eqn} mode
14414 will display as @samp{2 f prime ( 2 x )}.
14416 Assignments are written with the @samp{<-} (left-arrow) symbol,
14417 and @code{evalto} operators are written with @samp{->} or
14418 @samp{evalto ... ->} (@pxref{TeX Language Mode}, for a discussion
14419 of this).  The regular Calc symbols @samp{:=} and @samp{=>} are also
14420 recognized for these operators during reading.
14422 Vectors in @dfn{eqn} mode use regular Calc square brackets, but
14423 matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
14424 The words @code{lcol} and @code{rcol} are recognized as synonyms
14425 for @code{ccol} during input, and are generated instead of @code{ccol}
14426 if the matrix justification mode so specifies.
14428 @node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
14429 @subsection Mathematica Language Mode
14431 @noindent
14432 @kindex d M
14433 @pindex calc-mathematica-language
14434 @cindex Mathematica language
14435 The @kbd{d M} (@code{calc-mathematica-language}) command selects the
14436 conventions of Mathematica, a powerful and popular mathematical tool
14437 from Wolfram Research, Inc.  Notable differences in Mathematica mode
14438 are that the names of built-in functions are capitalized, and function
14439 calls use square brackets instead of parentheses.  Thus the Calc
14440 formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
14441 Mathematica mode.
14443 Vectors and matrices use curly braces in Mathematica.  Complex numbers
14444 are written @samp{3 + 4 I}.  The standard special constants in Calc are
14445 written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
14446 @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
14447 Mathematica mode.
14448 Non-decimal numbers are written, e.g., @samp{16^^7fff}.  Floating-point
14449 numbers in scientific notation are written @samp{1.23*10.^3}.
14450 Subscripts use double square brackets: @samp{a[[i]]}.@refill
14452 @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
14453 @subsection Maple Language Mode
14455 @noindent
14456 @kindex d W
14457 @pindex calc-maple-language
14458 @cindex Maple language
14459 The @kbd{d W} (@code{calc-maple-language}) command selects the
14460 conventions of Maple, another mathematical tool from the University
14461 of Waterloo.
14463 Maple's language is much like C.  Underscores are allowed in symbol
14464 names; square brackets are used for subscripts; explicit @samp{*}s for
14465 multiplications are required.  Use either @samp{^} or @samp{**} to
14466 denote powers.
14468 Maple uses square brackets for lists and curly braces for sets.  Calc
14469 interprets both notations as vectors, and displays vectors with square
14470 brackets.  This means Maple sets will be converted to lists when they
14471 pass through Calc.  As a special case, matrices are written as calls
14472 to the function @code{matrix}, given a list of lists as the argument,
14473 and can be read in this form or with all-capitals @code{MATRIX}.
14475 The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
14476 Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
14477 writes any kind of interval as @samp{2 .. 3}.  This means you cannot
14478 see the difference between an open and a closed interval while in
14479 Maple display mode.
14481 Maple writes complex numbers as @samp{3 + 4*I}.  Its special constants
14482 are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
14483 @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
14484 Floating-point numbers are written @samp{1.23*10.^3}.
14486 Among things not currently handled by Calc's Maple mode are the
14487 various quote symbols, procedures and functional operators, and
14488 inert (@samp{&}) operators.
14490 @node Compositions, Syntax Tables, Maple Language Mode, Language Modes
14491 @subsection Compositions
14493 @noindent
14494 @cindex Compositions
14495 There are several @dfn{composition functions} which allow you to get
14496 displays in a variety of formats similar to those in Big language
14497 mode.  Most of these functions do not evaluate to anything; they are
14498 placeholders which are left in symbolic form by Calc's evaluator but
14499 are recognized by Calc's display formatting routines.
14501 Two of these, @code{string} and @code{bstring}, are described elsewhere.
14502 @xref{Strings}.  For example, @samp{string("ABC")} is displayed as
14503 @samp{ABC}.  When viewed on the stack it will be indistinguishable from
14504 the variable @code{ABC}, but internally it will be stored as
14505 @samp{string([65, 66, 67])} and can still be manipulated this way; for
14506 example, the selection and vector commands @kbd{j 1 v v j u} would
14507 select the vector portion of this object and reverse the elements, then
14508 deselect to reveal a string whose characters had been reversed.
14510 The composition functions do the same thing in all language modes
14511 (although their components will of course be formatted in the current
14512 language mode).  The one exception is Unformatted mode (@kbd{d U}),
14513 which does not give the composition functions any special treatment.
14514 The functions are discussed here because of their relationship to
14515 the language modes.
14517 @menu
14518 * Composition Basics::
14519 * Horizontal Compositions::
14520 * Vertical Compositions::
14521 * Other Compositions::
14522 * Information about Compositions::
14523 * User-Defined Compositions::
14524 @end menu
14526 @node Composition Basics, Horizontal Compositions, Compositions, Compositions
14527 @subsubsection Composition Basics
14529 @noindent
14530 Compositions are generally formed by stacking formulas together
14531 horizontally or vertically in various ways.  Those formulas are
14532 themselves compositions.  @TeX{} users will find this analogous
14533 to @TeX{}'s ``boxes.''  Each multi-line composition has a
14534 @dfn{baseline}; horizontal compositions use the baselines to
14535 decide how formulas should be positioned relative to one another.
14536 For example, in the Big mode formula
14538 @example
14539 @group
14540           2
14541      a + b
14542 17 + ------
14543        c
14544 @end group
14545 @end example
14547 @noindent
14548 the second term of the sum is four lines tall and has line three as
14549 its baseline.  Thus when the term is combined with 17, line three
14550 is placed on the same level as the baseline of 17.
14552 @tex
14553 \bigskip
14554 @end tex
14556 Another important composition concept is @dfn{precedence}.  This is
14557 an integer that represents the binding strength of various operators.
14558 For example, @samp{*} has higher precedence (195) than @samp{+} (180),
14559 which means that @samp{(a * b) + c} will be formatted without the
14560 parentheses, but @samp{a * (b + c)} will keep the parentheses.
14562 The operator table used by normal and Big language modes has the
14563 following precedences:
14565 @example
14566 _     1200   @r{(subscripts)}
14567 %     1100   @r{(as in n}%@r{)}
14568 -     1000   @r{(as in }-@r{n)}
14569 !     1000   @r{(as in }!@r{n)}
14570 mod    400
14571 +/-    300
14572 !!     210    @r{(as in n}!!@r{)}
14573 !      210    @r{(as in n}!@r{)}
14574 ^      200
14575 *      195    @r{(or implicit multiplication)}
14576 / % \  190
14577 + -    180    @r{(as in a}+@r{b)}
14578 |      170
14579 < =    160    @r{(and other relations)}
14580 &&     110
14581 ||     100
14582 ? :     90
14583 !!!     85
14584 &&&     80
14585 |||     75
14586 :=      50
14587 ::      45
14588 =>      40
14589 @end example
14591 The general rule is that if an operator with precedence @cite{n}
14592 occurs as an argument to an operator with precedence @cite{m}, then
14593 the argument is enclosed in parentheses if @cite{n < m}.  Top-level
14594 expressions and expressions which are function arguments, vector
14595 components, etc., are formatted with precedence zero (so that they
14596 normally never get additional parentheses).
14598 For binary left-associative operators like @samp{+}, the righthand
14599 argument is actually formatted with one-higher precedence than shown
14600 in the table.  This makes sure @samp{(a + b) + c} omits the parentheses,
14601 but the unnatural form @samp{a + (b + c)} keeps its parentheses.
14602 Right-associative operators like @samp{^} format the lefthand argument
14603 with one-higher precedence.
14605 @ignore
14606 @starindex
14607 @end ignore
14608 @tindex cprec
14609 The @code{cprec} function formats an expression with an arbitrary
14610 precedence.  For example, @samp{cprec(abc, 185)} will combine into
14611 sums and products as follows:  @samp{7 + abc}, @samp{7 (abc)} (because
14612 this @code{cprec} form has higher precedence than addition, but lower
14613 precedence than multiplication).
14615 @tex
14616 \bigskip
14617 @end tex
14619 A final composition issue is @dfn{line breaking}.  Calc uses two
14620 different strategies for ``flat'' and ``non-flat'' compositions.
14621 A non-flat composition is anything that appears on multiple lines
14622 (not counting line breaking).  Examples would be matrices and Big
14623 mode powers and quotients.  Non-flat compositions are displayed
14624 exactly as specified.  If they come out wider than the current
14625 window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
14626 view them.
14628 Flat compositions, on the other hand, will be broken across several
14629 lines if they are too wide to fit the window.  Certain points in a
14630 composition are noted internally as @dfn{break points}.  Calc's
14631 general strategy is to fill each line as much as possible, then to
14632 move down to the next line starting at the first break point that
14633 didn't fit.  However, the line breaker understands the hierarchical
14634 structure of formulas.  It will not break an ``inner'' formula if
14635 it can use an earlier break point from an ``outer'' formula instead.
14636 For example, a vector of sums might be formatted as:
14638 @example
14639 @group
14640 [ a + b + c, d + e + f,
14641   g + h + i, j + k + l, m ]
14642 @end group
14643 @end example
14645 @noindent
14646 If the @samp{m} can fit, then so, it seems, could the @samp{g}.
14647 But Calc prefers to break at the comma since the comma is part
14648 of a ``more outer'' formula.  Calc would break at a plus sign
14649 only if it had to, say, if the very first sum in the vector had
14650 itself been too large to fit.
14652 Of the composition functions described below, only @code{choriz}
14653 generates break points.  The @code{bstring} function (@pxref{Strings})
14654 also generates breakable items:  A break point is added after every
14655 space (or group of spaces) except for spaces at the very beginning or
14656 end of the string.
14658 Composition functions themselves count as levels in the formula
14659 hierarchy, so a @code{choriz} that is a component of a larger
14660 @code{choriz} will be less likely to be broken.  As a special case,
14661 if a @code{bstring} occurs as a component of a @code{choriz} or
14662 @code{choriz}-like object (such as a vector or a list of arguments
14663 in a function call), then the break points in that @code{bstring}
14664 will be on the same level as the break points of the surrounding
14665 object.
14667 @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
14668 @subsubsection Horizontal Compositions
14670 @noindent
14671 @ignore
14672 @starindex
14673 @end ignore
14674 @tindex choriz
14675 The @code{choriz} function takes a vector of objects and composes
14676 them horizontally.  For example, @samp{choriz([17, a b/c, d])} formats
14677 as @w{@samp{17a b / cd}} in normal language mode, or as
14679 @example
14680 @group
14681   a b
14682 17---d
14683    c
14684 @end group
14685 @end example
14687 @noindent
14688 in Big language mode.  This is actually one case of the general
14689 function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
14690 either or both of @var{sep} and @var{prec} may be omitted.
14691 @var{Prec} gives the @dfn{precedence} to use when formatting
14692 each of the components of @var{vec}.  The default precedence is
14693 the precedence from the surrounding environment.
14695 @var{Sep} is a string (i.e., a vector of character codes as might
14696 be entered with @code{" "} notation) which should separate components
14697 of the composition.  Also, if @var{sep} is given, the line breaker
14698 will allow lines to be broken after each occurrence of @var{sep}.
14699 If @var{sep} is omitted, the composition will not be breakable
14700 (unless any of its component compositions are breakable).
14702 For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
14703 formatted as @samp{2 a + b c + (d = e)}.  To get the @code{choriz}
14704 to have precedence 180 ``outwards'' as well as ``inwards,''
14705 enclose it in a @code{cprec} form:  @samp{2 cprec(choriz(...), 180)}
14706 formats as @samp{2 (a + b c + (d = e))}.
14708 The baseline of a horizontal composition is the same as the
14709 baselines of the component compositions, which are all aligned.
14711 @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
14712 @subsubsection Vertical Compositions
14714 @noindent
14715 @ignore
14716 @starindex
14717 @end ignore
14718 @tindex cvert
14719 The @code{cvert} function makes a vertical composition.  Each
14720 component of the vector is centered in a column.  The baseline of
14721 the result is by default the top line of the resulting composition.
14722 For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
14723 formats in Big mode as
14725 @example
14726 @group
14727 f( a ,  2    )
14728   bb   a  + 1
14729   ccc     2
14730          b
14731 @end group
14732 @end example
14734 @ignore
14735 @starindex
14736 @end ignore
14737 @tindex cbase
14738 There are several special composition functions that work only as
14739 components of a vertical composition.  The @code{cbase} function
14740 controls the baseline of the vertical composition; the baseline
14741 will be the same as the baseline of whatever component is enclosed
14742 in @code{cbase}.  Thus @samp{f(cvert([a, cbase(bb), ccc]),
14743 cvert([a^2 + 1, cbase(b^2)]))} displays as
14745 @example
14746 @group
14747         2
14748        a  + 1
14749    a      2
14750 f(bb ,   b   )
14751   ccc
14752 @end group
14753 @end example
14755 @ignore
14756 @starindex
14757 @end ignore
14758 @tindex ctbase
14759 @ignore
14760 @starindex
14761 @end ignore
14762 @tindex cbbase
14763 There are also @code{ctbase} and @code{cbbase} functions which
14764 make the baseline of the vertical composition equal to the top
14765 or bottom line (rather than the baseline) of that component.
14766 Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
14767 cvert([cbbase(a / b)])} gives
14769 @example
14770 @group
14771         a
14772 a       -
14773 - + a + b
14774 b   -
14775     b
14776 @end group
14777 @end example
14779 There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
14780 function in a given vertical composition.  These functions can also
14781 be written with no arguments:  @samp{ctbase()} is a zero-height object
14782 which means the baseline is the top line of the following item, and
14783 @samp{cbbase()} means the baseline is the bottom line of the preceding
14784 item.
14786 @ignore
14787 @starindex
14788 @end ignore
14789 @tindex crule
14790 The @code{crule} function builds a ``rule,'' or horizontal line,
14791 across a vertical composition.  By itself @samp{crule()} uses @samp{-}
14792 characters to build the rule.  You can specify any other character,
14793 e.g., @samp{crule("=")}.  The argument must be a character code or
14794 vector of exactly one character code.  It is repeated to match the
14795 width of the widest item in the stack.  For example, a quotient
14796 with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
14798 @example
14799 @group
14800 a + 1
14801 =====
14802   2
14804 @end group
14805 @end example
14807 @ignore
14808 @starindex
14809 @end ignore
14810 @tindex clvert
14811 @ignore
14812 @starindex
14813 @end ignore
14814 @tindex crvert
14815 Finally, the functions @code{clvert} and @code{crvert} act exactly
14816 like @code{cvert} except that the items are left- or right-justified
14817 in the stack.  Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
14818 gives:
14820 @example
14821 @group
14822 a   +   a
14823 bb     bb
14824 ccc   ccc
14825 @end group
14826 @end example
14828 Like @code{choriz}, the vertical compositions accept a second argument
14829 which gives the precedence to use when formatting the components.
14830 Vertical compositions do not support separator strings.
14832 @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
14833 @subsubsection Other Compositions
14835 @noindent
14836 @ignore
14837 @starindex
14838 @end ignore
14839 @tindex csup
14840 The @code{csup} function builds a superscripted expression.  For
14841 example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
14842 language mode.  This is essentially a horizontal composition of
14843 @samp{a} and @samp{b}, where @samp{b} is shifted up so that its
14844 bottom line is one above the baseline.
14846 @ignore
14847 @starindex
14848 @end ignore
14849 @tindex csub
14850 Likewise, the @code{csub} function builds a subscripted expression.
14851 This shifts @samp{b} down so that its top line is one below the
14852 bottom line of @samp{a} (note that this is not quite analogous to
14853 @code{csup}).  Other arrangements can be obtained by using
14854 @code{choriz} and @code{cvert} directly.
14856 @ignore
14857 @starindex
14858 @end ignore
14859 @tindex cflat
14860 The @code{cflat} function formats its argument in ``flat'' mode,
14861 as obtained by @samp{d O}, if the current language mode is normal
14862 or Big.  It has no effect in other language modes.  For example,
14863 @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
14864 to improve its readability.
14866 @ignore
14867 @starindex
14868 @end ignore
14869 @tindex cspace
14870 The @code{cspace} function creates horizontal space.  For example,
14871 @samp{cspace(4)} is effectively the same as @samp{string("    ")}.
14872 A second string (i.e., vector of characters) argument is repeated
14873 instead of the space character.  For example, @samp{cspace(4, "ab")}
14874 looks like @samp{abababab}.  If the second argument is not a string,
14875 it is formatted in the normal way and then several copies of that
14876 are composed together:  @samp{cspace(4, a^2)} yields
14878 @example
14879 @group
14880  2 2 2 2
14881 a a a a
14882 @end group
14883 @end example
14885 @noindent
14886 If the number argument is zero, this is a zero-width object.
14888 @ignore
14889 @starindex
14890 @end ignore
14891 @tindex cvspace
14892 The @code{cvspace} function creates vertical space, or a vertical
14893 stack of copies of a certain string or formatted object.  The
14894 baseline is the center line of the resulting stack.  A numerical
14895 argument of zero will produce an object which contributes zero
14896 height if used in a vertical composition.
14898 @ignore
14899 @starindex
14900 @end ignore
14901 @tindex ctspace
14902 @ignore
14903 @starindex
14904 @end ignore
14905 @tindex cbspace
14906 There are also @code{ctspace} and @code{cbspace} functions which
14907 create vertical space with the baseline the same as the baseline
14908 of the top or bottom copy, respectively, of the second argument.
14909 Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
14910 displays as:
14912 @example
14913 @group
14914         a
14915         -
14916 a       b
14917 -   a   a
14918 b + - + -
14919 a   b   b
14920 -   a
14921 b   -
14922     b
14923 @end group
14924 @end example
14926 @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
14927 @subsubsection Information about Compositions
14929 @noindent
14930 The functions in this section are actual functions; they compose their
14931 arguments according to the current language and other display modes,
14932 then return a certain measurement of the composition as an integer.
14934 @ignore
14935 @starindex
14936 @end ignore
14937 @tindex cwidth
14938 The @code{cwidth} function measures the width, in characters, of a
14939 composition.  For example, @samp{cwidth(a + b)} is 5, and
14940 @samp{cwidth(a / b)} is 5 in normal mode, 1 in Big mode, and 11 in
14941 @TeX{} mode (for @samp{@{a \over b@}}).  The argument may involve
14942 the composition functions described in this section.
14944 @ignore
14945 @starindex
14946 @end ignore
14947 @tindex cheight
14948 The @code{cheight} function measures the height of a composition.
14949 This is the total number of lines in the argument's printed form.
14951 @ignore
14952 @starindex
14953 @end ignore
14954 @tindex cascent
14955 @ignore
14956 @starindex
14957 @end ignore
14958 @tindex cdescent
14959 The functions @code{cascent} and @code{cdescent} measure the amount
14960 of the height that is above (and including) the baseline, or below
14961 the baseline, respectively.  Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
14962 always equals @samp{cheight(@var{x})}.  For a one-line formula like
14963 @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
14964 For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
14965 returns 1.  The only formula for which @code{cascent} will return zero
14966 is @samp{cvspace(0)} or equivalents.
14968 @node User-Defined Compositions, , Information about Compositions, Compositions
14969 @subsubsection User-Defined Compositions
14971 @noindent
14972 @kindex Z C
14973 @pindex calc-user-define-composition
14974 The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
14975 define the display format for any algebraic function.  You provide a
14976 formula containing a certain number of argument variables on the stack.
14977 Any time Calc formats a call to the specified function in the current
14978 language mode and with that number of arguments, Calc effectively
14979 replaces the function call with that formula with the arguments
14980 replaced.
14982 Calc builds the default argument list by sorting all the variable names
14983 that appear in the formula into alphabetical order.  You can edit this
14984 argument list before pressing @key{RET} if you wish.  Any variables in
14985 the formula that do not appear in the argument list will be displayed
14986 literally; any arguments that do not appear in the formula will not
14987 affect the display at all.
14989 You can define formats for built-in functions, for functions you have
14990 defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
14991 which have no definitions but are being used as purely syntactic objects.
14992 You can define different formats for each language mode, and for each
14993 number of arguments, using a succession of @kbd{Z C} commands.  When
14994 Calc formats a function call, it first searches for a format defined
14995 for the current language mode (and number of arguments); if there is
14996 none, it uses the format defined for the Normal language mode.  If
14997 neither format exists, Calc uses its built-in standard format for that
14998 function (usually just @samp{@var{func}(@var{args})}).
15000 If you execute @kbd{Z C} with the number 0 on the stack instead of a
15001 formula, any defined formats for the function in the current language
15002 mode will be removed.  The function will revert to its standard format.
15004 For example, the default format for the binomial coefficient function
15005 @samp{choose(n, m)} in the Big language mode is
15007 @example
15008 @group
15010 ( )
15012 @end group
15013 @end example
15015 @noindent
15016 You might prefer the notation,
15018 @example
15019 @group
15021 n m
15022 @end group
15023 @end example
15025 @noindent
15026 To define this notation, first make sure you are in Big mode,
15027 then put the formula
15029 @smallexample
15030 choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
15031 @end smallexample
15033 @noindent
15034 on the stack and type @kbd{Z C}.  Answer the first prompt with
15035 @code{choose}.  The second prompt will be the default argument list
15036 of @samp{(C m n)}.  Edit this list to be @samp{(n m)} and press
15037 @key{RET}.  Now, try it out:  For example, turn simplification
15038 off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
15039 as an algebraic entry.
15041 @example
15042 @group
15043  C  +  C
15044 a b   7 3
15045 @end group
15046 @end example
15048 As another example, let's define the usual notation for Stirling
15049 numbers of the first kind, @samp{stir1(n, m)}.  This is just like
15050 the regular format for binomial coefficients but with square brackets
15051 instead of parentheses.
15053 @smallexample
15054 choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
15055 @end smallexample
15057 Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
15058 @samp{(n m)}, and type @key{RET}.
15060 The formula provided to @kbd{Z C} usually will involve composition
15061 functions, but it doesn't have to.  Putting the formula @samp{a + b + c}
15062 onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
15063 the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
15064 This ``sum'' will act exactly like a real sum for all formatting
15065 purposes (it will be parenthesized the same, and so on).  However
15066 it will be computationally unrelated to a sum.  For example, the
15067 formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
15068 Operator precedences have caused the ``sum'' to be written in
15069 parentheses, but the arguments have not actually been summed.
15070 (Generally a display format like this would be undesirable, since
15071 it can easily be confused with a real sum.)
15073 The special function @code{eval} can be used inside a @kbd{Z C}
15074 composition formula to cause all or part of the formula to be
15075 evaluated at display time.  For example, if the formula is
15076 @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
15077 as @samp{1 + 5}.  Evaluation will use the default simplifications,
15078 regardless of the current simplification mode.  There are also
15079 @code{evalsimp} and @code{evalextsimp} which simplify as if by
15080 @kbd{a s} and @kbd{a e} (respectively).  Note that these ``functions''
15081 operate only in the context of composition formulas (and also in
15082 rewrite rules, where they serve a similar purpose; @pxref{Rewrite
15083 Rules}).  On the stack, a call to @code{eval} will be left in
15084 symbolic form.
15086 It is not a good idea to use @code{eval} except as a last resort.
15087 It can cause the display of formulas to be extremely slow.  For
15088 example, while @samp{eval(a + b)} might seem quite fast and simple,
15089 there are several situations where it could be slow.  For example,
15090 @samp{a} and/or @samp{b} could be polar complex numbers, in which
15091 case doing the sum requires trigonometry.  Or, @samp{a} could be
15092 the factorial @samp{fact(100)} which is unevaluated because you
15093 have typed @kbd{m O}; @code{eval} will evaluate it anyway to
15094 produce a large, unwieldy integer.
15096 You can save your display formats permanently using the @kbd{Z P}
15097 command (@pxref{Creating User Keys}).
15099 @node Syntax Tables, , Compositions, Language Modes
15100 @subsection Syntax Tables
15102 @noindent
15103 @cindex Syntax tables
15104 @cindex Parsing formulas, customized
15105 Syntax tables do for input what compositions do for output:  They
15106 allow you to teach custom notations to Calc's formula parser.
15107 Calc keeps a separate syntax table for each language mode.
15109 (Note that the Calc ``syntax tables'' discussed here are completely
15110 unrelated to the syntax tables described in the Emacs manual.)
15112 @kindex Z S
15113 @pindex calc-edit-user-syntax
15114 The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
15115 syntax table for the current language mode.  If you want your
15116 syntax to work in any language, define it in the normal language
15117 mode.  Type @kbd{M-# M-#} to finish editing the syntax table, or
15118 @kbd{M-# x} to cancel the edit.  The @kbd{m m} command saves all
15119 the syntax tables along with the other mode settings;
15120 @pxref{General Mode Commands}.
15122 @menu
15123 * Syntax Table Basics::
15124 * Precedence in Syntax Tables::
15125 * Advanced Syntax Patterns::
15126 * Conditional Syntax Rules::
15127 @end menu
15129 @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
15130 @subsubsection Syntax Table Basics
15132 @noindent
15133 @dfn{Parsing} is the process of converting a raw string of characters,
15134 such as you would type in during algebraic entry, into a Calc formula.
15135 Calc's parser works in two stages.  First, the input is broken down
15136 into @dfn{tokens}, such as words, numbers, and punctuation symbols
15137 like @samp{+}, @samp{:=}, and @samp{+/-}.  Space between tokens is
15138 ignored (except when it serves to separate adjacent words).  Next,
15139 the parser matches this string of tokens against various built-in
15140 syntactic patterns, such as ``an expression followed by @samp{+}
15141 followed by another expression'' or ``a name followed by @samp{(},
15142 zero or more expressions separated by commas, and @samp{)}.''
15144 A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
15145 which allow you to specify new patterns to define your own
15146 favorite input notations.  Calc's parser always checks the syntax
15147 table for the current language mode, then the table for the normal
15148 language mode, before it uses its built-in rules to parse an
15149 algebraic formula you have entered.  Each syntax rule should go on
15150 its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
15151 and a Calc formula with an optional @dfn{condition}.  (Syntax rules
15152 resemble algebraic rewrite rules, but the notation for patterns is
15153 completely different.)
15155 A syntax pattern is a list of tokens, separated by spaces.
15156 Except for a few special symbols, tokens in syntax patterns are
15157 matched literally, from left to right.  For example, the rule,
15159 @example
15160 foo ( ) := 2+3
15161 @end example
15163 @noindent
15164 would cause Calc to parse the formula @samp{4+foo()*5} as if it
15165 were @samp{4+(2+3)*5}.  Notice that the parentheses were written
15166 as two separate tokens in the rule.  As a result, the rule works
15167 for both @samp{foo()} and @w{@samp{foo (  )}}.  If we had written
15168 the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
15169 as a single, indivisible token, so that @w{@samp{foo( )}} would
15170 not be recognized by the rule.  (It would be parsed as a regular
15171 zero-argument function call instead.)  In fact, this rule would
15172 also make trouble for the rest of Calc's parser:  An unrelated
15173 formula like @samp{bar()} would now be tokenized into @samp{bar ()}
15174 instead of @samp{bar ( )}, so that the standard parser for function
15175 calls would no longer recognize it!
15177 While it is possible to make a token with a mixture of letters
15178 and punctuation symbols, this is not recommended.  It is better to
15179 break it into several tokens, as we did with @samp{foo()} above.
15181 The symbol @samp{#} in a syntax pattern matches any Calc expression.
15182 On the righthand side, the things that matched the @samp{#}s can
15183 be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
15184 matches the leftmost @samp{#} in the pattern).  For example, these
15185 rules match a user-defined function, prefix operator, infix operator,
15186 and postfix operator, respectively:
15188 @example
15189 foo ( # ) := myfunc(#1)
15190 foo # := myprefix(#1)
15191 # foo # := myinfix(#1,#2)
15192 # foo := mypostfix(#1)
15193 @end example
15195 Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
15196 will parse as @samp{mypostfix(2+3)}.
15198 It is important to write the first two rules in the order shown,
15199 because Calc tries rules in order from first to last.  If the
15200 pattern @samp{foo #} came first, it would match anything that could
15201 match the @samp{foo ( # )} rule, since an expression in parentheses
15202 is itself a valid expression.  Thus the @w{@samp{foo ( # )}} rule would
15203 never get to match anything.  Likewise, the last two rules must be
15204 written in the order shown or else @samp{3 foo 4} will be parsed as
15205 @samp{mypostfix(3) * 4}.  (Of course, the best way to avoid these
15206 ambiguities is not to use the same symbol in more than one way at
15207 the same time!  In case you're not convinced, try the following
15208 exercise:  How will the above rules parse the input @samp{foo(3,4)},
15209 if at all?  Work it out for yourself, then try it in Calc and see.)
15211 Calc is quite flexible about what sorts of patterns are allowed.
15212 The only rule is that every pattern must begin with a literal
15213 token (like @samp{foo} in the first two patterns above), or with
15214 a @samp{#} followed by a literal token (as in the last two
15215 patterns).  After that, any mixture is allowed, although putting
15216 two @samp{#}s in a row will not be very useful since two
15217 expressions with nothing between them will be parsed as one
15218 expression that uses implicit multiplication.
15220 As a more practical example, Maple uses the notation
15221 @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
15222 recognize at present.  To handle this syntax, we simply add the
15223 rule,
15225 @example
15226 sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
15227 @end example
15229 @noindent
15230 to the Maple mode syntax table.  As another example, C mode can't
15231 read assignment operators like @samp{++} and @samp{*=}.  We can
15232 define these operators quite easily:
15234 @example
15235 # *= # := muleq(#1,#2)
15236 # ++ := postinc(#1)
15237 ++ # := preinc(#1)
15238 @end example
15240 @noindent
15241 To complete the job, we would use corresponding composition functions
15242 and @kbd{Z C} to cause these functions to display in their respective
15243 Maple and C notations.  (Note that the C example ignores issues of
15244 operator precedence, which are discussed in the next section.)
15246 You can enclose any token in quotes to prevent its usual
15247 interpretation in syntax patterns:
15249 @example
15250 # ":=" # := becomes(#1,#2)
15251 @end example
15253 Quotes also allow you to include spaces in a token, although once
15254 again it is generally better to use two tokens than one token with
15255 an embedded space.  To include an actual quotation mark in a quoted
15256 token, precede it with a backslash.  (This also works to include
15257 backslashes in tokens.)
15259 @example
15260 # "bad token" # "/\"\\" # := silly(#1,#2,#3)
15261 @end example
15263 @noindent
15264 This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
15266 The token @kbd{#} has a predefined meaning in Calc's formula parser;
15267 it is not legal to use @samp{"#"} in a syntax rule.  However, longer
15268 tokens that include the @samp{#} character are allowed.  Also, while
15269 @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
15270 the syntax table will prevent those characters from working in their
15271 usual ways (referring to stack entries and quoting strings,
15272 respectively).
15274 Finally, the notation @samp{%%} anywhere in a syntax table causes
15275 the rest of the line to be ignored as a comment.
15277 @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
15278 @subsubsection Precedence
15280 @noindent
15281 Different operators are generally assigned different @dfn{precedences}.
15282 By default, an operator defined by a rule like
15284 @example
15285 # foo # := foo(#1,#2)
15286 @end example
15288 @noindent
15289 will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
15290 will be parsed as @samp{(2*3+4) foo (5 == 6)}.  To change the
15291 precedence of an operator, use the notation @samp{#/@var{p}} in
15292 place of @samp{#}, where @var{p} is an integer precedence level.
15293 For example, 185 lies between the precedences for @samp{+} and
15294 @samp{*}, so if we change this rule to
15296 @example
15297 #/185 foo #/186 := foo(#1,#2)
15298 @end example
15300 @noindent
15301 then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
15302 Also, because we've given the righthand expression slightly higher
15303 precedence, our new operator will be left-associative:
15304 @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
15305 By raising the precedence of the lefthand expression instead, we
15306 can create a right-associative operator.
15308 @xref{Composition Basics}, for a table of precedences of the
15309 standard Calc operators.  For the precedences of operators in other
15310 language modes, look in the Calc source file @file{calc-lang.el}.
15312 @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
15313 @subsubsection Advanced Syntax Patterns
15315 @noindent
15316 To match a function with a variable number of arguments, you could
15317 write
15319 @example
15320 foo ( # ) := myfunc(#1)
15321 foo ( # , # ) := myfunc(#1,#2)
15322 foo ( # , # , # ) := myfunc(#1,#2,#3)
15323 @end example
15325 @noindent
15326 but this isn't very elegant.  To match variable numbers of items,
15327 Calc uses some notations inspired regular expressions and the
15328 ``extended BNF'' style used by some language designers.
15330 @example
15331 foo ( @{ # @}*, ) := apply(myfunc,#1)
15332 @end example
15334 The token @samp{@{} introduces a repeated or optional portion.
15335 One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
15336 ends the portion.  These will match zero or more, one or more,
15337 or zero or one copies of the enclosed pattern, respectively.
15338 In addition, @samp{@}*} and @samp{@}+} can be followed by a
15339 separator token (with no space in between, as shown above).
15340 Thus @samp{@{ # @}*,} matches nothing, or one expression, or
15341 several expressions separated by commas.
15343 A complete @samp{@{ ... @}} item matches as a vector of the
15344 items that matched inside it.  For example, the above rule will
15345 match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
15346 The Calc @code{apply} function takes a function name and a vector
15347 of arguments and builds a call to the function with those
15348 arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
15350 If the body of a @samp{@{ ... @}} contains several @samp{#}s
15351 (or nested @samp{@{ ... @}} constructs), then the items will be
15352 strung together into the resulting vector.  If the body
15353 does not contain anything but literal tokens, the result will
15354 always be an empty vector.
15356 @example
15357 foo ( @{ # , # @}+, ) := bar(#1)
15358 foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
15359 @end example
15361 @noindent
15362 will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
15363 @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}.  Also, after
15364 some thought it's easy to see how this pair of rules will parse
15365 @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
15366 rule will only match an even number of arguments.  The rule
15368 @example
15369 foo ( # @{ , # , # @}? ) := bar(#1,#2)
15370 @end example
15372 @noindent
15373 will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
15374 @samp{foo(2)} as @samp{bar(2,[])}.
15376 The notation @samp{@{ ... @}?.} (note the trailing period) works
15377 just the same as regular @samp{@{ ... @}?}, except that it does not
15378 count as an argument; the following two rules are equivalent:
15380 @example
15381 foo ( # , @{ also @}? # ) := bar(#1,#3)
15382 foo ( # , @{ also @}?. # ) := bar(#1,#2)
15383 @end example
15385 @noindent
15386 Note that in the first case the optional text counts as @samp{#2},
15387 which will always be an empty vector, but in the second case no
15388 empty vector is produced.
15390 Another variant is @samp{@{ ... @}?$}, which means the body is
15391 optional only at the end of the input formula.  All built-in syntax
15392 rules in Calc use this for closing delimiters, so that during
15393 algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
15394 the closing parenthesis and bracket.  Calc does this automatically
15395 for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
15396 rules, but you can use @samp{@{ ... @}?$} explicitly to get
15397 this effect with any token (such as @samp{"@}"} or @samp{end}).
15398 Like @samp{@{ ... @}?.}, this notation does not count as an
15399 argument.  Conversely, you can use quotes, as in @samp{")"}, to
15400 prevent a closing-delimiter token from being automatically treated
15401 as optional.
15403 Calc's parser does not have full backtracking, which means some
15404 patterns will not work as you might expect:
15406 @example
15407 foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
15408 @end example
15410 @noindent
15411 Here we are trying to make the first argument optional, so that
15412 @samp{foo(2,3)} parses as @samp{bar([],2,3)}.  Unfortunately, Calc
15413 first tries to match @samp{2,} against the optional part of the
15414 pattern, finds a match, and so goes ahead to match the rest of the
15415 pattern.  Later on it will fail to match the second comma, but it
15416 doesn't know how to go back and try the other alternative at that
15417 point.  One way to get around this would be to use two rules:
15419 @example
15420 foo ( # , # , # ) := bar([#1],#2,#3)
15421 foo ( # , # ) := bar([],#1,#2)
15422 @end example
15424 More precisely, when Calc wants to match an optional or repeated
15425 part of a pattern, it scans forward attempting to match that part.
15426 If it reaches the end of the optional part without failing, it
15427 ``finalizes'' its choice and proceeds.  If it fails, though, it
15428 backs up and tries the other alternative.  Thus Calc has ``partial''
15429 backtracking.  A fully backtracking parser would go on to make sure
15430 the rest of the pattern matched before finalizing the choice.
15432 @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
15433 @subsubsection Conditional Syntax Rules
15435 @noindent
15436 It is possible to attach a @dfn{condition} to a syntax rule.  For
15437 example, the rules
15439 @example
15440 foo ( # ) := ifoo(#1) :: integer(#1)
15441 foo ( # ) := gfoo(#1)
15442 @end example
15444 @noindent
15445 will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
15446 @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}.  Any
15447 number of conditions may be attached; all must be true for the
15448 rule to succeed.  A condition is ``true'' if it evaluates to a
15449 nonzero number.  @xref{Logical Operations}, for a list of Calc
15450 functions like @code{integer} that perform logical tests.
15452 The exact sequence of events is as follows:  When Calc tries a
15453 rule, it first matches the pattern as usual.  It then substitutes
15454 @samp{#1}, @samp{#2}, etc., in the conditions, if any.  Next, the
15455 conditions are simplified and evaluated in order from left to right,
15456 as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}).
15457 Each result is true if it is a nonzero number, or an expression
15458 that can be proven to be nonzero (@pxref{Declarations}).  If the
15459 results of all conditions are true, the expression (such as
15460 @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
15461 result of the parse.  If the result of any condition is false, Calc
15462 goes on to try the next rule in the syntax table.
15464 Syntax rules also support @code{let} conditions, which operate in
15465 exactly the same way as they do in algebraic rewrite rules.
15466 @xref{Other Features of Rewrite Rules}, for details.  A @code{let}
15467 condition is always true, but as a side effect it defines a
15468 variable which can be used in later conditions, and also in the
15469 expression after the @samp{:=} sign:
15471 @example
15472 foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
15473 @end example
15475 @noindent
15476 The @code{dnumint} function tests if a value is numerically an
15477 integer, i.e., either a true integer or an integer-valued float.
15478 This rule will parse @code{foo} with a half-integer argument,
15479 like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
15481 The lefthand side of a syntax rule @code{let} must be a simple
15482 variable, not the arbitrary pattern that is allowed in rewrite
15483 rules.
15485 The @code{matches} function is also treated specially in syntax
15486 rule conditions (again, in the same way as in rewrite rules).
15487 @xref{Matching Commands}.  If the matching pattern contains
15488 meta-variables, then those meta-variables may be used in later
15489 conditions and in the result expression.  The arguments to
15490 @code{matches} are not evaluated in this situation.
15492 @example
15493 sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
15494 @end example
15496 @noindent
15497 This is another way to implement the Maple mode @code{sum} notation.
15498 In this approach, we allow @samp{#2} to equal the whole expression
15499 @samp{i=1..10}.  Then, we use @code{matches} to break it apart into
15500 its components.  If the expression turns out not to match the pattern,
15501 the syntax rule will fail.  Note that @kbd{Z S} always uses Calc's
15502 normal language mode for editing expressions in syntax rules, so we
15503 must use regular Calc notation for the interval @samp{[b..c]} that
15504 will correspond to the Maple mode interval @samp{1..10}.
15506 @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
15507 @section The @code{Modes} Variable
15509 @noindent
15510 @kindex m g
15511 @pindex calc-get-modes
15512 The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
15513 a vector of numbers that describes the various mode settings that
15514 are in effect.  With a numeric prefix argument, it pushes only the
15515 @var{n}th mode, i.e., the @var{n}th element of this vector.  Keyboard
15516 macros can use the @kbd{m g} command to modify their behavior based
15517 on the current mode settings.
15519 @cindex @code{Modes} variable
15520 @vindex Modes
15521 The modes vector is also available in the special variable
15522 @code{Modes}.  In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
15523 It will not work to store into this variable; in fact, if you do,
15524 @code{Modes} will cease to track the current modes.  (The @kbd{m g}
15525 command will continue to work, however.)
15527 In general, each number in this vector is suitable as a numeric
15528 prefix argument to the associated mode-setting command.  (Recall
15529 that the @kbd{~} key takes a number from the stack and gives it as
15530 a numeric prefix to the next command.)
15532 The elements of the modes vector are as follows:
15534 @enumerate
15535 @item
15536 Current precision.  Default is 12; associated command is @kbd{p}.
15538 @item
15539 Binary word size.  Default is 32; associated command is @kbd{b w}.
15541 @item
15542 Stack size (not counting the value about to be pushed by @kbd{m g}).
15543 This is zero if @kbd{m g} is executed with an empty stack.
15545 @item
15546 Number radix.  Default is 10; command is @kbd{d r}.
15548 @item
15549 Floating-point format.  This is the number of digits, plus the
15550 constant 0 for normal notation, 10000 for scientific notation,
15551 20000 for engineering notation, or 30000 for fixed-point notation.
15552 These codes are acceptable as prefix arguments to the @kbd{d n}
15553 command, but note that this may lose information:  For example,
15554 @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
15555 identical) effects if the current precision is 12, but they both
15556 produce a code of 10012, which will be treated by @kbd{d n} as
15557 @kbd{C-u 12 d s}.  If the precision then changes, the float format
15558 will still be frozen at 12 significant figures.
15560 @item
15561 Angular mode.  Default is 1 (degrees).  Other values are 2 (radians)
15562 and 3 (HMS).  The @kbd{m d} command accepts these prefixes.
15564 @item
15565 Symbolic mode.  Value is 0 or 1; default is 0.  Command is @kbd{m s}.
15567 @item
15568 Fraction mode.  Value is 0 or 1; default is 0.  Command is @kbd{m f}.
15570 @item
15571 Polar mode.  Value is 0 (rectangular) or 1 (polar); default is 0.
15572 Command is @kbd{m p}.
15574 @item
15575 Matrix/scalar mode.  Default value is @i{-1}.  Value is 0 for scalar
15576 mode, @i{-2} for matrix mode, or @var{N} for @c{$N\times N$}
15577 @var{N}x@var{N} matrix mode.  Command is @kbd{m v}.
15579 @item
15580 Simplification mode.  Default is 1.  Value is @i{-1} for off (@kbd{m O}),
15581 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
15582 or 5 for @w{@kbd{m U}}.  The @kbd{m D} command accepts these prefixes.
15584 @item
15585 Infinite mode.  Default is @i{-1} (off).  Value is 1 if the mode is on,
15586 or 0 if the mode is on with positive zeros.  Command is @kbd{m i}.
15587 @end enumerate
15589 For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
15590 precision by two, leaving a copy of the old precision on the stack.
15591 Later, @kbd{~ p} will restore the original precision using that
15592 stack value.  (This sequence might be especially useful inside a
15593 keyboard macro.)
15595 As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
15596 oldest (bottommost) stack entry.
15598 Yet another example:  The HP-48 ``round'' command rounds a number
15599 to the current displayed precision.  You could roughly emulate this
15600 in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}.  (This
15601 would not work for fixed-point mode, but it wouldn't be hard to
15602 do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
15603 programming commands.  @xref{Conditionals in Macros}.)
15605 @node Calc Mode Line, , Modes Variable, Mode Settings
15606 @section The Calc Mode Line
15608 @noindent
15609 @cindex Mode line indicators
15610 This section is a summary of all symbols that can appear on the
15611 Calc mode line, the highlighted bar that appears under the Calc
15612 stack window (or under an editing window in Embedded Mode).
15614 The basic mode line format is:
15616 @example
15617 --%%-Calc: 12 Deg @var{other modes}       (Calculator)
15618 @end example
15620 The @samp{%%} is the Emacs symbol for ``read-only''; it shows that
15621 regular Emacs commands are not allowed to edit the stack buffer
15622 as if it were text.
15624 The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded Mode
15625 is enabled.  The words after this describe the various Calc modes
15626 that are in effect.
15628 The first mode is always the current precision, an integer.
15629 The second mode is always the angular mode, either @code{Deg},
15630 @code{Rad}, or @code{Hms}.
15632 Here is a complete list of the remaining symbols that can appear
15633 on the mode line:
15635 @table @code
15636 @item Alg
15637 Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
15639 @item Alg[(
15640 Incomplete algebraic mode (@kbd{C-u m a}).
15642 @item Alg*
15643 Total algebraic mode (@kbd{m t}).
15645 @item Symb
15646 Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
15648 @item Matrix
15649 Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
15651 @item Matrix@var{n}
15652 Dimensioned matrix mode (@kbd{C-u @var{n} m v}).
15654 @item Scalar
15655 Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
15657 @item Polar
15658 Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
15660 @item Frac
15661 Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
15663 @item Inf
15664 Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
15666 @item +Inf
15667 Positive infinite mode (@kbd{C-u 0 m i}).
15669 @item NoSimp
15670 Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
15672 @item NumSimp
15673 Default simplifications for numeric arguments only (@kbd{m N}).
15675 @item BinSimp@var{w}
15676 Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
15678 @item AlgSimp
15679 Algebraic simplification mode (@kbd{m A}).
15681 @item ExtSimp
15682 Extended algebraic simplification mode (@kbd{m E}).
15684 @item UnitSimp
15685 Units simplification mode (@kbd{m U}).
15687 @item Bin
15688 Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
15690 @item Oct
15691 Current radix is 8 (@kbd{d 8}).
15693 @item Hex
15694 Current radix is 16 (@kbd{d 6}).
15696 @item Radix@var{n}
15697 Current radix is @var{n} (@kbd{d r}).
15699 @item Zero
15700 Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
15702 @item Big
15703 Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
15705 @item Flat
15706 One-line normal language mode (@kbd{d O}).
15708 @item Unform
15709 Unformatted language mode (@kbd{d U}).
15711 @item C
15712 C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
15714 @item Pascal
15715 Pascal language mode (@kbd{d P}).
15717 @item Fortran
15718 FORTRAN language mode (@kbd{d F}).
15720 @item TeX
15721 @TeX{} language mode (@kbd{d T}; @pxref{TeX Language Mode}).
15723 @item Eqn
15724 @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
15726 @item Math
15727 Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
15729 @item Maple
15730 Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
15732 @item Norm@var{n}
15733 Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
15735 @item Fix@var{n}
15736 Fixed point mode with @var{n} digits after the point (@kbd{d f}).
15738 @item Sci
15739 Scientific notation mode (@kbd{d s}).
15741 @item Sci@var{n}
15742 Scientific notation with @var{n} digits (@kbd{d s}).
15744 @item Eng
15745 Engineering notation mode (@kbd{d e}).
15747 @item Eng@var{n}
15748 Engineering notation with @var{n} digits (@kbd{d e}).
15750 @item Left@var{n}
15751 Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
15753 @item Right
15754 Right-justified display (@kbd{d >}).
15756 @item Right@var{n}
15757 Right-justified display with width @var{n} (@kbd{d >}).
15759 @item Center
15760 Centered display (@kbd{d =}).
15762 @item Center@var{n}
15763 Centered display with center column @var{n} (@kbd{d =}).
15765 @item Wid@var{n}
15766 Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
15768 @item Wide
15769 No line breaking (@kbd{d b}).
15771 @item Break
15772 Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
15774 @item Save
15775 Record modes in @file{~/.emacs} (@kbd{m R}; @pxref{General Mode Commands}).
15777 @item Local
15778 Record modes in Embedded buffer (@kbd{m R}).
15780 @item LocEdit
15781 Record modes as editing-only in Embedded buffer (@kbd{m R}).
15783 @item LocPerm
15784 Record modes as permanent-only in Embedded buffer (@kbd{m R}).
15786 @item Global
15787 Record modes as global in Embedded buffer (@kbd{m R}).
15789 @item Manual
15790 Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
15791 Recomputation}).
15793 @item Graph
15794 GNUPLOT process is alive in background (@pxref{Graphics}).
15796 @item Sel
15797 Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
15799 @item Dirty
15800 The stack display may not be up-to-date (@pxref{Display Modes}).
15802 @item Inv
15803 ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
15805 @item Hyp
15806 ``Hyperbolic'' prefix was pressed (@kbd{H}).
15808 @item Keep
15809 ``Keep-arguments'' prefix was pressed (@kbd{K}).
15811 @item Narrow
15812 Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
15813 @end table
15815 In addition, the symbols @code{Active} and @code{~Active} can appear
15816 as minor modes on an Embedded buffer's mode line.  @xref{Embedded Mode}.
15818 @node Arithmetic, Scientific Functions, Mode Settings, Top
15819 @chapter Arithmetic Functions
15821 @noindent
15822 This chapter describes the Calc commands for doing simple calculations
15823 on numbers, such as addition, absolute value, and square roots.  These
15824 commands work by removing the top one or two values from the stack,
15825 performing the desired operation, and pushing the result back onto the
15826 stack.  If the operation cannot be performed, the result pushed is a
15827 formula instead of a number, such as @samp{2/0} (because division by zero
15828 is illegal) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
15830 Most of the commands described here can be invoked by a single keystroke.
15831 Some of the more obscure ones are two-letter sequences beginning with
15832 the @kbd{f} (``functions'') prefix key.
15834 @xref{Prefix Arguments}, for a discussion of the effect of numeric
15835 prefix arguments on commands in this chapter which do not otherwise
15836 interpret a prefix argument.
15838 @menu
15839 * Basic Arithmetic::
15840 * Integer Truncation::
15841 * Complex Number Functions::
15842 * Conversions::
15843 * Date Arithmetic::
15844 * Financial Functions::
15845 * Binary Functions::
15846 @end menu
15848 @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
15849 @section Basic Arithmetic
15851 @noindent
15852 @kindex +
15853 @pindex calc-plus
15854 @ignore
15855 @mindex @null
15856 @end ignore
15857 @tindex +
15858 The @kbd{+} (@code{calc-plus}) command adds two numbers.  The numbers may
15859 be any of the standard Calc data types.  The resulting sum is pushed back
15860 onto the stack.
15862 If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
15863 the result is a vector or matrix sum.  If one argument is a vector and the
15864 other a scalar (i.e., a non-vector), the scalar is added to each of the
15865 elements of the vector to form a new vector.  If the scalar is not a
15866 number, the operation is left in symbolic form:  Suppose you added @samp{x}
15867 to the vector @samp{[1,2]}.  You may want the result @samp{[1+x,2+x]}, or
15868 you may plan to substitute a 2-vector for @samp{x} in the future.  Since
15869 the Calculator can't tell which interpretation you want, it makes the
15870 safest assumption.  @xref{Reducing and Mapping}, for a way to add @samp{x}
15871 to every element of a vector.
15873 If either argument of @kbd{+} is a complex number, the result will in general
15874 be complex.  If one argument is in rectangular form and the other polar,
15875 the current Polar Mode determines the form of the result.  If Symbolic
15876 Mode is enabled, the sum may be left as a formula if the necessary
15877 conversions for polar addition are non-trivial.
15879 If both arguments of @kbd{+} are HMS forms, the forms are added according to
15880 the usual conventions of hours-minutes-seconds notation.  If one argument
15881 is an HMS form and the other is a number, that number is converted from
15882 degrees or radians (depending on the current Angular Mode) to HMS format
15883 and then the two HMS forms are added.
15885 If one argument of @kbd{+} is a date form, the other can be either a
15886 real number, which advances the date by a certain number of days, or
15887 an HMS form, which advances the date by a certain amount of time.
15888 Subtracting two date forms yields the number of days between them.
15889 Adding two date forms is meaningless, but Calc interprets it as the
15890 subtraction of one date form and the negative of the other.  (The
15891 negative of a date form can be understood by remembering that dates
15892 are stored as the number of days before or after Jan 1, 1 AD.)
15894 If both arguments of @kbd{+} are error forms, the result is an error form
15895 with an appropriately computed standard deviation.  If one argument is an
15896 error form and the other is a number, the number is taken to have zero error.
15897 Error forms may have symbolic formulas as their mean and/or error parts;
15898 adding these will produce a symbolic error form result.  However, adding an
15899 error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
15900 work, for the same reasons just mentioned for vectors.  Instead you must
15901 write @samp{(a +/- b) + (c +/- 0)}.
15903 If both arguments of @kbd{+} are modulo forms with equal values of @cite{M},
15904 or if one argument is a modulo form and the other a plain number, the
15905 result is a modulo form which represents the sum, modulo @cite{M}, of
15906 the two values.
15908 If both arguments of @kbd{+} are intervals, the result is an interval
15909 which describes all possible sums of the possible input values.  If
15910 one argument is a plain number, it is treated as the interval
15911 @w{@samp{[x ..@: x]}}.
15913 If one argument of @kbd{+} is an infinity and the other is not, the
15914 result is that same infinity.  If both arguments are infinite and in
15915 the same direction, the result is the same infinity, but if they are
15916 infinite in different directions the result is @code{nan}.
15918 @kindex -
15919 @pindex calc-minus
15920 @ignore
15921 @mindex @null
15922 @end ignore
15923 @tindex -
15924 The @kbd{-} (@code{calc-minus}) command subtracts two values.  The top
15925 number on the stack is subtracted from the one behind it, so that the
15926 computation @kbd{5 @key{RET} 2 -} produces 3, not @i{-3}.  All options
15927 available for @kbd{+} are available for @kbd{-} as well.
15929 @kindex *
15930 @pindex calc-times
15931 @ignore
15932 @mindex @null
15933 @end ignore
15934 @tindex *
15935 The @kbd{*} (@code{calc-times}) command multiplies two numbers.  If one
15936 argument is a vector and the other a scalar, the scalar is multiplied by
15937 the elements of the vector to produce a new vector.  If both arguments
15938 are vectors, the interpretation depends on the dimensions of the
15939 vectors:  If both arguments are matrices, a matrix multiplication is
15940 done.  If one argument is a matrix and the other a plain vector, the
15941 vector is interpreted as a row vector or column vector, whichever is
15942 dimensionally correct.  If both arguments are plain vectors, the result
15943 is a single scalar number which is the dot product of the two vectors.
15945 If one argument of @kbd{*} is an HMS form and the other a number, the
15946 HMS form is multiplied by that amount.  It is an error to multiply two
15947 HMS forms together, or to attempt any multiplication involving date
15948 forms.  Error forms, modulo forms, and intervals can be multiplied;
15949 see the comments for addition of those forms.  When two error forms
15950 or intervals are multiplied they are considered to be statistically
15951 independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
15952 whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
15954 @kindex /
15955 @pindex calc-divide
15956 @ignore
15957 @mindex @null
15958 @end ignore
15959 @tindex /
15960 The @kbd{/} (@code{calc-divide}) command divides two numbers.  When
15961 dividing a scalar @cite{B} by a square matrix @cite{A}, the computation
15962 performed is @cite{B} times the inverse of @cite{A}.  This also occurs
15963 if @cite{B} is itself a vector or matrix, in which case the effect is
15964 to solve the set of linear equations represented by @cite{B}.  If @cite{B}
15965 is a matrix with the same number of rows as @cite{A}, or a plain vector
15966 (which is interpreted here as a column vector), then the equation
15967 @cite{A X = B} is solved for the vector or matrix @cite{X}.  Otherwise,
15968 if @cite{B} is a non-square matrix with the same number of @emph{columns}
15969 as @cite{A}, the equation @cite{X A = B} is solved.  If you wish a vector
15970 @cite{B} to be interpreted as a row vector to be solved as @cite{X A = B},
15971 make it into a one-row matrix with @kbd{C-u 1 v p} first.  To force a
15972 left-handed solution with a square matrix @cite{B}, transpose @cite{A} and
15973 @cite{B} before dividing, then transpose the result.
15975 HMS forms can be divided by real numbers or by other HMS forms.  Error
15976 forms can be divided in any combination of ways.  Modulo forms where both
15977 values and the modulo are integers can be divided to get an integer modulo
15978 form result.  Intervals can be divided; dividing by an interval that
15979 encompasses zero or has zero as a limit will result in an infinite
15980 interval.
15982 @kindex ^
15983 @pindex calc-power
15984 @ignore
15985 @mindex @null
15986 @end ignore
15987 @tindex ^
15988 The @kbd{^} (@code{calc-power}) command raises a number to a power.  If
15989 the power is an integer, an exact result is computed using repeated
15990 multiplications.  For non-integer powers, Calc uses Newton's method or
15991 logarithms and exponentials.  Square matrices can be raised to integer
15992 powers.  If either argument is an error (or interval or modulo) form,
15993 the result is also an error (or interval or modulo) form.
15995 @kindex I ^
15996 @tindex nroot
15997 If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
15998 computes an Nth root:  @kbd{125 @key{RET} 3 I ^} computes the number 5.
15999 (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
16001 @kindex \
16002 @pindex calc-idiv
16003 @tindex idiv
16004 @ignore
16005 @mindex @null
16006 @end ignore
16007 @tindex \
16008 The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
16009 to produce an integer result.  It is equivalent to dividing with
16010 @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
16011 more convenient and efficient.  Also, since it is an all-integer
16012 operation when the arguments are integers, it avoids problems that
16013 @kbd{/ F} would have with floating-point roundoff.
16015 @kindex %
16016 @pindex calc-mod
16017 @ignore
16018 @mindex @null
16019 @end ignore
16020 @tindex %
16021 The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
16022 operation.  Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
16023 for all real numbers @cite{a} and @cite{b} (except @cite{b=0}).  For
16024 positive @cite{b}, the result will always be between 0 (inclusive) and
16025 @cite{b} (exclusive).  Modulo does not work for HMS forms and error forms.
16026 If @cite{a} is a modulo form, its modulo is changed to @cite{b}, which
16027 must be positive real number.
16029 @kindex :
16030 @pindex calc-fdiv
16031 @tindex fdiv
16032 The @kbd{:} (@code{calc-fdiv}) command [@code{fdiv} function in a formula]
16033 divides the two integers on the top of the stack to produce a fractional
16034 result.  This is a convenient shorthand for enabling Fraction Mode (with
16035 @kbd{m f}) temporarily and using @samp{/}.  Note that during numeric entry
16036 the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
16037 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}.  (Of course, in
16038 this case, it would be much easier simply to enter the fraction directly
16039 as @kbd{8:6 @key{RET}}!)
16041 @kindex n
16042 @pindex calc-change-sign
16043 The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
16044 of the stack.  It works on numbers, vectors and matrices, HMS forms, date
16045 forms, error forms, intervals, and modulo forms.
16047 @kindex A
16048 @pindex calc-abs
16049 @tindex abs
16050 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
16051 value of a number.  The result of @code{abs} is always a nonnegative
16052 real number:  With a complex argument, it computes the complex magnitude.
16053 With a vector or matrix argument, it computes the Frobenius norm, i.e.,
16054 the square root of the sum of the squares of the absolute values of the
16055 elements.  The absolute value of an error form is defined by replacing
16056 the mean part with its absolute value and leaving the error part the same.
16057 The absolute value of a modulo form is undefined.  The absolute value of
16058 an interval is defined in the obvious way.
16060 @kindex f A
16061 @pindex calc-abssqr
16062 @tindex abssqr
16063 The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
16064 absolute value squared of a number, vector or matrix, or error form.
16066 @kindex f s
16067 @pindex calc-sign
16068 @tindex sign
16069 The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
16070 argument is positive, @i{-1} if its argument is negative, or 0 if its
16071 argument is zero.  In algebraic form, you can also write @samp{sign(a,x)}
16072 which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
16073 zero depending on the sign of @samp{a}.
16075 @kindex &
16076 @pindex calc-inv
16077 @tindex inv
16078 @cindex Reciprocal
16079 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
16080 reciprocal of a number, i.e., @cite{1 / x}.  Operating on a square
16081 matrix, it computes the inverse of that matrix.
16083 @kindex Q
16084 @pindex calc-sqrt
16085 @tindex sqrt
16086 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
16087 root of a number.  For a negative real argument, the result will be a
16088 complex number whose form is determined by the current Polar Mode.
16090 @kindex f h
16091 @pindex calc-hypot
16092 @tindex hypot
16093 The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
16094 root of the sum of the squares of two numbers.  That is, @samp{hypot(a,b)}
16095 is the length of the hypotenuse of a right triangle with sides @cite{a}
16096 and @cite{b}.  If the arguments are complex numbers, their squared
16097 magnitudes are used.
16099 @kindex f Q
16100 @pindex calc-isqrt
16101 @tindex isqrt
16102 The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
16103 integer square root of an integer.  This is the true square root of the
16104 number, rounded down to an integer.  For example, @samp{isqrt(10)}
16105 produces 3.  Note that, like @kbd{\} [@code{idiv}], this uses exact
16106 integer arithmetic throughout to avoid roundoff problems.  If the input
16107 is a floating-point number or other non-integer value, this is exactly
16108 the same as @samp{floor(sqrt(x))}.
16110 @kindex f n
16111 @kindex f x
16112 @pindex calc-min
16113 @tindex min
16114 @pindex calc-max
16115 @tindex max
16116 The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
16117 [@code{max}] commands take the minimum or maximum of two real numbers,
16118 respectively.  These commands also work on HMS forms, date forms,
16119 intervals, and infinities.  (In algebraic expressions, these functions
16120 take any number of arguments and return the maximum or minimum among
16121 all the arguments.)@refill
16123 @kindex f M
16124 @kindex f X
16125 @pindex calc-mant-part
16126 @tindex mant
16127 @pindex calc-xpon-part
16128 @tindex xpon
16129 The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
16130 the ``mantissa'' part @cite{m} of its floating-point argument; @kbd{f X}
16131 (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
16132 @cite{e}.  The original number is equal to @c{$m \times 10^e$}
16133 @cite{m * 10^e},
16134 where @cite{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
16135 @cite{m=e=0} if the original number is zero.  For integers
16136 and fractions, @code{mant} returns the number unchanged and @code{xpon}
16137 returns zero.  The @kbd{v u} (@code{calc-unpack}) command can also be
16138 used to ``unpack'' a floating-point number; this produces an integer
16139 mantissa and exponent, with the constraint that the mantissa is not
16140 a multiple of ten (again except for the @cite{m=e=0} case).@refill
16142 @kindex f S
16143 @pindex calc-scale-float
16144 @tindex scf
16145 The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
16146 by a given power of ten.  Thus, @samp{scf(mant(x), xpon(x)) = x} for any
16147 real @samp{x}.  The second argument must be an integer, but the first
16148 may actually be any numeric value.  For example, @samp{scf(5,-2) = 0.05}
16149 or @samp{1:20} depending on the current Fraction Mode.@refill
16151 @kindex f [
16152 @kindex f ]
16153 @pindex calc-decrement
16154 @pindex calc-increment
16155 @tindex decr
16156 @tindex incr
16157 The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
16158 (@code{calc-increment}) [@code{incr}] functions decrease or increase
16159 a number by one unit.  For integers, the effect is obvious.  For
16160 floating-point numbers, the change is by one unit in the last place.
16161 For example, incrementing @samp{12.3456} when the current precision
16162 is 6 digits yields @samp{12.3457}.  If the current precision had been
16163 8 digits, the result would have been @samp{12.345601}.  Incrementing
16164 @samp{0.0} produces @c{$10^{-p}$}
16165 @cite{10^-p}, where @cite{p} is the current
16166 precision.  These operations are defined only on integers and floats.
16167 With numeric prefix arguments, they change the number by @cite{n} units.
16169 Note that incrementing followed by decrementing, or vice-versa, will
16170 almost but not quite always cancel out.  Suppose the precision is
16171 6 digits and the number @samp{9.99999} is on the stack.  Incrementing
16172 will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
16173 One digit has been dropped.  This is an unavoidable consequence of the
16174 way floating-point numbers work.
16176 Incrementing a date/time form adjusts it by a certain number of seconds.
16177 Incrementing a pure date form adjusts it by a certain number of days.
16179 @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
16180 @section Integer Truncation
16182 @noindent
16183 There are four commands for truncating a real number to an integer,
16184 differing mainly in their treatment of negative numbers.  All of these
16185 commands have the property that if the argument is an integer, the result
16186 is the same integer.  An integer-valued floating-point argument is converted
16187 to integer form.
16189 If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
16190 expressed as an integer-valued floating-point number.
16192 @cindex Integer part of a number
16193 @kindex F
16194 @pindex calc-floor
16195 @tindex floor
16196 @tindex ffloor
16197 @ignore
16198 @mindex @null
16199 @end ignore
16200 @kindex H F
16201 The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
16202 truncates a real number to the next lower integer, i.e., toward minus
16203 infinity.  Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
16204 @i{-4}.@refill
16206 @kindex I F
16207 @pindex calc-ceiling
16208 @tindex ceil
16209 @tindex fceil
16210 @ignore
16211 @mindex @null
16212 @end ignore
16213 @kindex H I F
16214 The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
16215 command truncates toward positive infinity.  Thus @kbd{3.6 I F} produces
16216 4, and @kbd{_3.6 I F} produces @i{-3}.@refill
16218 @kindex R
16219 @pindex calc-round
16220 @tindex round
16221 @tindex fround
16222 @ignore
16223 @mindex @null
16224 @end ignore
16225 @kindex H R
16226 The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
16227 rounds to the nearest integer.  When the fractional part is .5 exactly,
16228 this command rounds away from zero.  (All other rounding in the
16229 Calculator uses this convention as well.)  Thus @kbd{3.5 R} produces 4
16230 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @i{-4}.@refill
16232 @kindex I R
16233 @pindex calc-trunc
16234 @tindex trunc
16235 @tindex ftrunc
16236 @ignore
16237 @mindex @null
16238 @end ignore
16239 @kindex H I R
16240 The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
16241 command truncates toward zero.  In other words, it ``chops off''
16242 everything after the decimal point.  Thus @kbd{3.6 I R} produces 3 and
16243 @kbd{_3.6 I R} produces @i{-3}.@refill
16245 These functions may not be applied meaningfully to error forms, but they
16246 do work for intervals.  As a convenience, applying @code{floor} to a
16247 modulo form floors the value part of the form.  Applied to a vector,
16248 these functions operate on all elements of the vector one by one.
16249 Applied to a date form, they operate on the internal numerical
16250 representation of dates, converting a date/time form into a pure date.
16252 @ignore
16253 @starindex
16254 @end ignore
16255 @tindex rounde
16256 @ignore
16257 @starindex
16258 @end ignore
16259 @tindex roundu
16260 @ignore
16261 @starindex
16262 @end ignore
16263 @tindex frounde
16264 @ignore
16265 @starindex
16266 @end ignore
16267 @tindex froundu
16268 There are two more rounding functions which can only be entered in
16269 algebraic notation.  The @code{roundu} function is like @code{round}
16270 except that it rounds up, toward plus infinity, when the fractional
16271 part is .5.  This distinction matters only for negative arguments.
16272 Also, @code{rounde} rounds to an even number in the case of a tie,
16273 rounding up or down as necessary.  For example, @samp{rounde(3.5)} and
16274 @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
16275 The advantage of round-to-even is that the net error due to rounding
16276 after a long calculation tends to cancel out to zero.  An important
16277 subtle point here is that the number being fed to @code{rounde} will
16278 already have been rounded to the current precision before @code{rounde}
16279 begins.  For example, @samp{rounde(2.500001)} with a current precision
16280 of 6 will incorrectly, or at least surprisingly, yield 2 because the
16281 argument will first have been rounded down to @cite{2.5} (which
16282 @code{rounde} sees as an exact tie between 2 and 3).
16284 Each of these functions, when written in algebraic formulas, allows
16285 a second argument which specifies the number of digits after the
16286 decimal point to keep.  For example, @samp{round(123.4567, 2)} will
16287 produce the answer 123.46, and @samp{round(123.4567, -1)} will
16288 produce 120 (i.e., the cutoff is one digit to the @emph{left} of
16289 the decimal point).  A second argument of zero is equivalent to
16290 no second argument at all.
16292 @cindex Fractional part of a number
16293 To compute the fractional part of a number (i.e., the amount which, when
16294 added to `@t{floor(}@var{n}@t{)}', will produce @var{n}) just take @var{n}
16295 modulo 1 using the @code{%} command.@refill
16297 Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
16298 and @kbd{f Q} (integer square root) commands, which are analogous to
16299 @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
16300 arguments and return the result rounded down to an integer.
16302 @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
16303 @section Complex Number Functions
16305 @noindent
16306 @kindex J
16307 @pindex calc-conj
16308 @tindex conj
16309 The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
16310 complex conjugate of a number.  For complex number @cite{a+bi}, the
16311 complex conjugate is @cite{a-bi}.  If the argument is a real number,
16312 this command leaves it the same.  If the argument is a vector or matrix,
16313 this command replaces each element by its complex conjugate.
16315 @kindex G
16316 @pindex calc-argument
16317 @tindex arg
16318 The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
16319 ``argument'' or polar angle of a complex number.  For a number in polar
16320 notation, this is simply the second component of the pair
16321 `@t{(}@var{r}@t{;}@c{$\theta$}
16322 @var{theta}@t{)}'.
16323 The result is expressed according to the current angular mode and will
16324 be in the range @i{-180} degrees (exclusive) to @i{+180} degrees
16325 (inclusive), or the equivalent range in radians.@refill
16327 @pindex calc-imaginary
16328 The @code{calc-imaginary} command multiplies the number on the
16329 top of the stack by the imaginary number @cite{i = (0,1)}.  This
16330 command is not normally bound to a key in Calc, but it is available
16331 on the @key{IMAG} button in Keypad Mode.
16333 @kindex f r
16334 @pindex calc-re
16335 @tindex re
16336 The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
16337 by its real part.  This command has no effect on real numbers.  (As an
16338 added convenience, @code{re} applied to a modulo form extracts
16339 the value part.)@refill
16341 @kindex f i
16342 @pindex calc-im
16343 @tindex im
16344 The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
16345 by its imaginary part; real numbers are converted to zero.  With a vector
16346 or matrix argument, these functions operate element-wise.@refill
16348 @ignore
16349 @mindex v p
16350 @end ignore
16351 @kindex v p (complex)
16352 @pindex calc-pack
16353 The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
16354 the stack into a composite object such as a complex number.  With
16355 a prefix argument of @i{-1}, it produces a rectangular complex number;
16356 with an argument of @i{-2}, it produces a polar complex number.
16357 (Also, @pxref{Building Vectors}.)
16359 @ignore
16360 @mindex v u
16361 @end ignore
16362 @kindex v u (complex)
16363 @pindex calc-unpack
16364 The @kbd{v u} (@code{calc-unpack}) command takes the complex number
16365 (or other composite object) on the top of the stack and unpacks it
16366 into its separate components.
16368 @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
16369 @section Conversions
16371 @noindent
16372 The commands described in this section convert numbers from one form
16373 to another; they are two-key sequences beginning with the letter @kbd{c}.
16375 @kindex c f
16376 @pindex calc-float
16377 @tindex pfloat
16378 The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
16379 number on the top of the stack to floating-point form.  For example,
16380 @cite{23} is converted to @cite{23.0}, @cite{3:2} is converted to
16381 @cite{1.5}, and @cite{2.3} is left the same.  If the value is a composite
16382 object such as a complex number or vector, each of the components is
16383 converted to floating-point.  If the value is a formula, all numbers
16384 in the formula are converted to floating-point.  Note that depending
16385 on the current floating-point precision, conversion to floating-point
16386 format may lose information.@refill
16388 As a special exception, integers which appear as powers or subscripts
16389 are not floated by @kbd{c f}.  If you really want to float a power,
16390 you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
16391 Because @kbd{c f} cannot examine the formula outside of the selection,
16392 it does not notice that the thing being floated is a power.
16393 @xref{Selecting Subformulas}.
16395 The normal @kbd{c f} command is ``pervasive'' in the sense that it
16396 applies to all numbers throughout the formula.  The @code{pfloat}
16397 algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
16398 changes to @samp{a + 1.0} as soon as it is evaluated.
16400 @kindex H c f
16401 @tindex float
16402 With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
16403 only on the number or vector of numbers at the top level of its
16404 argument.  Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
16405 is left unevaluated because its argument is not a number.
16407 You should use @kbd{H c f} if you wish to guarantee that the final
16408 value, once all the variables have been assigned, is a float; you
16409 would use @kbd{c f} if you wish to do the conversion on the numbers
16410 that appear right now.
16412 @kindex c F
16413 @pindex calc-fraction
16414 @tindex pfrac
16415 The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
16416 floating-point number into a fractional approximation.  By default, it
16417 produces a fraction whose decimal representation is the same as the
16418 input number, to within the current precision.  You can also give a
16419 numeric prefix argument to specify a tolerance, either directly, or,
16420 if the prefix argument is zero, by using the number on top of the stack
16421 as the tolerance.  If the tolerance is a positive integer, the fraction
16422 is correct to within that many significant figures.  If the tolerance is
16423 a non-positive integer, it specifies how many digits fewer than the current
16424 precision to use.  If the tolerance is a floating-point number, the
16425 fraction is correct to within that absolute amount.
16427 @kindex H c F
16428 @tindex frac
16429 The @code{pfrac} function is pervasive, like @code{pfloat}.
16430 There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
16431 which is analogous to @kbd{H c f} discussed above.
16433 @kindex c d
16434 @pindex calc-to-degrees
16435 @tindex deg
16436 The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
16437 number into degrees form.  The value on the top of the stack may be an
16438 HMS form (interpreted as degrees-minutes-seconds), or a real number which
16439 will be interpreted in radians regardless of the current angular mode.@refill
16441 @kindex c r
16442 @pindex calc-to-radians
16443 @tindex rad
16444 The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
16445 HMS form or angle in degrees into an angle in radians.
16447 @kindex c h
16448 @pindex calc-to-hms
16449 @tindex hms
16450 The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
16451 number, interpreted according to the current angular mode, to an HMS
16452 form describing the same angle.  In algebraic notation, the @code{hms}
16453 function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
16454 (The three-argument version is independent of the current angular mode.)
16456 @pindex calc-from-hms
16457 The @code{calc-from-hms} command converts the HMS form on the top of the
16458 stack into a real number according to the current angular mode.
16460 @kindex c p
16461 @kindex I c p
16462 @pindex calc-polar
16463 @tindex polar
16464 @tindex rect
16465 The @kbd{c p} (@code{calc-polar}) command converts the complex number on
16466 the top of the stack from polar to rectangular form, or from rectangular
16467 to polar form, whichever is appropriate.  Real numbers are left the same.
16468 This command is equivalent to the @code{rect} or @code{polar}
16469 functions in algebraic formulas, depending on the direction of
16470 conversion.  (It uses @code{polar}, except that if the argument is
16471 already a polar complex number, it uses @code{rect} instead.  The
16472 @kbd{I c p} command always uses @code{rect}.)@refill
16474 @kindex c c
16475 @pindex calc-clean
16476 @tindex pclean
16477 The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
16478 number on the top of the stack.  Floating point numbers are re-rounded
16479 according to the current precision.  Polar numbers whose angular
16480 components have strayed from the @i{-180} to @i{+180} degree range
16481 are normalized.  (Note that results will be undesirable if the current
16482 angular mode is different from the one under which the number was
16483 produced!)  Integers and fractions are generally unaffected by this
16484 operation.  Vectors and formulas are cleaned by cleaning each component
16485 number (i.e., pervasively).@refill
16487 If the simplification mode is set below the default level, it is raised
16488 to the default level for the purposes of this command.  Thus, @kbd{c c}
16489 applies the default simplifications even if their automatic application
16490 is disabled.  @xref{Simplification Modes}.
16492 @cindex Roundoff errors, correcting
16493 A numeric prefix argument to @kbd{c c} sets the floating-point precision
16494 to that value for the duration of the command.  A positive prefix (of at
16495 least 3) sets the precision to the specified value; a negative or zero
16496 prefix decreases the precision by the specified amount.
16498 @kindex c 0-9
16499 @pindex calc-clean-num
16500 The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
16501 to @kbd{c c} with the corresponding negative prefix argument.  If roundoff
16502 errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
16503 decimal place often conveniently does the trick.
16505 The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
16506 through @kbd{c 9} commands, also ``clip'' very small floating-point
16507 numbers to zero.  If the exponent is less than or equal to the negative
16508 of the specified precision, the number is changed to 0.0.  For example,
16509 if the current precision is 12, then @kbd{c 2} changes the vector
16510 @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
16511 Numbers this small generally arise from roundoff noise.
16513 If the numbers you are using really are legitimately this small,
16514 you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
16515 (The plain @kbd{c c} command rounds to the current precision but
16516 does not clip small numbers.)
16518 One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
16519 a prefix argument, is that integer-valued floats are converted to
16520 plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
16521 produces @samp{[1, 1.5, 2, 2.5, 3]}.  This is not done for huge
16522 numbers (@samp{1e100} is technically an integer-valued float, but
16523 you wouldn't want it automatically converted to a 100-digit integer).
16525 @kindex H c 0-9
16526 @kindex H c c
16527 @tindex clean
16528 With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
16529 operate non-pervasively [@code{clean}].
16531 @node Date Arithmetic, Financial Functions, Conversions, Arithmetic
16532 @section Date Arithmetic
16534 @noindent
16535 @cindex Date arithmetic, additional functions
16536 The commands described in this section perform various conversions
16537 and calculations involving date forms (@pxref{Date Forms}).  They
16538 use the @kbd{t} (for time/date) prefix key followed by shifted
16539 letters.
16541 The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
16542 commands.  In particular, adding a number to a date form advances the
16543 date form by a certain number of days; adding an HMS form to a date
16544 form advances the date by a certain amount of time; and subtracting two
16545 date forms produces a difference measured in days.  The commands
16546 described here provide additional, more specialized operations on dates.
16548 Many of these commands accept a numeric prefix argument; if you give
16549 plain @kbd{C-u} as the prefix, these commands will instead take the
16550 additional argument from the top of the stack.
16552 @menu
16553 * Date Conversions::
16554 * Date Functions::
16555 * Time Zones::
16556 * Business Days::
16557 @end menu
16559 @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
16560 @subsection Date Conversions
16562 @noindent
16563 @kindex t D
16564 @pindex calc-date
16565 @tindex date
16566 The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
16567 date form into a number, measured in days since Jan 1, 1 AD.  The
16568 result will be an integer if @var{date} is a pure date form, or a
16569 fraction or float if @var{date} is a date/time form.  Or, if its
16570 argument is a number, it converts this number into a date form.
16572 With a numeric prefix argument, @kbd{t D} takes that many objects
16573 (up to six) from the top of the stack and interprets them in one
16574 of the following ways:
16576 The @samp{date(@var{year}, @var{month}, @var{day})} function
16577 builds a pure date form out of the specified year, month, and
16578 day, which must all be integers.  @var{Year} is a year number,
16579 such as 1991 (@emph{not} the same as 91!).  @var{Month} must be
16580 an integer in the range 1 to 12; @var{day} must be in the range
16581 1 to 31.  If the specified month has fewer than 31 days and
16582 @var{day} is too large, the equivalent day in the following
16583 month will be used.
16585 The @samp{date(@var{month}, @var{day})} function builds a
16586 pure date form using the current year, as determined by the
16587 real-time clock.
16589 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
16590 function builds a date/time form using an @var{hms} form.
16592 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
16593 @var{minute}, @var{second})} function builds a date/time form.
16594 @var{hour} should be an integer in the range 0 to 23;
16595 @var{minute} should be an integer in the range 0 to 59;
16596 @var{second} should be any real number in the range @samp{[0 .. 60)}.
16597 The last two arguments default to zero if omitted.
16599 @kindex t J
16600 @pindex calc-julian
16601 @tindex julian
16602 @cindex Julian day counts, conversions
16603 The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
16604 a date form into a Julian day count, which is the number of days
16605 since noon on Jan 1, 4713 BC.  A pure date is converted to an integer
16606 Julian count representing noon of that day.  A date/time form is
16607 converted to an exact floating-point Julian count, adjusted to
16608 interpret the date form in the current time zone but the Julian
16609 day count in Greenwich Mean Time.  A numeric prefix argument allows
16610 you to specify the time zone; @pxref{Time Zones}.  Use a prefix of
16611 zero to suppress the time zone adjustment.  Note that pure date forms
16612 are never time-zone adjusted.
16614 This command can also do the opposite conversion, from a Julian day
16615 count (either an integer day, or a floating-point day and time in
16616 the GMT zone), into a pure date form or a date/time form in the
16617 current or specified time zone.
16619 @kindex t U
16620 @pindex calc-unix-time
16621 @tindex unixtime
16622 @cindex Unix time format, conversions
16623 The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
16624 converts a date form into a Unix time value, which is the number of
16625 seconds since midnight on Jan 1, 1970, or vice-versa.  The numeric result
16626 will be an integer if the current precision is 12 or less; for higher
16627 precisions, the result may be a float with (@var{precision}@minus{}12)
16628 digits after the decimal.  Just as for @kbd{t J}, the numeric time
16629 is interpreted in the GMT time zone and the date form is interpreted
16630 in the current or specified zone.  Some systems use Unix-like
16631 numbering but with the local time zone; give a prefix of zero to
16632 suppress the adjustment if so.
16634 @kindex t C
16635 @pindex calc-convert-time-zones
16636 @tindex tzconv
16637 @cindex Time Zones, converting between
16638 The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
16639 command converts a date form from one time zone to another.  You
16640 are prompted for each time zone name in turn; you can answer with
16641 any suitable Calc time zone expression (@pxref{Time Zones}).
16642 If you answer either prompt with a blank line, the local time
16643 zone is used for that prompt.  You can also answer the first
16644 prompt with @kbd{$} to take the two time zone names from the
16645 stack (and the date to be converted from the third stack level).
16647 @node Date Functions, Business Days, Date Conversions, Date Arithmetic
16648 @subsection Date Functions
16650 @noindent
16651 @kindex t N
16652 @pindex calc-now
16653 @tindex now
16654 The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
16655 current date and time on the stack as a date form.  The time is
16656 reported in terms of the specified time zone; with no numeric prefix
16657 argument, @kbd{t N} reports for the current time zone.
16659 @kindex t P
16660 @pindex calc-date-part
16661 The @kbd{t P} (@code{calc-date-part}) command extracts one part
16662 of a date form.  The prefix argument specifies the part; with no
16663 argument, this command prompts for a part code from 1 to 9.
16664 The various part codes are described in the following paragraphs.
16666 @tindex year
16667 The @kbd{M-1 t P} [@code{year}] function extracts the year number
16668 from a date form as an integer, e.g., 1991.  This and the
16669 following functions will also accept a real number for an
16670 argument, which is interpreted as a standard Calc day number.
16671 Note that this function will never return zero, since the year
16672 1 BC immediately precedes the year 1 AD.
16674 @tindex month
16675 The @kbd{M-2 t P} [@code{month}] function extracts the month number
16676 from a date form as an integer in the range 1 to 12.
16678 @tindex day
16679 The @kbd{M-3 t P} [@code{day}] function extracts the day number
16680 from a date form as an integer in the range 1 to 31.
16682 @tindex hour
16683 The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
16684 a date form as an integer in the range 0 (midnight) to 23.  Note
16685 that 24-hour time is always used.  This returns zero for a pure
16686 date form.  This function (and the following two) also accept
16687 HMS forms as input.
16689 @tindex minute
16690 The @kbd{M-5 t P} [@code{minute}] function extracts the minute
16691 from a date form as an integer in the range 0 to 59.
16693 @tindex second
16694 The @kbd{M-6 t P} [@code{second}] function extracts the second
16695 from a date form.  If the current precision is 12 or less,
16696 the result is an integer in the range 0 to 59.  For higher
16697 precisions, the result may instead be a floating-point number.
16699 @tindex weekday
16700 The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
16701 number from a date form as an integer in the range 0 (Sunday)
16702 to 6 (Saturday).
16704 @tindex yearday
16705 The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
16706 number from a date form as an integer in the range 1 (January 1)
16707 to 366 (December 31 of a leap year).
16709 @tindex time
16710 The @kbd{M-9 t P} [@code{time}] function extracts the time portion
16711 of a date form as an HMS form.  This returns @samp{0@@ 0' 0"}
16712 for a pure date form.
16714 @kindex t M
16715 @pindex calc-new-month
16716 @tindex newmonth
16717 The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
16718 computes a new date form that represents the first day of the month
16719 specified by the input date.  The result is always a pure date
16720 form; only the year and month numbers of the input are retained.
16721 With a numeric prefix argument @var{n} in the range from 1 to 31,
16722 @kbd{t M} computes the @var{n}th day of the month.  (If @var{n}
16723 is greater than the actual number of days in the month, or if
16724 @var{n} is zero, the last day of the month is used.)
16726 @kindex t Y
16727 @pindex calc-new-year
16728 @tindex newyear
16729 The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
16730 computes a new pure date form that represents the first day of
16731 the year specified by the input.  The month, day, and time
16732 of the input date form are lost.  With a numeric prefix argument
16733 @var{n} in the range from 1 to 366, @kbd{t Y} computes the
16734 @var{n}th day of the year (366 is treated as 365 in non-leap
16735 years).  A prefix argument of 0 computes the last day of the
16736 year (December 31).  A negative prefix argument from @i{-1} to
16737 @i{-12} computes the first day of the @var{n}th month of the year.
16739 @kindex t W
16740 @pindex calc-new-week
16741 @tindex newweek
16742 The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
16743 computes a new pure date form that represents the Sunday on or before
16744 the input date.  With a numeric prefix argument, it can be made to
16745 use any day of the week as the starting day; the argument must be in
16746 the range from 0 (Sunday) to 6 (Saturday).  This function always
16747 subtracts between 0 and 6 days from the input date.
16749 Here's an example use of @code{newweek}:  Find the date of the next
16750 Wednesday after a given date.  Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
16751 will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
16752 will give you the following Wednesday.  A further look at the definition
16753 of @code{newweek} shows that if the input date is itself a Wednesday,
16754 this formula will return the Wednesday one week in the future.  An
16755 exercise for the reader is to modify this formula to yield the same day
16756 if the input is already a Wednesday.  Another interesting exercise is
16757 to preserve the time-of-day portion of the input (@code{newweek} resets
16758 the time to midnight; hint:@: how can @code{newweek} be defined in terms
16759 of the @code{weekday} function?).
16761 @ignore
16762 @starindex
16763 @end ignore
16764 @tindex pwday
16765 The @samp{pwday(@var{date})} function (not on any key) computes the
16766 day-of-month number of the Sunday on or before @var{date}.  With
16767 two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
16768 number of the Sunday on or before day number @var{day} of the month
16769 specified by @var{date}.  The @var{day} must be in the range from
16770 7 to 31; if the day number is greater than the actual number of days
16771 in the month, the true number of days is used instead.  Thus
16772 @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
16773 @samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
16774 With a third @var{weekday} argument, @code{pwday} can be made to look
16775 for any day of the week instead of Sunday.
16777 @kindex t I
16778 @pindex calc-inc-month
16779 @tindex incmonth
16780 The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
16781 increases a date form by one month, or by an arbitrary number of
16782 months specified by a numeric prefix argument.  The time portion,
16783 if any, of the date form stays the same.  The day also stays the
16784 same, except that if the new month has fewer days the day
16785 number may be reduced to lie in the valid range.  For example,
16786 @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
16787 Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
16788 the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
16789 in this case).
16791 @ignore
16792 @starindex
16793 @end ignore
16794 @tindex incyear
16795 The @samp{incyear(@var{date}, @var{step})} function increases
16796 a date form by the specified number of years, which may be
16797 any positive or negative integer.  Note that @samp{incyear(d, n)}
16798 is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
16799 simple equivalents in terms of day arithmetic because
16800 months and years have varying lengths.  If the @var{step}
16801 argument is omitted, 1 year is assumed.  There is no keyboard
16802 command for this function; use @kbd{C-u 12 t I} instead.
16804 There is no @code{newday} function at all because @kbd{F} [@code{floor}]
16805 serves this purpose.  Similarly, instead of @code{incday} and
16806 @code{incweek} simply use @cite{d + n} or @cite{d + 7 n}.
16808 @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
16809 which can adjust a date/time form by a certain number of seconds.
16811 @node Business Days, Time Zones, Date Functions, Date Arithmetic
16812 @subsection Business Days
16814 @noindent
16815 Often time is measured in ``business days'' or ``working days,''
16816 where weekends and holidays are skipped.  Calc's normal date
16817 arithmetic functions use calendar days, so that subtracting two
16818 consecutive Mondays will yield a difference of 7 days.  By contrast,
16819 subtracting two consecutive Mondays would yield 5 business days
16820 (assuming two-day weekends and the absence of holidays).
16822 @kindex t +
16823 @kindex t -
16824 @tindex badd
16825 @tindex bsub
16826 @pindex calc-business-days-plus
16827 @pindex calc-business-days-minus
16828 The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
16829 and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
16830 commands perform arithmetic using business days.  For @kbd{t +},
16831 one argument must be a date form and the other must be a real
16832 number (positive or negative).  If the number is not an integer,
16833 then a certain amount of time is added as well as a number of
16834 days; for example, adding 0.5 business days to a time in Friday
16835 evening will produce a time in Monday morning.  It is also
16836 possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
16837 half a business day.  For @kbd{t -}, the arguments are either a
16838 date form and a number or HMS form, or two date forms, in which
16839 case the result is the number of business days between the two
16840 dates.
16842 @cindex @code{Holidays} variable
16843 @vindex Holidays
16844 By default, Calc considers any day that is not a Saturday or
16845 Sunday to be a business day.  You can define any number of
16846 additional holidays by editing the variable @code{Holidays}.
16847 (There is an @w{@kbd{s H}} convenience command for editing this
16848 variable.)  Initially, @code{Holidays} contains the vector
16849 @samp{[sat, sun]}.  Entries in the @code{Holidays} vector may
16850 be any of the following kinds of objects:
16852 @itemize @bullet
16853 @item
16854 Date forms (pure dates, not date/time forms).  These specify
16855 particular days which are to be treated as holidays.
16857 @item
16858 Intervals of date forms.  These specify a range of days, all of
16859 which are holidays (e.g., Christmas week).  @xref{Interval Forms}.
16861 @item
16862 Nested vectors of date forms.  Each date form in the vector is
16863 considered to be a holiday.
16865 @item
16866 Any Calc formula which evaluates to one of the above three things.
16867 If the formula involves the variable @cite{y}, it stands for a
16868 yearly repeating holiday; @cite{y} will take on various year
16869 numbers like 1992.  For example, @samp{date(y, 12, 25)} specifies
16870 Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
16871 Thanksgiving (which is held on the fourth Thursday of November).
16872 If the formula involves the variable @cite{m}, that variable
16873 takes on month numbers from 1 to 12:  @samp{date(y, m, 15)} is
16874 a holiday that takes place on the 15th of every month.
16876 @item
16877 A weekday name, such as @code{sat} or @code{sun}.  This is really
16878 a variable whose name is a three-letter, lower-case day name.
16880 @item
16881 An interval of year numbers (integers).  This specifies the span of
16882 years over which this holiday list is to be considered valid.  Any
16883 business-day arithmetic that goes outside this range will result
16884 in an error message.  Use this if you are including an explicit
16885 list of holidays, rather than a formula to generate them, and you
16886 want to make sure you don't accidentally go beyond the last point
16887 where the holidays you entered are complete.  If there is no
16888 limiting interval in the @code{Holidays} vector, the default
16889 @samp{[1 .. 2737]} is used.  (This is the absolute range of years
16890 for which Calc's business-day algorithms will operate.)
16892 @item
16893 An interval of HMS forms.  This specifies the span of hours that
16894 are to be considered one business day.  For example, if this
16895 range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
16896 the business day is only eight hours long, so that @kbd{1.5 t +}
16897 on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
16898 four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
16899 Likewise, @kbd{t -} will now express differences in time as
16900 fractions of an eight-hour day.  Times before 9am will be treated
16901 as 9am by business date arithmetic, and times at or after 5pm will
16902 be treated as 4:59:59pm.  If there is no HMS interval in @code{Holidays},
16903 the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
16904 (Regardless of the type of bounds you specify, the interval is
16905 treated as inclusive on the low end and exclusive on the high end,
16906 so that the work day goes from 9am up to, but not including, 5pm.)
16907 @end itemize
16909 If the @code{Holidays} vector is empty, then @kbd{t +} and
16910 @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
16911 then be no difference between business days and calendar days.
16913 Calc expands the intervals and formulas you give into a complete
16914 list of holidays for internal use.  This is done mainly to make
16915 sure it can detect multiple holidays.  (For example,
16916 @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
16917 Calc's algorithms take care to count it only once when figuring
16918 the number of holidays between two dates.)
16920 Since the complete list of holidays for all the years from 1 to
16921 2737 would be huge, Calc actually computes only the part of the
16922 list between the smallest and largest years that have been involved
16923 in business-day calculations so far.  Normally, you won't have to
16924 worry about this.  Keep in mind, however, that if you do one
16925 calculation for 1992, and another for 1792, even if both involve
16926 only a small range of years, Calc will still work out all the
16927 holidays that fall in that 200-year span.
16929 If you add a (positive) number of days to a date form that falls on a
16930 weekend or holiday, the date form is treated as if it were the most
16931 recent business day.  (Thus adding one business day to a Friday,
16932 Saturday, or Sunday will all yield the following Monday.)  If you
16933 subtract a number of days from a weekend or holiday, the date is
16934 effectively on the following business day.  (So subtracting one business
16935 day from Saturday, Sunday, or Monday yields the preceding Friday.)  The
16936 difference between two dates one or both of which fall on holidays
16937 equals the number of actual business days between them.  These
16938 conventions are consistent in the sense that, if you add @var{n}
16939 business days to any date, the difference between the result and the
16940 original date will come out to @var{n} business days.  (It can't be
16941 completely consistent though; a subtraction followed by an addition
16942 might come out a bit differently, since @kbd{t +} is incapable of
16943 producing a date that falls on a weekend or holiday.)
16945 @ignore
16946 @starindex
16947 @end ignore
16948 @tindex holiday
16949 There is a @code{holiday} function, not on any keys, that takes
16950 any date form and returns 1 if that date falls on a weekend or
16951 holiday, as defined in @code{Holidays}, or 0 if the date is a
16952 business day.
16954 @node Time Zones, , Business Days, Date Arithmetic
16955 @subsection Time Zones
16957 @noindent
16958 @cindex Time zones
16959 @cindex Daylight savings time
16960 Time zones and daylight savings time are a complicated business.
16961 The conversions to and from Julian and Unix-style dates automatically
16962 compute the correct time zone and daylight savings adjustment to use,
16963 provided they can figure out this information.  This section describes
16964 Calc's time zone adjustment algorithm in detail, in case you want to
16965 do conversions in different time zones or in case Calc's algorithms
16966 can't determine the right correction to use.
16968 Adjustments for time zones and daylight savings time are done by
16969 @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
16970 commands.  In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
16971 to exactly 30 days even though there is a daylight-savings
16972 transition in between.  This is also true for Julian pure dates:
16973 @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}.  But Julian
16974 and Unix date/times will adjust for daylight savings time:
16975 @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
16976 evaluates to @samp{29.95834} (that's 29 days and 23 hours)
16977 because one hour was lost when daylight savings commenced on
16978 April 7, 1991.
16980 In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
16981 computes the actual number of 24-hour periods between two dates, whereas
16982 @samp{@var{date1} - @var{date2}} computes the number of calendar
16983 days between two dates without taking daylight savings into account.
16985 @pindex calc-time-zone
16986 @ignore
16987 @starindex
16988 @end ignore
16989 @tindex tzone
16990 The @code{calc-time-zone} [@code{tzone}] command converts the time
16991 zone specified by its numeric prefix argument into a number of
16992 seconds difference from Greenwich mean time (GMT).  If the argument
16993 is a number, the result is simply that value multiplied by 3600.
16994 Typical arguments for North America are 5 (Eastern) or 8 (Pacific).  If
16995 Daylight Savings time is in effect, one hour should be subtracted from
16996 the normal difference.
16998 If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
16999 date arithmetic commands that include a time zone argument) takes the
17000 zone argument from the top of the stack.  (In the case of @kbd{t J}
17001 and @kbd{t U}, the normal argument is then taken from the second-to-top
17002 stack position.)  This allows you to give a non-integer time zone
17003 adjustment.  The time-zone argument can also be an HMS form, or
17004 it can be a variable which is a time zone name in upper- or lower-case.
17005 For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
17006 (for Pacific standard and daylight savings times, respectively).
17008 North American and European time zone names are defined as follows;
17009 note that for each time zone there is one name for standard time,
17010 another for daylight savings time, and a third for ``generalized'' time
17011 in which the daylight savings adjustment is computed from context.
17013 @smallexample
17014 @group
17015 YST  PST  MST  CST  EST  AST    NST    GMT   WET     MET    MEZ
17016  9    8    7    6    5    4     3.5     0     -1      -2     -2
17018 YDT  PDT  MDT  CDT  EDT  ADT    NDT    BST  WETDST  METDST  MESZ
17019  8    7    6    5    4    3     2.5     -1    -2      -3     -3
17021 YGT  PGT  MGT  CGT  EGT  AGT    NGT    BGT   WEGT    MEGT   MEGZ
17022 9/8  8/7  7/6  6/5  5/4  4/3  3.5/2.5  0/-1 -1/-2   -2/-3  -2/-3
17023 @end group
17024 @end smallexample
17026 @vindex math-tzone-names
17027 To define time zone names that do not appear in the above table,
17028 you must modify the Lisp variable @code{math-tzone-names}.  This
17029 is a list of lists describing the different time zone names; its
17030 structure is best explained by an example.  The three entries for
17031 Pacific Time look like this:
17033 @smallexample
17034 @group
17035 ( ( "PST" 8 0 )    ; Name as an upper-case string, then standard
17036   ( "PDT" 8 -1 )   ; adjustment, then daylight savings adjustment.
17037   ( "PGT" 8 "PST" "PDT" ) )   ; Generalized time zone.
17038 @end group
17039 @end smallexample
17041 @cindex @code{TimeZone} variable
17042 @vindex TimeZone
17043 With no arguments, @code{calc-time-zone} or @samp{tzone()} obtains an
17044 argument from the Calc variable @code{TimeZone} if a value has been
17045 stored for that variable.  If not, Calc runs the Unix @samp{date}
17046 command and looks for one of the above time zone names in the output;
17047 if this does not succeed, @samp{tzone()} leaves itself unevaluated.
17048 The time zone name in the @samp{date} output may be followed by a signed
17049 adjustment, e.g., @samp{GMT+5} or @samp{GMT+0500} which specifies a
17050 number of hours and minutes to be added to the base time zone.
17051 Calc stores the time zone it finds into @code{TimeZone} to speed
17052 later calls to @samp{tzone()}.
17054 The special time zone name @code{local} is equivalent to no argument,
17055 i.e., it uses the local time zone as obtained from the @code{date}
17056 command.
17058 If the time zone name found is one of the standard or daylight
17059 savings zone names from the above table, and Calc's internal
17060 daylight savings algorithm says that time and zone are consistent
17061 (e.g., @code{PDT} accompanies a date that Calc's algorithm would also
17062 consider to be daylight savings, or @code{PST} accompanies a date
17063 that Calc would consider to be standard time), then Calc substitutes
17064 the corresponding generalized time zone (like @code{PGT}).
17066 If your system does not have a suitable @samp{date} command, you
17067 may wish to put a @samp{(setq var-TimeZone ...)} in your Emacs
17068 initialization file to set the time zone.  The easiest way to do
17069 this is to edit the @code{TimeZone} variable using Calc's @kbd{s T}
17070 command, then use the @kbd{s p} (@code{calc-permanent-variable})
17071 command to save the value of @code{TimeZone} permanently.
17073 The @kbd{t J} and @code{t U} commands with no numeric prefix
17074 arguments do the same thing as @samp{tzone()}.  If the current
17075 time zone is a generalized time zone, e.g., @code{EGT}, Calc
17076 examines the date being converted to tell whether to use standard
17077 or daylight savings time.  But if the current time zone is explicit,
17078 e.g., @code{EST} or @code{EDT}, then that adjustment is used exactly
17079 and Calc's daylight savings algorithm is not consulted.
17081 Some places don't follow the usual rules for daylight savings time.
17082 The state of Arizona, for example, does not observe daylight savings
17083 time.  If you run Calc during the winter season in Arizona, the
17084 Unix @code{date} command will report @code{MST} time zone, which
17085 Calc will change to @code{MGT}.  If you then convert a time that
17086 lies in the summer months, Calc will apply an incorrect daylight
17087 savings time adjustment.  To avoid this, set your @code{TimeZone}
17088 variable explicitly to @code{MST} to force the use of standard,
17089 non-daylight-savings time.
17091 @vindex math-daylight-savings-hook
17092 @findex math-std-daylight-savings
17093 By default Calc always considers daylight savings time to begin at
17094 2 a.m.@: on the first Sunday of April, and to end at 2 a.m.@: on the
17095 last Sunday of October.  This is the rule that has been in effect
17096 in North America since 1987.  If you are in a country that uses
17097 different rules for computing daylight savings time, you have two
17098 choices:  Write your own daylight savings hook, or control time
17099 zones explicitly by setting the @code{TimeZone} variable and/or
17100 always giving a time-zone argument for the conversion functions.
17102 The Lisp variable @code{math-daylight-savings-hook} holds the
17103 name of a function that is used to compute the daylight savings
17104 adjustment for a given date.  The default is
17105 @code{math-std-daylight-savings}, which computes an adjustment
17106 (either 0 or @i{-1}) using the North American rules given above.
17108 The daylight savings hook function is called with four arguments:
17109 The date, as a floating-point number in standard Calc format;
17110 a six-element list of the date decomposed into year, month, day,
17111 hour, minute, and second, respectively; a string which contains
17112 the generalized time zone name in upper-case, e.g., @code{"WEGT"};
17113 and a special adjustment to be applied to the hour value when
17114 converting into a generalized time zone (see below).
17116 @findex math-prev-weekday-in-month
17117 The Lisp function @code{math-prev-weekday-in-month} is useful for
17118 daylight savings computations.  This is an internal version of
17119 the user-level @code{pwday} function described in the previous
17120 section. It takes four arguments:  The floating-point date value,
17121 the corresponding six-element date list, the day-of-month number,
17122 and the weekday number (0-6).
17124 The default daylight savings hook ignores the time zone name, but a
17125 more sophisticated hook could use different algorithms for different
17126 time zones.  It would also be possible to use different algorithms
17127 depending on the year number, but the default hook always uses the
17128 algorithm for 1987 and later.  Here is a listing of the default
17129 daylight savings hook:
17131 @smallexample
17132 (defun math-std-daylight-savings (date dt zone bump)
17133   (cond ((< (nth 1 dt) 4) 0)
17134         ((= (nth 1 dt) 4)
17135          (let ((sunday (math-prev-weekday-in-month date dt 7 0)))
17136            (cond ((< (nth 2 dt) sunday) 0)
17137                  ((= (nth 2 dt) sunday)
17138                   (if (>= (nth 3 dt) (+ 3 bump)) -1 0))
17139                  (t -1))))
17140         ((< (nth 1 dt) 10) -1)
17141         ((= (nth 1 dt) 10)
17142          (let ((sunday (math-prev-weekday-in-month date dt 31 0)))
17143            (cond ((< (nth 2 dt) sunday) -1)
17144                  ((= (nth 2 dt) sunday)
17145                   (if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
17146                  (t 0))))
17147         (t 0))
17149 @end smallexample
17151 @noindent
17152 The @code{bump} parameter is equal to zero when Calc is converting
17153 from a date form in a generalized time zone into a GMT date value.
17154 It is @i{-1} when Calc is converting in the other direction.  The
17155 adjustments shown above ensure that the conversion behaves correctly
17156 and reasonably around the 2 a.m.@: transition in each direction.
17158 There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
17159 beginning of daylight savings time; converting a date/time form that
17160 falls in this hour results in a time value for the following hour,
17161 from 3 a.m.@: to 4 a.m.  At the end of daylight savings time, the
17162 hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
17163 form that falls in in this hour results in a time value for the first
17164 manifestation of that time (@emph{not} the one that occurs one hour later).
17166 If @code{math-daylight-savings-hook} is @code{nil}, then the
17167 daylight savings adjustment is always taken to be zero.
17169 In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
17170 computes the time zone adjustment for a given zone name at a
17171 given date.  The @var{date} is ignored unless @var{zone} is a
17172 generalized time zone.  If @var{date} is a date form, the
17173 daylight savings computation is applied to it as it appears.
17174 If @var{date} is a numeric date value, it is adjusted for the
17175 daylight-savings version of @var{zone} before being given to
17176 the daylight savings hook.  This odd-sounding rule ensures
17177 that the daylight-savings computation is always done in
17178 local time, not in the GMT time that a numeric @var{date}
17179 is typically represented in.
17181 @ignore
17182 @starindex
17183 @end ignore
17184 @tindex dsadj
17185 The @samp{dsadj(@var{date}, @var{zone})} function computes the
17186 daylight savings adjustment that is appropriate for @var{date} in
17187 time zone @var{zone}.  If @var{zone} is explicitly in or not in
17188 daylight savings time (e.g., @code{PDT} or @code{PST}) the
17189 @var{date} is ignored.  If @var{zone} is a generalized time zone,
17190 the algorithms described above are used.  If @var{zone} is omitted,
17191 the computation is done for the current time zone.
17193 @xref{Reporting Bugs}, for the address of Calc's author, if you
17194 should wish to contribute your improved versions of
17195 @code{math-tzone-names} and @code{math-daylight-savings-hook}
17196 to the Calc distribution.
17198 @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
17199 @section Financial Functions
17201 @noindent
17202 Calc's financial or business functions use the @kbd{b} prefix
17203 key followed by a shifted letter.  (The @kbd{b} prefix followed by
17204 a lower-case letter is used for operations on binary numbers.)
17206 Note that the rate and the number of intervals given to these
17207 functions must be on the same time scale, e.g., both months or
17208 both years.  Mixing an annual interest rate with a time expressed
17209 in months will give you very wrong answers!
17211 It is wise to compute these functions to a higher precision than
17212 you really need, just to make sure your answer is correct to the
17213 last penny; also, you may wish to check the definitions at the end
17214 of this section to make sure the functions have the meaning you expect.
17216 @menu
17217 * Percentages::
17218 * Future Value::
17219 * Present Value::
17220 * Related Financial Functions::
17221 * Depreciation Functions::
17222 * Definitions of Financial Functions::
17223 @end menu
17225 @node Percentages, Future Value, Financial Functions, Financial Functions
17226 @subsection Percentages
17228 @kindex M-%
17229 @pindex calc-percent
17230 @tindex %
17231 @tindex percent
17232 The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
17233 say 5.4, and converts it to an equivalent actual number.  For example,
17234 @kbd{5.4 M-%} enters 0.054 on the stack.  (That's the @key{META} or
17235 @key{ESC} key combined with @kbd{%}.)
17237 Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
17238 You can enter @samp{5.4%} yourself during algebraic entry.  The
17239 @samp{%} operator simply means, ``the preceding value divided by
17240 100.''  The @samp{%} operator has very high precedence, so that
17241 @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
17242 (The @samp{%} operator is just a postfix notation for the
17243 @code{percent} function, just like @samp{20!} is the notation for
17244 @samp{fact(20)}, or twenty-factorial.)
17246 The formula @samp{5.4%} would normally evaluate immediately to
17247 0.054, but the @kbd{M-%} command suppresses evaluation as it puts
17248 the formula onto the stack.  However, the next Calc command that
17249 uses the formula @samp{5.4%} will evaluate it as its first step.
17250 The net effect is that you get to look at @samp{5.4%} on the stack,
17251 but Calc commands see it as @samp{0.054}, which is what they expect.
17253 In particular, @samp{5.4%} and @samp{0.054} are suitable values
17254 for the @var{rate} arguments of the various financial functions,
17255 but the number @samp{5.4} is probably @emph{not} suitable---it
17256 represents a rate of 540 percent!
17258 The key sequence @kbd{M-% *} effectively means ``percent-of.''
17259 For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
17260 68 (and also 68% of 25, which comes out to the same thing).
17262 @kindex c %
17263 @pindex calc-convert-percent
17264 The @kbd{c %} (@code{calc-convert-percent}) command converts the
17265 value on the top of the stack from numeric to percentage form.
17266 For example, if 0.08 is on the stack, @kbd{c %} converts it to
17267 @samp{8%}.  The quantity is the same, it's just represented
17268 differently.  (Contrast this with @kbd{M-%}, which would convert
17269 this number to @samp{0.08%}.)  The @kbd{=} key is a convenient way
17270 to convert a formula like @samp{8%} back to numeric form, 0.08.
17272 To compute what percentage one quantity is of another quantity,
17273 use @kbd{/ c %}.  For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
17274 @samp{25%}.
17276 @kindex b %
17277 @pindex calc-percent-change
17278 @tindex relch
17279 The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
17280 calculates the percentage change from one number to another.
17281 For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
17282 since 50 is 25% larger than 40.  A negative result represents a
17283 decrease:  @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
17284 20% smaller than 50.  (The answers are different in magnitude
17285 because, in the first case, we're increasing by 25% of 40, but
17286 in the second case, we're decreasing by 20% of 50.)  The effect
17287 of @kbd{40 @key{RET} 50 b %} is to compute @cite{(50-40)/40}, converting
17288 the answer to percentage form as if by @kbd{c %}.
17290 @node Future Value, Present Value, Percentages, Financial Functions
17291 @subsection Future Value
17293 @noindent
17294 @kindex b F
17295 @pindex calc-fin-fv
17296 @tindex fv
17297 The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
17298 the future value of an investment.  It takes three arguments
17299 from the stack:  @samp{fv(@var{rate}, @var{n}, @var{payment})}.
17300 If you give payments of @var{payment} every year for @var{n}
17301 years, and the money you have paid earns interest at @var{rate} per
17302 year, then this function tells you what your investment would be
17303 worth at the end of the period.  (The actual interval doesn't
17304 have to be years, as long as @var{n} and @var{rate} are expressed
17305 in terms of the same intervals.)  This function assumes payments
17306 occur at the @emph{end} of each interval.
17308 @kindex I b F
17309 @tindex fvb
17310 The @kbd{I b F} [@code{fvb}] command does the same computation,
17311 but assuming your payments are at the beginning of each interval.
17312 Suppose you plan to deposit $1000 per year in a savings account
17313 earning 5.4% interest, starting right now.  How much will be
17314 in the account after five years?  @code{fvb(5.4%, 5, 1000) = 5870.73}.
17315 Thus you will have earned $870 worth of interest over the years.
17316 Using the stack, this calculation would have been
17317 @kbd{5.4 M-% 5 @key{RET} 1000 I b F}.  Note that the rate is expressed
17318 as a number between 0 and 1, @emph{not} as a percentage.
17320 @kindex H b F
17321 @tindex fvl
17322 The @kbd{H b F} [@code{fvl}] command computes the future value
17323 of an initial lump sum investment.  Suppose you could deposit
17324 those five thousand dollars in the bank right now; how much would
17325 they be worth in five years?  @code{fvl(5.4%, 5, 5000) = 6503.89}.
17327 The algebraic functions @code{fv} and @code{fvb} accept an optional
17328 fourth argument, which is used as an initial lump sum in the sense
17329 of @code{fvl}.  In other words, @code{fv(@var{rate}, @var{n},
17330 @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
17331 + fvl(@var{rate}, @var{n}, @var{initial})}.@refill
17333 To illustrate the relationships between these functions, we could
17334 do the @code{fvb} calculation ``by hand'' using @code{fvl}.  The
17335 final balance will be the sum of the contributions of our five
17336 deposits at various times.  The first deposit earns interest for
17337 five years:  @code{fvl(5.4%, 5, 1000) = 1300.78}.  The second
17338 deposit only earns interest for four years:  @code{fvl(5.4%, 4, 1000) =
17339 1234.13}.  And so on down to the last deposit, which earns one
17340 year's interest:  @code{fvl(5.4%, 1, 1000) = 1054.00}.  The sum of
17341 these five values is, sure enough, $5870.73, just as was computed
17342 by @code{fvb} directly.
17344 What does @code{fv(5.4%, 5, 1000) = 5569.96} mean?  The payments
17345 are now at the ends of the periods.  The end of one year is the same
17346 as the beginning of the next, so what this really means is that we've
17347 lost the payment at year zero (which contributed $1300.78), but we're
17348 now counting the payment at year five (which, since it didn't have
17349 a chance to earn interest, counts as $1000).  Indeed, @cite{5569.96 =
17350 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
17352 @node Present Value, Related Financial Functions, Future Value, Financial Functions
17353 @subsection Present Value
17355 @noindent
17356 @kindex b P
17357 @pindex calc-fin-pv
17358 @tindex pv
17359 The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
17360 the present value of an investment.  Like @code{fv}, it takes
17361 three arguments:  @code{pv(@var{rate}, @var{n}, @var{payment})}.
17362 It computes the present value of a series of regular payments.
17363 Suppose you have the chance to make an investment that will
17364 pay $2000 per year over the next four years; as you receive
17365 these payments you can put them in the bank at 9% interest.
17366 You want to know whether it is better to make the investment, or
17367 to keep the money in the bank where it earns 9% interest right
17368 from the start.  The calculation @code{pv(9%, 4, 2000)} gives the
17369 result 6479.44.  If your initial investment must be less than this,
17370 say, $6000, then the investment is worthwhile.  But if you had to
17371 put up $7000, then it would be better just to leave it in the bank.
17373 Here is the interpretation of the result of @code{pv}:  You are
17374 trying to compare the return from the investment you are
17375 considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
17376 the return from leaving the money in the bank, which is
17377 @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
17378 you would have to put up in advance.  The @code{pv} function
17379 finds the break-even point, @cite{x = 6479.44}, at which
17380 @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26.  This is
17381 the largest amount you should be willing to invest.
17383 @kindex I b P
17384 @tindex pvb
17385 The @kbd{I b P} [@code{pvb}] command solves the same problem,
17386 but with payments occurring at the beginning of each interval.
17387 It has the same relationship to @code{fvb} as @code{pv} has
17388 to @code{fv}.  For example @code{pvb(9%, 4, 2000) = 7062.59},
17389 a larger number than @code{pv} produced because we get to start
17390 earning interest on the return from our investment sooner.
17392 @kindex H b P
17393 @tindex pvl
17394 The @kbd{H b P} [@code{pvl}] command computes the present value of
17395 an investment that will pay off in one lump sum at the end of the
17396 period.  For example, if we get our $8000 all at the end of the
17397 four years, @code{pvl(9%, 4, 8000) = 5667.40}.  This is much
17398 less than @code{pv} reported, because we don't earn any interest
17399 on the return from this investment.  Note that @code{pvl} and
17400 @code{fvl} are simple inverses:  @code{fvl(9%, 4, 5667.40) = 8000}.
17402 You can give an optional fourth lump-sum argument to @code{pv}
17403 and @code{pvb}; this is handled in exactly the same way as the
17404 fourth argument for @code{fv} and @code{fvb}.
17406 @kindex b N
17407 @pindex calc-fin-npv
17408 @tindex npv
17409 The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
17410 the net present value of a series of irregular investments.
17411 The first argument is the interest rate.  The second argument is
17412 a vector which represents the expected return from the investment
17413 at the end of each interval.  For example, if the rate represents
17414 a yearly interest rate, then the vector elements are the return
17415 from the first year, second year, and so on.
17417 Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
17418 Obviously this function is more interesting when the payments are
17419 not all the same!
17421 The @code{npv} function can actually have two or more arguments.
17422 Multiple arguments are interpreted in the same way as for the
17423 vector statistical functions like @code{vsum}.
17424 @xref{Single-Variable Statistics}.  Basically, if there are several
17425 payment arguments, each either a vector or a plain number, all these
17426 values are collected left-to-right into the complete list of payments.
17427 A numeric prefix argument on the @kbd{b N} command says how many
17428 payment values or vectors to take from the stack.@refill
17430 @kindex I b N
17431 @tindex npvb
17432 The @kbd{I b N} [@code{npvb}] command computes the net present
17433 value where payments occur at the beginning of each interval
17434 rather than at the end.
17436 @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
17437 @subsection Related Financial Functions
17439 @noindent
17440 The functions in this section are basically inverses of the
17441 present value functions with respect to the various arguments.
17443 @kindex b M
17444 @pindex calc-fin-pmt
17445 @tindex pmt
17446 The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
17447 the amount of periodic payment necessary to amortize a loan.
17448 Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
17449 value of @var{payment} such that @code{pv(@var{rate}, @var{n},
17450 @var{payment}) = @var{amount}}.@refill
17452 @kindex I b M
17453 @tindex pmtb
17454 The @kbd{I b M} [@code{pmtb}] command does the same computation
17455 but using @code{pvb} instead of @code{pv}.  Like @code{pv} and
17456 @code{pvb}, these functions can also take a fourth argument which
17457 represents an initial lump-sum investment.
17459 @kindex H b M
17460 The @kbd{H b M} key just invokes the @code{fvl} function, which is
17461 the inverse of @code{pvl}.  There is no explicit @code{pmtl} function.
17463 @kindex b #
17464 @pindex calc-fin-nper
17465 @tindex nper
17466 The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
17467 the number of regular payments necessary to amortize a loan.
17468 Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
17469 the value of @var{n} such that @code{pv(@var{rate}, @var{n},
17470 @var{payment}) = @var{amount}}.  If @var{payment} is too small
17471 ever to amortize a loan for @var{amount} at interest rate @var{rate},
17472 the @code{nper} function is left in symbolic form.@refill
17474 @kindex I b #
17475 @tindex nperb
17476 The @kbd{I b #} [@code{nperb}] command does the same computation
17477 but using @code{pvb} instead of @code{pv}.  You can give a fourth
17478 lump-sum argument to these functions, but the computation will be
17479 rather slow in the four-argument case.@refill
17481 @kindex H b #
17482 @tindex nperl
17483 The @kbd{H b #} [@code{nperl}] command does the same computation
17484 using @code{pvl}.  By exchanging @var{payment} and @var{amount} you
17485 can also get the solution for @code{fvl}.  For example,
17486 @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
17487 bank account earning 8%, it will take nine years to grow to $2000.@refill
17489 @kindex b T
17490 @pindex calc-fin-rate
17491 @tindex rate
17492 The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
17493 the rate of return on an investment.  This is also an inverse of @code{pv}:
17494 @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
17495 @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
17496 @var{amount}}.  The result is expressed as a formula like @samp{6.3%}.@refill
17498 @kindex I b T
17499 @kindex H b T
17500 @tindex rateb
17501 @tindex ratel
17502 The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
17503 commands solve the analogous equations with @code{pvb} or @code{pvl}
17504 in place of @code{pv}.  Also, @code{rate} and @code{rateb} can
17505 accept an optional fourth argument just like @code{pv} and @code{pvb}.
17506 To redo the above example from a different perspective,
17507 @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
17508 interest rate of 8% in order to double your account in nine years.@refill
17510 @kindex b I
17511 @pindex calc-fin-irr
17512 @tindex irr
17513 The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
17514 analogous function to @code{rate} but for net present value.
17515 Its argument is a vector of payments.  Thus @code{irr(@var{payments})}
17516 computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
17517 this rate is known as the @dfn{internal rate of return}.
17519 @kindex I b I
17520 @tindex irrb
17521 The @kbd{I b I} [@code{irrb}] command computes the internal rate of
17522 return assuming payments occur at the beginning of each period.
17524 @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
17525 @subsection Depreciation Functions
17527 @noindent
17528 The functions in this section calculate @dfn{depreciation}, which is
17529 the amount of value that a possession loses over time.  These functions
17530 are characterized by three parameters:  @var{cost}, the original cost
17531 of the asset; @var{salvage}, the value the asset will have at the end
17532 of its expected ``useful life''; and @var{life}, the number of years
17533 (or other periods) of the expected useful life.
17535 There are several methods for calculating depreciation that differ in
17536 the way they spread the depreciation over the lifetime of the asset.
17538 @kindex b S
17539 @pindex calc-fin-sln
17540 @tindex sln
17541 The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
17542 ``straight-line'' depreciation.  In this method, the asset depreciates
17543 by the same amount every year (or period).  For example,
17544 @samp{sln(12000, 2000, 5)} returns 2000.  The asset costs $12000
17545 initially and will be worth $2000 after five years; it loses $2000
17546 per year.
17548 @kindex b Y
17549 @pindex calc-fin-syd
17550 @tindex syd
17551 The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
17552 accelerated ``sum-of-years'-digits'' depreciation.  Here the depreciation
17553 is higher during the early years of the asset's life.  Since the
17554 depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
17555 parameter which specifies which year is requested, from 1 to @var{life}.
17556 If @var{period} is outside this range, the @code{syd} function will
17557 return zero.
17559 @kindex b D
17560 @pindex calc-fin-ddb
17561 @tindex ddb
17562 The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
17563 accelerated depreciation using the double-declining balance method.
17564 It also takes a fourth @var{period} parameter.
17566 For symmetry, the @code{sln} function will accept a @var{period}
17567 parameter as well, although it will ignore its value except that the
17568 return value will as usual be zero if @var{period} is out of range.
17570 For example, pushing the vector @cite{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
17571 and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
17572 ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
17573 the three depreciation methods:
17575 @example
17576 @group
17577 [ [ 2000, 3333, 4800 ]
17578   [ 2000, 2667, 2880 ]
17579   [ 2000, 2000, 1728 ]
17580   [ 2000, 1333,  592 ]
17581   [ 2000,  667,   0  ] ]
17582 @end group
17583 @end example
17585 @noindent
17586 (Values have been rounded to nearest integers in this figure.)
17587 We see that @code{sln} depreciates by the same amount each year,
17588 @kbd{syd} depreciates more at the beginning and less at the end,
17589 and @kbd{ddb} weights the depreciation even more toward the beginning.
17591 Summing columns with @kbd{V R : +} yields @cite{[10000, 10000, 10000]};
17592 the total depreciation in any method is (by definition) the
17593 difference between the cost and the salvage value.
17595 @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
17596 @subsection Definitions
17598 @noindent
17599 For your reference, here are the actual formulas used to compute
17600 Calc's financial functions.
17602 Calc will not evaluate a financial function unless the @var{rate} or
17603 @var{n} argument is known.  However, @var{payment} or @var{amount} can
17604 be a variable.  Calc expands these functions according to the
17605 formulas below for symbolic arguments only when you use the @kbd{a "}
17606 (@code{calc-expand-formula}) command, or when taking derivatives or
17607 integrals or solving equations involving the functions.
17609 @ifinfo
17610 These formulas are shown using the conventions of ``Big'' display
17611 mode (@kbd{d B}); for example, the formula for @code{fv} written
17612 linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
17614 @example
17615                                         n
17616                               (1 + rate)  - 1
17617 fv(rate, n, pmt) =      pmt * ---------------
17618                                    rate
17620                                          n
17621                               ((1 + rate)  - 1) (1 + rate)
17622 fvb(rate, n, pmt) =     pmt * ----------------------------
17623                                          rate
17625                                         n
17626 fvl(rate, n, pmt) =     pmt * (1 + rate)
17628                                             -n
17629                               1 - (1 + rate)
17630 pv(rate, n, pmt) =      pmt * ----------------
17631                                     rate
17633                                              -n
17634                               (1 - (1 + rate)  ) (1 + rate)
17635 pvb(rate, n, pmt) =     pmt * -----------------------------
17636                                          rate
17638                                         -n
17639 pvl(rate, n, pmt) =     pmt * (1 + rate)
17641                                     -1               -2               -3
17642 npv(rate, [a, b, c]) =  a*(1 + rate)   + b*(1 + rate)   + c*(1 + rate)
17644                                         -1               -2
17645 npvb(rate, [a, b, c]) = a + b*(1 + rate)   + c*(1 + rate)
17647                                              -n
17648                         (amt - x * (1 + rate)  ) * rate
17649 pmt(rate, n, amt, x) =  -------------------------------
17650                                              -n
17651                                1 - (1 + rate)
17653                                              -n
17654                         (amt - x * (1 + rate)  ) * rate
17655 pmtb(rate, n, amt, x) = -------------------------------
17656                                         -n
17657                          (1 - (1 + rate)  ) (1 + rate)
17659                                    amt * rate
17660 nper(rate, pmt, amt) =  - log(1 - ------------, 1 + rate)
17661                                       pmt
17663                                     amt * rate
17664 nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
17665                                   pmt * (1 + rate)
17667                               amt
17668 nperl(rate, pmt, amt) = - log(---, 1 + rate)
17669                               pmt
17671                            1/n
17672                         pmt
17673 ratel(n, pmt, amt) =    ------ - 1
17674                            1/n
17675                         amt
17677                         cost - salv
17678 sln(cost, salv, life) = -----------
17679                            life
17681                              (cost - salv) * (life - per + 1)
17682 syd(cost, salv, life, per) = --------------------------------
17683                                   life * (life + 1) / 2
17685                              book * 2
17686 ddb(cost, salv, life, per) = --------,  book = cost - depreciation so far
17687                                life
17688 @end example
17689 @end ifinfo
17690 @tex
17691 \turnoffactive
17692 $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
17693 $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
17694 $$ \code{fvl}(r, n, p) = p (1 + r)^n $$
17695 $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
17696 $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
17697 $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
17698 $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
17699 $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
17700 $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
17701 $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
17702                                (1 - (1 + r)^{-n}) (1 + r) } $$
17703 $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
17704 $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
17705 $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
17706 $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
17707 $$ \code{sln}(c, s, l) = { c - s \over l } $$
17708 $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
17709 $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
17710 @end tex
17712 @noindent
17713 In @code{pmt} and @code{pmtb}, @cite{x=0} if omitted.
17715 These functions accept any numeric objects, including error forms,
17716 intervals, and even (though not very usefully) complex numbers.  The
17717 above formulas specify exactly the behavior of these functions with
17718 all sorts of inputs.
17720 Note that if the first argument to the @code{log} in @code{nper} is
17721 negative, @code{nper} leaves itself in symbolic form rather than
17722 returning a (financially meaningless) complex number.
17724 @samp{rate(num, pmt, amt)} solves the equation
17725 @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
17726 (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
17727 for an initial guess.  The @code{rateb} function is the same except
17728 that it uses @code{pvb}.  Note that @code{ratel} can be solved
17729 directly; its formula is shown in the above list.
17731 Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
17732 for @samp{rate}.
17734 If you give a fourth argument to @code{nper} or @code{nperb}, Calc
17735 will also use @kbd{H a R} to solve the equation using an initial
17736 guess interval of @samp{[0 .. 100]}.
17738 A fourth argument to @code{fv} simply sums the two components
17739 calculated from the above formulas for @code{fv} and @code{fvl}.
17740 The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
17742 The @kbd{ddb} function is computed iteratively; the ``book'' value
17743 starts out equal to @var{cost}, and decreases according to the above
17744 formula for the specified number of periods.  If the book value
17745 would decrease below @var{salvage}, it only decreases to @var{salvage}
17746 and the depreciation is zero for all subsequent periods.  The @code{ddb}
17747 function returns the amount the book value decreased in the specified
17748 period.
17750 The Calc financial function names were borrowed mostly from Microsoft
17751 Excel and Borland's Quattro.  The @code{ratel} function corresponds to
17752 @samp{@@CGR} in Borland's Reflex.  The @code{nper} and @code{nperl}
17753 functions correspond to @samp{@@TERM} and @samp{@@CTERM} in Quattro,
17754 respectively.  Beware that the Calc functions may take their arguments
17755 in a different order than the corresponding functions in your favorite
17756 spreadsheet.
17758 @node Binary Functions, , Financial Functions, Arithmetic
17759 @section Binary Number Functions
17761 @noindent
17762 The commands in this chapter all use two-letter sequences beginning with
17763 the @kbd{b} prefix.
17765 @cindex Binary numbers
17766 The ``binary'' operations actually work regardless of the currently
17767 displayed radix, although their results make the most sense in a radix
17768 like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
17769 commands, respectively).  You may also wish to enable display of leading
17770 zeros with @kbd{d z}.  @xref{Radix Modes}.
17772 @cindex Word size for binary operations
17773 The Calculator maintains a current @dfn{word size} @cite{w}, an
17774 arbitrary positive or negative integer.  For a positive word size, all
17775 of the binary operations described here operate modulo @cite{2^w}.  In
17776 particular, negative arguments are converted to positive integers modulo
17777 @cite{2^w} by all binary functions.@refill
17779 If the word size is negative, binary operations produce 2's complement
17780 integers from @c{$-2^{-w-1}$}
17781 @cite{-(2^(-w-1))} to @c{$2^{-w-1}-1$}
17782 @cite{2^(-w-1)-1} inclusive.  Either
17783 mode accepts inputs in any range; the sign of @cite{w} affects only
17784 the results produced.
17786 @kindex b c
17787 @pindex calc-clip
17788 @tindex clip
17789 The @kbd{b c} (@code{calc-clip})
17790 [@code{clip}] command can be used to clip a number by reducing it modulo
17791 @cite{2^w}.  The commands described in this chapter automatically clip
17792 their results to the current word size.  Note that other operations like
17793 addition do not use the current word size, since integer addition
17794 generally is not ``binary.''  (However, @pxref{Simplification Modes},
17795 @code{calc-bin-simplify-mode}.)  For example, with a word size of 8
17796 bits @kbd{b c} converts a number to the range 0 to 255; with a word
17797 size of @i{-8} @kbd{b c} converts to the range @i{-128} to 127.@refill
17799 @kindex b w
17800 @pindex calc-word-size
17801 The default word size is 32 bits.  All operations except the shifts and
17802 rotates allow you to specify a different word size for that one
17803 operation by giving a numeric prefix argument:  @kbd{C-u 8 b c} clips the
17804 top of stack to the range 0 to 255 regardless of the current word size.
17805 To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
17806 This command displays a prompt with the current word size; press @key{RET}
17807 immediately to keep this word size, or type a new word size at the prompt.
17809 When the binary operations are written in symbolic form, they take an
17810 optional second (or third) word-size parameter.  When a formula like
17811 @samp{and(a,b)} is finally evaluated, the word size current at that time
17812 will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
17813 @i{-8} will always be used.  A symbolic binary function will be left
17814 in symbolic form unless the all of its argument(s) are integers or
17815 integer-valued floats.
17817 If either or both arguments are modulo forms for which @cite{M} is a
17818 power of two, that power of two is taken as the word size unless a
17819 numeric prefix argument overrides it.  The current word size is never
17820 consulted when modulo-power-of-two forms are involved.
17822 @kindex b a
17823 @pindex calc-and
17824 @tindex and
17825 The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
17826 AND of the two numbers on the top of the stack.  In other words, for each
17827 of the @cite{w} binary digits of the two numbers (pairwise), the corresponding
17828 bit of the result is 1 if and only if both input bits are 1:
17829 @samp{and(2#1100, 2#1010) = 2#1000}.
17831 @kindex b o
17832 @pindex calc-or
17833 @tindex or
17834 The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
17835 inclusive OR of two numbers.  A bit is 1 if either of the input bits, or
17836 both, are 1:  @samp{or(2#1100, 2#1010) = 2#1110}.
17838 @kindex b x
17839 @pindex calc-xor
17840 @tindex xor
17841 The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
17842 exclusive OR of two numbers.  A bit is 1 if exactly one of the input bits
17843 is 1:  @samp{xor(2#1100, 2#1010) = 2#0110}.
17845 @kindex b d
17846 @pindex calc-diff
17847 @tindex diff
17848 The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
17849 difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
17850 so that @samp{diff(2#1100, 2#1010) = 2#0100}.
17852 @kindex b n
17853 @pindex calc-not
17854 @tindex not
17855 The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
17856 NOT of a number.  A bit is 1 if the input bit is 0 and vice-versa.
17858 @kindex b l
17859 @pindex calc-lshift-binary
17860 @tindex lsh
17861 The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
17862 number left by one bit, or by the number of bits specified in the numeric
17863 prefix argument.  A negative prefix argument performs a logical right shift,
17864 in which zeros are shifted in on the left.  In symbolic form, @samp{lsh(a)}
17865 is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
17866 Bits shifted ``off the end,'' according to the current word size, are lost.
17868 @kindex H b l
17869 @kindex H b r
17870 @ignore
17871 @mindex @idots
17872 @end ignore
17873 @kindex H b L
17874 @ignore
17875 @mindex @null
17876 @end ignore
17877 @kindex H b R
17878 @ignore
17879 @mindex @null
17880 @end ignore
17881 @kindex H b t
17882 The @kbd{H b l} command also does a left shift, but it takes two arguments
17883 from the stack (the value to shift, and, at top-of-stack, the number of
17884 bits to shift).  This version interprets the prefix argument just like
17885 the regular binary operations, i.e., as a word size.  The Hyperbolic flag
17886 has a similar effect on the rest of the binary shift and rotate commands.
17888 @kindex b r
17889 @pindex calc-rshift-binary
17890 @tindex rsh
17891 The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
17892 number right by one bit, or by the number of bits specified in the numeric
17893 prefix argument:  @samp{rsh(a,n) = lsh(a,-n)}.
17895 @kindex b L
17896 @pindex calc-lshift-arith
17897 @tindex ash
17898 The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
17899 number left.  It is analogous to @code{lsh}, except that if the shift
17900 is rightward (the prefix argument is negative), an arithmetic shift
17901 is performed as described below.
17903 @kindex b R
17904 @pindex calc-rshift-arith
17905 @tindex rash
17906 The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
17907 an ``arithmetic'' shift to the right, in which the leftmost bit (according
17908 to the current word size) is duplicated rather than shifting in zeros.
17909 This corresponds to dividing by a power of two where the input is interpreted
17910 as a signed, twos-complement number.  (The distinction between the @samp{rsh}
17911 and @samp{rash} operations is totally independent from whether the word
17912 size is positive or negative.)  With a negative prefix argument, this
17913 performs a standard left shift.
17915 @kindex b t
17916 @pindex calc-rotate-binary
17917 @tindex rot
17918 The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
17919 number one bit to the left.  The leftmost bit (according to the current
17920 word size) is dropped off the left and shifted in on the right.  With a
17921 numeric prefix argument, the number is rotated that many bits to the left
17922 or right.
17924 @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
17925 pack and unpack binary integers into sets.  (For example, @kbd{b u}
17926 unpacks the number @samp{2#11001} to the set of bit-numbers
17927 @samp{[0, 3, 4]}.)  Type @kbd{b u V #} to count the number of ``1''
17928 bits in a binary integer.
17930 Another interesting use of the set representation of binary integers
17931 is to reverse the bits in, say, a 32-bit integer.  Type @kbd{b u} to
17932 unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
17933 with 31 minus that bit-number; type @kbd{b p} to pack the set back
17934 into a binary integer.
17936 @node Scientific Functions, Matrix Functions, Arithmetic, Top
17937 @chapter Scientific Functions
17939 @noindent
17940 The functions described here perform trigonometric and other transcendental
17941 calculations.  They generally produce floating-point answers correct to the
17942 full current precision.  The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
17943 flag keys must be used to get some of these functions from the keyboard.
17945 @kindex P
17946 @pindex calc-pi
17947 @cindex @code{pi} variable
17948 @vindex pi
17949 @kindex H P
17950 @cindex @code{e} variable
17951 @vindex e
17952 @kindex I P
17953 @cindex @code{gamma} variable
17954 @vindex gamma
17955 @cindex Gamma constant, Euler's
17956 @cindex Euler's gamma constant
17957 @kindex H I P
17958 @cindex @code{phi} variable
17959 @cindex Phi, golden ratio
17960 @cindex Golden ratio
17961 One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
17962 the value of @c{$\pi$}
17963 @cite{pi} (at the current precision) onto the stack.  With the
17964 Hyperbolic flag, it pushes the value @cite{e}, the base of natural logarithms.
17965 With the Inverse flag, it pushes Euler's constant @c{$\gamma$}
17966 @cite{gamma} (about 0.5772).  With both Inverse and Hyperbolic, it
17967 pushes the ``golden ratio'' @c{$\phi$}
17968 @cite{phi} (about 1.618).  (At present, Euler's constant is not available
17969 to unlimited precision; Calc knows only the first 100 digits.)
17970 In Symbolic mode, these commands push the
17971 actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
17972 respectively, instead of their values; @pxref{Symbolic Mode}.@refill
17974 @ignore
17975 @mindex Q
17976 @end ignore
17977 @ignore
17978 @mindex I Q
17979 @end ignore
17980 @kindex I Q
17981 @tindex sqr
17982 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
17983 @pxref{Basic Arithmetic}.  With the Inverse flag [@code{sqr}], this command
17984 computes the square of the argument.
17986 @xref{Prefix Arguments}, for a discussion of the effect of numeric
17987 prefix arguments on commands in this chapter which do not otherwise
17988 interpret a prefix argument.
17990 @menu
17991 * Logarithmic Functions::
17992 * Trigonometric and Hyperbolic Functions::
17993 * Advanced Math Functions::
17994 * Branch Cuts::
17995 * Random Numbers::
17996 * Combinatorial Functions::
17997 * Probability Distribution Functions::
17998 @end menu
18000 @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
18001 @section Logarithmic Functions
18003 @noindent
18004 @kindex L
18005 @pindex calc-ln
18006 @tindex ln
18007 @ignore
18008 @mindex @null
18009 @end ignore
18010 @kindex I E
18011 The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
18012 logarithm of the real or complex number on the top of the stack.  With
18013 the Inverse flag it computes the exponential function instead, although
18014 this is redundant with the @kbd{E} command.
18016 @kindex E
18017 @pindex calc-exp
18018 @tindex exp
18019 @ignore
18020 @mindex @null
18021 @end ignore
18022 @kindex I L
18023 The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
18024 exponential, i.e., @cite{e} raised to the power of the number on the stack.
18025 The meanings of the Inverse and Hyperbolic flags follow from those for
18026 the @code{calc-ln} command.
18028 @kindex H L
18029 @kindex H E
18030 @pindex calc-log10
18031 @tindex log10
18032 @tindex exp10
18033 @ignore
18034 @mindex @null
18035 @end ignore
18036 @kindex H I L
18037 @ignore
18038 @mindex @null
18039 @end ignore
18040 @kindex H I E
18041 The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
18042 (base-10) logarithm of a number.  (With the Inverse flag [@code{exp10}],
18043 it raises ten to a given power.)  Note that the common logarithm of a
18044 complex number is computed by taking the natural logarithm and dividing
18045 by @c{$\ln10$}
18046 @cite{ln(10)}.
18048 @kindex B
18049 @kindex I B
18050 @pindex calc-log
18051 @tindex log
18052 @tindex alog
18053 The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
18054 to any base.  For example, @kbd{1024 @key{RET} 2 B} produces 10, since
18055 @c{$2^{10} = 1024$}
18056 @cite{2^10 = 1024}.  In certain cases like @samp{log(3,9)}, the result
18057 will be either @cite{1:2} or @cite{0.5} depending on the current Fraction
18058 Mode setting.  With the Inverse flag [@code{alog}], this command is
18059 similar to @kbd{^} except that the order of the arguments is reversed.
18061 @kindex f I
18062 @pindex calc-ilog
18063 @tindex ilog
18064 The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
18065 integer logarithm of a number to any base.  The number and the base must
18066 themselves be positive integers.  This is the true logarithm, rounded
18067 down to an integer.  Thus @kbd{ilog(x,10)} is 3 for all @cite{x} in the
18068 range from 1000 to 9999.  If both arguments are positive integers, exact
18069 integer arithmetic is used; otherwise, this is equivalent to
18070 @samp{floor(log(x,b))}.
18072 @kindex f E
18073 @pindex calc-expm1
18074 @tindex expm1
18075 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
18076 @c{$e^x - 1$}
18077 @cite{exp(x)-1}, but using an algorithm that produces a more accurate
18078 answer when the result is close to zero, i.e., when @c{$e^x$}
18079 @cite{exp(x)} is close
18080 to one.
18082 @kindex f L
18083 @pindex calc-lnp1
18084 @tindex lnp1
18085 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
18086 @c{$\ln(x+1)$}
18087 @cite{ln(x+1)}, producing a more accurate answer when @cite{x} is close
18088 to zero.
18090 @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
18091 @section Trigonometric/Hyperbolic Functions
18093 @noindent
18094 @kindex S
18095 @pindex calc-sin
18096 @tindex sin
18097 The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
18098 of an angle or complex number.  If the input is an HMS form, it is interpreted
18099 as degrees-minutes-seconds; otherwise, the input is interpreted according
18100 to the current angular mode.  It is best to use Radians mode when operating
18101 on complex numbers.@refill
18103 Calc's ``units'' mechanism includes angular units like @code{deg},
18104 @code{rad}, and @code{grad}.  While @samp{sin(45 deg)} is not evaluated
18105 all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
18106 simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
18107 of the current angular mode.  @xref{Basic Operations on Units}.
18109 Also, the symbolic variable @code{pi} is not ordinarily recognized in
18110 arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
18111 the @kbd{a s} (@code{calc-simplify}) command recognizes many such
18112 formulas when the current angular mode is radians @emph{and} symbolic
18113 mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
18114 @xref{Symbolic Mode}.  Beware, this simplification occurs even if you
18115 have stored a different value in the variable @samp{pi}; this is one
18116 reason why changing built-in variables is a bad idea.  Arguments of
18117 the form @cite{x} plus a multiple of @c{$\pi/2$}
18118 @cite{pi/2} are also simplified.
18119 Calc includes similar formulas for @code{cos} and @code{tan}.@refill
18121 The @kbd{a s} command knows all angles which are integer multiples of
18122 @c{$\pi/12$}
18123 @cite{pi/12}, @c{$\pi/10$}
18124 @cite{pi/10}, or @c{$\pi/8$}
18125 @cite{pi/8} radians.  In degrees mode,
18126 analogous simplifications occur for integer multiples of 15 or 18
18127 degrees, and for arguments plus multiples of 90 degrees.
18129 @kindex I S
18130 @pindex calc-arcsin
18131 @tindex arcsin
18132 With the Inverse flag, @code{calc-sin} computes an arcsine.  This is also
18133 available as the @code{calc-arcsin} command or @code{arcsin} algebraic
18134 function.  The returned argument is converted to degrees, radians, or HMS
18135 notation depending on the current angular mode.
18137 @kindex H S
18138 @pindex calc-sinh
18139 @tindex sinh
18140 @kindex H I S
18141 @pindex calc-arcsinh
18142 @tindex arcsinh
18143 With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
18144 sine, also available as @code{calc-sinh} [@code{sinh}].  With the
18145 Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
18146 (@code{calc-arcsinh}) [@code{arcsinh}].
18148 @kindex C
18149 @pindex calc-cos
18150 @tindex cos
18151 @ignore
18152 @mindex @idots
18153 @end ignore
18154 @kindex I C
18155 @pindex calc-arccos
18156 @ignore
18157 @mindex @null
18158 @end ignore
18159 @tindex arccos
18160 @ignore
18161 @mindex @null
18162 @end ignore
18163 @kindex H C
18164 @pindex calc-cosh
18165 @ignore
18166 @mindex @null
18167 @end ignore
18168 @tindex cosh
18169 @ignore
18170 @mindex @null
18171 @end ignore
18172 @kindex H I C
18173 @pindex calc-arccosh
18174 @ignore
18175 @mindex @null
18176 @end ignore
18177 @tindex arccosh
18178 @ignore
18179 @mindex @null
18180 @end ignore
18181 @kindex T
18182 @pindex calc-tan
18183 @ignore
18184 @mindex @null
18185 @end ignore
18186 @tindex tan
18187 @ignore
18188 @mindex @null
18189 @end ignore
18190 @kindex I T
18191 @pindex calc-arctan
18192 @ignore
18193 @mindex @null
18194 @end ignore
18195 @tindex arctan
18196 @ignore
18197 @mindex @null
18198 @end ignore
18199 @kindex H T
18200 @pindex calc-tanh
18201 @ignore
18202 @mindex @null
18203 @end ignore
18204 @tindex tanh
18205 @ignore
18206 @mindex @null
18207 @end ignore
18208 @kindex H I T
18209 @pindex calc-arctanh
18210 @ignore
18211 @mindex @null
18212 @end ignore
18213 @tindex arctanh
18214 The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
18215 of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
18216 computes the tangent, along with all the various inverse and hyperbolic
18217 variants of these functions.
18219 @kindex f T
18220 @pindex calc-arctan2
18221 @tindex arctan2
18222 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
18223 numbers from the stack and computes the arc tangent of their ratio.  The
18224 result is in the full range from @i{-180} (exclusive) to @i{+180}
18225 (inclusive) degrees, or the analogous range in radians.  A similar
18226 result would be obtained with @kbd{/} followed by @kbd{I T}, but the
18227 value would only be in the range from @i{-90} to @i{+90} degrees
18228 since the division loses information about the signs of the two
18229 components, and an error might result from an explicit division by zero
18230 which @code{arctan2} would avoid.  By (arbitrary) definition,
18231 @samp{arctan2(0,0)=0}.
18233 @pindex calc-sincos
18234 @ignore
18235 @starindex
18236 @end ignore
18237 @tindex sincos
18238 @ignore
18239 @starindex
18240 @end ignore
18241 @ignore
18242 @mindex arc@idots
18243 @end ignore
18244 @tindex arcsincos
18245 The @code{calc-sincos} [@code{sincos}] command computes the sine and
18246 cosine of a number, returning them as a vector of the form
18247 @samp{[@var{cos}, @var{sin}]}.
18248 With the Inverse flag [@code{arcsincos}], this command takes a two-element
18249 vector as an argument and computes @code{arctan2} of the elements.
18250 (This command does not accept the Hyperbolic flag.)@refill
18252 @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
18253 @section Advanced Mathematical Functions
18255 @noindent
18256 Calc can compute a variety of less common functions that arise in
18257 various branches of mathematics.  All of the functions described in
18258 this section allow arbitrary complex arguments and, except as noted,
18259 will work to arbitrarily large precisions.  They can not at present
18260 handle error forms or intervals as arguments.
18262 NOTE:  These functions are still experimental.  In particular, their
18263 accuracy is not guaranteed in all domains.  It is advisable to set the
18264 current precision comfortably higher than you actually need when
18265 using these functions.  Also, these functions may be impractically
18266 slow for some values of the arguments.
18268 @kindex f g
18269 @pindex calc-gamma
18270 @tindex gamma
18271 The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
18272 gamma function.  For positive integer arguments, this is related to the
18273 factorial function:  @samp{gamma(n+1) = fact(n)}.  For general complex
18274 arguments the gamma function can be defined by the following definite
18275 integral:  @c{$\Gamma(a) = \int_0^\infty t^{a-1} e^t dt$}
18276 @cite{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
18277 (The actual implementation uses far more efficient computational methods.)
18279 @kindex f G
18280 @tindex gammaP
18281 @ignore
18282 @mindex @idots
18283 @end ignore
18284 @kindex I f G
18285 @ignore
18286 @mindex @null
18287 @end ignore
18288 @kindex H f G
18289 @ignore
18290 @mindex @null
18291 @end ignore
18292 @kindex H I f G
18293 @pindex calc-inc-gamma
18294 @ignore
18295 @mindex @null
18296 @end ignore
18297 @tindex gammaQ
18298 @ignore
18299 @mindex @null
18300 @end ignore
18301 @tindex gammag
18302 @ignore
18303 @mindex @null
18304 @end ignore
18305 @tindex gammaG
18306 The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
18307 the incomplete gamma function, denoted @samp{P(a,x)}.  This is defined by
18308 the integral, @c{$P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)$}
18309 @cite{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
18310 This implies that @samp{gammaP(a,inf) = 1} for any @cite{a} (see the
18311 definition of the normal gamma function).
18313 Several other varieties of incomplete gamma function are defined.
18314 The complement of @cite{P(a,x)}, called @cite{Q(a,x) = 1-P(a,x)} by
18315 some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
18316 You can think of this as taking the other half of the integral, from
18317 @cite{x} to infinity.
18319 @ifinfo
18320 The functions corresponding to the integrals that define @cite{P(a,x)}
18321 and @cite{Q(a,x)} but without the normalizing @cite{1/gamma(a)}
18322 factor are called @cite{g(a,x)} and @cite{G(a,x)}, respectively
18323 (where @cite{g} and @cite{G} represent the lower- and upper-case Greek
18324 letter gamma).  You can obtain these using the @kbd{H f G} [@code{gammag}]
18325 and @kbd{H I f G} [@code{gammaG}] commands.
18326 @end ifinfo
18327 @tex
18328 \turnoffactive
18329 The functions corresponding to the integrals that define $P(a,x)$
18330 and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
18331 factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
18332 You can obtain these using the \kbd{H f G} [\code{gammag}] and
18333 \kbd{I H f G} [\code{gammaG}] commands.
18334 @end tex
18336 @kindex f b
18337 @pindex calc-beta
18338 @tindex beta
18339 The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
18340 Euler beta function, which is defined in terms of the gamma function as
18341 @c{$B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)$}
18342 @cite{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)}, or by
18343 @c{$B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt$}
18344 @cite{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
18346 @kindex f B
18347 @kindex H f B
18348 @pindex calc-inc-beta
18349 @tindex betaI
18350 @tindex betaB
18351 The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
18352 the incomplete beta function @cite{I(x,a,b)}.  It is defined by
18353 @c{$I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)$}
18354 @cite{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
18355 Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
18356 un-normalized version [@code{betaB}].
18358 @kindex f e
18359 @kindex I f e
18360 @pindex calc-erf
18361 @tindex erf
18362 @tindex erfc
18363 The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
18364 error function @c{$\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt$}
18365 @cite{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
18366 The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
18367 is the corresponding integral from @samp{x} to infinity; the sum
18368 @c{$\hbox{erf}(x) + \hbox{erfc}(x) = 1$}
18369 @cite{erf(x) + erfc(x) = 1}.
18371 @kindex f j
18372 @kindex f y
18373 @pindex calc-bessel-J
18374 @pindex calc-bessel-Y
18375 @tindex besJ
18376 @tindex besY
18377 The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
18378 (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
18379 functions of the first and second kinds, respectively.
18380 In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
18381 @cite{n} is often an integer, but is not required to be one.
18382 Calc's implementation of the Bessel functions currently limits the
18383 precision to 8 digits, and may not be exact even to that precision.
18384 Use with care!@refill
18386 @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
18387 @section Branch Cuts and Principal Values
18389 @noindent
18390 @cindex Branch cuts
18391 @cindex Principal values
18392 All of the logarithmic, trigonometric, and other scientific functions are
18393 defined for complex numbers as well as for reals.
18394 This section describes the values
18395 returned in cases where the general result is a family of possible values.
18396 Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
18397 second edition, in these matters.  This section will describe each
18398 function briefly; for a more detailed discussion (including some nifty
18399 diagrams), consult Steele's book.
18401 Note that the branch cuts for @code{arctan} and @code{arctanh} were
18402 changed between the first and second editions of Steele.  Versions of
18403 Calc starting with 2.00 follow the second edition.
18405 The new branch cuts exactly match those of the HP-28/48 calculators.
18406 They also match those of Mathematica 1.2, except that Mathematica's
18407 @code{arctan} cut is always in the right half of the complex plane,
18408 and its @code{arctanh} cut is always in the top half of the plane.
18409 Calc's cuts are continuous with quadrants I and III for @code{arctan},
18410 or II and IV for @code{arctanh}.
18412 Note:  The current implementations of these functions with complex arguments
18413 are designed with proper behavior around the branch cuts in mind, @emph{not}
18414 efficiency or accuracy.  You may need to increase the floating precision
18415 and wait a while to get suitable answers from them.
18417 For @samp{sqrt(a+bi)}:  When @cite{a<0} and @cite{b} is small but positive
18418 or zero, the result is close to the @cite{+i} axis.  For @cite{b} small and
18419 negative, the result is close to the @cite{-i} axis.  The result always lies
18420 in the right half of the complex plane.
18422 For @samp{ln(a+bi)}:  The real part is defined as @samp{ln(abs(a+bi))}.
18423 The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
18424 Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
18425 negative real axis.
18427 The following table describes these branch cuts in another way.
18428 If the real and imaginary parts of @cite{z} are as shown, then
18429 the real and imaginary parts of @cite{f(z)} will be as shown.
18430 Here @code{eps} stands for a small positive value; each
18431 occurrence of @code{eps} may stand for a different small value.
18433 @smallexample
18434      z           sqrt(z)       ln(z)
18435 ----------------------------------------
18436    +,   0         +,  0       any, 0
18437    -,   0         0,  +       any, pi
18438    -, +eps      +eps, +      +eps, +
18439    -, -eps      +eps, -      +eps, -
18440 @end smallexample
18442 For @samp{z1^z2}:  This is defined by @samp{exp(ln(z1)*z2)}.
18443 One interesting consequence of this is that @samp{(-8)^1:3} does
18444 not evaluate to @i{-2} as you might expect, but to the complex
18445 number @cite{(1., 1.732)}.  Both of these are valid cube roots
18446 of @i{-8} (as is @cite{(1., -1.732)}); Calc chooses a perhaps
18447 less-obvious root for the sake of mathematical consistency.
18449 For @samp{arcsin(z)}:  This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
18450 The branch cuts are on the real axis, less than @i{-1} and greater than 1.
18452 For @samp{arccos(z)}:  This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
18453 or equivalently by @samp{pi/2 - arcsin(z)}.  The branch cuts are on
18454 the real axis, less than @i{-1} and greater than 1.
18456 For @samp{arctan(z)}:  This is defined by
18457 @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}.  The branch cuts are on the
18458 imaginary axis, below @cite{-i} and above @cite{i}.
18460 For @samp{arcsinh(z)}:  This is defined by @samp{ln(z + sqrt(1+z^2))}.
18461 The branch cuts are on the imaginary axis, below @cite{-i} and
18462 above @cite{i}.
18464 For @samp{arccosh(z)}:  This is defined by
18465 @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}.  The branch cut is on the
18466 real axis less than 1.
18468 For @samp{arctanh(z)}:  This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
18469 The branch cuts are on the real axis, less than @i{-1} and greater than 1.
18471 The following tables for @code{arcsin}, @code{arccos}, and
18472 @code{arctan} assume the current angular mode is radians.  The
18473 hyperbolic functions operate independently of the angular mode.
18475 @smallexample
18476        z             arcsin(z)            arccos(z)
18477 -------------------------------------------------------
18478  (-1..1),  0      (-pi/2..pi/2), 0       (0..pi), 0
18479  (-1..1), +eps    (-pi/2..pi/2), +eps    (0..pi), -eps
18480  (-1..1), -eps    (-pi/2..pi/2), -eps    (0..pi), +eps
18481    <-1,    0          -pi/2,     +         pi,    -
18482    <-1,  +eps      -pi/2 + eps,  +      pi - eps, -
18483    <-1,  -eps      -pi/2 + eps,  -      pi - eps, +
18484     >1,    0           pi/2,     -          0,    +
18485     >1,  +eps       pi/2 - eps,  +        +eps,   -
18486     >1,  -eps       pi/2 - eps,  -        +eps,   +
18487 @end smallexample
18489 @smallexample
18490        z            arccosh(z)         arctanh(z)
18491 -----------------------------------------------------
18492  (-1..1),  0        0,  (0..pi)       any,     0
18493  (-1..1), +eps    +eps, (0..pi)       any,    +eps
18494  (-1..1), -eps    +eps, (-pi..0)      any,    -eps
18495    <-1,    0        +,    pi           -,     pi/2
18496    <-1,  +eps       +,  pi - eps       -,  pi/2 - eps
18497    <-1,  -eps       +, -pi + eps       -, -pi/2 + eps
18498     >1,    0        +,     0           +,    -pi/2
18499     >1,  +eps       +,   +eps          +,  pi/2 - eps
18500     >1,  -eps       +,   -eps          +, -pi/2 + eps
18501 @end smallexample
18503 @smallexample
18504        z           arcsinh(z)           arctan(z)
18505 -----------------------------------------------------
18506    0, (-1..1)    0, (-pi/2..pi/2)         0,     any
18507    0,   <-1      -,    -pi/2            -pi/2,    -
18508  +eps,  <-1      +, -pi/2 + eps       pi/2 - eps, -
18509  -eps,  <-1      -, -pi/2 + eps      -pi/2 + eps, -
18510    0,    >1      +,     pi/2             pi/2,    +
18511  +eps,   >1      +,  pi/2 - eps       pi/2 - eps, +
18512  -eps,   >1      -,  pi/2 - eps      -pi/2 + eps, +
18513 @end smallexample
18515 Finally, the following identities help to illustrate the relationship
18516 between the complex trigonometric and hyperbolic functions.  They
18517 are valid everywhere, including on the branch cuts.
18519 @smallexample
18520 sin(i*z)  = i*sinh(z)       arcsin(i*z)  = i*arcsinh(z)
18521 cos(i*z)  =   cosh(z)       arcsinh(i*z) = i*arcsin(z)
18522 tan(i*z)  = i*tanh(z)       arctan(i*z)  = i*arctanh(z)
18523 sinh(i*z) = i*sin(z)        cosh(i*z)    =   cos(z)
18524 @end smallexample
18526 The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
18527 for general complex arguments, but their branch cuts and principal values
18528 are not rigorously specified at present.
18530 @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
18531 @section Random Numbers
18533 @noindent
18534 @kindex k r
18535 @pindex calc-random
18536 @tindex random
18537 The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
18538 random numbers of various sorts.
18540 Given a positive numeric prefix argument @cite{M}, it produces a random
18541 integer @cite{N} in the range @c{$0 \le N < M$}
18542 @cite{0 <= N < M}.  Each of the @cite{M}
18543 values appears with equal probability.@refill
18545 With no numeric prefix argument, the @kbd{k r} command takes its argument
18546 from the stack instead.  Once again, if this is a positive integer @cite{M}
18547 the result is a random integer less than @cite{M}.  However, note that
18548 while numeric prefix arguments are limited to six digits or so, an @cite{M}
18549 taken from the stack can be arbitrarily large.  If @cite{M} is negative,
18550 the result is a random integer in the range @c{$M < N \le 0$}
18551 @cite{M < N <= 0}.
18553 If the value on the stack is a floating-point number @cite{M}, the result
18554 is a random floating-point number @cite{N} in the range @c{$0 \le N < M$}
18555 @cite{0 <= N < M}
18556 or @c{$M < N \le 0$}
18557 @cite{M < N <= 0}, according to the sign of @cite{M}.
18559 If @cite{M} is zero, the result is a Gaussian-distributed random real
18560 number; the distribution has a mean of zero and a standard deviation
18561 of one.  The algorithm used generates random numbers in pairs; thus,
18562 every other call to this function will be especially fast.
18564 If @cite{M} is an error form @c{$m$ @code{+/-} $\sigma$}
18565 @samp{m +/- s} where @var{m}
18566 and @c{$\sigma$}
18567 @var{s} are both real numbers, the result uses a Gaussian
18568 distribution with mean @var{m} and standard deviation @c{$\sigma$}
18569 @var{s}.
18571 If @cite{M} is an interval form, the lower and upper bounds specify the
18572 acceptable limits of the random numbers.  If both bounds are integers,
18573 the result is a random integer in the specified range.  If either bound
18574 is floating-point, the result is a random real number in the specified
18575 range.  If the interval is open at either end, the result will be sure
18576 not to equal that end value.  (This makes a big difference for integer
18577 intervals, but for floating-point intervals it's relatively minor:
18578 with a precision of 6, @samp{random([1.0..2.0))} will return any of one
18579 million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
18580 additionally return 2.00000, but the probability of this happening is
18581 extremely small.)
18583 If @cite{M} is a vector, the result is one element taken at random from
18584 the vector.  All elements of the vector are given equal probabilities.
18586 @vindex RandSeed
18587 The sequence of numbers produced by @kbd{k r} is completely random by
18588 default, i.e., the sequence is seeded each time you start Calc using
18589 the current time and other information.  You can get a reproducible
18590 sequence by storing a particular ``seed value'' in the Calc variable
18591 @code{RandSeed}.  Any integer will do for a seed; integers of from 1
18592 to 12 digits are good.  If you later store a different integer into
18593 @code{RandSeed}, Calc will switch to a different pseudo-random
18594 sequence.  If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
18595 from the current time.  If you store the same integer that you used
18596 before back into @code{RandSeed}, you will get the exact same sequence
18597 of random numbers as before.
18599 @pindex calc-rrandom
18600 The @code{calc-rrandom} command (not on any key) produces a random real
18601 number between zero and one.  It is equivalent to @samp{random(1.0)}.
18603 @kindex k a
18604 @pindex calc-random-again
18605 The @kbd{k a} (@code{calc-random-again}) command produces another random
18606 number, re-using the most recent value of @cite{M}.  With a numeric
18607 prefix argument @var{n}, it produces @var{n} more random numbers using
18608 that value of @cite{M}.
18610 @kindex k h
18611 @pindex calc-shuffle
18612 @tindex shuffle
18613 The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
18614 random values with no duplicates.  The value on the top of the stack
18615 specifies the set from which the random values are drawn, and may be any
18616 of the @cite{M} formats described above.  The numeric prefix argument
18617 gives the length of the desired list.  (If you do not provide a numeric
18618 prefix argument, the length of the list is taken from the top of the
18619 stack, and @cite{M} from second-to-top.)
18621 If @cite{M} is a floating-point number, zero, or an error form (so
18622 that the random values are being drawn from the set of real numbers)
18623 there is little practical difference between using @kbd{k h} and using
18624 @kbd{k r} several times.  But if the set of possible values consists
18625 of just a few integers, or the elements of a vector, then there is
18626 a very real chance that multiple @kbd{k r}'s will produce the same
18627 number more than once.  The @kbd{k h} command produces a vector whose
18628 elements are always distinct.  (Actually, there is a slight exception:
18629 If @cite{M} is a vector, no given vector element will be drawn more
18630 than once, but if several elements of @cite{M} are equal, they may
18631 each make it into the result vector.)
18633 One use of @kbd{k h} is to rearrange a list at random.  This happens
18634 if the prefix argument is equal to the number of values in the list:
18635 @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
18636 @samp{[2.5, 1, 1.5, 3, 2]}.  As a convenient feature, if the argument
18637 @var{n} is negative it is replaced by the size of the set represented
18638 by @cite{M}.  Naturally, this is allowed only when @cite{M} specifies
18639 a small discrete set of possibilities.
18641 To do the equivalent of @kbd{k h} but with duplications allowed,
18642 given @cite{M} on the stack and with @var{n} just entered as a numeric
18643 prefix, use @kbd{v b} to build a vector of copies of @cite{M}, then use
18644 @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
18645 elements of this vector.  @xref{Matrix Functions}.
18647 @menu
18648 * Random Number Generator::     (Complete description of Calc's algorithm)
18649 @end menu
18651 @node Random Number Generator, , Random Numbers, Random Numbers
18652 @subsection Random Number Generator
18654 Calc's random number generator uses several methods to ensure that
18655 the numbers it produces are highly random.  Knuth's @emph{Art of
18656 Computer Programming}, Volume II, contains a thorough description
18657 of the theory of random number generators and their measurement and
18658 characterization.
18660 If @code{RandSeed} has no stored value, Calc calls Emacs' built-in
18661 @code{random} function to get a stream of random numbers, which it
18662 then treats in various ways to avoid problems inherent in the simple
18663 random number generators that many systems use to implement @code{random}.
18665 When Calc's random number generator is first invoked, it ``seeds''
18666 the low-level random sequence using the time of day, so that the
18667 random number sequence will be different every time you use Calc.
18669 Since Emacs Lisp doesn't specify the range of values that will be
18670 returned by its @code{random} function, Calc exercises the function
18671 several times to estimate the range.  When Calc subsequently uses
18672 the @code{random} function, it takes only 10 bits of the result
18673 near the most-significant end.  (It avoids at least the bottom
18674 four bits, preferably more, and also tries to avoid the top two
18675 bits.)  This strategy works well with the linear congruential
18676 generators that are typically used to implement @code{random}.
18678 If @code{RandSeed} contains an integer, Calc uses this integer to
18679 seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
18680 computing @c{$X_{n-55} - X_{n-24}$}
18681 @cite{X_n-55 - X_n-24}).  This method expands the seed
18682 value into a large table which is maintained internally; the variable
18683 @code{RandSeed} is changed from, e.g., 42 to the vector @cite{[42]}
18684 to indicate that the seed has been absorbed into this table.  When
18685 @code{RandSeed} contains a vector, @kbd{k r} and related commands
18686 continue to use the same internal table as last time.  There is no
18687 way to extract the complete state of the random number generator
18688 so that you can restart it from any point; you can only restart it
18689 from the same initial seed value.  A simple way to restart from the
18690 same seed is to type @kbd{s r RandSeed} to get the seed vector,
18691 @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
18692 to reseed the generator with that number.
18694 Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
18695 of Knuth.  It fills a table with 13 random 10-bit numbers.  Then,
18696 to generate a new random number, it uses the previous number to
18697 index into the table, picks the value it finds there as the new
18698 random number, then replaces that table entry with a new value
18699 obtained from a call to the base random number generator (either
18700 the additive congruential generator or the @code{random} function
18701 supplied by the system).  If there are any flaws in the base
18702 generator, shuffling will tend to even them out.  But if the system
18703 provides an excellent @code{random} function, shuffling will not
18704 damage its randomness.
18706 To create a random integer of a certain number of digits, Calc
18707 builds the integer three decimal digits at a time.  For each group
18708 of three digits, Calc calls its 10-bit shuffling random number generator
18709 (which returns a value from 0 to 1023); if the random value is 1000
18710 or more, Calc throws it out and tries again until it gets a suitable
18711 value.
18713 To create a random floating-point number with precision @var{p}, Calc
18714 simply creates a random @var{p}-digit integer and multiplies by
18715 @c{$10^{-p}$}
18716 @cite{10^-p}.  The resulting random numbers should be very clean, but note
18717 that relatively small numbers will have few significant random digits.
18718 In other words, with a precision of 12, you will occasionally get
18719 numbers on the order of @c{$10^{-9}$}
18720 @cite{10^-9} or @c{$10^{-10}$}
18721 @cite{10^-10}, but those numbers
18722 will only have two or three random digits since they correspond to small
18723 integers times @c{$10^{-12}$}
18724 @cite{10^-12}.
18726 To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
18727 counts the digits in @var{m}, creates a random integer with three
18728 additional digits, then reduces modulo @var{m}.  Unless @var{m} is a
18729 power of ten the resulting values will be very slightly biased toward
18730 the lower numbers, but this bias will be less than 0.1%.  (For example,
18731 if @var{m} is 42, Calc will reduce a random integer less than 100000
18732 modulo 42 to get a result less than 42.  It is easy to show that the
18733 numbers 40 and 41 will be only 2380/2381 as likely to result from this
18734 modulo operation as numbers 39 and below.)  If @var{m} is a power of
18735 ten, however, the numbers should be completely unbiased.
18737 The Gaussian random numbers generated by @samp{random(0.0)} use the
18738 ``polar'' method described in Knuth section 3.4.1C.  This method
18739 generates a pair of Gaussian random numbers at a time, so only every
18740 other call to @samp{random(0.0)} will require significant calculations.
18742 @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
18743 @section Combinatorial Functions
18745 @noindent
18746 Commands relating to combinatorics and number theory begin with the
18747 @kbd{k} key prefix.
18749 @kindex k g
18750 @pindex calc-gcd
18751 @tindex gcd
18752 The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
18753 Greatest Common Divisor of two integers.  It also accepts fractions;
18754 the GCD of two fractions is defined by taking the GCD of the
18755 numerators, and the LCM of the denominators.  This definition is
18756 consistent with the idea that @samp{a / gcd(a,x)} should yield an
18757 integer for any @samp{a} and @samp{x}.  For other types of arguments,
18758 the operation is left in symbolic form.@refill
18760 @kindex k l
18761 @pindex calc-lcm
18762 @tindex lcm
18763 The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
18764 Least Common Multiple of two integers or fractions.  The product of
18765 the LCM and GCD of two numbers is equal to the product of the
18766 numbers.@refill
18768 @kindex k E
18769 @pindex calc-extended-gcd
18770 @tindex egcd
18771 The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
18772 the GCD of two integers @cite{x} and @cite{y} and returns a vector
18773 @cite{[g, a, b]} where @c{$g = \gcd(x,y) = a x + b y$}
18774 @cite{g = gcd(x,y) = a x + b y}.
18776 @kindex !
18777 @pindex calc-factorial
18778 @tindex fact
18779 @ignore
18780 @mindex @null
18781 @end ignore
18782 @tindex !
18783 The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
18784 factorial of the number at the top of the stack.  If the number is an
18785 integer, the result is an exact integer.  If the number is an
18786 integer-valued float, the result is a floating-point approximation.  If
18787 the number is a non-integral real number, the generalized factorial is used,
18788 as defined by the Euler Gamma function.  Please note that computation of
18789 large factorials can be slow; using floating-point format will help
18790 since fewer digits must be maintained.  The same is true of many of
18791 the commands in this section.@refill
18793 @kindex k d
18794 @pindex calc-double-factorial
18795 @tindex dfact
18796 @ignore
18797 @mindex @null
18798 @end ignore
18799 @tindex !!
18800 The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
18801 computes the ``double factorial'' of an integer.  For an even integer,
18802 this is the product of even integers from 2 to @cite{N}.  For an odd
18803 integer, this is the product of odd integers from 3 to @cite{N}.  If
18804 the argument is an integer-valued float, the result is a floating-point
18805 approximation.  This function is undefined for negative even integers.
18806 The notation @cite{N!!} is also recognized for double factorials.@refill
18808 @kindex k c
18809 @pindex calc-choose
18810 @tindex choose
18811 The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
18812 binomial coefficient @cite{N}-choose-@cite{M}, where @cite{M} is the number
18813 on the top of the stack and @cite{N} is second-to-top.  If both arguments
18814 are integers, the result is an exact integer.  Otherwise, the result is a
18815 floating-point approximation.  The binomial coefficient is defined for all
18816 real numbers by @c{$N! \over M! (N-M)!\,$}
18817 @cite{N! / M! (N-M)!}.
18819 @kindex H k c
18820 @pindex calc-perm
18821 @tindex perm
18822 @ifinfo
18823 The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
18824 number-of-permutations function @cite{N! / (N-M)!}.
18825 @end ifinfo
18826 @tex
18827 The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
18828 number-of-perm\-utations function $N! \over (N-M)!\,$.
18829 @end tex
18831 @kindex k b
18832 @kindex H k b
18833 @pindex calc-bernoulli-number
18834 @tindex bern
18835 The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
18836 computes a given Bernoulli number.  The value at the top of the stack
18837 is a nonnegative integer @cite{n} that specifies which Bernoulli number
18838 is desired.  The @kbd{H k b} command computes a Bernoulli polynomial,
18839 taking @cite{n} from the second-to-top position and @cite{x} from the
18840 top of the stack.  If @cite{x} is a variable or formula the result is
18841 a polynomial in @cite{x}; if @cite{x} is a number the result is a number.
18843 @kindex k e
18844 @kindex H k e
18845 @pindex calc-euler-number
18846 @tindex euler
18847 The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
18848 computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
18849 Bernoulli and Euler numbers occur in the Taylor expansions of several
18850 functions.
18852 @kindex k s
18853 @kindex H k s
18854 @pindex calc-stirling-number
18855 @tindex stir1
18856 @tindex stir2
18857 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
18858 computes a Stirling number of the first kind@c{ $n \brack m$}
18859 @asis{}, given two integers
18860 @cite{n} and @cite{m} on the stack.  The @kbd{H k s} [@code{stir2}]
18861 command computes a Stirling number of the second kind@c{ $n \brace m$}
18862 @asis{}.  These are
18863 the number of @cite{m}-cycle permutations of @cite{n} objects, and
18864 the number of ways to partition @cite{n} objects into @cite{m}
18865 non-empty sets, respectively.
18867 @kindex k p
18868 @pindex calc-prime-test
18869 @cindex Primes
18870 The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
18871 the top of the stack is prime.  For integers less than eight million, the
18872 answer is always exact and reasonably fast.  For larger integers, a
18873 probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
18874 The number is first checked against small prime factors (up to 13).  Then,
18875 any number of iterations of the algorithm are performed.  Each step either
18876 discovers that the number is non-prime, or substantially increases the
18877 certainty that the number is prime.  After a few steps, the chance that
18878 a number was mistakenly described as prime will be less than one percent.
18879 (Indeed, this is a worst-case estimate of the probability; in practice
18880 even a single iteration is quite reliable.)  After the @kbd{k p} command,
18881 the number will be reported as definitely prime or non-prime if possible,
18882 or otherwise ``probably'' prime with a certain probability of error.
18884 @ignore
18885 @starindex
18886 @end ignore
18887 @tindex prime
18888 The normal @kbd{k p} command performs one iteration of the primality
18889 test.  Pressing @kbd{k p} repeatedly for the same integer will perform
18890 additional iterations.  Also, @kbd{k p} with a numeric prefix performs
18891 the specified number of iterations.  There is also an algebraic function
18892 @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @cite{n}
18893 is (probably) prime and 0 if not.
18895 @kindex k f
18896 @pindex calc-prime-factors
18897 @tindex prfac
18898 The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
18899 attempts to decompose an integer into its prime factors.  For numbers up
18900 to 25 million, the answer is exact although it may take some time.  The
18901 result is a vector of the prime factors in increasing order.  For larger
18902 inputs, prime factors above 5000 may not be found, in which case the
18903 last number in the vector will be an unfactored integer greater than 25
18904 million (with a warning message).  For negative integers, the first
18905 element of the list will be @i{-1}.  For inputs @i{-1}, @i{0}, and
18906 @i{1}, the result is a list of the same number.
18908 @kindex k n
18909 @pindex calc-next-prime
18910 @ignore
18911 @mindex nextpr@idots
18912 @end ignore
18913 @tindex nextprime
18914 The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
18915 the next prime above a given number.  Essentially, it searches by calling
18916 @code{calc-prime-test} on successive integers until it finds one that
18917 passes the test.  This is quite fast for integers less than eight million,
18918 but once the probabilistic test comes into play the search may be rather
18919 slow.  Ordinarily this command stops for any prime that passes one iteration
18920 of the primality test.  With a numeric prefix argument, a number must pass
18921 the specified number of iterations before the search stops.  (This only
18922 matters when searching above eight million.)  You can always use additional
18923 @kbd{k p} commands to increase your certainty that the number is indeed
18924 prime.
18926 @kindex I k n
18927 @pindex calc-prev-prime
18928 @ignore
18929 @mindex prevpr@idots
18930 @end ignore
18931 @tindex prevprime
18932 The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
18933 analogously finds the next prime less than a given number.
18935 @kindex k t
18936 @pindex calc-totient
18937 @tindex totient
18938 The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
18939 Euler ``totient'' function@c{ $\phi(n)$}
18940 @asis{}, the number of integers less than @cite{n} which
18941 are relatively prime to @cite{n}.
18943 @kindex k m
18944 @pindex calc-moebius
18945 @tindex moebius
18946 The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
18947 @c{M\"obius $\mu$}
18948 @asis{Moebius ``mu''} function.  If the input number is a product of @cite{k}
18949 distinct factors, this is @cite{(-1)^k}.  If the input number has any
18950 duplicate factors (i.e., can be divided by the same prime more than once),
18951 the result is zero.
18953 @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
18954 @section Probability Distribution Functions
18956 @noindent
18957 The functions in this section compute various probability distributions.
18958 For continuous distributions, this is the integral of the probability
18959 density function from @cite{x} to infinity.  (These are the ``upper
18960 tail'' distribution functions; there are also corresponding ``lower
18961 tail'' functions which integrate from minus infinity to @cite{x}.)
18962 For discrete distributions, the upper tail function gives the sum
18963 from @cite{x} to infinity; the lower tail function gives the sum
18964 from minus infinity up to, but not including,@w{ }@cite{x}.
18966 To integrate from @cite{x} to @cite{y}, just use the distribution
18967 function twice and subtract.  For example, the probability that a
18968 Gaussian random variable with mean 2 and standard deviation 1 will
18969 lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
18970 (``the probability that it is greater than 2.5, but not greater than 2.8''),
18971 or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
18973 @kindex k B
18974 @kindex I k B
18975 @pindex calc-utpb
18976 @tindex utpb
18977 @tindex ltpb
18978 The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
18979 binomial distribution.  Push the parameters @var{n}, @var{p}, and
18980 then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
18981 probability that an event will occur @var{x} or more times out
18982 of @var{n} trials, if its probability of occurring in any given
18983 trial is @var{p}.  The @kbd{I k B} [@code{ltpb}] function is
18984 the probability that the event will occur fewer than @var{x} times.
18986 The other probability distribution functions similarly take the
18987 form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
18988 and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
18989 @var{x}.  The arguments to the algebraic functions are the value of
18990 the random variable first, then whatever other parameters define the
18991 distribution.  Note these are among the few Calc functions where the
18992 order of the arguments in algebraic form differs from the order of
18993 arguments as found on the stack.  (The random variable comes last on
18994 the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
18995 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
18996 recover the original arguments but substitute a new value for @cite{x}.)
18998 @kindex k C
18999 @pindex calc-utpc
19000 @tindex utpc
19001 @ignore
19002 @mindex @idots
19003 @end ignore
19004 @kindex I k C
19005 @ignore
19006 @mindex @null
19007 @end ignore
19008 @tindex ltpc
19009 The @samp{utpc(x,v)} function uses the chi-square distribution with
19010 @c{$\nu$}
19011 @cite{v} degrees of freedom.  It is the probability that a model is
19012 correct if its chi-square statistic is @cite{x}.
19014 @kindex k F
19015 @pindex calc-utpf
19016 @tindex utpf
19017 @ignore
19018 @mindex @idots
19019 @end ignore
19020 @kindex I k F
19021 @ignore
19022 @mindex @null
19023 @end ignore
19024 @tindex ltpf
19025 The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
19026 various statistical tests.  The parameters @c{$\nu_1$}
19027 @cite{v1} and @c{$\nu_2$}
19028 @cite{v2}
19029 are the degrees of freedom in the numerator and denominator,
19030 respectively, used in computing the statistic @cite{F}.
19032 @kindex k N
19033 @pindex calc-utpn
19034 @tindex utpn
19035 @ignore
19036 @mindex @idots
19037 @end ignore
19038 @kindex I k N
19039 @ignore
19040 @mindex @null
19041 @end ignore
19042 @tindex ltpn
19043 The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
19044 with mean @cite{m} and standard deviation @c{$\sigma$}
19045 @cite{s}.  It is the
19046 probability that such a normal-distributed random variable would
19047 exceed @cite{x}.
19049 @kindex k P
19050 @pindex calc-utpp
19051 @tindex utpp
19052 @ignore
19053 @mindex @idots
19054 @end ignore
19055 @kindex I k P
19056 @ignore
19057 @mindex @null
19058 @end ignore
19059 @tindex ltpp
19060 The @samp{utpp(n,x)} function uses a Poisson distribution with
19061 mean @cite{x}.  It is the probability that @cite{n} or more such
19062 Poisson random events will occur.
19064 @kindex k T
19065 @pindex calc-ltpt
19066 @tindex utpt
19067 @ignore
19068 @mindex @idots
19069 @end ignore
19070 @kindex I k T
19071 @ignore
19072 @mindex @null
19073 @end ignore
19074 @tindex ltpt
19075 The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
19076 with @c{$\nu$}
19077 @cite{v} degrees of freedom.  It is the probability that a
19078 t-distributed random variable will be greater than @cite{t}.
19079 (Note:  This computes the distribution function @c{$A(t|\nu)$}
19080 @cite{A(t|v)}
19081 where @c{$A(0|\nu) = 1$}
19082 @cite{A(0|v) = 1} and @c{$A(\infty|\nu) \to 0$}
19083 @cite{A(inf|v) -> 0}.  The
19084 @code{UTPT} operation on the HP-48 uses a different definition
19085 which returns half of Calc's value:  @samp{UTPT(t,v) = .5*utpt(t,v)}.)
19087 While Calc does not provide inverses of the probability distribution
19088 functions, the @kbd{a R} command can be used to solve for the inverse.
19089 Since the distribution functions are monotonic, @kbd{a R} is guaranteed
19090 to be able to find a solution given any initial guess.
19091 @xref{Numerical Solutions}.
19093 @node Matrix Functions, Algebra, Scientific Functions, Top
19094 @chapter Vector/Matrix Functions
19096 @noindent
19097 Many of the commands described here begin with the @kbd{v} prefix.
19098 (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
19099 The commands usually apply to both plain vectors and matrices; some
19100 apply only to matrices or only to square matrices.  If the argument
19101 has the wrong dimensions the operation is left in symbolic form.
19103 Vectors are entered and displayed using @samp{[a,b,c]} notation.
19104 Matrices are vectors of which all elements are vectors of equal length.
19105 (Though none of the standard Calc commands use this concept, a
19106 three-dimensional matrix or rank-3 tensor could be defined as a
19107 vector of matrices, and so on.)
19109 @menu
19110 * Packing and Unpacking::
19111 * Building Vectors::
19112 * Extracting Elements::
19113 * Manipulating Vectors::
19114 * Vector and Matrix Arithmetic::
19115 * Set Operations::
19116 * Statistical Operations::
19117 * Reducing and Mapping::
19118 * Vector and Matrix Formats::
19119 @end menu
19121 @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
19122 @section Packing and Unpacking
19124 @noindent
19125 Calc's ``pack'' and ``unpack'' commands collect stack entries to build
19126 composite objects such as vectors and complex numbers.  They are
19127 described in this chapter because they are most often used to build
19128 vectors.
19130 @kindex v p
19131 @pindex calc-pack
19132 The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
19133 elements from the stack into a matrix, complex number, HMS form, error
19134 form, etc.  It uses a numeric prefix argument to specify the kind of
19135 object to be built; this argument is referred to as the ``packing mode.''
19136 If the packing mode is a nonnegative integer, a vector of that
19137 length is created.  For example, @kbd{C-u 5 v p} will pop the top
19138 five stack elements and push back a single vector of those five
19139 elements.  (@kbd{C-u 0 v p} simply creates an empty vector.)
19141 The same effect can be had by pressing @kbd{[} to push an incomplete
19142 vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
19143 the incomplete object up past a certain number of elements, and
19144 then pressing @kbd{]} to complete the vector.
19146 Negative packing modes create other kinds of composite objects:
19148 @table @cite
19149 @item -1
19150 Two values are collected to build a complex number.  For example,
19151 @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
19152 @cite{(5, 7)}.  The result is always a rectangular complex
19153 number.  The two input values must both be real numbers,
19154 i.e., integers, fractions, or floats.  If they are not, Calc
19155 will instead build a formula like @samp{a + (0, 1) b}.  (The
19156 other packing modes also create a symbolic answer if the
19157 components are not suitable.)
19159 @item -2
19160 Two values are collected to build a polar complex number.
19161 The first is the magnitude; the second is the phase expressed
19162 in either degrees or radians according to the current angular
19163 mode.
19165 @item -3
19166 Three values are collected into an HMS form.  The first
19167 two values (hours and minutes) must be integers or
19168 integer-valued floats.  The third value may be any real
19169 number.
19171 @item -4
19172 Two values are collected into an error form.  The inputs
19173 may be real numbers or formulas.
19175 @item -5
19176 Two values are collected into a modulo form.  The inputs
19177 must be real numbers.
19179 @item -6
19180 Two values are collected into the interval @samp{[a .. b]}.
19181 The inputs may be real numbers, HMS or date forms, or formulas.
19183 @item -7
19184 Two values are collected into the interval @samp{[a .. b)}.
19186 @item -8
19187 Two values are collected into the interval @samp{(a .. b]}.
19189 @item -9
19190 Two values are collected into the interval @samp{(a .. b)}.
19192 @item -10
19193 Two integer values are collected into a fraction.
19195 @item -11
19196 Two values are collected into a floating-point number.
19197 The first is the mantissa; the second, which must be an
19198 integer, is the exponent.  The result is the mantissa
19199 times ten to the power of the exponent.
19201 @item -12
19202 This is treated the same as @i{-11} by the @kbd{v p} command.
19203 When unpacking, @i{-12} specifies that a floating-point mantissa
19204 is desired.
19206 @item -13
19207 A real number is converted into a date form.
19209 @item -14
19210 Three numbers (year, month, day) are packed into a pure date form.
19212 @item -15
19213 Six numbers are packed into a date/time form.
19214 @end table
19216 With any of the two-input negative packing modes, either or both
19217 of the inputs may be vectors.  If both are vectors of the same
19218 length, the result is another vector made by packing corresponding
19219 elements of the input vectors.  If one input is a vector and the
19220 other is a plain number, the number is packed along with each vector
19221 element to produce a new vector.  For example, @kbd{C-u -4 v p}
19222 could be used to convert a vector of numbers and a vector of errors
19223 into a single vector of error forms; @kbd{C-u -5 v p} could convert
19224 a vector of numbers and a single number @var{M} into a vector of
19225 numbers modulo @var{M}.
19227 If you don't give a prefix argument to @kbd{v p}, it takes
19228 the packing mode from the top of the stack.  The elements to
19229 be packed then begin at stack level 2.  Thus
19230 @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
19231 enter the error form @samp{1 +/- 2}.
19233 If the packing mode taken from the stack is a vector, the result is a
19234 matrix with the dimensions specified by the elements of the vector,
19235 which must each be integers.  For example, if the packing mode is
19236 @samp{[2, 3]}, then six numbers will be taken from the stack and
19237 returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
19239 If any elements of the vector are negative, other kinds of
19240 packing are done at that level as described above.  For
19241 example, @samp{[2, 3, -4]} takes 12 objects and creates a
19242 @c{$2\times3$}
19243 @asis{2x3} matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
19244 Also, @samp{[-4, -10]} will convert four integers into an
19245 error form consisting of two fractions:  @samp{a:b +/- c:d}.
19247 @ignore
19248 @starindex
19249 @end ignore
19250 @tindex pack
19251 There is an equivalent algebraic function,
19252 @samp{pack(@var{mode}, @var{items})} where @var{mode} is a
19253 packing mode (an integer or a vector of integers) and @var{items}
19254 is a vector of objects to be packed (re-packed, really) according
19255 to that mode.  For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
19256 yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}.  The function is
19257 left in symbolic form if the packing mode is illegal, or if the
19258 number of data items does not match the number of items required
19259 by the mode.
19261 @kindex v u
19262 @pindex calc-unpack
19263 The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
19264 number, HMS form, or other composite object on the top of the stack and
19265 ``unpacks'' it, pushing each of its elements onto the stack as separate
19266 objects.  Thus, it is the ``inverse'' of @kbd{v p}.  If the value
19267 at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
19268 each of the arguments of the top-level operator onto the stack.
19270 You can optionally give a numeric prefix argument to @kbd{v u}
19271 to specify an explicit (un)packing mode.  If the packing mode is
19272 negative and the input is actually a vector or matrix, the result
19273 will be two or more similar vectors or matrices of the elements.
19274 For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
19275 the result of @kbd{C-u -4 v u} will be the two vectors
19276 @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
19278 Note that the prefix argument can have an effect even when the input is
19279 not a vector.  For example, if the input is the number @i{-5}, then
19280 @kbd{c-u -1 v u} yields @i{-5} and 0 (the components of @i{-5}
19281 when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
19282 and 180 (assuming degrees mode); and @kbd{C-u -10 v u} yields @i{-5}
19283 and 1 (the numerator and denominator of @i{-5}, viewed as a rational
19284 number).  Plain @kbd{v u} with this input would complain that the input
19285 is not a composite object.
19287 Unpacking mode @i{-11} converts a float into an integer mantissa and
19288 an integer exponent, where the mantissa is not divisible by 10
19289 (except that 0.0 is represented by a mantissa and exponent of 0).
19290 Unpacking mode @i{-12} converts a float into a floating-point mantissa
19291 and integer exponent, where the mantissa (for non-zero numbers)
19292 is guaranteed to lie in the range [1 .. 10).  In both cases,
19293 the mantissa is shifted left or right (and the exponent adjusted
19294 to compensate) in order to satisfy these constraints.
19296 Positive unpacking modes are treated differently than for @kbd{v p}.
19297 A mode of 1 is much like plain @kbd{v u} with no prefix argument,
19298 except that in addition to the components of the input object,
19299 a suitable packing mode to re-pack the object is also pushed.
19300 Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
19301 original object.
19303 A mode of 2 unpacks two levels of the object; the resulting
19304 re-packing mode will be a vector of length 2.  This might be used
19305 to unpack a matrix, say, or a vector of error forms.  Higher
19306 unpacking modes unpack the input even more deeply.
19308 @ignore
19309 @starindex
19310 @end ignore
19311 @tindex unpack
19312 There are two algebraic functions analogous to @kbd{v u}.
19313 The @samp{unpack(@var{mode}, @var{item})} function unpacks the
19314 @var{item} using the given @var{mode}, returning the result as
19315 a vector of components.  Here the @var{mode} must be an
19316 integer, not a vector.  For example, @samp{unpack(-4, a +/- b)}
19317 returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
19319 @ignore
19320 @starindex
19321 @end ignore
19322 @tindex unpackt
19323 The @code{unpackt} function is like @code{unpack} but instead
19324 of returning a simple vector of items, it returns a vector of
19325 two things:  The mode, and the vector of items.  For example,
19326 @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
19327 and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
19328 The identity for re-building the original object is
19329 @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}.  (The
19330 @code{apply} function builds a function call given the function
19331 name and a vector of arguments.)
19333 @cindex Numerator of a fraction, extracting
19334 Subscript notation is a useful way to extract a particular part
19335 of an object.  For example, to get the numerator of a rational
19336 number, you can use @samp{unpack(-10, @var{x})_1}.
19338 @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
19339 @section Building Vectors
19341 @noindent
19342 Vectors and matrices can be added,
19343 subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.@refill
19345 @kindex |
19346 @pindex calc-concat
19347 @ignore
19348 @mindex @null
19349 @end ignore
19350 @tindex |
19351 The @kbd{|} (@code{calc-concat}) command ``concatenates'' two vectors
19352 into one.  For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
19353 will contain the single vector @samp{[1, 2, 3, 4]}.  If the arguments
19354 are matrices, the rows of the first matrix are concatenated with the
19355 rows of the second.  (In other words, two matrices are just two vectors
19356 of row-vectors as far as @kbd{|} is concerned.)
19358 If either argument to @kbd{|} is a scalar (a non-vector), it is treated
19359 like a one-element vector for purposes of concatenation:  @kbd{1 [ 2 , 3 ] |}
19360 produces the vector @samp{[1, 2, 3]}.  Likewise, if one argument is a
19361 matrix and the other is a plain vector, the vector is treated as a
19362 one-row matrix.
19364 @kindex H |
19365 @tindex append
19366 The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
19367 two vectors without any special cases.  Both inputs must be vectors.
19368 Whether or not they are matrices is not taken into account.  If either
19369 argument is a scalar, the @code{append} function is left in symbolic form.
19370 See also @code{cons} and @code{rcons} below.
19372 @kindex I |
19373 @kindex H I |
19374 The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
19375 two stack arguments in the opposite order.  Thus @kbd{I |} is equivalent
19376 to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
19378 @kindex v d
19379 @pindex calc-diag
19380 @tindex diag
19381 The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
19382 square matrix.  The optional numeric prefix gives the number of rows
19383 and columns in the matrix.  If the value at the top of the stack is a
19384 vector, the elements of the vector are used as the diagonal elements; the
19385 prefix, if specified, must match the size of the vector.  If the value on
19386 the stack is a scalar, it is used for each element on the diagonal, and
19387 the prefix argument is required.
19389 To build a constant square matrix, e.g., a @c{$3\times3$}
19390 @asis{3x3} matrix filled with ones,
19391 use @kbd{0 M-3 v d 1 +}, i.e., build a zero matrix first and then add a
19392 constant value to that matrix.  (Another alternative would be to use
19393 @kbd{v b} and @kbd{v a}; see below.)
19395 @kindex v i
19396 @pindex calc-ident
19397 @tindex idn
19398 The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
19399 matrix of the specified size.  It is a convenient form of @kbd{v d}
19400 where the diagonal element is always one.  If no prefix argument is given,
19401 this command prompts for one.
19403 In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
19404 except that @cite{a} is required to be a scalar (non-vector) quantity.
19405 If @cite{n} is omitted, @samp{idn(a)} represents @cite{a} times an
19406 identity matrix of unknown size.  Calc can operate algebraically on
19407 such generic identity matrices, and if one is combined with a matrix
19408 whose size is known, it is converted automatically to an identity
19409 matrix of a suitable matching size.  The @kbd{v i} command with an
19410 argument of zero creates a generic identity matrix, @samp{idn(1)}.
19411 Note that in dimensioned matrix mode (@pxref{Matrix Mode}), generic
19412 identity matrices are immediately expanded to the current default
19413 dimensions.
19415 @kindex v x
19416 @pindex calc-index
19417 @tindex index
19418 The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
19419 of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
19420 prefix argument.  If you do not provide a prefix argument, you will be
19421 prompted to enter a suitable number.  If @var{n} is negative, the result
19422 is a vector of negative integers from @var{n} to @i{-1}.
19424 With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
19425 three values from the stack: @var{n}, @var{start}, and @var{incr} (with
19426 @var{incr} at top-of-stack).  Counting starts at @var{start} and increases
19427 by @var{incr} for successive vector elements.  If @var{start} or @var{n}
19428 is in floating-point format, the resulting vector elements will also be
19429 floats.  Note that @var{start} and @var{incr} may in fact be any kind
19430 of numbers or formulas.
19432 When @var{start} and @var{incr} are specified, a negative @var{n} has a
19433 different interpretation:  It causes a geometric instead of arithmetic
19434 sequence to be generated.  For example, @samp{index(-3, a, b)} produces
19435 @samp{[a, a b, a b^2]}.  If you omit @var{incr} in the algebraic form,
19436 @samp{index(@var{n}, @var{start})}, the default value for @var{incr}
19437 is one for positive @var{n} or two for negative @var{n}.
19439 @kindex v b
19440 @pindex calc-build-vector
19441 @tindex cvec
19442 The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
19443 vector of @var{n} copies of the value on the top of the stack, where @var{n}
19444 is the numeric prefix argument.  In algebraic formulas, @samp{cvec(x,n,m)}
19445 can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
19446 (Interactively, just use @kbd{v b} twice: once to build a row, then again
19447 to build a matrix of copies of that row.)
19449 @kindex v h
19450 @kindex I v h
19451 @pindex calc-head
19452 @pindex calc-tail
19453 @tindex head
19454 @tindex tail
19455 The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
19456 element of a vector.  The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
19457 function returns the vector with its first element removed.  In both
19458 cases, the argument must be a non-empty vector.
19460 @kindex v k
19461 @pindex calc-cons
19462 @tindex cons
19463 The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
19464 and a vector @var{t} from the stack, and produces the vector whose head is
19465 @var{h} and whose tail is @var{t}.  This is similar to @kbd{|}, except
19466 if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
19467 whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
19469 @kindex H v h
19470 @tindex rhead
19471 @ignore
19472 @mindex @idots
19473 @end ignore
19474 @kindex H I v h
19475 @ignore
19476 @mindex @null
19477 @end ignore
19478 @kindex H v k
19479 @ignore
19480 @mindex @null
19481 @end ignore
19482 @tindex rtail
19483 @ignore
19484 @mindex @null
19485 @end ignore
19486 @tindex rcons
19487 Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
19488 @code{rtail}, @code{rcons}] in which case @var{t} instead represents
19489 the @emph{last} single element of the vector, with @var{h}
19490 representing the remainder of the vector.  Thus the vector
19491 @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
19492 Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
19493 @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
19495 @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
19496 @section Extracting Vector Elements
19498 @noindent
19499 @kindex v r
19500 @pindex calc-mrow
19501 @tindex mrow
19502 The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
19503 the matrix on the top of the stack, or one element of the plain vector on
19504 the top of the stack.  The row or element is specified by the numeric
19505 prefix argument; the default is to prompt for the row or element number.
19506 The matrix or vector is replaced by the specified row or element in the
19507 form of a vector or scalar, respectively.
19509 @cindex Permutations, applying
19510 With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
19511 the element or row from the top of the stack, and the vector or matrix
19512 from the second-to-top position.  If the index is itself a vector of
19513 integers, the result is a vector of the corresponding elements of the
19514 input vector, or a matrix of the corresponding rows of the input matrix.
19515 This command can be used to obtain any permutation of a vector.
19517 With @kbd{C-u}, if the index is an interval form with integer components,
19518 it is interpreted as a range of indices and the corresponding subvector or
19519 submatrix is returned.
19521 @cindex Subscript notation
19522 @kindex a _
19523 @pindex calc-subscript
19524 @tindex subscr
19525 @tindex _
19526 Subscript notation in algebraic formulas (@samp{a_b}) stands for the
19527 Calc function @code{subscr}, which is synonymous with @code{mrow}.
19528 Thus, @samp{[x, y, z]_k} produces @cite{x}, @cite{y}, or @cite{z} if
19529 @cite{k} is one, two, or three, respectively.  A double subscript
19530 (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
19531 access the element at row @cite{i}, column @cite{j} of a matrix.
19532 The @kbd{a _} (@code{calc-subscript}) command creates a subscript
19533 formula @samp{a_b} out of two stack entries.  (It is on the @kbd{a}
19534 ``algebra'' prefix because subscripted variables are often used
19535 purely as an algebraic notation.)
19537 @tindex mrrow
19538 Given a negative prefix argument, @kbd{v r} instead deletes one row or
19539 element from the matrix or vector on the top of the stack.  Thus
19540 @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
19541 replaces the matrix with the same matrix with its second row removed.
19542 In algebraic form this function is called @code{mrrow}.
19544 @tindex getdiag
19545 Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
19546 of a square matrix in the form of a vector.  In algebraic form this
19547 function is called @code{getdiag}.
19549 @kindex v c
19550 @pindex calc-mcol
19551 @tindex mcol
19552 @tindex mrcol
19553 The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
19554 the analogous operation on columns of a matrix.  Given a plain vector
19555 it extracts (or removes) one element, just like @kbd{v r}.  If the
19556 index in @kbd{C-u v c} is an interval or vector and the argument is a
19557 matrix, the result is a submatrix with only the specified columns
19558 retained (and possibly permuted in the case of a vector index).@refill
19560 To extract a matrix element at a given row and column, use @kbd{v r} to
19561 extract the row as a vector, then @kbd{v c} to extract the column element
19562 from that vector.  In algebraic formulas, it is often more convenient to
19563 use subscript notation:  @samp{m_i_j} gives row @cite{i}, column @cite{j}
19564 of matrix @cite{m}.
19566 @kindex v s
19567 @pindex calc-subvector
19568 @tindex subvec
19569 The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
19570 a subvector of a vector.  The arguments are the vector, the starting
19571 index, and the ending index, with the ending index in the top-of-stack
19572 position.  The starting index indicates the first element of the vector
19573 to take.  The ending index indicates the first element @emph{past} the
19574 range to be taken.  Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
19575 the subvector @samp{[b, c]}.  You could get the same result using
19576 @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
19578 If either the start or the end index is zero or negative, it is
19579 interpreted as relative to the end of the vector.  Thus
19580 @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}.  In
19581 the algebraic form, the end index can be omitted in which case it
19582 is taken as zero, i.e., elements from the starting element to the
19583 end of the vector are used.  The infinity symbol, @code{inf}, also
19584 has this effect when used as the ending index.
19586 @kindex I v s
19587 @tindex rsubvec
19588 With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
19589 from a vector.  The arguments are interpreted the same as for the
19590 normal @kbd{v s} command.  Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
19591 produces @samp{[a, d, e]}.  It is always true that @code{subvec} and
19592 @code{rsubvec} return complementary parts of the input vector.
19594 @xref{Selecting Subformulas}, for an alternative way to operate on
19595 vectors one element at a time.
19597 @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
19598 @section Manipulating Vectors
19600 @noindent
19601 @kindex v l
19602 @pindex calc-vlength
19603 @tindex vlen
19604 The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
19605 length of a vector.  The length of a non-vector is considered to be zero.
19606 Note that matrices are just vectors of vectors for the purposes of this
19607 command.@refill
19609 @kindex H v l
19610 @tindex mdims
19611 With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
19612 of the dimensions of a vector, matrix, or higher-order object.  For
19613 example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
19614 its argument is a @c{$2\times3$}
19615 @asis{2x3} matrix.
19617 @kindex v f
19618 @pindex calc-vector-find
19619 @tindex find
19620 The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
19621 along a vector for the first element equal to a given target.  The target
19622 is on the top of the stack; the vector is in the second-to-top position.
19623 If a match is found, the result is the index of the matching element.
19624 Otherwise, the result is zero.  The numeric prefix argument, if given,
19625 allows you to select any starting index for the search.
19627 @kindex v a
19628 @pindex calc-arrange-vector
19629 @tindex arrange
19630 @cindex Arranging a matrix
19631 @cindex Reshaping a matrix
19632 @cindex Flattening a matrix
19633 The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
19634 rearranges a vector to have a certain number of columns and rows.  The
19635 numeric prefix argument specifies the number of columns; if you do not
19636 provide an argument, you will be prompted for the number of columns.
19637 The vector or matrix on the top of the stack is @dfn{flattened} into a
19638 plain vector.  If the number of columns is nonzero, this vector is
19639 then formed into a matrix by taking successive groups of @var{n} elements.
19640 If the number of columns does not evenly divide the number of elements
19641 in the vector, the last row will be short and the result will not be
19642 suitable for use as a matrix.  For example, with the matrix
19643 @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
19644 @samp{[[1, 2, 3, 4]]} (a @c{$1\times4$}
19645 @asis{1x4} matrix), @kbd{v a 1} produces
19646 @samp{[[1], [2], [3], [4]]} (a @c{$4\times1$}
19647 @asis{4x1} matrix), @kbd{v a 2} produces
19648 @samp{[[1, 2], [3, 4]]} (the original @c{$2\times2$}
19649 @asis{2x2} matrix), @w{@kbd{v a 3}} produces
19650 @samp{[[1, 2, 3], [4]]} (not a matrix), and @kbd{v a 0} produces
19651 the flattened list @samp{[1, 2, @w{3, 4}]}.
19653 @cindex Sorting data
19654 @kindex V S
19655 @kindex I V S
19656 @pindex calc-sort
19657 @tindex sort
19658 @tindex rsort
19659 The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
19660 a vector into increasing order.  Real numbers, real infinities, and
19661 constant interval forms come first in this ordering; next come other
19662 kinds of numbers, then variables (in alphabetical order), then finally
19663 come formulas and other kinds of objects; these are sorted according
19664 to a kind of lexicographic ordering with the useful property that
19665 one vector is less or greater than another if the first corresponding
19666 unequal elements are less or greater, respectively.  Since quoted strings
19667 are stored by Calc internally as vectors of ASCII character codes
19668 (@pxref{Strings}), this means vectors of strings are also sorted into
19669 alphabetical order by this command.
19671 The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
19673 @cindex Permutation, inverse of
19674 @cindex Inverse of permutation
19675 @cindex Index tables
19676 @cindex Rank tables
19677 @kindex V G
19678 @kindex I V G
19679 @pindex calc-grade
19680 @tindex grade
19681 @tindex rgrade
19682 The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
19683 produces an index table or permutation vector which, if applied to the
19684 input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
19685 A permutation vector is just a vector of integers from 1 to @var{n}, where
19686 each integer occurs exactly once.  One application of this is to sort a
19687 matrix of data rows using one column as the sort key; extract that column,
19688 grade it with @kbd{V G}, then use the result to reorder the original matrix
19689 with @kbd{C-u v r}.  Another interesting property of the @code{V G} command
19690 is that, if the input is itself a permutation vector, the result will
19691 be the inverse of the permutation.  The inverse of an index table is
19692 a rank table, whose @var{k}th element says where the @var{k}th original
19693 vector element will rest when the vector is sorted.  To get a rank
19694 table, just use @kbd{V G V G}.
19696 With the Inverse flag, @kbd{I V G} produces an index table that would
19697 sort the input into decreasing order.  Note that @kbd{V S} and @kbd{V G}
19698 use a ``stable'' sorting algorithm, i.e., any two elements which are equal
19699 will not be moved out of their original order.  Generally there is no way
19700 to tell with @kbd{V S}, since two elements which are equal look the same,
19701 but with @kbd{V G} this can be an important issue.  In the matrix-of-rows
19702 example, suppose you have names and telephone numbers as two columns and
19703 you wish to sort by phone number primarily, and by name when the numbers
19704 are equal.  You can sort the data matrix by names first, and then again
19705 by phone numbers.  Because the sort is stable, any two rows with equal
19706 phone numbers will remain sorted by name even after the second sort.
19708 @cindex Histograms
19709 @kindex V H
19710 @pindex calc-histogram
19711 @ignore
19712 @mindex histo@idots
19713 @end ignore
19714 @tindex histogram
19715 The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
19716 histogram of a vector of numbers.  Vector elements are assumed to be
19717 integers or real numbers in the range [0..@var{n}) for some ``number of
19718 bins'' @var{n}, which is the numeric prefix argument given to the
19719 command.  The result is a vector of @var{n} counts of how many times
19720 each value appeared in the original vector.  Non-integers in the input
19721 are rounded down to integers.  Any vector elements outside the specified
19722 range are ignored.  (You can tell if elements have been ignored by noting
19723 that the counts in the result vector don't add up to the length of the
19724 input vector.)
19726 @kindex H V H
19727 With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
19728 The second-to-top vector is the list of numbers as before.  The top
19729 vector is an equal-sized list of ``weights'' to attach to the elements
19730 of the data vector.  For example, if the first data element is 4.2 and
19731 the first weight is 10, then 10 will be added to bin 4 of the result
19732 vector.  Without the hyperbolic flag, every element has a weight of one.
19734 @kindex v t
19735 @pindex calc-transpose
19736 @tindex trn
19737 The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
19738 the transpose of the matrix at the top of the stack.  If the argument
19739 is a plain vector, it is treated as a row vector and transposed into
19740 a one-column matrix.
19742 @kindex v v
19743 @pindex calc-reverse-vector
19744 @tindex rev
19745 The @kbd{v v} (@code{calc-reverse-vector}) [@code{vec}] command reverses
19746 a vector end-for-end.  Given a matrix, it reverses the order of the rows.
19747 (To reverse the columns instead, just use @kbd{v t v v v t}.  The same
19748 principle can be used to apply other vector commands to the columns of
19749 a matrix.)
19751 @kindex v m
19752 @pindex calc-mask-vector
19753 @tindex vmask
19754 The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
19755 one vector as a mask to extract elements of another vector.  The mask
19756 is in the second-to-top position; the target vector is on the top of
19757 the stack.  These vectors must have the same length.  The result is
19758 the same as the target vector, but with all elements which correspond
19759 to zeros in the mask vector deleted.  Thus, for example,
19760 @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
19761 @xref{Logical Operations}.
19763 @kindex v e
19764 @pindex calc-expand-vector
19765 @tindex vexp
19766 The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
19767 expands a vector according to another mask vector.  The result is a
19768 vector the same length as the mask, but with nonzero elements replaced
19769 by successive elements from the target vector.  The length of the target
19770 vector is normally the number of nonzero elements in the mask.  If the
19771 target vector is longer, its last few elements are lost.  If the target
19772 vector is shorter, the last few nonzero mask elements are left
19773 unreplaced in the result.  Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
19774 produces @samp{[a, 0, b, 0, 7]}.
19776 @kindex H v e
19777 With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
19778 top of the stack; the mask and target vectors come from the third and
19779 second elements of the stack.  This filler is used where the mask is
19780 zero:  @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
19781 @samp{[a, z, c, z, 7]}.  If the filler value is itself a vector,
19782 then successive values are taken from it, so that the effect is to
19783 interleave two vectors according to the mask:
19784 @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
19785 @samp{[a, x, b, 7, y, 0]}.
19787 Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
19788 with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
19789 You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
19790 operation across the two vectors.  @xref{Logical Operations}.  Note that
19791 the @code{? :} operation also discussed there allows other types of
19792 masking using vectors.
19794 @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
19795 @section Vector and Matrix Arithmetic
19797 @noindent
19798 Basic arithmetic operations like addition and multiplication are defined
19799 for vectors and matrices as well as for numbers.  Division of matrices, in
19800 the sense of multiplying by the inverse, is supported.  (Division by a
19801 matrix actually uses LU-decomposition for greater accuracy and speed.)
19802 @xref{Basic Arithmetic}.
19804 The following functions are applied element-wise if their arguments are
19805 vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
19806 @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
19807 @code{float}, @code{frac}.  @xref{Function Index}.@refill
19809 @kindex V J
19810 @pindex calc-conj-transpose
19811 @tindex ctrn
19812 The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
19813 the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
19815 @ignore
19816 @mindex A
19817 @end ignore
19818 @kindex A (vectors)
19819 @pindex calc-abs (vectors)
19820 @ignore
19821 @mindex abs
19822 @end ignore
19823 @tindex abs (vectors)
19824 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
19825 Frobenius norm of a vector or matrix argument.  This is the square
19826 root of the sum of the squares of the absolute values of the
19827 elements of the vector or matrix.  If the vector is interpreted as
19828 a point in two- or three-dimensional space, this is the distance
19829 from that point to the origin.@refill
19831 @kindex v n
19832 @pindex calc-rnorm
19833 @tindex rnorm
19834 The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes
19835 the row norm, or infinity-norm, of a vector or matrix.  For a plain
19836 vector, this is the maximum of the absolute values of the elements.
19837 For a matrix, this is the maximum of the row-absolute-value-sums,
19838 i.e., of the sums of the absolute values of the elements along the
19839 various rows.
19841 @kindex V N
19842 @pindex calc-cnorm
19843 @tindex cnorm
19844 The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
19845 the column norm, or one-norm, of a vector or matrix.  For a plain
19846 vector, this is the sum of the absolute values of the elements.
19847 For a matrix, this is the maximum of the column-absolute-value-sums.
19848 General @cite{k}-norms for @cite{k} other than one or infinity are
19849 not provided.
19851 @kindex V C
19852 @pindex calc-cross
19853 @tindex cross
19854 The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
19855 right-handed cross product of two vectors, each of which must have
19856 exactly three elements.
19858 @ignore
19859 @mindex &
19860 @end ignore
19861 @kindex & (matrices)
19862 @pindex calc-inv (matrices)
19863 @ignore
19864 @mindex inv
19865 @end ignore
19866 @tindex inv (matrices)
19867 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
19868 inverse of a square matrix.  If the matrix is singular, the inverse
19869 operation is left in symbolic form.  Matrix inverses are recorded so
19870 that once an inverse (or determinant) of a particular matrix has been
19871 computed, the inverse and determinant of the matrix can be recomputed
19872 quickly in the future.
19874 If the argument to @kbd{&} is a plain number @cite{x}, this
19875 command simply computes @cite{1/x}.  This is okay, because the
19876 @samp{/} operator also does a matrix inversion when dividing one
19877 by a matrix.
19879 @kindex V D
19880 @pindex calc-mdet
19881 @tindex det
19882 The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
19883 determinant of a square matrix.
19885 @kindex V L
19886 @pindex calc-mlud
19887 @tindex lud
19888 The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
19889 LU decomposition of a matrix.  The result is a list of three matrices
19890 which, when multiplied together left-to-right, form the original matrix.
19891 The first is a permutation matrix that arises from pivoting in the
19892 algorithm, the second is lower-triangular with ones on the diagonal,
19893 and the third is upper-triangular.
19895 @kindex V T
19896 @pindex calc-mtrace
19897 @tindex tr
19898 The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
19899 trace of a square matrix.  This is defined as the sum of the diagonal
19900 elements of the matrix.
19902 @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
19903 @section Set Operations using Vectors
19905 @noindent
19906 @cindex Sets, as vectors
19907 Calc includes several commands which interpret vectors as @dfn{sets} of
19908 objects.  A set is a collection of objects; any given object can appear
19909 only once in the set.  Calc stores sets as vectors of objects in
19910 sorted order.  Objects in a Calc set can be any of the usual things,
19911 such as numbers, variables, or formulas.  Two set elements are considered
19912 equal if they are identical, except that numerically equal numbers like
19913 the integer 4 and the float 4.0 are considered equal even though they
19914 are not ``identical.''  Variables are treated like plain symbols without
19915 attached values by the set operations; subtracting the set @samp{[b]}
19916 from @samp{[a, b]} always yields the set @samp{[a]} even though if
19917 the variables @samp{a} and @samp{b} both equaled 17, you might
19918 expect the answer @samp{[]}.
19920 If a set contains interval forms, then it is assumed to be a set of
19921 real numbers.  In this case, all set operations require the elements
19922 of the set to be only things that are allowed in intervals:  Real
19923 numbers, plus and minus infinity, HMS forms, and date forms.  If
19924 there are variables or other non-real objects present in a real set,
19925 all set operations on it will be left in unevaluated form.
19927 If the input to a set operation is a plain number or interval form
19928 @var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
19929 The result is always a vector, except that if the set consists of a
19930 single interval, the interval itself is returned instead.
19932 @xref{Logical Operations}, for the @code{in} function which tests if
19933 a certain value is a member of a given set.  To test if the set @cite{A}
19934 is a subset of the set @cite{B}, use @samp{vdiff(A, B) = []}.
19936 @kindex V +
19937 @pindex calc-remove-duplicates
19938 @tindex rdup
19939 The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
19940 converts an arbitrary vector into set notation.  It works by sorting
19941 the vector as if by @kbd{V S}, then removing duplicates.  (For example,
19942 @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
19943 reduced to @samp{[4, 5, a]}).  Overlapping intervals are merged as
19944 necessary.  You rarely need to use @kbd{V +} explicitly, since all the
19945 other set-based commands apply @kbd{V +} to their inputs before using
19946 them.
19948 @kindex V V
19949 @pindex calc-set-union
19950 @tindex vunion
19951 The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
19952 the union of two sets.  An object is in the union of two sets if and
19953 only if it is in either (or both) of the input sets.  (You could
19954 accomplish the same thing by concatenating the sets with @kbd{|},
19955 then using @kbd{V +}.)
19957 @kindex V ^
19958 @pindex calc-set-intersect
19959 @tindex vint
19960 The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
19961 the intersection of two sets.  An object is in the intersection if
19962 and only if it is in both of the input sets.  Thus if the input
19963 sets are disjoint, i.e., if they share no common elements, the result
19964 will be the empty vector @samp{[]}.  Note that the characters @kbd{V}
19965 and @kbd{^} were chosen to be close to the conventional mathematical
19966 notation for set union@c{ ($A \cup B$)}
19967 @asis{} and intersection@c{ ($A \cap B$)}
19968 @asis{}.
19970 @kindex V -
19971 @pindex calc-set-difference
19972 @tindex vdiff
19973 The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
19974 the difference between two sets.  An object is in the difference
19975 @cite{A - B} if and only if it is in @cite{A} but not in @cite{B}.
19976 Thus subtracting @samp{[y,z]} from a set will remove the elements
19977 @samp{y} and @samp{z} if they are present.  You can also think of this
19978 as a general @dfn{set complement} operator; if @cite{A} is the set of
19979 all possible values, then @cite{A - B} is the ``complement'' of @cite{B}.
19980 Obviously this is only practical if the set of all possible values in
19981 your problem is small enough to list in a Calc vector (or simple
19982 enough to express in a few intervals).
19984 @kindex V X
19985 @pindex calc-set-xor
19986 @tindex vxor
19987 The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
19988 the ``exclusive-or,'' or ``symmetric difference'' of two sets.
19989 An object is in the symmetric difference of two sets if and only
19990 if it is in one, but @emph{not} both, of the sets.  Objects that
19991 occur in both sets ``cancel out.''
19993 @kindex V ~
19994 @pindex calc-set-complement
19995 @tindex vcompl
19996 The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
19997 computes the complement of a set with respect to the real numbers.
19998 Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
19999 For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
20000 @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
20002 @kindex V F
20003 @pindex calc-set-floor
20004 @tindex vfloor
20005 The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
20006 reinterprets a set as a set of integers.  Any non-integer values,
20007 and intervals that do not enclose any integers, are removed.  Open
20008 intervals are converted to equivalent closed intervals.  Successive
20009 integers are converted into intervals of integers.  For example, the
20010 complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
20011 the complement with respect to the set of integers you could type
20012 @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
20014 @kindex V E
20015 @pindex calc-set-enumerate
20016 @tindex venum
20017 The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
20018 converts a set of integers into an explicit vector.  Intervals in
20019 the set are expanded out to lists of all integers encompassed by
20020 the intervals.  This only works for finite sets (i.e., sets which
20021 do not involve @samp{-inf} or @samp{inf}).
20023 @kindex V :
20024 @pindex calc-set-span
20025 @tindex vspan
20026 The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
20027 set of reals into an interval form that encompasses all its elements.
20028 The lower limit will be the smallest element in the set; the upper
20029 limit will be the largest element.  For an empty set, @samp{vspan([])}
20030 returns the empty interval @w{@samp{[0 .. 0)}}.
20032 @kindex V #
20033 @pindex calc-set-cardinality
20034 @tindex vcard
20035 The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
20036 the number of integers in a set.  The result is the length of the vector
20037 that would be produced by @kbd{V E}, although the computation is much
20038 more efficient than actually producing that vector.
20040 @cindex Sets, as binary numbers
20041 Another representation for sets that may be more appropriate in some
20042 cases is binary numbers.  If you are dealing with sets of integers
20043 in the range 0 to 49, you can use a 50-bit binary number where a
20044 particular bit is 1 if the corresponding element is in the set.
20045 @xref{Binary Functions}, for a list of commands that operate on
20046 binary numbers.  Note that many of the above set operations have
20047 direct equivalents in binary arithmetic:  @kbd{b o} (@code{calc-or}),
20048 @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
20049 @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
20050 respectively.  You can use whatever representation for sets is most
20051 convenient to you.
20053 @kindex b p
20054 @kindex b u
20055 @pindex calc-pack-bits
20056 @pindex calc-unpack-bits
20057 @tindex vpack
20058 @tindex vunpack
20059 The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
20060 converts an integer that represents a set in binary into a set
20061 in vector/interval notation.  For example, @samp{vunpack(67)}
20062 returns @samp{[[0 .. 1], 6]}.  If the input is negative, the set
20063 it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
20064 Use @kbd{V E} afterwards to expand intervals to individual
20065 values if you wish.  Note that this command uses the @kbd{b}
20066 (binary) prefix key.
20068 The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
20069 converts the other way, from a vector or interval representing
20070 a set of nonnegative integers into a binary integer describing
20071 the same set.  The set may include positive infinity, but must
20072 not include any negative numbers.  The input is interpreted as a
20073 set of integers in the sense of @kbd{V F} (@code{vfloor}).  Beware
20074 that a simple input like @samp{[100]} can result in a huge integer
20075 representation (@c{$2^{100}$}
20076 @cite{2^100}, a 31-digit integer, in this case).
20078 @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
20079 @section Statistical Operations on Vectors
20081 @noindent
20082 @cindex Statistical functions
20083 The commands in this section take vectors as arguments and compute
20084 various statistical measures on the data stored in the vectors.  The
20085 references used in the definitions of these functions are Bevington's
20086 @emph{Data Reduction and Error Analysis for the Physical Sciences},
20087 and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
20088 Vetterling.
20090 The statistical commands use the @kbd{u} prefix key followed by
20091 a shifted letter or other character.
20093 @xref{Manipulating Vectors}, for a description of @kbd{V H}
20094 (@code{calc-histogram}).
20096 @xref{Curve Fitting}, for the @kbd{a F} command for doing
20097 least-squares fits to statistical data.
20099 @xref{Probability Distribution Functions}, for several common
20100 probability distribution functions.
20102 @menu
20103 * Single-Variable Statistics::
20104 * Paired-Sample Statistics::
20105 @end menu
20107 @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
20108 @subsection Single-Variable Statistics
20110 @noindent
20111 These functions do various statistical computations on single
20112 vectors.  Given a numeric prefix argument, they actually pop
20113 @var{n} objects from the stack and combine them into a data
20114 vector.  Each object may be either a number or a vector; if a
20115 vector, any sub-vectors inside it are ``flattened'' as if by
20116 @kbd{v a 0}; @pxref{Manipulating Vectors}.  By default one object
20117 is popped, which (in order to be useful) is usually a vector.
20119 If an argument is a variable name, and the value stored in that
20120 variable is a vector, then the stored vector is used.  This method
20121 has the advantage that if your data vector is large, you can avoid
20122 the slow process of manipulating it directly on the stack.
20124 These functions are left in symbolic form if any of their arguments
20125 are not numbers or vectors, e.g., if an argument is a formula, or
20126 a non-vector variable.  However, formulas embedded within vector
20127 arguments are accepted; the result is a symbolic representation
20128 of the computation, based on the assumption that the formula does
20129 not itself represent a vector.  All varieties of numbers such as
20130 error forms and interval forms are acceptable.
20132 Some of the functions in this section also accept a single error form
20133 or interval as an argument.  They then describe a property of the
20134 normal or uniform (respectively) statistical distribution described
20135 by the argument.  The arguments are interpreted in the same way as
20136 the @var{M} argument of the random number function @kbd{k r}.  In
20137 particular, an interval with integer limits is considered an integer
20138 distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
20139 An interval with at least one floating-point limit is a continuous
20140 distribution:  @samp{[2.0 .. 6.0)} is @emph{not} the same as
20141 @samp{[2.0 .. 5.0]}!
20143 @kindex u #
20144 @pindex calc-vector-count
20145 @tindex vcount
20146 The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
20147 computes the number of data values represented by the inputs.
20148 For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
20149 If the argument is a single vector with no sub-vectors, this
20150 simply computes the length of the vector.
20152 @kindex u +
20153 @kindex u *
20154 @pindex calc-vector-sum
20155 @pindex calc-vector-prod
20156 @tindex vsum
20157 @tindex vprod
20158 @cindex Summations (statistical)
20159 The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
20160 computes the sum of the data values.  The @kbd{u *}
20161 (@code{calc-vector-prod}) [@code{vprod}] command computes the
20162 product of the data values.  If the input is a single flat vector,
20163 these are the same as @kbd{V R +} and @kbd{V R *}
20164 (@pxref{Reducing and Mapping}).@refill
20166 @kindex u X
20167 @kindex u N
20168 @pindex calc-vector-max
20169 @pindex calc-vector-min
20170 @tindex vmax
20171 @tindex vmin
20172 The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
20173 computes the maximum of the data values, and the @kbd{u N}
20174 (@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
20175 If the argument is an interval, this finds the minimum or maximum
20176 value in the interval.  (Note that @samp{vmax([2..6)) = 5} as
20177 described above.)  If the argument is an error form, this returns
20178 plus or minus infinity.
20180 @kindex u M
20181 @pindex calc-vector-mean
20182 @tindex vmean
20183 @cindex Mean of data values
20184 The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
20185 computes the average (arithmetic mean) of the data values.
20186 If the inputs are error forms @c{$x$ @code{+/-} $\sigma$}
20187 @samp{x +/- s}, this is the weighted
20188 mean of the @cite{x} values with weights @c{$1 / \sigma^2$}
20189 @cite{1 / s^2}.
20190 @tex
20191 \turnoffactive
20192 $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
20193            \displaystyle \sum { 1 \over \sigma_i^2 } } $$
20194 @end tex
20195 If the inputs are not error forms, this is simply the sum of the
20196 values divided by the count of the values.@refill
20198 Note that a plain number can be considered an error form with
20199 error @c{$\sigma = 0$}
20200 @cite{s = 0}.  If the input to @kbd{u M} is a mixture of
20201 plain numbers and error forms, the result is the mean of the
20202 plain numbers, ignoring all values with non-zero errors.  (By the
20203 above definitions it's clear that a plain number effectively
20204 has an infinite weight, next to which an error form with a finite
20205 weight is completely negligible.)
20207 This function also works for distributions (error forms or
20208 intervals).  The mean of an error form `@var{a} @t{+/-} @var{b}' is simply
20209 @cite{a}.  The mean of an interval is the mean of the minimum
20210 and maximum values of the interval.
20212 @kindex I u M
20213 @pindex calc-vector-mean-error
20214 @tindex vmeane
20215 The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
20216 command computes the mean of the data points expressed as an
20217 error form.  This includes the estimated error associated with
20218 the mean.  If the inputs are error forms, the error is the square
20219 root of the reciprocal of the sum of the reciprocals of the squares
20220 of the input errors.  (I.e., the variance is the reciprocal of the
20221 sum of the reciprocals of the variances.)
20222 @tex
20223 \turnoffactive
20224 $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
20225 @end tex
20226 If the inputs are plain
20227 numbers, the error is equal to the standard deviation of the values
20228 divided by the square root of the number of values.  (This works
20229 out to be equivalent to calculating the standard deviation and
20230 then assuming each value's error is equal to this standard
20231 deviation.)@refill
20232 @tex
20233 \turnoffactive
20234 $$ \sigma_\mu^2 = {\sigma^2 \over N} $$
20235 @end tex
20237 @kindex H u M
20238 @pindex calc-vector-median
20239 @tindex vmedian
20240 @cindex Median of data values
20241 The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
20242 command computes the median of the data values.  The values are
20243 first sorted into numerical order; the median is the middle
20244 value after sorting.  (If the number of data values is even,
20245 the median is taken to be the average of the two middle values.)
20246 The median function is different from the other functions in
20247 this section in that the arguments must all be real numbers;
20248 variables are not accepted even when nested inside vectors.
20249 (Otherwise it is not possible to sort the data values.)  If
20250 any of the input values are error forms, their error parts are
20251 ignored.
20253 The median function also accepts distributions.  For both normal
20254 (error form) and uniform (interval) distributions, the median is
20255 the same as the mean.
20257 @kindex H I u M
20258 @pindex calc-vector-harmonic-mean
20259 @tindex vhmean
20260 @cindex Harmonic mean
20261 The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
20262 command computes the harmonic mean of the data values.  This is
20263 defined as the reciprocal of the arithmetic mean of the reciprocals
20264 of the values.
20265 @tex
20266 \turnoffactive
20267 $$ { N \over \displaystyle \sum {1 \over x_i} } $$
20268 @end tex
20270 @kindex u G
20271 @pindex calc-vector-geometric-mean
20272 @tindex vgmean
20273 @cindex Geometric mean
20274 The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
20275 command computes the geometric mean of the data values.  This
20276 is the @var{n}th root of the product of the values.  This is also
20277 equal to the @code{exp} of the arithmetic mean of the logarithms
20278 of the data values.
20279 @tex
20280 \turnoffactive
20281 $$ \exp \left ( \sum { \ln x_i } \right ) =
20282    \left ( \prod { x_i } \right)^{1 / N} $$
20283 @end tex
20285 @kindex H u G
20286 @tindex agmean
20287 The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
20288 mean'' of two numbers taken from the stack.  This is computed by
20289 replacing the two numbers with their arithmetic mean and geometric
20290 mean, then repeating until the two values converge.
20291 @tex
20292 \turnoffactive
20293 $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
20294 @end tex
20296 @cindex Root-mean-square
20297 Another commonly used mean, the RMS (root-mean-square), can be computed
20298 for a vector of numbers simply by using the @kbd{A} command.
20300 @kindex u S
20301 @pindex calc-vector-sdev
20302 @tindex vsdev
20303 @cindex Standard deviation
20304 @cindex Sample statistics
20305 The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
20306 computes the standard deviation@c{ $\sigma$}
20307 @asis{} of the data values.  If the
20308 values are error forms, the errors are used as weights just
20309 as for @kbd{u M}.  This is the @emph{sample} standard deviation,
20310 whose value is the square root of the sum of the squares of the
20311 differences between the values and the mean of the @cite{N} values,
20312 divided by @cite{N-1}.
20313 @tex
20314 \turnoffactive
20315 $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
20316 @end tex
20318 This function also applies to distributions.  The standard deviation
20319 of a single error form is simply the error part.  The standard deviation
20320 of a continuous interval happens to equal the difference between the
20321 limits, divided by @c{$\sqrt{12}$}
20322 @cite{sqrt(12)}.  The standard deviation of an
20323 integer interval is the same as the standard deviation of a vector
20324 of those integers.
20326 @kindex I u S
20327 @pindex calc-vector-pop-sdev
20328 @tindex vpsdev
20329 @cindex Population statistics
20330 The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
20331 command computes the @emph{population} standard deviation.
20332 It is defined by the same formula as above but dividing
20333 by @cite{N} instead of by @cite{N-1}.  The population standard
20334 deviation is used when the input represents the entire set of
20335 data values in the distribution; the sample standard deviation
20336 is used when the input represents a sample of the set of all
20337 data values, so that the mean computed from the input is itself
20338 only an estimate of the true mean.
20339 @tex
20340 \turnoffactive
20341 $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
20342 @end tex
20344 For error forms and continuous intervals, @code{vpsdev} works
20345 exactly like @code{vsdev}.  For integer intervals, it computes the
20346 population standard deviation of the equivalent vector of integers.
20348 @kindex H u S
20349 @kindex H I u S
20350 @pindex calc-vector-variance
20351 @pindex calc-vector-pop-variance
20352 @tindex vvar
20353 @tindex vpvar
20354 @cindex Variance of data values
20355 The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
20356 @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
20357 commands compute the variance of the data values.  The variance
20358 is the square@c{ $\sigma^2$}
20359 @asis{} of the standard deviation, i.e., the sum of the
20360 squares of the deviations of the data values from the mean.
20361 (This definition also applies when the argument is a distribution.)
20363 @ignore
20364 @starindex
20365 @end ignore
20366 @tindex vflat
20367 The @code{vflat} algebraic function returns a vector of its
20368 arguments, interpreted in the same way as the other functions
20369 in this section.  For example, @samp{vflat(1, [2, [3, 4]], 5)}
20370 returns @samp{[1, 2, 3, 4, 5]}.
20372 @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
20373 @subsection Paired-Sample Statistics
20375 @noindent
20376 The functions in this section take two arguments, which must be
20377 vectors of equal size.  The vectors are each flattened in the same
20378 way as by the single-variable statistical functions.  Given a numeric
20379 prefix argument of 1, these functions instead take one object from
20380 the stack, which must be an @c{$N\times2$}
20381 @asis{Nx2} matrix of data values.  Once
20382 again, variable names can be used in place of actual vectors and
20383 matrices.
20385 @kindex u C
20386 @pindex calc-vector-covariance
20387 @tindex vcov
20388 @cindex Covariance
20389 The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
20390 computes the sample covariance of two vectors.  The covariance
20391 of vectors @var{x} and @var{y} is the sum of the products of the
20392 differences between the elements of @var{x} and the mean of @var{x}
20393 times the differences between the corresponding elements of @var{y}
20394 and the mean of @var{y}, all divided by @cite{N-1}.  Note that
20395 the variance of a vector is just the covariance of the vector
20396 with itself.  Once again, if the inputs are error forms the
20397 errors are used as weight factors.  If both @var{x} and @var{y}
20398 are composed of error forms, the error for a given data point
20399 is taken as the square root of the sum of the squares of the two
20400 input errors.
20401 @tex
20402 \turnoffactive
20403 $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
20404 $$ \sigma_{x\!y}^2 =
20405     {\displaystyle {1 \over N-1}
20406                    \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
20407      \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
20409 @end tex
20411 @kindex I u C
20412 @pindex calc-vector-pop-covariance
20413 @tindex vpcov
20414 The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
20415 command computes the population covariance, which is the same as the
20416 sample covariance computed by @kbd{u C} except dividing by @cite{N}
20417 instead of @cite{N-1}.
20419 @kindex H u C
20420 @pindex calc-vector-correlation
20421 @tindex vcorr
20422 @cindex Correlation coefficient
20423 @cindex Linear correlation
20424 The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
20425 command computes the linear correlation coefficient of two vectors.
20426 This is defined by the covariance of the vectors divided by the
20427 product of their standard deviations.  (There is no difference
20428 between sample or population statistics here.)
20429 @tex
20430 \turnoffactive
20431 $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
20432 @end tex
20434 @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
20435 @section Reducing and Mapping Vectors
20437 @noindent
20438 The commands in this section allow for more general operations on the
20439 elements of vectors.
20441 @kindex V A
20442 @pindex calc-apply
20443 @tindex apply
20444 The simplest of these operations is @kbd{V A} (@code{calc-apply})
20445 [@code{apply}], which applies a given operator to the elements of a vector.
20446 For example, applying the hypothetical function @code{f} to the vector
20447 @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
20448 Applying the @code{+} function to the vector @samp{[a, b]} gives
20449 @samp{a + b}.  Applying @code{+} to the vector @samp{[a, b, c]} is an
20450 error, since the @code{+} function expects exactly two arguments.
20452 While @kbd{V A} is useful in some cases, you will usually find that either
20453 @kbd{V R} or @kbd{V M}, described below, is closer to what you want.
20455 @menu
20456 * Specifying Operators::
20457 * Mapping::
20458 * Reducing::
20459 * Nesting and Fixed Points::
20460 * Generalized Products::
20461 @end menu
20463 @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
20464 @subsection Specifying Operators
20466 @noindent
20467 Commands in this section (like @kbd{V A}) prompt you to press the key
20468 corresponding to the desired operator.  Press @kbd{?} for a partial
20469 list of the available operators.  Generally, an operator is any key or
20470 sequence of keys that would normally take one or more arguments from
20471 the stack and replace them with a result.  For example, @kbd{V A H C}
20472 uses the hyperbolic cosine operator, @code{cosh}.  (Since @code{cosh}
20473 expects one argument, @kbd{V A H C} requires a vector with a single
20474 element as its argument.)
20476 You can press @kbd{x} at the operator prompt to select any algebraic
20477 function by name to use as the operator.  This includes functions you
20478 have defined yourself using the @kbd{Z F} command.  (@xref{Algebraic
20479 Definitions}.)  If you give a name for which no function has been
20480 defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
20481 Calc will prompt for the number of arguments the function takes if it
20482 can't figure it out on its own (say, because you named a function that
20483 is currently undefined).  It is also possible to type a digit key before
20484 the function name to specify the number of arguments, e.g.,
20485 @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
20486 looks like it ought to have only two.  This technique may be necessary
20487 if the function allows a variable number of arguments.  For example,
20488 the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
20489 if you want to map with the three-argument version, you will have to
20490 type @kbd{V M 3 v e}.
20492 It is also possible to apply any formula to a vector by treating that
20493 formula as a function.  When prompted for the operator to use, press
20494 @kbd{'} (the apostrophe) and type your formula as an algebraic entry.
20495 You will then be prompted for the argument list, which defaults to a
20496 list of all variables that appear in the formula, sorted into alphabetic
20497 order.  For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
20498 The default argument list would be @samp{(x y)}, which means that if
20499 this function is applied to the arguments @samp{[3, 10]} the result will
20500 be @samp{3 + 2*10^3}.  (If you plan to use a certain formula in this
20501 way often, you might consider defining it as a function with @kbd{Z F}.)
20503 Another way to specify the arguments to the formula you enter is with
20504 @kbd{$}, @kbd{$$}, and so on.  For example, @kbd{V A ' $$ + 2$^$$}
20505 has the same effect as the previous example.  The argument list is
20506 automatically taken to be @samp{($$ $)}.  (The order of the arguments
20507 may seem backwards, but it is analogous to the way normal algebraic
20508 entry interacts with the stack.)
20510 If you press @kbd{$} at the operator prompt, the effect is similar to
20511 the apostrophe except that the relevant formula is taken from top-of-stack
20512 instead.  The actual vector arguments of the @kbd{V A $} or related command
20513 then start at the second-to-top stack position.  You will still be
20514 prompted for an argument list.
20516 @cindex Nameless functions
20517 @cindex Generic functions
20518 A function can be written without a name using the notation @samp{<#1 - #2>},
20519 which means ``a function of two arguments that computes the first
20520 argument minus the second argument.''  The symbols @samp{#1} and @samp{#2}
20521 are placeholders for the arguments.  You can use any names for these
20522 placeholders if you wish, by including an argument list followed by a
20523 colon:  @samp{<x, y : x - y>}.  When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
20524 Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
20525 to map across the vectors.  When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
20526 Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}.  In both
20527 cases, Calc also writes the nameless function to the Trail so that you
20528 can get it back later if you wish.
20530 If there is only one argument, you can write @samp{#} in place of @samp{#1}.
20531 (Note that @samp{< >} notation is also used for date forms.  Calc tells
20532 that @samp{<@var{stuff}>} is a nameless function by the presence of
20533 @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
20534 begins with a list of variables followed by a colon.)
20536 You can type a nameless function directly to @kbd{V A '}, or put one on
20537 the stack and use it with @w{@kbd{V A $}}.  Calc will not prompt for an
20538 argument list in this case, since the nameless function specifies the
20539 argument list as well as the function itself.  In @kbd{V A '}, you can
20540 omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
20541 so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
20542 which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
20544 @cindex Lambda expressions
20545 @ignore
20546 @starindex
20547 @end ignore
20548 @tindex lambda
20549 The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
20550 (The word @code{lambda} derives from Lisp notation and the theory of
20551 functions.)  The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
20552 ArgB, ArgA + ArgB)}.  Note that there is no actual Calc function called
20553 @code{lambda}; the whole point is that the @code{lambda} expression is
20554 used in its symbolic form, not evaluated for an answer until it is applied
20555 to specific arguments by a command like @kbd{V A} or @kbd{V M}.
20557 (Actually, @code{lambda} does have one special property:  Its arguments
20558 are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
20559 will not simplify the @samp{2/3} until the nameless function is actually
20560 called.)
20562 @tindex add
20563 @tindex sub
20564 @ignore
20565 @mindex @idots
20566 @end ignore
20567 @tindex mul
20568 @ignore
20569 @mindex @null
20570 @end ignore
20571 @tindex div
20572 @ignore
20573 @mindex @null
20574 @end ignore
20575 @tindex pow
20576 @ignore
20577 @mindex @null
20578 @end ignore
20579 @tindex neg
20580 @ignore
20581 @mindex @null
20582 @end ignore
20583 @tindex mod
20584 @ignore
20585 @mindex @null
20586 @end ignore
20587 @tindex vconcat
20588 As usual, commands like @kbd{V A} have algebraic function name equivalents.
20589 For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
20590 @samp{apply(gcd, v)}.  The first argument specifies the operator name,
20591 and is either a variable whose name is the same as the function name,
20592 or a nameless function like @samp{<#^3+1>}.  Operators that are normally
20593 written as algebraic symbols have the names @code{add}, @code{sub},
20594 @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
20595 @code{vconcat}.@refill
20597 @ignore
20598 @starindex
20599 @end ignore
20600 @tindex call
20601 The @code{call} function builds a function call out of several arguments:
20602 @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
20603 in turn is the same as @samp{gcd(x, y)}.  The first argument of @code{call},
20604 like the other functions described here, may be either a variable naming a
20605 function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
20606 as @samp{x + 2y}).
20608 (Experts will notice that it's not quite proper to use a variable to name
20609 a function, since the name @code{gcd} corresponds to the Lisp variable
20610 @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}.  Calc
20611 automatically makes this translation, so you don't have to worry
20612 about it.)
20614 @node Mapping, Reducing, Specifying Operators, Reducing and Mapping
20615 @subsection Mapping
20617 @noindent
20618 @kindex V M
20619 @pindex calc-map
20620 @tindex map
20621 The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
20622 operator elementwise to one or more vectors.  For example, mapping
20623 @code{A} [@code{abs}] produces a vector of the absolute values of the
20624 elements in the input vector.  Mapping @code{+} pops two vectors from
20625 the stack, which must be of equal length, and produces a vector of the
20626 pairwise sums of the elements.  If either argument is a non-vector, it
20627 is duplicated for each element of the other vector.  For example,
20628 @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
20629 With the 2 listed first, it would have computed a vector of powers of
20630 two.  Mapping a user-defined function pops as many arguments from the
20631 stack as the function requires.  If you give an undefined name, you will
20632 be prompted for the number of arguments to use.@refill
20634 If any argument to @kbd{V M} is a matrix, the operator is normally mapped
20635 across all elements of the matrix.  For example, given the matrix
20636 @cite{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
20637 produce another @c{$3\times2$}
20638 @asis{3x2} matrix, @cite{[[1, 2, 3], [4, 5, 6]]}.
20640 @tindex mapr
20641 The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
20642 operator prompt) maps by rows instead.  For example, @kbd{V M _ A} views
20643 the above matrix as a vector of two 3-element row vectors.  It produces
20644 a new vector which contains the absolute values of those row vectors,
20645 namely @cite{[3.74, 8.77]}.  (Recall, the absolute value of a vector is
20646 defined as the square root of the sum of the squares of the elements.)
20647 Some operators accept vectors and return new vectors; for example,
20648 @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
20649 of the matrix to get a new matrix, @cite{[[3, -2, 1], [-6, 5, -4]]}.
20651 Sometimes a vector of vectors (representing, say, strings, sets, or lists)
20652 happens to look like a matrix.  If so, remember to use @kbd{V M _} if you
20653 want to map a function across the whole strings or sets rather than across
20654 their individual elements.
20656 @tindex mapc
20657 The command @kbd{V M :} [@code{mapc}] maps by columns.  Basically, it
20658 transposes the input matrix, maps by rows, and then, if the result is a
20659 matrix, transposes again.  For example, @kbd{V M : A} takes the absolute
20660 values of the three columns of the matrix, treating each as a 2-vector,
20661 and @kbd{V M : v v} reverses the columns to get the matrix
20662 @cite{[[-4, 5, -6], [1, -2, 3]]}.
20664 (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
20665 and column-like appearances, and were not already taken by useful
20666 operators.  Also, they appear shifted on most keyboards so they are easy
20667 to type after @kbd{V M}.)
20669 The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
20670 not matrices (so if none of the arguments are matrices, they have no
20671 effect at all).  If some of the arguments are matrices and others are
20672 plain numbers, the plain numbers are held constant for all rows of the
20673 matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
20674 a vector takes a dot product of the vector with itself).
20676 If some of the arguments are vectors with the same lengths as the
20677 rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
20678 arguments, those vectors are also held constant for every row or
20679 column.
20681 Sometimes it is useful to specify another mapping command as the operator
20682 to use with @kbd{V M}.  For example, @kbd{V M _ V A +} applies @kbd{V A +}
20683 to each row of the input matrix, which in turn adds the two values on that
20684 row.  If you give another vector-operator command as the operator for
20685 @kbd{V M}, it automatically uses map-by-rows mode if you don't specify
20686 otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}.  (If
20687 you really want to map-by-elements another mapping command, you can use
20688 a triple-nested mapping command:  @kbd{V M V M V A +} means to map
20689 @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
20690 mapped over the elements of each row.)
20692 @tindex mapa
20693 @tindex mapd
20694 Previous versions of Calc had ``map across'' and ``map down'' modes
20695 that are now considered obsolete; the old ``map across'' is now simply
20696 @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}.  The algebraic
20697 functions @code{mapa} and @code{mapd} are still supported, though.
20698 Note also that, while the old mapping modes were persistent (once you
20699 set the mode, it would apply to later mapping commands until you reset
20700 it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
20701 mapping command.  The default @kbd{V M} always means map-by-elements.
20703 @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
20704 @kbd{V M} but for equations and inequalities instead of vectors.
20705 @xref{Storing Variables}, for the @kbd{s m} command which modifies a
20706 variable's stored value using a @kbd{V M}-like operator.
20708 @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
20709 @subsection Reducing
20711 @noindent
20712 @kindex V R
20713 @pindex calc-reduce
20714 @tindex reduce
20715 The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
20716 binary operator across all the elements of a vector.  A binary operator is
20717 a function such as @code{+} or @code{max} which takes two arguments.  For
20718 example, reducing @code{+} over a vector computes the sum of the elements
20719 of the vector.  Reducing @code{-} computes the first element minus each of
20720 the remaining elements.  Reducing @code{max} computes the maximum element
20721 and so on.  In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
20722 produces @samp{f(f(f(a, b), c), d)}.
20724 @kindex I V R
20725 @tindex rreduce
20726 The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
20727 that works from right to left through the vector.  For example, plain
20728 @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
20729 but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
20730 or @samp{a - b + c - d}.  This ``alternating sum'' occurs frequently
20731 in power series expansions.
20733 @kindex V U
20734 @tindex accum
20735 The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
20736 accumulation operation.  Here Calc does the corresponding reduction
20737 operation, but instead of producing only the final result, it produces
20738 a vector of all the intermediate results.  Accumulating @code{+} over
20739 the vector @samp{[a, b, c, d]} produces the vector
20740 @samp{[a, a + b, a + b + c, a + b + c + d]}.
20742 @kindex I V U
20743 @tindex raccum
20744 The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
20745 For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
20746 vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
20748 @tindex reducea
20749 @tindex rreducea
20750 @tindex reduced
20751 @tindex rreduced
20752 As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise.  For
20753 example, given the matrix @cite{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
20754 compute @cite{a + b + c + d + e + f}.  You can type @kbd{V R _} or
20755 @kbd{V R :} to modify this behavior.  The @kbd{V R _} [@code{reducea}]
20756 command reduces ``across'' the matrix; it reduces each row of the matrix
20757 as a vector, then collects the results.  Thus @kbd{V R _ +} of this
20758 matrix would produce @cite{[a + b + c, d + e + f]}.  Similarly, @kbd{V R :}
20759 [@code{reduced}] reduces down; @kbd{V R : +} would produce @cite{[a + d,
20760 b + e, c + f]}.
20762 @tindex reducer
20763 @tindex rreducer
20764 There is a third ``by rows'' mode for reduction that is occasionally
20765 useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
20766 the rows of the matrix themselves.  Thus @kbd{V R = +} on the above
20767 matrix would get the same result as @kbd{V R : +}, since adding two
20768 row vectors is equivalent to adding their elements.  But @kbd{V R = *}
20769 would multiply the two rows (to get a single number, their dot product),
20770 while @kbd{V R : *} would produce a vector of the products of the columns.
20772 These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
20773 but they are not currently supported with @kbd{V U} or @kbd{I V U}.
20775 @tindex reducec
20776 @tindex rreducec
20777 The obsolete reduce-by-columns function, @code{reducec}, is still
20778 supported but there is no way to get it through the @kbd{V R} command.
20780 The commands @kbd{M-# :} and @kbd{M-# _} are equivalent to typing
20781 @kbd{M-# r} to grab a rectangle of data into Calc, and then typing
20782 @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
20783 rows of the matrix.  @xref{Grabbing From Buffers}.
20785 @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
20786 @subsection Nesting and Fixed Points
20788 @noindent
20789 @kindex H V R
20790 @tindex nest
20791 The @kbd{H V R} [@code{nest}] command applies a function to a given
20792 argument repeatedly.  It takes two values, @samp{a} and @samp{n}, from
20793 the stack, where @samp{n} must be an integer.  It then applies the
20794 function nested @samp{n} times; if the function is @samp{f} and @samp{n}
20795 is 3, the result is @samp{f(f(f(a)))}.  The number @samp{n} may be
20796 negative if Calc knows an inverse for the function @samp{f}; for
20797 example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
20799 @kindex H V U
20800 @tindex anest
20801 The @kbd{H V U} [@code{anest}] command is an accumulating version of
20802 @code{nest}:  It returns a vector of @samp{n+1} values, e.g.,
20803 @samp{[a, f(a), f(f(a)), f(f(f(a)))]}.  If @samp{n} is negative and
20804 @samp{F} is the inverse of @samp{f}, then the result is of the
20805 form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
20807 @kindex H I V R
20808 @tindex fixp
20809 @cindex Fixed points
20810 The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
20811 that it takes only an @samp{a} value from the stack; the function is
20812 applied until it reaches a ``fixed point,'' i.e., until the result
20813 no longer changes.
20815 @kindex H I V U
20816 @tindex afixp
20817 The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
20818 The first element of the return vector will be the initial value @samp{a};
20819 the last element will be the final result that would have been returned
20820 by @code{fixp}.
20822 For example, 0.739085 is a fixed point of the cosine function (in radians):
20823 @samp{cos(0.739085) = 0.739085}.  You can find this value by putting, say,
20824 1.0 on the stack and typing @kbd{H I V U C}.  (We use the accumulating
20825 version so we can see the intermediate results:  @samp{[1, 0.540302, 0.857553,
20826 0.65329, ...]}.  With a precision of six, this command will take 36 steps
20827 to converge to 0.739085.)
20829 Newton's method for finding roots is a classic example of iteration
20830 to a fixed point.  To find the square root of five starting with an
20831 initial guess, Newton's method would look for a fixed point of the
20832 function @samp{(x + 5/x) / 2}.  Putting a guess of 1 on the stack
20833 and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
20834 2.23607.  This is equivalent to using the @kbd{a R} (@code{calc-find-root})
20835 command to find a root of the equation @samp{x^2 = 5}.
20837 These examples used numbers for @samp{a} values.  Calc keeps applying
20838 the function until two successive results are equal to within the
20839 current precision.  For complex numbers, both the real parts and the
20840 imaginary parts must be equal to within the current precision.  If
20841 @samp{a} is a formula (say, a variable name), then the function is
20842 applied until two successive results are exactly the same formula.
20843 It is up to you to ensure that the function will eventually converge;
20844 if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
20846 The algebraic @code{fixp} function takes two optional arguments, @samp{n}
20847 and @samp{tol}.  The first is the maximum number of steps to be allowed,
20848 and must be either an integer or the symbol @samp{inf} (infinity, the
20849 default).  The second is a convergence tolerance.  If a tolerance is
20850 specified, all results during the calculation must be numbers, not
20851 formulas, and the iteration stops when the magnitude of the difference
20852 between two successive results is less than or equal to the tolerance.
20853 (This implies that a tolerance of zero iterates until the results are
20854 exactly equal.)
20856 Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
20857 computes the square root of @samp{A} given the initial guess @samp{B},
20858 stopping when the result is correct within the specified tolerance, or
20859 when 20 steps have been taken, whichever is sooner.
20861 @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
20862 @subsection Generalized Products
20864 @kindex V O
20865 @pindex calc-outer-product
20866 @tindex outer
20867 The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
20868 a given binary operator to all possible pairs of elements from two
20869 vectors, to produce a matrix.  For example, @kbd{V O *} with @samp{[a, b]}
20870 and @samp{[x, y, z]} on the stack produces a multiplication table:
20871 @samp{[[a x, a y, a z], [b x, b y, b z]]}.  Element @var{r},@var{c} of
20872 the result matrix is obtained by applying the operator to element @var{r}
20873 of the lefthand vector and element @var{c} of the righthand vector.
20875 @kindex V I
20876 @pindex calc-inner-product
20877 @tindex inner
20878 The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
20879 the generalized inner product of two vectors or matrices, given a
20880 ``multiplicative'' operator and an ``additive'' operator.  These can each
20881 actually be any binary operators; if they are @samp{*} and @samp{+},
20882 respectively, the result is a standard matrix multiplication.  Element
20883 @var{r},@var{c} of the result matrix is obtained by mapping the
20884 multiplicative operator across row @var{r} of the lefthand matrix and
20885 column @var{c} of the righthand matrix, and then reducing with the additive
20886 operator.  Just as for the standard @kbd{*} command, this can also do a
20887 vector-matrix or matrix-vector inner product, or a vector-vector
20888 generalized dot product.
20890 Since @kbd{V I} requires two operators, it prompts twice.  In each case,
20891 you can use any of the usual methods for entering the operator.  If you
20892 use @kbd{$} twice to take both operator formulas from the stack, the
20893 first (multiplicative) operator is taken from the top of the stack
20894 and the second (additive) operator is taken from second-to-top.
20896 @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
20897 @section Vector and Matrix Display Formats
20899 @noindent
20900 Commands for controlling vector and matrix display use the @kbd{v} prefix
20901 instead of the usual @kbd{d} prefix.  But they are display modes; in
20902 particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
20903 in the same way (@pxref{Display Modes}).  Matrix display is also
20904 influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
20905 @pxref{Normal Language Modes}.
20907 @kindex V <
20908 @pindex calc-matrix-left-justify
20909 @kindex V =
20910 @pindex calc-matrix-center-justify
20911 @kindex V >
20912 @pindex calc-matrix-right-justify
20913 The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
20914 (@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
20915 (@code{calc-matrix-center-justify}) control whether matrix elements
20916 are justified to the left, right, or center of their columns.@refill
20918 @kindex V [
20919 @pindex calc-vector-brackets
20920 @kindex V @{
20921 @pindex calc-vector-braces
20922 @kindex V (
20923 @pindex calc-vector-parens
20924 The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
20925 brackets that surround vectors and matrices displayed in the stack on
20926 and off.  The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
20927 (@code{calc-vector-parens}) commands use curly braces or parentheses,
20928 respectively, instead of square brackets.  For example, @kbd{v @{} might
20929 be used in preparation for yanking a matrix into a buffer running
20930 Mathematica.  (In fact, the Mathematica language mode uses this mode;
20931 @pxref{Mathematica Language Mode}.)  Note that, regardless of the
20932 display mode, either brackets or braces may be used to enter vectors,
20933 and parentheses may never be used for this purpose.@refill
20935 @kindex V ]
20936 @pindex calc-matrix-brackets
20937 The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
20938 ``big'' style display of matrices.  It prompts for a string of code
20939 letters; currently implemented letters are @code{R}, which enables
20940 brackets on each row of the matrix; @code{O}, which enables outer
20941 brackets in opposite corners of the matrix; and @code{C}, which
20942 enables commas or semicolons at the ends of all rows but the last.
20943 The default format is @samp{RO}.  (Before Calc 2.00, the format
20944 was fixed at @samp{ROC}.)  Here are some example matrices:
20946 @example
20947 @group
20948 [ [ 123,  0,   0  ]       [ [ 123,  0,   0  ],
20949   [  0,  123,  0  ]         [  0,  123,  0  ],
20950   [  0,   0,  123 ] ]       [  0,   0,  123 ] ]
20952          RO                        ROC
20954 @end group
20955 @end example
20956 @noindent
20957 @example
20958 @group
20959   [ 123,  0,   0            [ 123,  0,   0 ;
20960      0,  123,  0               0,  123,  0 ;
20961      0,   0,  123 ]            0,   0,  123 ]
20963           O                        OC
20965 @end group
20966 @end example
20967 @noindent
20968 @example
20969 @group
20970   [ 123,  0,   0  ]           123,  0,   0
20971   [  0,  123,  0  ]            0,  123,  0
20972   [  0,   0,  123 ]            0,   0,  123
20974           R                       @r{blank}
20975 @end group
20976 @end example
20978 @noindent
20979 Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
20980 @samp{OC} are all recognized as matrices during reading, while
20981 the others are useful for display only.
20983 @kindex V ,
20984 @pindex calc-vector-commas
20985 The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
20986 off in vector and matrix display.@refill
20988 In vectors of length one, and in all vectors when commas have been
20989 turned off, Calc adds extra parentheses around formulas that might
20990 otherwise be ambiguous.  For example, @samp{[a b]} could be a vector
20991 of the one formula @samp{a b}, or it could be a vector of two
20992 variables with commas turned off.  Calc will display the former
20993 case as @samp{[(a b)]}.  You can disable these extra parentheses
20994 (to make the output less cluttered at the expense of allowing some
20995 ambiguity) by adding the letter @code{P} to the control string you
20996 give to @kbd{v ]} (as described above).
20998 @kindex V .
20999 @pindex calc-full-vectors
21000 The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
21001 display of long vectors on and off.  In this mode, vectors of six
21002 or more elements, or matrices of six or more rows or columns, will
21003 be displayed in an abbreviated form that displays only the first
21004 three elements and the last element:  @samp{[a, b, c, ..., z]}.
21005 When very large vectors are involved this will substantially
21006 improve Calc's display speed.
21008 @kindex t .
21009 @pindex calc-full-trail-vectors
21010 The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
21011 similar mode for recording vectors in the Trail.  If you turn on
21012 this mode, vectors of six or more elements and matrices of six or
21013 more rows or columns will be abbreviated when they are put in the
21014 Trail.  The @kbd{t y} (@code{calc-trail-yank}) command will be
21015 unable to recover those vectors.  If you are working with very
21016 large vectors, this mode will improve the speed of all operations
21017 that involve the trail.
21019 @kindex V /
21020 @pindex calc-break-vectors
21021 The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
21022 vector display on and off.  Normally, matrices are displayed with one
21023 row per line but all other types of vectors are displayed in a single
21024 line.  This mode causes all vectors, whether matrices or not, to be
21025 displayed with a single element per line.  Sub-vectors within the
21026 vectors will still use the normal linear form.
21028 @node Algebra, Units, Matrix Functions, Top
21029 @chapter Algebra
21031 @noindent
21032 This section covers the Calc features that help you work with
21033 algebraic formulas.  First, the general sub-formula selection
21034 mechanism is described; this works in conjunction with any Calc
21035 commands.  Then, commands for specific algebraic operations are
21036 described.  Finally, the flexible @dfn{rewrite rule} mechanism
21037 is discussed.
21039 The algebraic commands use the @kbd{a} key prefix; selection
21040 commands use the @kbd{j} (for ``just a letter that wasn't used
21041 for anything else'') prefix.
21043 @xref{Editing Stack Entries}, to see how to manipulate formulas
21044 using regular Emacs editing commands.@refill
21046 When doing algebraic work, you may find several of the Calculator's
21047 modes to be helpful, including algebraic-simplification mode (@kbd{m A})
21048 or no-simplification mode (@kbd{m O}),
21049 algebraic-entry mode (@kbd{m a}), fraction mode (@kbd{m f}), and
21050 symbolic mode (@kbd{m s}).  @xref{Mode Settings}, for discussions
21051 of these modes.  You may also wish to select ``big'' display mode (@kbd{d B}).
21052 @xref{Normal Language Modes}.@refill
21054 @menu
21055 * Selecting Subformulas::
21056 * Algebraic Manipulation::
21057 * Simplifying Formulas::
21058 * Polynomials::
21059 * Calculus::
21060 * Solving Equations::
21061 * Numerical Solutions::
21062 * Curve Fitting::
21063 * Summations::
21064 * Logical Operations::
21065 * Rewrite Rules::
21066 @end menu
21068 @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
21069 @section Selecting Sub-Formulas
21071 @noindent
21072 @cindex Selections
21073 @cindex Sub-formulas
21074 @cindex Parts of formulas
21075 When working with an algebraic formula it is often necessary to
21076 manipulate a portion of the formula rather than the formula as a
21077 whole.  Calc allows you to ``select'' a portion of any formula on
21078 the stack.  Commands which would normally operate on that stack
21079 entry will now operate only on the sub-formula, leaving the
21080 surrounding part of the stack entry alone.
21082 One common non-algebraic use for selection involves vectors.  To work
21083 on one element of a vector in-place, simply select that element as a
21084 ``sub-formula'' of the vector.
21086 @menu
21087 * Making Selections::
21088 * Changing Selections::
21089 * Displaying Selections::
21090 * Operating on Selections::
21091 * Rearranging with Selections::
21092 @end menu
21094 @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
21095 @subsection Making Selections
21097 @noindent
21098 @kindex j s
21099 @pindex calc-select-here
21100 To select a sub-formula, move the Emacs cursor to any character in that
21101 sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}).  Calc will
21102 highlight the smallest portion of the formula that contains that
21103 character.  By default the sub-formula is highlighted by blanking out
21104 all of the rest of the formula with dots.  Selection works in any
21105 display mode but is perhaps easiest in ``big'' (@kbd{d B}) mode.
21106 Suppose you enter the following formula:
21108 @smallexample
21109 @group
21110            3    ___
21111     (a + b)  + V c
21112 1:  ---------------
21113         2 x + 1
21114 @end group
21115 @end smallexample
21117 @noindent
21118 (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}).  If you move the
21119 cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
21122 @smallexample
21123 @group
21124            .    ...
21125     .. . b.  . . .
21126 1*  ...............
21127         . . . .
21128 @end group
21129 @end smallexample
21131 @noindent
21132 Every character not part of the sub-formula @samp{b} has been changed
21133 to a dot.  The @samp{*} next to the line number is to remind you that
21134 the formula has a portion of it selected.  (In this case, it's very
21135 obvious, but it might not always be.  If Embedded Mode is enabled,
21136 the word @samp{Sel} also appears in the mode line because the stack
21137 may not be visible.  @pxref{Embedded Mode}.)
21139 If you had instead placed the cursor on the parenthesis immediately to
21140 the right of the @samp{b}, the selection would have been:
21142 @smallexample
21143 @group
21144            .    ...
21145     (a + b)  . . .
21146 1*  ...............
21147         . . . .
21148 @end group
21149 @end smallexample
21151 @noindent
21152 The portion selected is always large enough to be considered a complete
21153 formula all by itself, so selecting the parenthesis selects the whole
21154 formula that it encloses.  Putting the cursor on the @samp{+} sign
21155 would have had the same effect.
21157 (Strictly speaking, the Emacs cursor is really the manifestation of
21158 the Emacs ``point,'' which is a position @emph{between} two characters
21159 in the buffer.  So purists would say that Calc selects the smallest
21160 sub-formula which contains the character to the right of ``point.'')
21162 If you supply a numeric prefix argument @var{n}, the selection is
21163 expanded to the @var{n}th enclosing sub-formula.  Thus, positioning
21164 the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
21165 @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
21166 and so on.
21168 If the cursor is not on any part of the formula, or if you give a
21169 numeric prefix that is too large, the entire formula is selected.
21171 If the cursor is on the @samp{.} line that marks the top of the stack
21172 (i.e., its normal ``rest position''), this command selects the entire
21173 formula at stack level 1.  Most selection commands similarly operate
21174 on the formula at the top of the stack if you haven't positioned the
21175 cursor on any stack entry.
21177 @kindex j a
21178 @pindex calc-select-additional
21179 The @kbd{j a} (@code{calc-select-additional}) command enlarges the
21180 current selection to encompass the cursor.  To select the smallest
21181 sub-formula defined by two different points, move to the first and
21182 press @kbd{j s}, then move to the other and press @kbd{j a}.  This
21183 is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
21184 select the two ends of a region of text during normal Emacs editing.
21186 @kindex j o
21187 @pindex calc-select-once
21188 The @kbd{j o} (@code{calc-select-once}) command selects a formula in
21189 exactly the same way as @kbd{j s}, except that the selection will
21190 last only as long as the next command that uses it.  For example,
21191 @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
21192 by the cursor.
21194 (A somewhat more precise definition: The @kbd{j o} command sets a flag
21195 such that the next command involving selected stack entries will clear
21196 the selections on those stack entries afterwards.  All other selection
21197 commands except @kbd{j a} and @kbd{j O} clear this flag.)
21199 @kindex j S
21200 @kindex j O
21201 @pindex calc-select-here-maybe
21202 @pindex calc-select-once-maybe
21203 The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
21204 (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
21205 and @kbd{j o}, respectively, except that if the formula already
21206 has a selection they have no effect.  This is analogous to the
21207 behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
21208 @pxref{Selections with Rewrite Rules}) and is mainly intended to be
21209 used in keyboard macros that implement your own selection-oriented
21210 commands.@refill
21212 Selection of sub-formulas normally treats associative terms like
21213 @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
21214 If you place the cursor anywhere inside @samp{a + b - c + d} except
21215 on one of the variable names and use @kbd{j s}, you will select the
21216 entire four-term sum.
21218 @kindex j b
21219 @pindex calc-break-selections
21220 The @kbd{j b} (@code{calc-break-selections}) command controls a mode
21221 in which the ``deep structure'' of these associative formulas shows
21222 through.  Calc actually stores the above formulas as @samp{((a + b) - c) + d}
21223 and @samp{x * (y * z)}.  (Note that for certain obscure reasons, Calc
21224 treats multiplication as right-associative.)  Once you have enabled
21225 @kbd{j b} mode, selecting with the cursor on the @samp{-} sign would
21226 only select the @samp{a + b - c} portion, which makes sense when the
21227 deep structure of the sum is considered.  There is no way to select
21228 the @samp{b - c + d} portion; although this might initially look
21229 like just as legitimate a sub-formula as @samp{a + b - c}, the deep
21230 structure shows that it isn't.  The @kbd{d U} command can be used
21231 to view the deep structure of any formula (@pxref{Normal Language Modes}).
21233 When @kbd{j b} mode has not been enabled, the deep structure is
21234 generally hidden by the selection commands---what you see is what
21235 you get.
21237 @kindex j u
21238 @pindex calc-unselect
21239 The @kbd{j u} (@code{calc-unselect}) command unselects the formula
21240 that the cursor is on.  If there was no selection in the formula,
21241 this command has no effect.  With a numeric prefix argument, it
21242 unselects the @var{n}th stack element rather than using the cursor
21243 position.
21245 @kindex j c
21246 @pindex calc-clear-selections
21247 The @kbd{j c} (@code{calc-clear-selections}) command unselects all
21248 stack elements.
21250 @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
21251 @subsection Changing Selections
21253 @noindent
21254 @kindex j m
21255 @pindex calc-select-more
21256 Once you have selected a sub-formula, you can expand it using the
21257 @w{@kbd{j m}} (@code{calc-select-more}) command.  If @samp{a + b} is
21258 selected, pressing @w{@kbd{j m}} repeatedly works as follows:
21260 @smallexample
21261 @group
21262            3    ...                3    ___                3    ___
21263     (a + b)  . . .          (a + b)  + V c          (a + b)  + V c
21264 1*  ...............     1*  ...............     1*  ---------------
21265         . . . .                 . . . .                 2 x + 1
21266 @end group
21267 @end smallexample
21269 @noindent
21270 In the last example, the entire formula is selected.  This is roughly
21271 the same as having no selection at all, but because there are subtle
21272 differences the @samp{*} character is still there on the line number.
21274 With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
21275 times (or until the entire formula is selected).  Note that @kbd{j s}
21276 with argument @var{n} is equivalent to plain @kbd{j s} followed by
21277 @kbd{j m} with argument @var{n}.  If @w{@kbd{j m}} is used when there
21278 is no current selection, it is equivalent to @w{@kbd{j s}}.
21280 Even though @kbd{j m} does not explicitly use the location of the
21281 cursor within the formula, it nevertheless uses the cursor to determine
21282 which stack element to operate on.  As usual, @kbd{j m} when the cursor
21283 is not on any stack element operates on the top stack element.
21285 @kindex j l
21286 @pindex calc-select-less
21287 The @kbd{j l} (@code{calc-select-less}) command reduces the current
21288 selection around the cursor position.  That is, it selects the
21289 immediate sub-formula of the current selection which contains the
21290 cursor, the opposite of @kbd{j m}.  If the cursor is not inside the
21291 current selection, the command de-selects the formula.
21293 @kindex j 1-9
21294 @pindex calc-select-part
21295 The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
21296 select the @var{n}th sub-formula of the current selection.  They are
21297 like @kbd{j l} (@code{calc-select-less}) except they use counting
21298 rather than the cursor position to decide which sub-formula to select.
21299 For example, if the current selection is @kbd{a + b + c} or
21300 @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
21301 @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
21302 these cases, @kbd{j 4} through @kbd{j 9} would be errors.
21304 If there is no current selection, @kbd{j 1} through @kbd{j 9} select
21305 the @var{n}th top-level sub-formula.  (In other words, they act as if
21306 the entire stack entry were selected first.)  To select the @var{n}th
21307 sub-formula where @var{n} is greater than nine, you must instead invoke
21308 @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.@refill
21310 @kindex j n
21311 @kindex j p
21312 @pindex calc-select-next
21313 @pindex calc-select-previous
21314 The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
21315 (@code{calc-select-previous}) commands change the current selection
21316 to the next or previous sub-formula at the same level.  For example,
21317 if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
21318 selects @samp{c}.  Further @kbd{j n} commands would be in error because,
21319 even though there is something to the right of @samp{c} (namely, @samp{x}),
21320 it is not at the same level; in this case, it is not a term of the
21321 same product as @samp{b} and @samp{c}.  However, @kbd{j m} (to select
21322 the whole product @samp{a*b*c} as a term of the sum) followed by
21323 @w{@kbd{j n}} would successfully select the @samp{x}.
21325 Similarly, @kbd{j p} moves the selection from the @samp{b} in this
21326 sample formula to the @samp{a}.  Both commands accept numeric prefix
21327 arguments to move several steps at a time.
21329 It is interesting to compare Calc's selection commands with the
21330 Emacs Info system's commands for navigating through hierarchically
21331 organized documentation.  Calc's @kbd{j n} command is completely
21332 analogous to Info's @kbd{n} command.  Likewise, @kbd{j p} maps to
21333 @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
21334 (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
21335 The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
21336 @kbd{j l}; in each case, you can jump directly to a sub-component
21337 of the hierarchy simply by pointing to it with the cursor.
21339 @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
21340 @subsection Displaying Selections
21342 @noindent
21343 @kindex j d
21344 @pindex calc-show-selections
21345 The @kbd{j d} (@code{calc-show-selections}) command controls how
21346 selected sub-formulas are displayed.  One of the alternatives is
21347 illustrated in the above examples; if we press @kbd{j d} we switch
21348 to the other style in which the selected portion itself is obscured
21349 by @samp{#} signs:
21351 @smallexample
21352 @group
21353            3    ...                  #    ___
21354     (a + b)  . . .            ## # ##  + V c
21355 1*  ...............       1*  ---------------
21356         . . . .                   2 x + 1
21357 @end group
21358 @end smallexample
21360 @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
21361 @subsection Operating on Selections
21363 @noindent
21364 Once a selection is made, all Calc commands that manipulate items
21365 on the stack will operate on the selected portions of the items
21366 instead.  (Note that several stack elements may have selections
21367 at once, though there can be only one selection at a time in any
21368 given stack element.)
21370 @kindex j e
21371 @pindex calc-enable-selections
21372 The @kbd{j e} (@code{calc-enable-selections}) command disables the
21373 effect that selections have on Calc commands.  The current selections
21374 still exist, but Calc commands operate on whole stack elements anyway.
21375 This mode can be identified by the fact that the @samp{*} markers on
21376 the line numbers are gone, even though selections are visible.  To
21377 reactivate the selections, press @kbd{j e} again.
21379 To extract a sub-formula as a new formula, simply select the
21380 sub-formula and press @key{RET}.  This normally duplicates the top
21381 stack element; here it duplicates only the selected portion of that
21382 element.
21384 To replace a sub-formula with something different, you can enter the
21385 new value onto the stack and press @key{TAB}.  This normally exchanges
21386 the top two stack elements; here it swaps the value you entered into
21387 the selected portion of the formula, returning the old selected
21388 portion to the top of the stack.
21390 @smallexample
21391 @group
21392            3    ...                    ...                    ___
21393     (a + b)  . . .           17 x y . . .           17 x y + V c
21394 2*  ...............      2*  .............      2:  -------------
21395         . . . .                 . . . .                2 x + 1
21397                                     3                      3
21398 1:  17 x y               1:  (a + b)            1:  (a + b)
21399 @end group
21400 @end smallexample
21402 In this example we select a sub-formula of our original example,
21403 enter a new formula, @key{TAB} it into place, then deselect to see
21404 the complete, edited formula.
21406 If you want to swap whole formulas around even though they contain
21407 selections, just use @kbd{j e} before and after.
21409 @kindex j '
21410 @pindex calc-enter-selection
21411 The @kbd{j '} (@code{calc-enter-selection}) command is another way
21412 to replace a selected sub-formula.  This command does an algebraic
21413 entry just like the regular @kbd{'} key.  When you press @key{RET},
21414 the formula you type replaces the original selection.  You can use
21415 the @samp{$} symbol in the formula to refer to the original
21416 selection.  If there is no selection in the formula under the cursor,
21417 the cursor is used to make a temporary selection for the purposes of
21418 the command.  Thus, to change a term of a formula, all you have to
21419 do is move the Emacs cursor to that term and press @kbd{j '}.
21421 @kindex j `
21422 @pindex calc-edit-selection
21423 The @kbd{j `} (@code{calc-edit-selection}) command is a similar
21424 analogue of the @kbd{`} (@code{calc-edit}) command.  It edits the
21425 selected sub-formula in a separate buffer.  If there is no
21426 selection, it edits the sub-formula indicated by the cursor.
21428 To delete a sub-formula, press @key{DEL}.  This generally replaces
21429 the sub-formula with the constant zero, but in a few suitable contexts
21430 it uses the constant one instead.  The @key{DEL} key automatically
21431 deselects and re-simplifies the entire formula afterwards.  Thus:
21433 @smallexample
21434 @group
21435               ###
21436     17 x y + # #          17 x y         17 # y          17 y
21437 1*  -------------     1:  -------    1*  -------    1:  -------
21438        2 x + 1            2 x + 1        2 x + 1        2 x + 1
21439 @end group
21440 @end smallexample
21442 In this example, we first delete the @samp{sqrt(c)} term; Calc
21443 accomplishes this by replacing @samp{sqrt(c)} with zero and
21444 resimplifying.  We then delete the @kbd{x} in the numerator;
21445 since this is part of a product, Calc replaces it with @samp{1}
21446 and resimplifies.
21448 If you select an element of a vector and press @key{DEL}, that
21449 element is deleted from the vector.  If you delete one side of
21450 an equation or inequality, only the opposite side remains.
21452 @kindex j @key{DEL}
21453 @pindex calc-del-selection
21454 The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
21455 @key{DEL} but with the auto-selecting behavior of @kbd{j '} and
21456 @kbd{j `}.  It deletes the selected portion of the formula
21457 indicated by the cursor, or, in the absence of a selection, it
21458 deletes the sub-formula indicated by the cursor position.
21460 @kindex j @key{RET}
21461 @pindex calc-grab-selection
21462 (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
21463 command.)
21465 Normal arithmetic operations also apply to sub-formulas.  Here we
21466 select the denominator, press @kbd{5 -} to subtract five from the
21467 denominator, press @kbd{n} to negate the denominator, then
21468 press @kbd{Q} to take the square root.
21470 @smallexample
21471 @group
21472      .. .           .. .           .. .             .. .
21473 1*  .......    1*  .......    1*  .......    1*  ..........
21474     2 x + 1        2 x - 4        4 - 2 x         _________
21475                                                  V 4 - 2 x
21476 @end group
21477 @end smallexample
21479 Certain types of operations on selections are not allowed.  For
21480 example, for an arithmetic function like @kbd{-} no more than one of
21481 the arguments may be a selected sub-formula.  (As the above example
21482 shows, the result of the subtraction is spliced back into the argument
21483 which had the selection; if there were more than one selection involved,
21484 this would not be well-defined.)  If you try to subtract two selections,
21485 the command will abort with an error message.
21487 Operations on sub-formulas sometimes leave the formula as a whole
21488 in an ``un-natural'' state.  Consider negating the @samp{2 x} term
21489 of our sample formula by selecting it and pressing @kbd{n}
21490 (@code{calc-change-sign}).@refill
21492 @smallexample
21493 @group
21494        .. .                .. .
21495 1*  ..........      1*  ...........
21496      .........           ..........
21497     . . . 2 x           . . . -2 x
21498 @end group
21499 @end smallexample
21501 Unselecting the sub-formula reveals that the minus sign, which would
21502 normally have cancelled out with the subtraction automatically, has
21503 not been able to do so because the subtraction was not part of the
21504 selected portion.  Pressing @kbd{=} (@code{calc-evaluate}) or doing
21505 any other mathematical operation on the whole formula will cause it
21506 to be simplified.
21508 @smallexample
21509 @group
21510        17 y                17 y
21511 1:  -----------     1:  ----------
21512      __________          _________
21513     V 4 - -2 x          V 4 + 2 x
21514 @end group
21515 @end smallexample
21517 @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
21518 @subsection Rearranging Formulas using Selections
21520 @noindent
21521 @kindex j R
21522 @pindex calc-commute-right
21523 The @kbd{j R} (@code{calc-commute-right}) command moves the selected
21524 sub-formula to the right in its surrounding formula.  Generally the
21525 selection is one term of a sum or product; the sum or product is
21526 rearranged according to the commutative laws of algebra.
21528 As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
21529 if there is no selection in the current formula.  All commands described
21530 in this section share this property.  In this example, we place the
21531 cursor on the @samp{a} and type @kbd{j R}, then repeat.
21533 @smallexample
21534 1:  a + b - c          1:  b + a - c          1:  b - c + a
21535 @end smallexample
21537 @noindent
21538 Note that in the final step above, the @samp{a} is switched with
21539 the @samp{c} but the signs are adjusted accordingly.  When moving
21540 terms of sums and products, @kbd{j R} will never change the
21541 mathematical meaning of the formula.
21543 The selected term may also be an element of a vector or an argument
21544 of a function.  The term is exchanged with the one to its right.
21545 In this case, the ``meaning'' of the vector or function may of
21546 course be drastically changed.
21548 @smallexample
21549 1:  [a, b, c]          1:  [b, a, c]          1:  [b, c, a]
21551 1:  f(a, b, c)         1:  f(b, a, c)         1:  f(b, c, a)
21552 @end smallexample
21554 @kindex j L
21555 @pindex calc-commute-left
21556 The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
21557 except that it swaps the selected term with the one to its left.
21559 With numeric prefix arguments, these commands move the selected
21560 term several steps at a time.  It is an error to try to move a
21561 term left or right past the end of its enclosing formula.
21562 With numeric prefix arguments of zero, these commands move the
21563 selected term as far as possible in the given direction.
21565 @kindex j D
21566 @pindex calc-sel-distribute
21567 The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
21568 sum or product into the surrounding formula using the distributive
21569 law.  For example, in @samp{a * (b - c)} with the @samp{b - c}
21570 selected, the result is @samp{a b - a c}.  This also distributes
21571 products or quotients into surrounding powers, and can also do
21572 transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
21573 where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
21574 to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
21576 For multiple-term sums or products, @kbd{j D} takes off one term
21577 at a time:  @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
21578 with the @samp{c - d} selected so that you can type @kbd{j D}
21579 repeatedly to expand completely.  The @kbd{j D} command allows a
21580 numeric prefix argument which specifies the maximum number of
21581 times to expand at once; the default is one time only.
21583 @vindex DistribRules
21584 The @kbd{j D} command is implemented using rewrite rules.
21585 @xref{Selections with Rewrite Rules}.  The rules are stored in
21586 the Calc variable @code{DistribRules}.  A convenient way to view
21587 these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
21588 displays and edits the stored value of a variable.  Press @kbd{M-# M-#}
21589 to return from editing mode; be careful not to make any actual changes
21590 or else you will affect the behavior of future @kbd{j D} commands!
21592 To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
21593 as described above.  You can then use the @kbd{s p} command to save
21594 this variable's value permanently for future Calc sessions.
21595 @xref{Operations on Variables}.
21597 @kindex j M
21598 @pindex calc-sel-merge
21599 @vindex MergeRules
21600 The @kbd{j M} (@code{calc-sel-merge}) command is the complement
21601 of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
21602 @samp{a c} selected, the result is @samp{a * (b - c)}.  Once
21603 again, @kbd{j M} can also merge calls to functions like @code{exp}
21604 and @code{ln}; examine the variable @code{MergeRules} to see all
21605 the relevant rules.
21607 @kindex j C
21608 @pindex calc-sel-commute
21609 @vindex CommuteRules
21610 The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
21611 of the selected sum, product, or equation.  It always behaves as
21612 if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
21613 treated as the nested sums @samp{(a + b) + c} by this command.
21614 If you put the cursor on the first @samp{+}, the result is
21615 @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
21616 result is @samp{c + (a + b)} (which the default simplifications
21617 will rearrange to @samp{(c + a) + b}).  The relevant rules are stored
21618 in the variable @code{CommuteRules}.
21620 You may need to turn default simplifications off (with the @kbd{m O}
21621 command) in order to get the full benefit of @kbd{j C}.  For example,
21622 commuting @samp{a - b} produces @samp{-b + a}, but the default
21623 simplifications will ``simplify'' this right back to @samp{a - b} if
21624 you don't turn them off.  The same is true of some of the other
21625 manipulations described in this section.
21627 @kindex j N
21628 @pindex calc-sel-negate
21629 @vindex NegateRules
21630 The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
21631 term with the negative of that term, then adjusts the surrounding
21632 formula in order to preserve the meaning.  For example, given
21633 @samp{exp(a - b)} where @samp{a - b} is selected, the result is
21634 @samp{1 / exp(b - a)}.  By contrast, selecting a term and using the
21635 regular @kbd{n} (@code{calc-change-sign}) command negates the
21636 term without adjusting the surroundings, thus changing the meaning
21637 of the formula as a whole.  The rules variable is @code{NegateRules}.
21639 @kindex j &
21640 @pindex calc-sel-invert
21641 @vindex InvertRules
21642 The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
21643 except it takes the reciprocal of the selected term.  For example,
21644 given @samp{a - ln(b)} with @samp{b} selected, the result is
21645 @samp{a + ln(1/b)}.  The rules variable is @code{InvertRules}.
21647 @kindex j E
21648 @pindex calc-sel-jump-equals
21649 @vindex JumpRules
21650 The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
21651 selected term from one side of an equation to the other.  Given
21652 @samp{a + b = c + d} with @samp{c} selected, the result is
21653 @samp{a + b - c = d}.  This command also works if the selected
21654 term is part of a @samp{*}, @samp{/}, or @samp{^} formula.  The
21655 relevant rules variable is @code{JumpRules}.
21657 @kindex j I
21658 @kindex H j I
21659 @pindex calc-sel-isolate
21660 The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
21661 selected term on its side of an equation.  It uses the @kbd{a S}
21662 (@code{calc-solve-for}) command to solve the equation, and the
21663 Hyperbolic flag affects it in the same way.  @xref{Solving Equations}.
21664 When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
21665 It understands more rules of algebra, and works for inequalities
21666 as well as equations.
21668 @kindex j *
21669 @kindex j /
21670 @pindex calc-sel-mult-both-sides
21671 @pindex calc-sel-div-both-sides
21672 The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
21673 formula using algebraic entry, then multiplies both sides of the
21674 selected quotient or equation by that formula.  It simplifies each
21675 side with @kbd{a s} (@code{calc-simplify}) before re-forming the
21676 quotient or equation.  You can suppress this simplification by
21677 providing any numeric prefix argument.  There is also a @kbd{j /}
21678 (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
21679 dividing instead of multiplying by the factor you enter.
21681 As a special feature, if the numerator of the quotient is 1, then
21682 the denominator is expanded at the top level using the distributive
21683 law (i.e., using the @kbd{C-u -1 a x} command).  Suppose the
21684 formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish
21685 to eliminate the square root in the denominator by multiplying both
21686 sides by @samp{sqrt(a) - 1}.  Calc's default simplifications would
21687 change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)}
21688 right back to the original form by cancellation; Calc expands the
21689 denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent
21690 this.  (You would now want to use an @kbd{a x} command to expand
21691 the rest of the way, whereupon the denominator would cancel out to
21692 the desired form, @samp{a - 1}.)  When the numerator is not 1, this
21693 initial expansion is not necessary because Calc's default
21694 simplifications will not notice the potential cancellation.
21696 If the selection is an inequality, @kbd{j *} and @kbd{j /} will
21697 accept any factor, but will warn unless they can prove the factor
21698 is either positive or negative.  (In the latter case the direction
21699 of the inequality will be switched appropriately.)  @xref{Declarations},
21700 for ways to inform Calc that a given variable is positive or
21701 negative.  If Calc can't tell for sure what the sign of the factor
21702 will be, it will assume it is positive and display a warning
21703 message.
21705 For selections that are not quotients, equations, or inequalities,
21706 these commands pull out a multiplicative factor:  They divide (or
21707 multiply) by the entered formula, simplify, then multiply (or divide)
21708 back by the formula.
21710 @kindex j +
21711 @kindex j -
21712 @pindex calc-sel-add-both-sides
21713 @pindex calc-sel-sub-both-sides
21714 The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
21715 (@code{calc-sel-sub-both-sides}) commands analogously add to or
21716 subtract from both sides of an equation or inequality.  For other
21717 types of selections, they extract an additive factor.  A numeric
21718 prefix argument suppresses simplification of the intermediate
21719 results.
21721 @kindex j U
21722 @pindex calc-sel-unpack
21723 The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
21724 selected function call with its argument.  For example, given
21725 @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
21726 is @samp{a + x^2}.  (The @samp{x^2} will remain selected; if you
21727 wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
21728 now to take the cosine of the selected part.)
21730 @kindex j v
21731 @pindex calc-sel-evaluate
21732 The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
21733 normal default simplifications on the selected sub-formula.
21734 These are the simplifications that are normally done automatically
21735 on all results, but which may have been partially inhibited by
21736 previous selection-related operations, or turned off altogether
21737 by the @kbd{m O} command.  This command is just an auto-selecting
21738 version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
21740 With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
21741 the @kbd{a s} (@code{calc-simplify}) command to the selected
21742 sub-formula.  With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
21743 applies the @kbd{a e} (@code{calc-simplify-extended}) command.
21744 @xref{Simplifying Formulas}.  With a negative prefix argument
21745 it simplifies at the top level only, just as with @kbd{a v}.
21746 Here the ``top'' level refers to the top level of the selected
21747 sub-formula.
21749 @kindex j "
21750 @pindex calc-sel-expand-formula
21751 The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
21752 (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
21754 You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
21755 to define other algebraic operations on sub-formulas.  @xref{Rewrite Rules}.
21757 @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
21758 @section Algebraic Manipulation
21760 @noindent
21761 The commands in this section perform general-purpose algebraic
21762 manipulations.  They work on the whole formula at the top of the
21763 stack (unless, of course, you have made a selection in that
21764 formula).
21766 Many algebra commands prompt for a variable name or formula.  If you
21767 answer the prompt with a blank line, the variable or formula is taken
21768 from top-of-stack, and the normal argument for the command is taken
21769 from the second-to-top stack level.
21771 @kindex a v
21772 @pindex calc-alg-evaluate
21773 The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
21774 default simplifications on a formula; for example, @samp{a - -b} is
21775 changed to @samp{a + b}.  These simplifications are normally done
21776 automatically on all Calc results, so this command is useful only if
21777 you have turned default simplifications off with an @kbd{m O}
21778 command.  @xref{Simplification Modes}.
21780 It is often more convenient to type @kbd{=}, which is like @kbd{a v}
21781 but which also substitutes stored values for variables in the formula.
21782 Use @kbd{a v} if you want the variables to ignore their stored values.
21784 If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
21785 as if in algebraic simplification mode.  This is equivalent to typing
21786 @kbd{a s}; @pxref{Simplifying Formulas}.  If you give a numeric prefix
21787 of 3 or more, it uses extended simplification mode (@kbd{a e}).
21789 If you give a negative prefix argument @i{-1}, @i{-2}, or @i{-3},
21790 it simplifies in the corresponding mode but only works on the top-level
21791 function call of the formula.  For example, @samp{(2 + 3) * (2 + 3)} will
21792 simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
21793 @samp{2 + 3}.  As another example, typing @kbd{V R +} to sum the vector
21794 @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
21795 in no-simplify mode.  Using @kbd{a v} will evaluate this all the way to
21796 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
21797 (@xref{Reducing and Mapping}.)
21799 @tindex evalv
21800 @tindex evalvn
21801 The @kbd{=} command corresponds to the @code{evalv} function, and
21802 the related @kbd{N} command, which is like @kbd{=} but temporarily
21803 disables symbolic (@kbd{m s}) mode during the evaluation, corresponds
21804 to the @code{evalvn} function.  (These commands interpret their prefix
21805 arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
21806 the number of stack elements to evaluate at once, and @kbd{N} treats
21807 it as a temporary different working precision.)
21809 The @code{evalvn} function can take an alternate working precision
21810 as an optional second argument.  This argument can be either an
21811 integer, to set the precision absolutely, or a vector containing
21812 a single integer, to adjust the precision relative to the current
21813 precision.  Note that @code{evalvn} with a larger than current
21814 precision will do the calculation at this higher precision, but the
21815 result will as usual be rounded back down to the current precision
21816 afterward.  For example, @samp{evalvn(pi - 3.1415)} at a precision
21817 of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
21818 will return @samp{9.26535897932e-5} (computing a 25-digit result which
21819 is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
21820 will return @samp{9.2654e-5}.
21822 @kindex a "
21823 @pindex calc-expand-formula
21824 The @kbd{a "} (@code{calc-expand-formula}) command expands functions
21825 into their defining formulas wherever possible.  For example,
21826 @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}.  Most functions,
21827 like @code{sin} and @code{gcd}, are not defined by simple formulas
21828 and so are unaffected by this command.  One important class of
21829 functions which @emph{can} be expanded is the user-defined functions
21830 created by the @kbd{Z F} command.  @xref{Algebraic Definitions}.
21831 Other functions which @kbd{a "} can expand include the probability
21832 distribution functions, most of the financial functions, and the
21833 hyperbolic and inverse hyperbolic functions.  A numeric prefix argument
21834 affects @kbd{a "} in the same way as it does @kbd{a v}:  A positive
21835 argument expands all functions in the formula and then simplifies in
21836 various ways; a negative argument expands and simplifies only the
21837 top-level function call.
21839 @kindex a M
21840 @pindex calc-map-equation
21841 @tindex mapeq
21842 The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
21843 a given function or operator to one or more equations.  It is analogous
21844 to @kbd{V M}, which operates on vectors instead of equations.
21845 @pxref{Reducing and Mapping}.  For example, @kbd{a M S} changes
21846 @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
21847 @samp{x = y+1} and @cite{6} on the stack produces @samp{x+6 = y+7}.
21848 With two equations on the stack, @kbd{a M +} would add the lefthand
21849 sides together and the righthand sides together to get the two
21850 respective sides of a new equation.
21852 Mapping also works on inequalities.  Mapping two similar inequalities
21853 produces another inequality of the same type.  Mapping an inequality
21854 with an equation produces an inequality of the same type.  Mapping a
21855 @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
21856 If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
21857 are mapped, the direction of the second inequality is reversed to
21858 match the first:  Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
21859 reverses the latter to get @samp{2 < a}, which then allows the
21860 combination @samp{a + 2 < b + a}, which the @kbd{a s} command can
21861 then simplify to get @samp{2 < b}.
21863 Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
21864 or invert an inequality will reverse the direction of the inequality.
21865 Other adjustments to inequalities are @emph{not} done automatically;
21866 @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
21867 though this is not true for all values of the variables.
21869 @kindex H a M
21870 @tindex mapeqp
21871 With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
21872 mapping operation without reversing the direction of any inequalities.
21873 Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
21874 (This change is mathematically incorrect, but perhaps you were
21875 fixing an inequality which was already incorrect.)
21877 @kindex I a M
21878 @tindex mapeqr
21879 With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
21880 the direction of the inequality.  You might use @kbd{I a M C} to
21881 change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
21882 working with small positive angles.
21884 @kindex a b
21885 @pindex calc-substitute
21886 @tindex subst
21887 The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
21888 all occurrences
21889 of some variable or sub-expression of an expression with a new
21890 sub-expression.  For example, substituting @samp{sin(x)} with @samp{cos(y)}
21891 in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
21892 @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
21893 Note that this is a purely structural substitution; the lone @samp{x} and
21894 the @samp{sin(2 x)} stayed the same because they did not look like
21895 @samp{sin(x)}.  @xref{Rewrite Rules}, for a more general method for
21896 doing substitutions.@refill
21898 The @kbd{a b} command normally prompts for two formulas, the old
21899 one and the new one.  If you enter a blank line for the first
21900 prompt, all three arguments are taken from the stack (new, then old,
21901 then target expression).  If you type an old formula but then enter a
21902 blank line for the new one, the new formula is taken from top-of-stack
21903 and the target from second-to-top.  If you answer both prompts, the
21904 target is taken from top-of-stack as usual.
21906 Note that @kbd{a b} has no understanding of commutativity or
21907 associativity.  The pattern @samp{x+y} will not match the formula
21908 @samp{y+x}.  Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
21909 because the @samp{+} operator is left-associative, so the ``deep
21910 structure'' of that formula is @samp{(x+y) + z}.  Use @kbd{d U}
21911 (@code{calc-unformatted-language}) mode to see the true structure of
21912 a formula.  The rewrite rule mechanism, discussed later, does not have
21913 these limitations.
21915 As an algebraic function, @code{subst} takes three arguments:
21916 Target expression, old, new.  Note that @code{subst} is always
21917 evaluated immediately, even if its arguments are variables, so if
21918 you wish to put a call to @code{subst} onto the stack you must
21919 turn the default simplifications off first (with @kbd{m O}).
21921 @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
21922 @section Simplifying Formulas
21924 @noindent
21925 @kindex a s
21926 @pindex calc-simplify
21927 @tindex simplify
21928 The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies
21929 various algebraic rules to simplify a formula.  This includes rules which
21930 are not part of the default simplifications because they may be too slow
21931 to apply all the time, or may not be desirable all of the time.  For
21932 example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a}
21933 to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are
21934 simplified to @samp{x}.
21936 The sections below describe all the various kinds of algebraic
21937 simplifications Calc provides in full detail.  None of Calc's
21938 simplification commands are designed to pull rabbits out of hats;
21939 they simply apply certain specific rules to put formulas into
21940 less redundant or more pleasing forms.  Serious algebra in Calc
21941 must be done manually, usually with a combination of selections
21942 and rewrite rules.  @xref{Rearranging with Selections}.
21943 @xref{Rewrite Rules}.
21945 @xref{Simplification Modes}, for commands to control what level of
21946 simplification occurs automatically.  Normally only the ``default
21947 simplifications'' occur.
21949 @menu
21950 * Default Simplifications::
21951 * Algebraic Simplifications::
21952 * Unsafe Simplifications::
21953 * Simplification of Units::
21954 @end menu
21956 @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
21957 @subsection Default Simplifications
21959 @noindent
21960 @cindex Default simplifications
21961 This section describes the ``default simplifications,'' those which are
21962 normally applied to all results.  For example, if you enter the variable
21963 @cite{x} on the stack twice and push @kbd{+}, Calc's default
21964 simplifications automatically change @cite{x + x} to @cite{2 x}.
21966 The @kbd{m O} command turns off the default simplifications, so that
21967 @cite{x + x} will remain in this form unless you give an explicit
21968 ``simplify'' command like @kbd{=} or @kbd{a v}.  @xref{Algebraic
21969 Manipulation}.  The @kbd{m D} command turns the default simplifications
21970 back on.
21972 The most basic default simplification is the evaluation of functions.
21973 For example, @cite{2 + 3} is evaluated to @cite{5}, and @cite{@t{sqrt}(9)}
21974 is evaluated to @cite{3}.  Evaluation does not occur if the arguments
21975 to a function are somehow of the wrong type (@cite{@t{tan}([2,3,4])},
21976 range (@cite{@t{tan}(90)}), or number (@cite{@t{tan}(3,5)}), or if the
21977 function name is not recognized (@cite{@t{f}(5)}), or if ``symbolic''
21978 mode (@pxref{Symbolic Mode}) prevents evaluation (@cite{@t{sqrt}(2)}).
21980 Calc simplifies (evaluates) the arguments to a function before it
21981 simplifies the function itself.  Thus @cite{@t{sqrt}(5+4)} is
21982 simplified to @cite{@t{sqrt}(9)} before the @code{sqrt} function
21983 itself is applied.  There are very few exceptions to this rule:
21984 @code{quote}, @code{lambda}, and @code{condition} (the @code{::}
21985 operator) do not evaluate their arguments, @code{if} (the @code{? :}
21986 operator) does not evaluate all of its arguments, and @code{evalto}
21987 does not evaluate its lefthand argument.
21989 Most commands apply the default simplifications to all arguments they
21990 take from the stack, perform a particular operation, then simplify
21991 the result before pushing it back on the stack.  In the common special
21992 case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}],
21993 the arguments are simply popped from the stack and collected into a
21994 suitable function call, which is then simplified (the arguments being
21995 simplified first as part of the process, as described above).
21997 The default simplifications are too numerous to describe completely
21998 here, but this section will describe the ones that apply to the
21999 major arithmetic operators.  This list will be rather technical in
22000 nature, and will probably be interesting to you only if you are
22001 a serious user of Calc's algebra facilities.
22003 @tex
22004 \bigskip
22005 @end tex
22007 As well as the simplifications described here, if you have stored
22008 any rewrite rules in the variable @code{EvalRules} then these rules
22009 will also be applied before any built-in default simplifications.
22010 @xref{Automatic Rewrites}, for details.
22012 @tex
22013 \bigskip
22014 @end tex
22016 And now, on with the default simplifications:
22018 Arithmetic operators like @kbd{+} and @kbd{*} always take two
22019 arguments in Calc's internal form.  Sums and products of three or
22020 more terms are arranged by the associative law of algebra into
22021 a left-associative form for sums, @cite{((a + b) + c) + d}, and
22022 a right-associative form for products, @cite{a * (b * (c * d))}.
22023 Formulas like @cite{(a + b) + (c + d)} are rearranged to
22024 left-associative form, though this rarely matters since Calc's
22025 algebra commands are designed to hide the inner structure of
22026 sums and products as much as possible.  Sums and products in
22027 their proper associative form will be written without parentheses
22028 in the examples below.
22030 Sums and products are @emph{not} rearranged according to the
22031 commutative law (@cite{a + b} to @cite{b + a}) except in a few
22032 special cases described below.  Some algebra programs always
22033 rearrange terms into a canonical order, which enables them to
22034 see that @cite{a b + b a} can be simplified to @cite{2 a b}.
22035 Calc assumes you have put the terms into the order you want
22036 and generally leaves that order alone, with the consequence
22037 that formulas like the above will only be simplified if you
22038 explicitly give the @kbd{a s} command.  @xref{Algebraic
22039 Simplifications}.
22041 Differences @cite{a - b} are treated like sums @cite{a + (-b)}
22042 for purposes of simplification; one of the default simplifications
22043 is to rewrite @cite{a + (-b)} or @cite{(-b) + a}, where @cite{-b}
22044 represents a ``negative-looking'' term, into @cite{a - b} form.
22045 ``Negative-looking'' means negative numbers, negated formulas like
22046 @cite{-x}, and products or quotients in which either term is
22047 negative-looking.
22049 Other simplifications involving negation are @cite{-(-x)} to @cite{x};
22050 @cite{-(a b)} or @cite{-(a/b)} where either @cite{a} or @cite{b} is
22051 negative-looking, simplified by negating that term, or else where
22052 @cite{a} or @cite{b} is any number, by negating that number;
22053 @cite{-(a + b)} to @cite{-a - b}, and @cite{-(b - a)} to @cite{a - b}.
22054 (This, and rewriting @cite{(-b) + a} to @cite{a - b}, are the only
22055 cases where the order of terms in a sum is changed by the default
22056 simplifications.)
22058 The distributive law is used to simplify sums in some cases:
22059 @cite{a x + b x} to @cite{(a + b) x}, where @cite{a} represents
22060 a number or an implicit 1 or @i{-1} (as in @cite{x} or @cite{-x})
22061 and similarly for @cite{b}.  Use the @kbd{a c}, @w{@kbd{a f}}, or
22062 @kbd{j M} commands to merge sums with non-numeric coefficients
22063 using the distributive law.
22065 The distributive law is only used for sums of two terms, or
22066 for adjacent terms in a larger sum.  Thus @cite{a + b + b + c}
22067 is simplified to @cite{a + 2 b + c}, but @cite{a + b + c + b}
22068 is not simplified.  The reason is that comparing all terms of a
22069 sum with one another would require time proportional to the
22070 square of the number of terms; Calc relegates potentially slow
22071 operations like this to commands that have to be invoked
22072 explicitly, like @kbd{a s}.
22074 Finally, @cite{a + 0} and @cite{0 + a} are simplified to @cite{a}.
22075 A consequence of the above rules is that @cite{0 - a} is simplified
22076 to @cite{-a}.
22078 @tex
22079 \bigskip
22080 @end tex
22082 The products @cite{1 a} and @cite{a 1} are simplified to @cite{a};
22083 @cite{(-1) a} and @cite{a (-1)} are simplified to @cite{-a};
22084 @cite{0 a} and @cite{a 0} are simplified to @cite{0}, except that
22085 in matrix mode where @cite{a} is not provably scalar the result
22086 is the generic zero matrix @samp{idn(0)}, and that if @cite{a} is
22087 infinite the result is @samp{nan}.
22089 Also, @cite{(-a) b} and @cite{a (-b)} are simplified to @cite{-(a b)},
22090 where this occurs for negated formulas but not for regular negative
22091 numbers.
22093 Products are commuted only to move numbers to the front:
22094 @cite{a b 2} is commuted to @cite{2 a b}.
22096 The product @cite{a (b + c)} is distributed over the sum only if
22097 @cite{a} and at least one of @cite{b} and @cite{c} are numbers:
22098 @cite{2 (x + 3)} goes to @cite{2 x + 6}.  The formula
22099 @cite{(-a) (b - c)}, where @cite{-a} is a negative number, is
22100 rewritten to @cite{a (c - b)}.
22102 The distributive law of products and powers is used for adjacent
22103 terms of the product: @cite{x^a x^b} goes to @c{$x^{a+b}$}
22104 @cite{x^(a+b)}
22105 where @cite{a} is a number, or an implicit 1 (as in @cite{x}),
22106 or the implicit one-half of @cite{@t{sqrt}(x)}, and similarly for
22107 @cite{b}.  The result is written using @samp{sqrt} or @samp{1/sqrt}
22108 if the sum of the powers is @cite{1/2} or @cite{-1/2}, respectively.
22109 If the sum of the powers is zero, the product is simplified to
22110 @cite{1} or to @samp{idn(1)} if matrix mode is enabled.
22112 The product of a negative power times anything but another negative
22113 power is changed to use division:  @c{$x^{-2} y$}
22114 @cite{x^(-2) y} goes to @cite{y / x^2} unless matrix mode is
22115 in effect and neither @cite{x} nor @cite{y} are scalar (in which
22116 case it is considered unsafe to rearrange the order of the terms).
22118 Finally, @cite{a (b/c)} is rewritten to @cite{(a b)/c}, and also
22119 @cite{(a/b) c} is changed to @cite{(a c)/b} unless in matrix mode.
22121 @tex
22122 \bigskip
22123 @end tex
22125 Simplifications for quotients are analogous to those for products.
22126 The quotient @cite{0 / x} is simplified to @cite{0}, with the same
22127 exceptions that were noted for @cite{0 x}.  Likewise, @cite{x / 1}
22128 and @cite{x / (-1)} are simplified to @cite{x} and @cite{-x},
22129 respectively.
22131 The quotient @cite{x / 0} is left unsimplified or changed to an
22132 infinite quantity, as directed by the current infinite mode.
22133 @xref{Infinite Mode}.
22135 The expression @c{$a / b^{-c}$}
22136 @cite{a / b^(-c)} is changed to @cite{a b^c},
22137 where @cite{-c} is any negative-looking power.  Also, @cite{1 / b^c}
22138 is changed to @c{$b^{-c}$}
22139 @cite{b^(-c)} for any power @cite{c}.
22141 Also, @cite{(-a) / b} and @cite{a / (-b)} go to @cite{-(a/b)};
22142 @cite{(a/b) / c} goes to @cite{a / (b c)}; and @cite{a / (b/c)}
22143 goes to @cite{(a c) / b} unless matrix mode prevents this
22144 rearrangement.  Similarly, @cite{a / (b:c)} is simplified to
22145 @cite{(c:b) a} for any fraction @cite{b:c}.
22147 The distributive law is applied to @cite{(a + b) / c} only if
22148 @cite{c} and at least one of @cite{a} and @cite{b} are numbers.
22149 Quotients of powers and square roots are distributed just as
22150 described for multiplication.
22152 Quotients of products cancel only in the leading terms of the
22153 numerator and denominator.  In other words, @cite{a x b / a y b}
22154 is cancelled to @cite{x b / y b} but not to @cite{x / y}.  Once
22155 again this is because full cancellation can be slow; use @kbd{a s}
22156 to cancel all terms of the quotient.
22158 Quotients of negative-looking values are simplified according
22159 to @cite{(-a) / (-b)} to @cite{a / b}, @cite{(-a) / (b - c)}
22160 to @cite{a / (c - b)}, and @cite{(a - b) / (-c)} to @cite{(b - a) / c}.
22162 @tex
22163 \bigskip
22164 @end tex
22166 The formula @cite{x^0} is simplified to @cite{1}, or to @samp{idn(1)}
22167 in matrix mode.  The formula @cite{0^x} is simplified to @cite{0}
22168 unless @cite{x} is a negative number or complex number, in which
22169 case the result is an infinity or an unsimplified formula according
22170 to the current infinite mode.  Note that @cite{0^0} is an
22171 indeterminate form, as evidenced by the fact that the simplifications
22172 for @cite{x^0} and @cite{0^x} conflict when @cite{x=0}.
22174 Powers of products or quotients @cite{(a b)^c}, @cite{(a/b)^c}
22175 are distributed to @cite{a^c b^c}, @cite{a^c / b^c} only if @cite{c}
22176 is an integer, or if either @cite{a} or @cite{b} are nonnegative
22177 real numbers.  Powers of powers @cite{(a^b)^c} are simplified to
22178 @c{$a^{b c}$}
22179 @cite{a^(b c)} only when @cite{c} is an integer and @cite{b c} also
22180 evaluates to an integer.  Without these restrictions these simplifications
22181 would not be safe because of problems with principal values.
22182 (In other words, @c{$((-3)^{1/2})^2$}
22183 @cite{((-3)^1:2)^2} is safe to simplify, but
22184 @c{$((-3)^2)^{1/2}$}
22185 @cite{((-3)^2)^1:2} is not.)  @xref{Declarations}, for ways to inform
22186 Calc that your variables satisfy these requirements.
22188 As a special case of this rule, @cite{@t{sqrt}(x)^n} is simplified to
22189 @c{$x^{n/2}$}
22190 @cite{x^(n/2)} only for even integers @cite{n}.
22192 If @cite{a} is known to be real, @cite{b} is an even integer, and
22193 @cite{c} is a half- or quarter-integer, then @cite{(a^b)^c} is
22194 simplified to @c{$@t{abs}(a^{b c})$}
22195 @cite{@t{abs}(a^(b c))}.
22197 Also, @cite{(-a)^b} is simplified to @cite{a^b} if @cite{b} is an
22198 even integer, or to @cite{-(a^b)} if @cite{b} is an odd integer,
22199 for any negative-looking expression @cite{-a}.
22201 Square roots @cite{@t{sqrt}(x)} generally act like one-half powers
22202 @c{$x^{1:2}$}
22203 @cite{x^1:2} for the purposes of the above-listed simplifications.
22205 Also, note that @c{$1 / x^{1:2}$}
22206 @cite{1 / x^1:2} is changed to @c{$x^{-1:2}$}
22207 @cite{x^(-1:2)},
22208 but @cite{1 / @t{sqrt}(x)} is left alone.
22210 @tex
22211 \bigskip
22212 @end tex
22214 Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
22215 following rules:  @cite{@t{idn}(a) + b} to @cite{a + b} if @cite{b}
22216 is provably scalar, or expanded out if @cite{b} is a matrix;
22217 @cite{@t{idn}(a) + @t{idn}(b)} to @cite{@t{idn}(a + b)};
22218 @cite{-@t{idn}(a)} to @cite{@t{idn}(-a)}; @cite{a @t{idn}(b)} to
22219 @cite{@t{idn}(a b)} if @cite{a} is provably scalar, or to @cite{a b}
22220 if @cite{a} is provably non-scalar; @cite{@t{idn}(a) @t{idn}(b)}
22221 to @cite{@t{idn}(a b)}; analogous simplifications for quotients
22222 involving @code{idn}; and @cite{@t{idn}(a)^n} to @cite{@t{idn}(a^n)}
22223 where @cite{n} is an integer.
22225 @tex
22226 \bigskip
22227 @end tex
22229 The @code{floor} function and other integer truncation functions
22230 vanish if the argument is provably integer-valued, so that
22231 @cite{@t{floor}(@t{round}(x))} simplifies to @cite{@t{round}(x)}.
22232 Also, combinations of @code{float}, @code{floor} and its friends,
22233 and @code{ffloor} and its friends, are simplified in appropriate
22234 ways.  @xref{Integer Truncation}.
22236 The expression @cite{@t{abs}(-x)} changes to @cite{@t{abs}(x)}.
22237 The expression @cite{@t{abs}(@t{abs}(x))} changes to @cite{@t{abs}(x)};
22238 in fact, @cite{@t{abs}(x)} changes to @cite{x} or @cite{-x} if @cite{x}
22239 is provably nonnegative or nonpositive (@pxref{Declarations}).
22241 While most functions do not recognize the variable @code{i} as an
22242 imaginary number, the @code{arg} function does handle the two cases
22243 @cite{@t{arg}(@t{i})} and @cite{@t{arg}(-@t{i})} just for convenience.
22245 The expression @cite{@t{conj}(@t{conj}(x))} simplifies to @cite{x}.
22246 Various other expressions involving @code{conj}, @code{re}, and
22247 @code{im} are simplified, especially if some of the arguments are
22248 provably real or involve the constant @code{i}.  For example,
22249 @cite{@t{conj}(a + b i)} is changed to @cite{@t{conj}(a) - @t{conj}(b) i},
22250 or to @cite{a - b i} if @cite{a} and @cite{b} are known to be real.
22252 Functions like @code{sin} and @code{arctan} generally don't have
22253 any default simplifications beyond simply evaluating the functions
22254 for suitable numeric arguments and infinity.  The @kbd{a s} command
22255 described in the next section does provide some simplifications for
22256 these functions, though.
22258 One important simplification that does occur is that @cite{@t{ln}(@t{e})}
22259 is simplified to 1, and @cite{@t{ln}(@t{e}^x)} is simplified to @cite{x}
22260 for any @cite{x}.  This occurs even if you have stored a different
22261 value in the Calc variable @samp{e}; but this would be a bad idea
22262 in any case if you were also using natural logarithms!
22264 Among the logical functions, @t{(@var{a} <= @var{b})} changes to
22265 @t{@var{a} > @var{b}} and so on.  Equations and inequalities where both sides
22266 are either negative-looking or zero are simplified by negating both sides
22267 and reversing the inequality.  While it might seem reasonable to simplify
22268 @cite{!!x} to @cite{x}, this would not be valid in general because
22269 @cite{!!2} is 1, not 2.
22271 Most other Calc functions have few if any default simplifications
22272 defined, aside of course from evaluation when the arguments are
22273 suitable numbers.
22275 @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas
22276 @subsection Algebraic Simplifications
22278 @noindent
22279 @cindex Algebraic simplifications
22280 The @kbd{a s} command makes simplifications that may be too slow to
22281 do all the time, or that may not be desirable all of the time.
22282 If you find these simplifications are worthwhile, you can type
22283 @kbd{m A} to have Calc apply them automatically.
22285 This section describes all simplifications that are performed by
22286 the @kbd{a s} command.  Note that these occur in addition to the
22287 default simplifications; even if the default simplifications have
22288 been turned off by an @kbd{m O} command, @kbd{a s} will turn them
22289 back on temporarily while it simplifies the formula.
22291 There is a variable, @code{AlgSimpRules}, in which you can put rewrites
22292 to be applied by @kbd{a s}.  Its use is analogous to @code{EvalRules},
22293 but without the special restrictions.  Basically, the simplifier does
22294 @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
22295 expression being simplified, then it traverses the expression applying
22296 the built-in rules described below.  If the result is different from
22297 the original expression, the process repeats with the default
22298 simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
22299 then the built-in simplifications, and so on.
22301 @tex
22302 \bigskip
22303 @end tex
22305 Sums are simplified in two ways.  Constant terms are commuted to the
22306 end of the sum, so that @cite{a + 2 + b} changes to @cite{a + b + 2}.
22307 The only exception is that a constant will not be commuted away
22308 from the first position of a difference, i.e., @cite{2 - x} is not
22309 commuted to @cite{-x + 2}.
22311 Also, terms of sums are combined by the distributive law, as in
22312 @cite{x + y + 2 x} to @cite{y + 3 x}.  This always occurs for
22313 adjacent terms, but @kbd{a s} compares all pairs of terms including
22314 non-adjacent ones.
22316 @tex
22317 \bigskip
22318 @end tex
22320 Products are sorted into a canonical order using the commutative
22321 law.  For example, @cite{b c a} is commuted to @cite{a b c}.
22322 This allows easier comparison of products; for example, the default
22323 simplifications will not change @cite{x y + y x} to @cite{2 x y},
22324 but @kbd{a s} will; it first rewrites the sum to @cite{x y + x y},
22325 and then the default simplifications are able to recognize a sum
22326 of identical terms.
22328 The canonical ordering used to sort terms of products has the
22329 property that real-valued numbers, interval forms and infinities
22330 come first, and are sorted into increasing order.  The @kbd{V S}
22331 command uses the same ordering when sorting a vector.
22333 Sorting of terms of products is inhibited when matrix mode is
22334 turned on; in this case, Calc will never exchange the order of
22335 two terms unless it knows at least one of the terms is a scalar.
22337 Products of powers are distributed by comparing all pairs of
22338 terms, using the same method that the default simplifications
22339 use for adjacent terms of products.
22341 Even though sums are not sorted, the commutative law is still
22342 taken into account when terms of a product are being compared.
22343 Thus @cite{(x + y) (y + x)} will be simplified to @cite{(x + y)^2}.
22344 A subtle point is that @cite{(x - y) (y - x)} will @emph{not}
22345 be simplified to @cite{-(x - y)^2}; Calc does not notice that
22346 one term can be written as a constant times the other, even if
22347 that constant is @i{-1}.
22349 A fraction times any expression, @cite{(a:b) x}, is changed to
22350 a quotient involving integers:  @cite{a x / b}.  This is not
22351 done for floating-point numbers like @cite{0.5}, however.  This
22352 is one reason why you may find it convenient to turn Fraction mode
22353 on while doing algebra; @pxref{Fraction Mode}.
22355 @tex
22356 \bigskip
22357 @end tex
22359 Quotients are simplified by comparing all terms in the numerator
22360 with all terms in the denominator for possible cancellation using
22361 the distributive law.  For example, @cite{a x^2 b / c x^3 d} will
22362 cancel @cite{x^2} from both sides to get @cite{a b / c x d}.
22363 (The terms in the denominator will then be rearranged to @cite{c d x}
22364 as described above.)  If there is any common integer or fractional
22365 factor in the numerator and denominator, it is cancelled out;
22366 for example, @cite{(4 x + 6) / 8 x} simplifies to @cite{(2 x + 3) / 4 x}.
22368 Non-constant common factors are not found even by @kbd{a s}.  To
22369 cancel the factor @cite{a} in @cite{(a x + a) / a^2} you could first
22370 use @kbd{j M} on the product @cite{a x} to Merge the numerator to
22371 @cite{a (1+x)}, which can then be simplified successfully.
22373 @tex
22374 \bigskip
22375 @end tex
22377 Integer powers of the variable @code{i} are simplified according
22378 to the identity @cite{i^2 = -1}.  If you store a new value other
22379 than the complex number @cite{(0,1)} in @code{i}, this simplification
22380 will no longer occur.  This is done by @kbd{a s} instead of by default
22381 in case someone (unwisely) uses the name @code{i} for a variable
22382 unrelated to complex numbers; it would be unfortunate if Calc
22383 quietly and automatically changed this formula for reasons the
22384 user might not have been thinking of.
22386 Square roots of integer or rational arguments are simplified in
22387 several ways.  (Note that these will be left unevaluated only in
22388 Symbolic mode.)  First, square integer or rational factors are
22389 pulled out so that @cite{@t{sqrt}(8)} is rewritten as
22390 @c{$2\,\t{sqrt}(2)$}
22391 @cite{2 sqrt(2)}.  Conceptually speaking this implies factoring
22392 the argument into primes and moving pairs of primes out of the
22393 square root, but for reasons of efficiency Calc only looks for
22394 primes up to 29.
22396 Square roots in the denominator of a quotient are moved to the
22397 numerator:  @cite{1 / @t{sqrt}(3)} changes to @cite{@t{sqrt}(3) / 3}.
22398 The same effect occurs for the square root of a fraction:
22399 @cite{@t{sqrt}(2:3)} changes to @cite{@t{sqrt}(6) / 3}.
22401 @tex
22402 \bigskip
22403 @end tex
22405 The @code{%} (modulo) operator is simplified in several ways
22406 when the modulus @cite{M} is a positive real number.  First, if
22407 the argument is of the form @cite{x + n} for some real number
22408 @cite{n}, then @cite{n} is itself reduced modulo @cite{M}.  For
22409 example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
22411 If the argument is multiplied by a constant, and this constant
22412 has a common integer divisor with the modulus, then this factor is
22413 cancelled out.  For example, @samp{12 x % 15} is changed to
22414 @samp{3 (4 x % 5)} by factoring out 3.  Also, @samp{(12 x + 1) % 15}
22415 is changed to @samp{3 ((4 x + 1:3) % 5)}.  While these forms may
22416 not seem ``simpler,'' they allow Calc to discover useful information
22417 about modulo forms in the presence of declarations.
22419 If the modulus is 1, then Calc can use @code{int} declarations to
22420 evaluate the expression.  For example, the idiom @samp{x % 2} is
22421 often used to check whether a number is odd or even.  As described
22422 above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
22423 @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
22424 can simplify these to 0 and 1 (respectively) if @code{n} has been
22425 declared to be an integer.
22427 @tex
22428 \bigskip
22429 @end tex
22431 Trigonometric functions are simplified in several ways.  First,
22432 @cite{@t{sin}(@t{arcsin}(x))} is simplified to @cite{x}, and
22433 similarly for @code{cos} and @code{tan}.  If the argument to
22434 @code{sin} is negative-looking, it is simplified to @cite{-@t{sin}(x)},
22435 and similarly for @code{cos} and @code{tan}.  Finally, certain
22436 special values of the argument are recognized;
22437 @pxref{Trigonometric and Hyperbolic Functions}.
22439 Trigonometric functions of inverses of different trigonometric
22440 functions can also be simplified, as in @cite{@t{sin}(@t{arccos}(x))}
22441 to @cite{@t{sqrt}(1 - x^2)}.
22443 Hyperbolic functions of their inverses and of negative-looking
22444 arguments are also handled, as are exponentials of inverse
22445 hyperbolic functions.
22447 No simplifications for inverse trigonometric and hyperbolic
22448 functions are known, except for negative arguments of @code{arcsin},
22449 @code{arctan}, @code{arcsinh}, and @code{arctanh}.  Note that
22450 @cite{@t{arcsin}(@t{sin}(x))} can @emph{not} safely change to
22451 @cite{x}, since this only correct within an integer multiple
22452 of @c{$2 \pi$}
22453 @cite{2 pi} radians or 360 degrees.  However,
22454 @cite{@t{arcsinh}(@t{sinh}(x))} is simplified to @cite{x} if
22455 @cite{x} is known to be real.
22457 Several simplifications that apply to logarithms and exponentials
22458 are that @cite{@t{exp}(@t{ln}(x))}, @c{$@t{e}^{\ln(x)}$}
22459 @cite{e^@t{ln}(x)}, and
22460 @c{$10^{{\rm log10}(x)}$}
22461 @cite{10^@t{log10}(x)} all reduce to @cite{x}.
22462 Also, @cite{@t{ln}(@t{exp}(x))}, etc., can reduce to @cite{x} if
22463 @cite{x} is provably real.  The form @cite{@t{exp}(x)^y} is simplified
22464 to @cite{@t{exp}(x y)}.  If @cite{x} is a suitable multiple of @c{$\pi i$}
22465 @cite{pi i}
22466 (as described above for the trigonometric functions), then @cite{@t{exp}(x)}
22467 or @cite{e^x} will be expanded.  Finally, @cite{@t{ln}(x)} is simplified
22468 to a form involving @code{pi} and @code{i} where @cite{x} is provably
22469 negative, positive imaginary, or negative imaginary.
22471 The error functions @code{erf} and @code{erfc} are simplified when
22472 their arguments are negative-looking or are calls to the @code{conj}
22473 function.
22475 @tex
22476 \bigskip
22477 @end tex
22479 Equations and inequalities are simplified by cancelling factors
22480 of products, quotients, or sums on both sides.  Inequalities
22481 change sign if a negative multiplicative factor is cancelled.
22482 Non-constant multiplicative factors as in @cite{a b = a c} are
22483 cancelled from equations only if they are provably nonzero (generally
22484 because they were declared so; @pxref{Declarations}).  Factors
22485 are cancelled from inequalities only if they are nonzero and their
22486 sign is known.
22488 Simplification also replaces an equation or inequality with
22489 1 or 0 (``true'' or ``false'') if it can through the use of
22490 declarations.  If @cite{x} is declared to be an integer greater
22491 than 5, then @cite{x < 3}, @cite{x = 3}, and @cite{x = 7.5} are
22492 all simplified to 0, but @cite{x > 3} is simplified to 1.
22493 By a similar analysis, @cite{abs(x) >= 0} is simplified to 1,
22494 as is @cite{x^2 >= 0} if @cite{x} is known to be real.
22496 @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
22497 @subsection ``Unsafe'' Simplifications
22499 @noindent
22500 @cindex Unsafe simplifications
22501 @cindex Extended simplification
22502 @kindex a e
22503 @pindex calc-simplify-extended
22504 @ignore
22505 @mindex esimpl@idots
22506 @end ignore
22507 @tindex esimplify
22508 The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command
22509 is like @kbd{a s}
22510 except that it applies some additional simplifications which are not
22511 ``safe'' in all cases.  Use this only if you know the values in your
22512 formula lie in the restricted ranges for which these simplifications
22513 are valid.  The symbolic integrator uses @kbd{a e};
22514 one effect of this is that the integrator's results must be used with
22515 caution.  Where an integral table will often attach conditions like
22516 ``for positive @cite{a} only,'' Calc (like most other symbolic
22517 integration programs) will simply produce an unqualified result.@refill
22519 Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
22520 to type @kbd{C-u -3 a v}, which does extended simplification only
22521 on the top level of the formula without affecting the sub-formulas.
22522 In fact, @kbd{C-u -3 j v} allows you to target extended simplification
22523 to any specific part of a formula.
22525 The variable @code{ExtSimpRules} contains rewrites to be applied by
22526 the @kbd{a e} command.  These are applied in addition to
22527 @code{EvalRules} and @code{AlgSimpRules}.  (The @kbd{a r AlgSimpRules}
22528 step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
22530 Following is a complete list of ``unsafe'' simplifications performed
22531 by @kbd{a e}.
22533 @tex
22534 \bigskip
22535 @end tex
22537 Inverse trigonometric or hyperbolic functions, called with their
22538 corresponding non-inverse functions as arguments, are simplified
22539 by @kbd{a e}.  For example, @cite{@t{arcsin}(@t{sin}(x))} changes
22540 to @cite{x}.  Also, @cite{@t{arcsin}(@t{cos}(x))} and
22541 @cite{@t{arccos}(@t{sin}(x))} both change to @cite{@t{pi}/2 - x}.
22542 These simplifications are unsafe because they are valid only for
22543 values of @cite{x} in a certain range; outside that range, values
22544 are folded down to the 360-degree range that the inverse trigonometric
22545 functions always produce.
22547 Powers of powers @cite{(x^a)^b} are simplified to @c{$x^{a b}$}
22548 @cite{x^(a b)}
22549 for all @cite{a} and @cite{b}.  These results will be valid only
22550 in a restricted range of @cite{x}; for example, in @c{$(x^2)^{1:2}$}
22551 @cite{(x^2)^1:2}
22552 the powers cancel to get @cite{x}, which is valid for positive values
22553 of @cite{x} but not for negative or complex values.
22555 Similarly, @cite{@t{sqrt}(x^a)} and @cite{@t{sqrt}(x)^a} are both
22556 simplified (possibly unsafely) to @c{$x^{a/2}$}
22557 @cite{x^(a/2)}.
22559 Forms like @cite{@t{sqrt}(1 - @t{sin}(x)^2)} are simplified to, e.g.,
22560 @cite{@t{cos}(x)}.  Calc has identities of this sort for @code{sin},
22561 @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
22563 Arguments of square roots are partially factored to look for
22564 squared terms that can be extracted.  For example,
22565 @cite{@t{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to @cite{a b @t{sqrt}(a+b)}.
22567 The simplifications of @cite{@t{ln}(@t{exp}(x))}, @cite{@t{ln}(@t{e}^x)},
22568 and @cite{@t{log10}(10^x)} to @cite{x} are also unsafe because
22569 of problems with principal values (although these simplifications
22570 are safe if @cite{x} is known to be real).
22572 Common factors are cancelled from products on both sides of an
22573 equation, even if those factors may be zero:  @cite{a x / b x}
22574 to @cite{a / b}.  Such factors are never cancelled from
22575 inequalities:  Even @kbd{a e} is not bold enough to reduce
22576 @cite{a x < b x} to @cite{a < b} (or @cite{a > b}, depending
22577 on whether you believe @cite{x} is positive or negative).
22578 The @kbd{a M /} command can be used to divide a factor out of
22579 both sides of an inequality.
22581 @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
22582 @subsection Simplification of Units
22584 @noindent
22585 The simplifications described in this section are applied by the
22586 @kbd{u s} (@code{calc-simplify-units}) command.  These are in addition
22587 to the regular @kbd{a s} (but not @kbd{a e}) simplifications described
22588 earlier.  @xref{Basic Operations on Units}.
22590 The variable @code{UnitSimpRules} contains rewrites to be applied by
22591 the @kbd{u s} command.  These are applied in addition to @code{EvalRules}
22592 and @code{AlgSimpRules}.
22594 Scalar mode is automatically put into effect when simplifying units.
22595 @xref{Matrix Mode}.
22597 Sums @cite{a + b} involving units are simplified by extracting the
22598 units of @cite{a} as if by the @kbd{u x} command (call the result
22599 @cite{u_a}), then simplifying the expression @cite{b / u_a}
22600 using @kbd{u b} and @kbd{u s}.  If the result has units then the sum
22601 is inconsistent and is left alone.  Otherwise, it is rewritten
22602 in terms of the units @cite{u_a}.
22604 If units auto-ranging mode is enabled, products or quotients in
22605 which the first argument is a number which is out of range for the
22606 leading unit are modified accordingly.
22608 When cancelling and combining units in products and quotients,
22609 Calc accounts for unit names that differ only in the prefix letter.
22610 For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
22611 However, compatible but different units like @code{ft} and @code{in}
22612 are not combined in this way.
22614 Quotients @cite{a / b} are simplified in three additional ways.  First,
22615 if @cite{b} is a number or a product beginning with a number, Calc
22616 computes the reciprocal of this number and moves it to the numerator.
22618 Second, for each pair of unit names from the numerator and denominator
22619 of a quotient, if the units are compatible (e.g., they are both
22620 units of area) then they are replaced by the ratio between those
22621 units.  For example, in @samp{3 s in N / kg cm} the units
22622 @samp{in / cm} will be replaced by @cite{2.54}.
22624 Third, if the units in the quotient exactly cancel out, so that
22625 a @kbd{u b} command on the quotient would produce a dimensionless
22626 number for an answer, then the quotient simplifies to that number.
22628 For powers and square roots, the ``unsafe'' simplifications
22629 @cite{(a b)^c} to @cite{a^c b^c}, @cite{(a/b)^c} to @cite{a^c / b^c},
22630 and @cite{(a^b)^c} to @c{$a^{b c}$}
22631 @cite{a^(b c)} are done if the powers are
22632 real numbers.  (These are safe in the context of units because
22633 all numbers involved can reasonably be assumed to be real.)
22635 Also, if a unit name is raised to a fractional power, and the
22636 base units in that unit name all occur to powers which are a
22637 multiple of the denominator of the power, then the unit name
22638 is expanded out into its base units, which can then be simplified
22639 according to the previous paragraph.  For example, @samp{acre^1.5}
22640 is simplified by noting that @cite{1.5 = 3:2}, that @samp{acre}
22641 is defined in terms of @samp{m^2}, and that the 2 in the power of
22642 @code{m} is a multiple of 2 in @cite{3:2}.  Thus, @code{acre^1.5} is
22643 replaced by approximately @c{$(4046 m^2)^{1.5}$}
22644 @cite{(4046 m^2)^1.5}, which is then
22645 changed to @c{$4046^{1.5} \, (m^2)^{1.5}$}
22646 @cite{4046^1.5 (m^2)^1.5}, then to @cite{257440 m^3}.
22648 The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
22649 as well as @code{floor} and the other integer truncation functions,
22650 applied to unit names or products or quotients involving units, are
22651 simplified.  For example, @samp{round(1.6 in)} is changed to
22652 @samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
22653 and the righthand term simplifies to @code{in}.
22655 The functions @code{sin}, @code{cos}, and @code{tan} with arguments
22656 that have angular units like @code{rad} or @code{arcmin} are
22657 simplified by converting to base units (radians), then evaluating
22658 with the angular mode temporarily set to radians.
22660 @node Polynomials, Calculus, Simplifying Formulas, Algebra
22661 @section Polynomials
22663 A @dfn{polynomial} is a sum of terms which are coefficients times
22664 various powers of a ``base'' variable.  For example, @cite{2 x^2 + 3 x - 4}
22665 is a polynomial in @cite{x}.  Some formulas can be considered
22666 polynomials in several different variables:  @cite{1 + 2 x + 3 y + 4 x y^2}
22667 is a polynomial in both @cite{x} and @cite{y}.  Polynomial coefficients
22668 are often numbers, but they may in general be any formulas not
22669 involving the base variable.
22671 @kindex a f
22672 @pindex calc-factor
22673 @tindex factor
22674 The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
22675 polynomial into a product of terms.  For example, the polynomial
22676 @cite{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}.  As another
22677 example, @cite{a c + b d + b c + a d} is factored into the product
22678 @cite{(a + b) (c + d)}.
22680 Calc currently has three algorithms for factoring.  Formulas which are
22681 linear in several variables, such as the second example above, are
22682 merged according to the distributive law.  Formulas which are
22683 polynomials in a single variable, with constant integer or fractional
22684 coefficients, are factored into irreducible linear and/or quadratic
22685 terms.  The first example above factors into three linear terms
22686 (@cite{x}, @cite{x+1}, and @cite{x+1} again).  Finally, formulas
22687 which do not fit the above criteria are handled by the algebraic
22688 rewrite mechanism.
22690 Calc's polynomial factorization algorithm works by using the general
22691 root-finding command (@w{@kbd{a P}}) to solve for the roots of the
22692 polynomial.  It then looks for roots which are rational numbers
22693 or complex-conjugate pairs, and converts these into linear and
22694 quadratic terms, respectively.  Because it uses floating-point
22695 arithmetic, it may be unable to find terms that involve large
22696 integers (whose number of digits approaches the current precision).
22697 Also, irreducible factors of degree higher than quadratic are not
22698 found, and polynomials in more than one variable are not treated.
22699 (A more robust factorization algorithm may be included in a future
22700 version of Calc.)
22702 @vindex FactorRules
22703 @ignore
22704 @starindex
22705 @end ignore
22706 @tindex thecoefs
22707 @ignore
22708 @starindex
22709 @end ignore
22710 @ignore
22711 @mindex @idots
22712 @end ignore
22713 @tindex thefactors
22714 The rewrite-based factorization method uses rules stored in the variable
22715 @code{FactorRules}.  @xref{Rewrite Rules}, for a discussion of the
22716 operation of rewrite rules.  The default @code{FactorRules} are able
22717 to factor quadratic forms symbolically into two linear terms,
22718 @cite{(a x + b) (c x + d)}.  You can edit these rules to include other
22719 cases if you wish.  To use the rules, Calc builds the formula
22720 @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
22721 base variable and @code{a}, @code{b}, etc., are polynomial coefficients
22722 (which may be numbers or formulas).  The constant term is written first,
22723 i.e., in the @code{a} position.  When the rules complete, they should have
22724 changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
22725 where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
22726 Calc then multiplies these terms together to get the complete
22727 factored form of the polynomial.  If the rules do not change the
22728 @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
22729 polynomial alone on the assumption that it is unfactorable.  (Note that
22730 the function names @code{thecoefs} and @code{thefactors} are used only
22731 as placeholders; there are no actual Calc functions by those names.)
22733 @kindex H a f
22734 @tindex factors
22735 The @kbd{H a f} [@code{factors}] command also factors a polynomial,
22736 but it returns a list of factors instead of an expression which is the
22737 product of the factors.  Each factor is represented by a sub-vector
22738 of the factor, and the power with which it appears.  For example,
22739 @cite{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @cite{(x + 7) x^2 (x - 3)^2}
22740 in @kbd{a f}, or to @cite{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
22741 If there is an overall numeric factor, it always comes first in the list.
22742 The functions @code{factor} and @code{factors} allow a second argument
22743 when written in algebraic form; @samp{factor(x,v)} factors @cite{x} with
22744 respect to the specific variable @cite{v}.  The default is to factor with
22745 respect to all the variables that appear in @cite{x}.
22747 @kindex a c
22748 @pindex calc-collect
22749 @tindex collect
22750 The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
22751 formula as a
22752 polynomial in a given variable, ordered in decreasing powers of that
22753 variable.  For example, given @cite{1 + 2 x + 3 y + 4 x y^2} on
22754 the stack, @kbd{a c x} would produce @cite{(2 + 4 y^2) x + (1 + 3 y)},
22755 and @kbd{a c y} would produce @cite{(4 x) y^2 + 3 y + (1 + 2 x)}.
22756 The polynomial will be expanded out using the distributive law as
22757 necessary:  Collecting @cite{x} in @cite{(x - 1)^3} produces
22758 @cite{x^3 - 3 x^2 + 3 x - 1}.  Terms not involving @cite{x} will
22759 not be expanded.
22761 The ``variable'' you specify at the prompt can actually be any
22762 expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
22763 by @samp{ln(x+1)} or integer powers thereof.  If @samp{x} also appears
22764 in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
22765 treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
22767 @kindex a x
22768 @pindex calc-expand
22769 @tindex expand
22770 The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
22771 expression by applying the distributive law everywhere.  It applies to
22772 products, quotients, and powers involving sums.  By default, it fully
22773 distributes all parts of the expression.  With a numeric prefix argument,
22774 the distributive law is applied only the specified number of times, then
22775 the partially expanded expression is left on the stack.
22777 The @kbd{a x} and @kbd{j D} commands are somewhat redundant.  Use
22778 @kbd{a x} if you want to expand all products of sums in your formula.
22779 Use @kbd{j D} if you want to expand a particular specified term of
22780 the formula.  There is an exactly analogous correspondence between
22781 @kbd{a f} and @kbd{j M}.  (The @kbd{j D} and @kbd{j M} commands
22782 also know many other kinds of expansions, such as
22783 @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
22784 do not do.)
22786 Calc's automatic simplifications will sometimes reverse a partial
22787 expansion.  For example, the first step in expanding @cite{(x+1)^3} is
22788 to write @cite{(x+1) (x+1)^2}.  If @kbd{a x} stops there and tries
22789 to put this formula onto the stack, though, Calc will automatically
22790 simplify it back to @cite{(x+1)^3} form.  The solution is to turn
22791 simplification off first (@pxref{Simplification Modes}), or to run
22792 @kbd{a x} without a numeric prefix argument so that it expands all
22793 the way in one step.
22795 @kindex a a
22796 @pindex calc-apart
22797 @tindex apart
22798 The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
22799 rational function by partial fractions.  A rational function is the
22800 quotient of two polynomials; @code{apart} pulls this apart into a
22801 sum of rational functions with simple denominators.  In algebraic
22802 notation, the @code{apart} function allows a second argument that
22803 specifies which variable to use as the ``base''; by default, Calc
22804 chooses the base variable automatically.
22806 @kindex a n
22807 @pindex calc-normalize-rat
22808 @tindex nrat
22809 The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
22810 attempts to arrange a formula into a quotient of two polynomials.
22811 For example, given @cite{1 + (a + b/c) / d}, the result would be
22812 @cite{(b + a c + c d) / c d}.  The quotient is reduced, so that
22813 @kbd{a n} will simplify @cite{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
22814 out the common factor @cite{x + 1}, yielding @cite{(x + 1) / (x - 1)}.
22816 @kindex a \
22817 @pindex calc-poly-div
22818 @tindex pdiv
22819 The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
22820 two polynomials @cite{u} and @cite{v}, yielding a new polynomial
22821 @cite{q}.  If several variables occur in the inputs, the inputs are
22822 considered multivariate polynomials.  (Calc divides by the variable
22823 with the largest power in @cite{u} first, or, in the case of equal
22824 powers, chooses the variables in alphabetical order.)  For example,
22825 dividing @cite{x^2 + 3 x + 2} by @cite{x + 2} yields @cite{x + 1}.
22826 The remainder from the division, if any, is reported at the bottom
22827 of the screen and is also placed in the Trail along with the quotient.
22829 Using @code{pdiv} in algebraic notation, you can specify the particular
22830 variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
22831 If @code{pdiv} is given only two arguments (as is always the case with
22832 the @kbd{a \} command), then it does a multivariate division as outlined
22833 above.
22835 @kindex a %
22836 @pindex calc-poly-rem
22837 @tindex prem
22838 The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
22839 two polynomials and keeps the remainder @cite{r}.  The quotient
22840 @cite{q} is discarded.  For any formulas @cite{a} and @cite{b}, the
22841 results of @kbd{a \} and @kbd{a %} satisfy @cite{a = q b + r}.
22842 (This is analogous to plain @kbd{\} and @kbd{%}, which compute the
22843 integer quotient and remainder from dividing two numbers.)
22845 @kindex a /
22846 @kindex H a /
22847 @pindex calc-poly-div-rem
22848 @tindex pdivrem
22849 @tindex pdivide
22850 The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
22851 divides two polynomials and reports both the quotient and the
22852 remainder as a vector @cite{[q, r]}.  The @kbd{H a /} [@code{pdivide}]
22853 command divides two polynomials and constructs the formula
22854 @cite{q + r/b} on the stack.  (Naturally if the remainder is zero,
22855 this will immediately simplify to @cite{q}.)
22857 @kindex a g
22858 @pindex calc-poly-gcd
22859 @tindex pgcd
22860 The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
22861 the greatest common divisor of two polynomials.  (The GCD actually
22862 is unique only to within a constant multiplier; Calc attempts to
22863 choose a GCD which will be unsurprising.)  For example, the @kbd{a n}
22864 command uses @kbd{a g} to take the GCD of the numerator and denominator
22865 of a quotient, then divides each by the result using @kbd{a \}.  (The
22866 definition of GCD ensures that this division can take place without
22867 leaving a remainder.)
22869 While the polynomials used in operations like @kbd{a /} and @kbd{a g}
22870 often have integer coefficients, this is not required.  Calc can also
22871 deal with polynomials over the rationals or floating-point reals.
22872 Polynomials with modulo-form coefficients are also useful in many
22873 applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
22874 automatically transforms this into a polynomial over the field of
22875 integers mod 5:  @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
22877 Congratulations and thanks go to Ove Ewerlid
22878 (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
22879 polynomial routines used in the above commands.
22881 @xref{Decomposing Polynomials}, for several useful functions for
22882 extracting the individual coefficients of a polynomial.
22884 @node Calculus, Solving Equations, Polynomials, Algebra
22885 @section Calculus
22887 @noindent
22888 The following calculus commands do not automatically simplify their
22889 inputs or outputs using @code{calc-simplify}.  You may find it helps
22890 to do this by hand by typing @kbd{a s} or @kbd{a e}.  It may also help
22891 to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
22892 readable way.
22894 @menu
22895 * Differentiation::
22896 * Integration::
22897 * Customizing the Integrator::
22898 * Numerical Integration::
22899 * Taylor Series::
22900 @end menu
22902 @node Differentiation, Integration, Calculus, Calculus
22903 @subsection Differentiation
22905 @noindent
22906 @kindex a d
22907 @kindex H a d
22908 @pindex calc-derivative
22909 @tindex deriv
22910 @tindex tderiv
22911 The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
22912 the derivative of the expression on the top of the stack with respect to
22913 some variable, which it will prompt you to enter.  Normally, variables
22914 in the formula other than the specified differentiation variable are
22915 considered constant, i.e., @samp{deriv(y,x)} is reduced to zero.  With
22916 the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
22917 instead, in which derivatives of variables are not reduced to zero
22918 unless those variables are known to be ``constant,'' i.e., independent
22919 of any other variables.  (The built-in special variables like @code{pi}
22920 are considered constant, as are variables that have been declared
22921 @code{const}; @pxref{Declarations}.)
22923 With a numeric prefix argument @var{n}, this command computes the
22924 @var{n}th derivative.
22926 When working with trigonometric functions, it is best to switch to
22927 radians mode first (with @w{@kbd{m r}}).  The derivative of @samp{sin(x)}
22928 in degrees is @samp{(pi/180) cos(x)}, probably not the expected
22929 answer!
22931 If you use the @code{deriv} function directly in an algebraic formula,
22932 you can write @samp{deriv(f,x,x0)} which represents the derivative
22933 of @cite{f} with respect to @cite{x}, evaluated at the point @c{$x=x_0$}
22934 @cite{x=x0}.
22936 If the formula being differentiated contains functions which Calc does
22937 not know, the derivatives of those functions are produced by adding
22938 primes (apostrophe characters).  For example, @samp{deriv(f(2x), x)}
22939 produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
22940 derivative of @code{f}.
22942 For functions you have defined with the @kbd{Z F} command, Calc expands
22943 the functions according to their defining formulas unless you have
22944 also defined @code{f'} suitably.  For example, suppose we define
22945 @samp{sinc(x) = sin(x)/x} using @kbd{Z F}.  If we then differentiate
22946 the formula @samp{sinc(2 x)}, the formula will be expanded to
22947 @samp{sin(2 x) / (2 x)} and differentiated.  However, if we also
22948 define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
22949 result as @samp{2 dsinc(2 x)}.  @xref{Algebraic Definitions}.
22951 For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
22952 to the first argument is written @samp{f'(x,y,z)}; derivatives with
22953 respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
22954 Various higher-order derivatives can be formed in the obvious way, e.g.,
22955 @samp{f'@var{}'(x)} (the second derivative of @code{f}) or
22956 @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
22957 argument once).@refill
22959 @node Integration, Customizing the Integrator, Differentiation, Calculus
22960 @subsection Integration
22962 @noindent
22963 @kindex a i
22964 @pindex calc-integral
22965 @tindex integ
22966 The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
22967 indefinite integral of the expression on the top of the stack with
22968 respect to a variable.  The integrator is not guaranteed to work for
22969 all integrable functions, but it is able to integrate several large
22970 classes of formulas.  In particular, any polynomial or rational function
22971 (a polynomial divided by a polynomial) is acceptable.  (Rational functions
22972 don't have to be in explicit quotient form, however; @c{$x/(1+x^{-2})$}
22973 @cite{x/(1+x^-2)}
22974 is not strictly a quotient of polynomials, but it is equivalent to
22975 @cite{x^3/(x^2+1)}, which is.)  Also, square roots of terms involving
22976 @cite{x} and @cite{x^2} may appear in rational functions being
22977 integrated.  Finally, rational functions involving trigonometric or
22978 hyperbolic functions can be integrated.
22980 @ifinfo
22981 If you use the @code{integ} function directly in an algebraic formula,
22982 you can also write @samp{integ(f,x,v)} which expresses the resulting
22983 indefinite integral in terms of variable @code{v} instead of @code{x}.
22984 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
22985 integral from @code{a} to @code{b}.
22986 @end ifinfo
22987 @tex
22988 If you use the @code{integ} function directly in an algebraic formula,
22989 you can also write @samp{integ(f,x,v)} which expresses the resulting
22990 indefinite integral in terms of variable @code{v} instead of @code{x}.
22991 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
22992 integral $\int_a^b f(x) \, dx$.
22993 @end tex
22995 Please note that the current implementation of Calc's integrator sometimes
22996 produces results that are significantly more complex than they need to
22997 be.  For example, the integral Calc finds for @c{$1/(x+\sqrt{x^2+1})$}
22998 @cite{1/(x+sqrt(x^2+1))}
22999 is several times more complicated than the answer Mathematica
23000 returns for the same input, although the two forms are numerically
23001 equivalent.  Also, any indefinite integral should be considered to have
23002 an arbitrary constant of integration added to it, although Calc does not
23003 write an explicit constant of integration in its result.  For example,
23004 Calc's solution for @c{$1/(1+\tan x)$}
23005 @cite{1/(1+tan(x))} differs from the solution given
23006 in the @emph{CRC Math Tables} by a constant factor of @c{$\pi i / 2$}
23007 @cite{pi i / 2},
23008 due to a different choice of constant of integration.
23010 The Calculator remembers all the integrals it has done.  If conditions
23011 change in a way that would invalidate the old integrals, say, a switch
23012 from degrees to radians mode, then they will be thrown out.  If you
23013 suspect this is not happening when it should, use the
23014 @code{calc-flush-caches} command; @pxref{Caches}.
23016 @vindex IntegLimit
23017 Calc normally will pursue integration by substitution or integration by
23018 parts up to 3 nested times before abandoning an approach as fruitless.
23019 If the integrator is taking too long, you can lower this limit by storing
23020 a number (like 2) in the variable @code{IntegLimit}.  (The @kbd{s I}
23021 command is a convenient way to edit @code{IntegLimit}.)  If this variable
23022 has no stored value or does not contain a nonnegative integer, a limit
23023 of 3 is used.  The lower this limit is, the greater the chance that Calc
23024 will be unable to integrate a function it could otherwise handle.  Raising
23025 this limit allows the Calculator to solve more integrals, though the time
23026 it takes may grow exponentially.  You can monitor the integrator's actions
23027 by creating an Emacs buffer called @code{*Trace*}.  If such a buffer
23028 exists, the @kbd{a i} command will write a log of its actions there.
23030 If you want to manipulate integrals in a purely symbolic way, you can
23031 set the integration nesting limit to 0 to prevent all but fast
23032 table-lookup solutions of integrals.  You might then wish to define
23033 rewrite rules for integration by parts, various kinds of substitutions,
23034 and so on.  @xref{Rewrite Rules}.
23036 @node Customizing the Integrator, Numerical Integration, Integration, Calculus
23037 @subsection Customizing the Integrator
23039 @noindent
23040 @vindex IntegRules
23041 Calc has two built-in rewrite rules called @code{IntegRules} and
23042 @code{IntegAfterRules} which you can edit to define new integration
23043 methods.  @xref{Rewrite Rules}.  At each step of the integration process,
23044 Calc wraps the current integrand in a call to the fictitious function
23045 @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
23046 integrand and @var{var} is the integration variable.  If your rules
23047 rewrite this to be a plain formula (not a call to @code{integtry}), then
23048 Calc will use this formula as the integral of @var{expr}.  For example,
23049 the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
23050 integrate a function @code{mysin} that acts like the sine function.
23051 Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
23052 will produce the integral @samp{-2 mycos(2y+1)}.  Note that Calc has
23053 automatically made various transformations on the integral to allow it
23054 to use your rule; integral tables generally give rules for
23055 @samp{mysin(a x + b)}, but you don't need to use this much generality
23056 in your @code{IntegRules}.
23058 @cindex Exponential integral Ei(x)
23059 @ignore
23060 @starindex
23061 @end ignore
23062 @tindex Ei
23063 As a more serious example, the expression @samp{exp(x)/x} cannot be
23064 integrated in terms of the standard functions, so the ``exponential
23065 integral'' function @c{${\rm Ei}(x)$}
23066 @cite{Ei(x)} was invented to describe it.
23067 We can get Calc to do this integral in terms of a made-up @code{Ei}
23068 function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
23069 to @code{IntegRules}.  Now entering @samp{exp(2x)/x} on the stack
23070 and typing @kbd{a i x} yields @samp{Ei(2 x)}.  This new rule will
23071 work with Calc's various built-in integration methods (such as
23072 integration by substitution) to solve a variety of other problems
23073 involving @code{Ei}:  For example, now Calc will also be able to
23074 integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
23075 and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
23077 Your rule may do further integration by calling @code{integ}.  For
23078 example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
23079 to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
23080 Note that @code{integ} was called with only one argument.  This notation
23081 is allowed only within @code{IntegRules}; it means ``integrate this
23082 with respect to the same integration variable.''  If Calc is unable
23083 to integrate @code{u}, the integration that invoked @code{IntegRules}
23084 also fails.  Thus integrating @samp{twice(f(x))} fails, returning the
23085 unevaluated integral @samp{integ(twice(f(x)), x)}.  It is still legal
23086 to call @code{integ} with two or more arguments, however; in this case,
23087 if @code{u} is not integrable, @code{twice} itself will still be
23088 integrated:  If the above rule is changed to @samp{... := twice(integ(u,x))},
23089 then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
23091 If a rule instead produces the formula @samp{integsubst(@var{sexpr},
23092 @var{svar})}, either replacing the top-level @code{integtry} call or
23093 nested anywhere inside the expression, then Calc will apply the
23094 substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
23095 integrate the original @var{expr}.  For example, the rule
23096 @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
23097 a square root in the integrand, it should attempt the substitution
23098 @samp{u = sqrt(x)}.  (This particular rule is unnecessary because
23099 Calc always tries ``obvious'' substitutions where @var{sexpr} actually
23100 appears in the integrand.)  The variable @var{svar} may be the same
23101 as the @var{var} that appeared in the call to @code{integtry}, but
23102 it need not be.
23104 When integrating according to an @code{integsubst}, Calc uses the
23105 equation solver to find the inverse of @var{sexpr} (if the integrand
23106 refers to @var{var} anywhere except in subexpressions that exactly
23107 match @var{sexpr}).  It uses the differentiator to find the derivative
23108 of @var{sexpr} and/or its inverse (it has two methods that use one
23109 derivative or the other).  You can also specify these items by adding
23110 extra arguments to the @code{integsubst} your rules construct; the
23111 general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
23112 @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
23113 written as a function of @var{svar}), and @var{sprime} is the
23114 derivative of @var{sexpr} with respect to @var{svar}.  If you don't
23115 specify these things, and Calc is not able to work them out on its
23116 own with the information it knows, then your substitution rule will
23117 work only in very specific, simple cases.
23119 Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
23120 in other words, Calc stops rewriting as soon as any rule in your rule
23121 set succeeds.  (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
23122 example above would keep on adding layers of @code{integsubst} calls
23123 forever!)
23125 @vindex IntegSimpRules
23126 Another set of rules, stored in @code{IntegSimpRules}, are applied
23127 every time the integrator uses @kbd{a s} to simplify an intermediate
23128 result.  For example, putting the rule @samp{twice(x) := 2 x} into
23129 @code{IntegSimpRules} would tell Calc to convert the @code{twice}
23130 function into a form it knows whenever integration is attempted.
23132 One more way to influence the integrator is to define a function with
23133 the @kbd{Z F} command (@pxref{Algebraic Definitions}).  Calc's
23134 integrator automatically expands such functions according to their
23135 defining formulas, even if you originally asked for the function to
23136 be left unevaluated for symbolic arguments.  (Certain other Calc
23137 systems, such as the differentiator and the equation solver, also
23138 do this.)
23140 @vindex IntegAfterRules
23141 Sometimes Calc is able to find a solution to your integral, but it
23142 expresses the result in a way that is unnecessarily complicated.  If
23143 this happens, you can either use @code{integsubst} as described
23144 above to try to hint at a more direct path to the desired result, or
23145 you can use @code{IntegAfterRules}.  This is an extra rule set that
23146 runs after the main integrator returns its result; basically, Calc does
23147 an @kbd{a r IntegAfterRules} on the result before showing it to you.
23148 (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that
23149 to further simplify the result.)  For example, Calc's integrator
23150 sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
23151 the default @code{IntegAfterRules} rewrite this into the more readable
23152 form @samp{2 arctanh(x)}.  Note that, unlike @code{IntegRules},
23153 @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
23154 of times until no further changes are possible.  Rewriting by
23155 @code{IntegAfterRules} occurs only after the main integrator has
23156 finished, not at every step as for @code{IntegRules} and
23157 @code{IntegSimpRules}.
23159 @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
23160 @subsection Numerical Integration
23162 @noindent
23163 @kindex a I
23164 @pindex calc-num-integral
23165 @tindex ninteg
23166 If you want a purely numerical answer to an integration problem, you can
23167 use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command.  This
23168 command prompts for an integration variable, a lower limit, and an
23169 upper limit.  Except for the integration variable, all other variables
23170 that appear in the integrand formula must have stored values.  (A stored
23171 value, if any, for the integration variable itself is ignored.)
23173 Numerical integration works by evaluating your formula at many points in
23174 the specified interval.  Calc uses an ``open Romberg'' method; this means
23175 that it does not evaluate the formula actually at the endpoints (so that
23176 it is safe to integrate @samp{sin(x)/x} from zero, for example).  Also,
23177 the Romberg method works especially well when the function being
23178 integrated is fairly smooth.  If the function is not smooth, Calc will
23179 have to evaluate it at quite a few points before it can accurately
23180 determine the value of the integral.
23182 Integration is much faster when the current precision is small.  It is
23183 best to set the precision to the smallest acceptable number of digits
23184 before you use @kbd{a I}.  If Calc appears to be taking too long, press
23185 @kbd{C-g} to halt it and try a lower precision.  If Calc still appears
23186 to need hundreds of evaluations, check to make sure your function is
23187 well-behaved in the specified interval.
23189 It is possible for the lower integration limit to be @samp{-inf} (minus
23190 infinity).  Likewise, the upper limit may be plus infinity.  Calc
23191 internally transforms the integral into an equivalent one with finite
23192 limits.  However, integration to or across singularities is not supported:
23193 The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
23194 by Calc's symbolic integrator, for example), but @kbd{a I} will fail
23195 because the integrand goes to infinity at one of the endpoints.
23197 @node Taylor Series, , Numerical Integration, Calculus
23198 @subsection Taylor Series
23200 @noindent
23201 @kindex a t
23202 @pindex calc-taylor
23203 @tindex taylor
23204 The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
23205 power series expansion or Taylor series of a function.  You specify the
23206 variable and the desired number of terms.  You may give an expression of
23207 the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
23208 of just a variable to produce a Taylor expansion about the point @var{a}.
23209 You may specify the number of terms with a numeric prefix argument;
23210 otherwise the command will prompt you for the number of terms.  Note that
23211 many series expansions have coefficients of zero for some terms, so you
23212 may appear to get fewer terms than you asked for.@refill
23214 If the @kbd{a i} command is unable to find a symbolic integral for a
23215 function, you can get an approximation by integrating the function's
23216 Taylor series.
23218 @node Solving Equations, Numerical Solutions, Calculus, Algebra
23219 @section Solving Equations
23221 @noindent
23222 @kindex a S
23223 @pindex calc-solve-for
23224 @tindex solve
23225 @cindex Equations, solving
23226 @cindex Solving equations
23227 The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
23228 an equation to solve for a specific variable.  An equation is an
23229 expression of the form @cite{L = R}.  For example, the command @kbd{a S x}
23230 will rearrange @cite{y = 3x + 6} to the form, @cite{x = y/3 - 2}.  If the
23231 input is not an equation, it is treated like an equation of the
23232 form @cite{X = 0}.
23234 This command also works for inequalities, as in @cite{y < 3x + 6}.
23235 Some inequalities cannot be solved where the analogous equation could
23236 be; for example, solving @c{$a < b \, c$}
23237 @cite{a < b c} for @cite{b} is impossible
23238 without knowing the sign of @cite{c}.  In this case, @kbd{a S} will
23239 produce the result @c{$b \mathbin{\hbox{\code{!=}}} a/c$}
23240 @cite{b != a/c} (using the not-equal-to operator)
23241 to signify that the direction of the inequality is now unknown.  The
23242 inequality @c{$a \le b \, c$}
23243 @cite{a <= b c} is not even partially solved.
23244 @xref{Declarations}, for a way to tell Calc that the signs of the
23245 variables in a formula are in fact known.
23247 Two useful commands for working with the result of @kbd{a S} are
23248 @kbd{a .} (@pxref{Logical Operations}), which converts @cite{x = y/3 - 2}
23249 to @cite{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
23250 another formula with @cite{x} set equal to @cite{y/3 - 2}.
23252 @menu
23253 * Multiple Solutions::
23254 * Solving Systems of Equations::
23255 * Decomposing Polynomials::
23256 @end menu
23258 @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
23259 @subsection Multiple Solutions
23261 @noindent
23262 @kindex H a S
23263 @tindex fsolve
23264 Some equations have more than one solution.  The Hyperbolic flag
23265 (@code{H a S}) [@code{fsolve}] tells the solver to report the fully
23266 general family of solutions.  It will invent variables @code{n1},
23267 @code{n2}, @dots{}, which represent independent arbitrary integers, and
23268 @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
23269 signs (either @i{+1} or @i{-1}).  If you don't use the Hyperbolic
23270 flag, Calc will use zero in place of all arbitrary integers, and plus
23271 one in place of all arbitrary signs.  Note that variables like @code{n1}
23272 and @code{s1} are not given any special interpretation in Calc except by
23273 the equation solver itself.  As usual, you can use the @w{@kbd{s l}}
23274 (@code{calc-let}) command to obtain solutions for various actual values
23275 of these variables.
23277 For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
23278 get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
23279 equation are @samp{sqrt(y)} and @samp{-sqrt(y)}.  Another way to
23280 think about it is that the square-root operation is really a
23281 two-valued function; since every Calc function must return a
23282 single result, @code{sqrt} chooses to return the positive result.
23283 Then @kbd{H a S} doctors this result using @code{s1} to indicate
23284 the full set of possible values of the mathematical square-root.
23286 There is a similar phenomenon going the other direction:  Suppose
23287 we solve @samp{sqrt(y) = x} for @code{y}.  Calc squares both sides
23288 to get @samp{y = x^2}.  This is correct, except that it introduces
23289 some dubious solutions.  Consider solving @samp{sqrt(y) = -3}:
23290 Calc will report @cite{y = 9} as a valid solution, which is true
23291 in the mathematical sense of square-root, but false (there is no
23292 solution) for the actual Calc positive-valued @code{sqrt}.  This
23293 happens for both @kbd{a S} and @kbd{H a S}.
23295 @cindex @code{GenCount} variable
23296 @vindex GenCount
23297 @ignore
23298 @starindex
23299 @end ignore
23300 @tindex an
23301 @ignore
23302 @starindex
23303 @end ignore
23304 @tindex as
23305 If you store a positive integer in the Calc variable @code{GenCount},
23306 then Calc will generate formulas of the form @samp{as(@var{n})} for
23307 arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
23308 where @var{n} represents successive values taken by incrementing
23309 @code{GenCount} by one.  While the normal arbitrary sign and
23310 integer symbols start over at @code{s1} and @code{n1} with each
23311 new Calc command, the @code{GenCount} approach will give each
23312 arbitrary value a name that is unique throughout the entire Calc
23313 session.  Also, the arbitrary values are function calls instead
23314 of variables, which is advantageous in some cases.  For example,
23315 you can make a rewrite rule that recognizes all arbitrary signs
23316 using a pattern like @samp{as(n)}.  The @kbd{s l} command only works
23317 on variables, but you can use the @kbd{a b} (@code{calc-substitute})
23318 command to substitute actual values for function calls like @samp{as(3)}.
23320 The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
23321 way to create or edit this variable.  Press @kbd{M-# M-#} to finish.
23323 If you have not stored a value in @code{GenCount}, or if the value
23324 in that variable is not a positive integer, the regular
23325 @code{s1}/@code{n1} notation is used.
23327 @kindex I a S
23328 @kindex H I a S
23329 @tindex finv
23330 @tindex ffinv
23331 With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
23332 on top of the stack as a function of the specified variable and solves
23333 to find the inverse function, written in terms of the same variable.
23334 For example, @kbd{I a S x} inverts @cite{2x + 6} to @cite{x/2 - 3}.
23335 You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
23336 fully general inverse, as described above.
23338 @kindex a P
23339 @pindex calc-poly-roots
23340 @tindex roots
23341 Some equations, specifically polynomials, have a known, finite number
23342 of solutions.  The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
23343 command uses @kbd{H a S} to solve an equation in general form, then, for
23344 all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
23345 variables like @code{n1} for which @code{n1} only usefully varies over
23346 a finite range, it expands these variables out to all their possible
23347 values.  The results are collected into a vector, which is returned.
23348 For example, @samp{roots(x^4 = 1, x)} returns the four solutions
23349 @samp{[1, -1, (0, 1), (0, -1)]}.  Generally an @var{n}th degree
23350 polynomial will always have @var{n} roots on the complex plane.
23351 (If you have given a @code{real} declaration for the solution
23352 variable, then only the real-valued solutions, if any, will be
23353 reported; @pxref{Declarations}.)
23355 Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
23356 symbolic solutions if the polynomial has symbolic coefficients.  Also
23357 note that Calc's solver is not able to get exact symbolic solutions
23358 to all polynomials.  Polynomials containing powers up to @cite{x^4}
23359 can always be solved exactly; polynomials of higher degree sometimes
23360 can be:  @cite{x^6 + x^3 + 1} is converted to @cite{(x^3)^2 + (x^3) + 1},
23361 which can be solved for @cite{x^3} using the quadratic equation, and then
23362 for @cite{x} by taking cube roots.  But in many cases, like
23363 @cite{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
23364 into a form it can solve.  The @kbd{a P} command can still deliver a
23365 list of numerical roots, however, provided that symbolic mode (@kbd{m s})
23366 is not turned on.  (If you work with symbolic mode on, recall that the
23367 @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
23368 formula on the stack with symbolic mode temporarily off.)  Naturally,
23369 @kbd{a P} can only provide numerical roots if the polynomial coefficients
23370 are all numbers (real or complex).
23372 @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
23373 @subsection Solving Systems of Equations
23375 @noindent
23376 @cindex Systems of equations, symbolic
23377 You can also use the commands described above to solve systems of
23378 simultaneous equations.  Just create a vector of equations, then
23379 specify a vector of variables for which to solve.  (You can omit
23380 the surrounding brackets when entering the vector of variables
23381 at the prompt.)
23383 For example, putting @samp{[x + y = a, x - y = b]} on the stack
23384 and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
23385 @samp{[x = a - (a-b)/2, y = (a-b)/2]}.  The result vector will
23386 have the same length as the variables vector, and the variables
23387 will be listed in the same order there.  Note that the solutions
23388 are not always simplified as far as possible; the solution for
23389 @cite{x} here could be improved by an application of the @kbd{a n}
23390 command.
23392 Calc's algorithm works by trying to eliminate one variable at a
23393 time by solving one of the equations for that variable and then
23394 substituting into the other equations.  Calc will try all the
23395 possibilities, but you can speed things up by noting that Calc
23396 first tries to eliminate the first variable with the first
23397 equation, then the second variable with the second equation,
23398 and so on.  It also helps to put the simpler (e.g., more linear)
23399 equations toward the front of the list.  Calc's algorithm will
23400 solve any system of linear equations, and also many kinds of
23401 nonlinear systems.
23403 @ignore
23404 @starindex
23405 @end ignore
23406 @tindex elim
23407 Normally there will be as many variables as equations.  If you
23408 give fewer variables than equations (an ``over-determined'' system
23409 of equations), Calc will find a partial solution.  For example,
23410 typing @kbd{a S y @key{RET}} with the above system of equations
23411 would produce @samp{[y = a - x]}.  There are now several ways to
23412 express this solution in terms of the original variables; Calc uses
23413 the first one that it finds.  You can control the choice by adding
23414 variable specifiers of the form @samp{elim(@var{v})} to the
23415 variables list.  This says that @var{v} should be eliminated from
23416 the equations; the variable will not appear at all in the solution.
23417 For example, typing @kbd{a S y,elim(x)} would yield
23418 @samp{[y = a - (b+a)/2]}.
23420 If the variables list contains only @code{elim} specifiers,
23421 Calc simply eliminates those variables from the equations
23422 and then returns the resulting set of equations.  For example,
23423 @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}.  Every variable
23424 eliminated will reduce the number of equations in the system
23425 by one.
23427 Again, @kbd{a S} gives you one solution to the system of
23428 equations.  If there are several solutions, you can use @kbd{H a S}
23429 to get a general family of solutions, or, if there is a finite
23430 number of solutions, you can use @kbd{a P} to get a list.  (In
23431 the latter case, the result will take the form of a matrix where
23432 the rows are different solutions and the columns correspond to the
23433 variables you requested.)
23435 Another way to deal with certain kinds of overdetermined systems of
23436 equations is the @kbd{a F} command, which does least-squares fitting
23437 to satisfy the equations.  @xref{Curve Fitting}.
23439 @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
23440 @subsection Decomposing Polynomials
23442 @noindent
23443 @ignore
23444 @starindex
23445 @end ignore
23446 @tindex poly
23447 The @code{poly} function takes a polynomial and a variable as
23448 arguments, and returns a vector of polynomial coefficients (constant
23449 coefficient first).  For example, @samp{poly(x^3 + 2 x, x)} returns
23450 @cite{[0, 2, 0, 1]}.  If the input is not a polynomial in @cite{x},
23451 the call to @code{poly} is left in symbolic form.  If the input does
23452 not involve the variable @cite{x}, the input is returned in a list
23453 of length one, representing a polynomial with only a constant
23454 coefficient.  The call @samp{poly(x, x)} returns the vector @cite{[0, 1]}.
23455 The last element of the returned vector is guaranteed to be nonzero;
23456 note that @samp{poly(0, x)} returns the empty vector @cite{[]}.
23457 Note also that @cite{x} may actually be any formula; for example,
23458 @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @cite{[3, -1, 1]}.
23460 @cindex Coefficients of polynomial
23461 @cindex Degree of polynomial
23462 To get the @cite{x^k} coefficient of polynomial @cite{p}, use
23463 @samp{poly(p, x)_(k+1)}.  To get the degree of polynomial @cite{p},
23464 use @samp{vlen(poly(p, x)) - 1}.  For example, @samp{poly((x+1)^4, x)}
23465 returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
23466 gives the @cite{x^2} coefficient of this polynomial, 6.
23468 @ignore
23469 @starindex
23470 @end ignore
23471 @tindex gpoly
23472 One important feature of the solver is its ability to recognize
23473 formulas which are ``essentially'' polynomials.  This ability is
23474 made available to the user through the @code{gpoly} function, which
23475 is used just like @code{poly}:  @samp{gpoly(@var{expr}, @var{var})}.
23476 If @var{expr} is a polynomial in some term which includes @var{var}, then
23477 this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
23478 where @var{x} is the term that depends on @var{var}, @var{c} is a
23479 vector of polynomial coefficients (like the one returned by @code{poly}),
23480 and @var{a} is a multiplier which is usually 1.  Basically,
23481 @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
23482 @var{c}_3 @var{x}^2 + ...)}.  The last element of @var{c} is
23483 guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
23484 (i.e., the trivial decomposition @var{expr} = @var{x} is not
23485 considered a polynomial).  One side effect is that @samp{gpoly(x, x)}
23486 and @samp{gpoly(6, x)}, both of which might be expected to recognize
23487 their arguments as polynomials, will not because the decomposition
23488 is considered trivial.
23490 For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
23491 since the expanded form of this polynomial is @cite{4 - 4 x + x^2}.
23493 The term @var{x} may itself be a polynomial in @var{var}.  This is
23494 done to reduce the size of the @var{c} vector.  For example,
23495 @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
23496 since a quadratic polynomial in @cite{x^2} is easier to solve than
23497 a quartic polynomial in @cite{x}.
23499 A few more examples of the kinds of polynomials @code{gpoly} can
23500 discover:
23502 @smallexample
23503 sin(x) - 1               [sin(x), [-1, 1], 1]
23504 x + 1/x - 1              [x, [1, -1, 1], 1/x]
23505 x + 1/x                  [x^2, [1, 1], 1/x]
23506 x^3 + 2 x                [x^2, [2, 1], x]
23507 x + x^2:3 + sqrt(x)      [x^1:6, [1, 1, 0, 1], x^1:2]
23508 x^(2a) + 2 x^a + 5       [x^a, [5, 2, 1], 1]
23509 (exp(-x) + exp(x)) / 2   [e^(2 x), [0.5, 0.5], e^-x]
23510 @end smallexample
23512 The @code{poly} and @code{gpoly} functions accept a third integer argument
23513 which specifies the largest degree of polynomial that is acceptable.
23514 If this is @cite{n}, then only @var{c} vectors of length @cite{n+1}
23515 or less will be returned.  Otherwise, the @code{poly} or @code{gpoly}
23516 call will remain in symbolic form.  For example, the equation solver
23517 can handle quartics and smaller polynomials, so it calls
23518 @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
23519 can be treated by its linear, quadratic, cubic, or quartic formulas.
23521 @ignore
23522 @starindex
23523 @end ignore
23524 @tindex pdeg
23525 The @code{pdeg} function computes the degree of a polynomial;
23526 @samp{pdeg(p,x)} is the highest power of @code{x} that appears in
23527 @code{p}.  This is the same as @samp{vlen(poly(p,x))-1}, but is
23528 much more efficient.  If @code{p} is constant with respect to @code{x},
23529 then @samp{pdeg(p,x) = 0}.  If @code{p} is not a polynomial in @code{x}
23530 (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
23531 It is possible to omit the second argument @code{x}, in which case
23532 @samp{pdeg(p)} returns the highest total degree of any term of the
23533 polynomial, counting all variables that appear in @code{p}.  Note
23534 that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
23535 the degree of the constant zero is considered to be @code{-inf}
23536 (minus infinity).
23538 @ignore
23539 @starindex
23540 @end ignore
23541 @tindex plead
23542 The @code{plead} function finds the leading term of a polynomial.
23543 Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
23544 though again more efficient.  In particular, @samp{plead((2x+1)^10, x)}
23545 returns 1024 without expanding out the list of coefficients.  The
23546 value of @code{plead(p,x)} will be zero only if @cite{p = 0}.
23548 @ignore
23549 @starindex
23550 @end ignore
23551 @tindex pcont
23552 The @code{pcont} function finds the @dfn{content} of a polynomial.  This
23553 is the greatest common divisor of all the coefficients of the polynomial.
23554 With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
23555 to get a list of coefficients, then uses @code{pgcd} (the polynomial
23556 GCD function) to combine these into an answer.  For example,
23557 @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}.  The content is
23558 basically the ``biggest'' polynomial that can be divided into @code{p}
23559 exactly.  The sign of the content is the same as the sign of the leading
23560 coefficient.
23562 With only one argument, @samp{pcont(p)} computes the numerical
23563 content of the polynomial, i.e., the @code{gcd} of the numerical
23564 coefficients of all the terms in the formula.  Note that @code{gcd}
23565 is defined on rational numbers as well as integers; it computes
23566 the @code{gcd} of the numerators and the @code{lcm} of the
23567 denominators.  Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
23568 Dividing the polynomial by this number will clear all the
23569 denominators, as well as dividing by any common content in the
23570 numerators.  The numerical content of a polynomial is negative only
23571 if all the coefficients in the polynomial are negative.
23573 @ignore
23574 @starindex
23575 @end ignore
23576 @tindex pprim
23577 The @code{pprim} function finds the @dfn{primitive part} of a
23578 polynomial, which is simply the polynomial divided (using @code{pdiv}
23579 if necessary) by its content.  If the input polynomial has rational
23580 coefficients, the result will have integer coefficients in simplest
23581 terms.
23583 @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
23584 @section Numerical Solutions
23586 @noindent
23587 Not all equations can be solved symbolically.  The commands in this
23588 section use numerical algorithms that can find a solution to a specific
23589 instance of an equation to any desired accuracy.  Note that the
23590 numerical commands are slower than their algebraic cousins; it is a
23591 good idea to try @kbd{a S} before resorting to these commands.
23593 (@xref{Curve Fitting}, for some other, more specialized, operations
23594 on numerical data.)
23596 @menu
23597 * Root Finding::
23598 * Minimization::
23599 * Numerical Systems of Equations::
23600 @end menu
23602 @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
23603 @subsection Root Finding
23605 @noindent
23606 @kindex a R
23607 @pindex calc-find-root
23608 @tindex root
23609 @cindex Newton's method
23610 @cindex Roots of equations
23611 @cindex Numerical root-finding
23612 The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
23613 numerical solution (or @dfn{root}) of an equation.  (This command treats
23614 inequalities the same as equations.  If the input is any other kind
23615 of formula, it is interpreted as an equation of the form @cite{X = 0}.)
23617 The @kbd{a R} command requires an initial guess on the top of the
23618 stack, and a formula in the second-to-top position.  It prompts for a
23619 solution variable, which must appear in the formula.  All other variables
23620 that appear in the formula must have assigned values, i.e., when
23621 a value is assigned to the solution variable and the formula is
23622 evaluated with @kbd{=}, it should evaluate to a number.  Any assigned
23623 value for the solution variable itself is ignored and unaffected by
23624 this command.
23626 When the command completes, the initial guess is replaced on the stack
23627 by a vector of two numbers:  The value of the solution variable that
23628 solves the equation, and the difference between the lefthand and
23629 righthand sides of the equation at that value.  Ordinarily, the second
23630 number will be zero or very nearly zero.  (Note that Calc uses a
23631 slightly higher precision while finding the root, and thus the second
23632 number may be slightly different from the value you would compute from
23633 the equation yourself.)
23635 The @kbd{v h} (@code{calc-head}) command is a handy way to extract
23636 the first element of the result vector, discarding the error term.
23638 The initial guess can be a real number, in which case Calc searches
23639 for a real solution near that number, or a complex number, in which
23640 case Calc searches the whole complex plane near that number for a
23641 solution, or it can be an interval form which restricts the search
23642 to real numbers inside that interval.
23644 Calc tries to use @kbd{a d} to take the derivative of the equation.
23645 If this succeeds, it uses Newton's method.  If the equation is not
23646 differentiable Calc uses a bisection method.  (If Newton's method
23647 appears to be going astray, Calc switches over to bisection if it
23648 can, or otherwise gives up.  In this case it may help to try again
23649 with a slightly different initial guess.)  If the initial guess is a
23650 complex number, the function must be differentiable.
23652 If the formula (or the difference between the sides of an equation)
23653 is negative at one end of the interval you specify and positive at
23654 the other end, the root finder is guaranteed to find a root.
23655 Otherwise, Calc subdivides the interval into small parts looking for
23656 positive and negative values to bracket the root.  When your guess is
23657 an interval, Calc will not look outside that interval for a root.
23659 @kindex H a R
23660 @tindex wroot
23661 The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
23662 that if the initial guess is an interval for which the function has
23663 the same sign at both ends, then rather than subdividing the interval
23664 Calc attempts to widen it to enclose a root.  Use this mode if
23665 you are not sure if the function has a root in your interval.
23667 If the function is not differentiable, and you give a simple number
23668 instead of an interval as your initial guess, Calc uses this widening
23669 process even if you did not type the Hyperbolic flag.  (If the function
23670 @emph{is} differentiable, Calc uses Newton's method which does not
23671 require a bounding interval in order to work.)
23673 If Calc leaves the @code{root} or @code{wroot} function in symbolic
23674 form on the stack, it will normally display an explanation for why
23675 no root was found.  If you miss this explanation, press @kbd{w}
23676 (@code{calc-why}) to get it back.
23678 @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
23679 @subsection Minimization
23681 @noindent
23682 @kindex a N
23683 @kindex H a N
23684 @kindex a X
23685 @kindex H a X
23686 @pindex calc-find-minimum
23687 @pindex calc-find-maximum
23688 @tindex minimize
23689 @tindex maximize
23690 @cindex Minimization, numerical
23691 The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
23692 finds a minimum value for a formula.  It is very similar in operation
23693 to @kbd{a R} (@code{calc-find-root}):  You give the formula and an initial
23694 guess on the stack, and are prompted for the name of a variable.  The guess
23695 may be either a number near the desired minimum, or an interval enclosing
23696 the desired minimum.  The function returns a vector containing the
23697 value of the variable which minimizes the formula's value, along
23698 with the minimum value itself.
23700 Note that this command looks for a @emph{local} minimum.  Many functions
23701 have more than one minimum; some, like @c{$x \sin x$}
23702 @cite{x sin(x)}, have infinitely
23703 many.  In fact, there is no easy way to define the ``global'' minimum
23704 of @c{$x \sin x$}
23705 @cite{x sin(x)} but Calc can still locate any particular local minimum
23706 for you.  Calc basically goes downhill from the initial guess until it
23707 finds a point at which the function's value is greater both to the left
23708 and to the right.  Calc does not use derivatives when minimizing a function.
23710 If your initial guess is an interval and it looks like the minimum
23711 occurs at one or the other endpoint of the interval, Calc will return
23712 that endpoint only if that endpoint is closed; thus, minimizing @cite{17 x}
23713 over @cite{[2..3]} will return @cite{[2, 38]}, but minimizing over
23714 @cite{(2..3]} would report no minimum found.  In general, you should
23715 use closed intervals to find literally the minimum value in that
23716 range of @cite{x}, or open intervals to find the local minimum, if
23717 any, that happens to lie in that range.
23719 Most functions are smooth and flat near their minimum values.  Because
23720 of this flatness, if the current precision is, say, 12 digits, the
23721 variable can only be determined meaningfully to about six digits.  Thus
23722 you should set the precision to twice as many digits as you need in your
23723 answer.
23725 @ignore
23726 @mindex wmin@idots
23727 @end ignore
23728 @tindex wminimize
23729 @ignore
23730 @mindex wmax@idots
23731 @end ignore
23732 @tindex wmaximize
23733 The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
23734 expands the guess interval to enclose a minimum rather than requiring
23735 that the minimum lie inside the interval you supply.
23737 The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
23738 @kbd{H a X} [@code{wmaximize}] commands effectively minimize the
23739 negative of the formula you supply.
23741 The formula must evaluate to a real number at all points inside the
23742 interval (or near the initial guess if the guess is a number).  If
23743 the initial guess is a complex number the variable will be minimized
23744 over the complex numbers; if it is real or an interval it will
23745 be minimized over the reals.
23747 @node Numerical Systems of Equations, , Minimization, Numerical Solutions
23748 @subsection Systems of Equations
23750 @noindent
23751 @cindex Systems of equations, numerical
23752 The @kbd{a R} command can also solve systems of equations.  In this
23753 case, the equation should instead be a vector of equations, the
23754 guess should instead be a vector of numbers (intervals are not
23755 supported), and the variable should be a vector of variables.  You
23756 can omit the brackets while entering the list of variables.  Each
23757 equation must be differentiable by each variable for this mode to
23758 work.  The result will be a vector of two vectors:  The variable
23759 values that solved the system of equations, and the differences
23760 between the sides of the equations with those variable values.
23761 There must be the same number of equations as variables.  Since
23762 only plain numbers are allowed as guesses, the Hyperbolic flag has
23763 no effect when solving a system of equations.
23765 It is also possible to minimize over many variables with @kbd{a N}
23766 (or maximize with @kbd{a X}).  Once again the variable name should
23767 be replaced by a vector of variables, and the initial guess should
23768 be an equal-sized vector of initial guesses.  But, unlike the case of
23769 multidimensional @kbd{a R}, the formula being minimized should
23770 still be a single formula, @emph{not} a vector.  Beware that
23771 multidimensional minimization is currently @emph{very} slow.
23773 @node Curve Fitting, Summations, Numerical Solutions, Algebra
23774 @section Curve Fitting
23776 @noindent
23777 The @kbd{a F} command fits a set of data to a @dfn{model formula},
23778 such as @cite{y = m x + b} where @cite{m} and @cite{b} are parameters
23779 to be determined.  For a typical set of measured data there will be
23780 no single @cite{m} and @cite{b} that exactly fit the data; in this
23781 case, Calc chooses values of the parameters that provide the closest
23782 possible fit.
23784 @menu
23785 * Linear Fits::
23786 * Polynomial and Multilinear Fits::
23787 * Error Estimates for Fits::
23788 * Standard Nonlinear Models::
23789 * Curve Fitting Details::
23790 * Interpolation::
23791 @end menu
23793 @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
23794 @subsection Linear Fits
23796 @noindent
23797 @kindex a F
23798 @pindex calc-curve-fit
23799 @tindex fit
23800 @cindex Linear regression
23801 @cindex Least-squares fits
23802 The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
23803 to fit a set of data (@cite{x} and @cite{y} vectors of numbers) to a
23804 straight line, polynomial, or other function of @cite{x}.  For the
23805 moment we will consider only the case of fitting to a line, and we
23806 will ignore the issue of whether or not the model was in fact a good
23807 fit for the data.
23809 In a standard linear least-squares fit, we have a set of @cite{(x,y)}
23810 data points that we wish to fit to the model @cite{y = m x + b}
23811 by adjusting the parameters @cite{m} and @cite{b} to make the @cite{y}
23812 values calculated from the formula be as close as possible to the actual
23813 @cite{y} values in the data set.  (In a polynomial fit, the model is
23814 instead, say, @cite{y = a x^3 + b x^2 + c x + d}.  In a multilinear fit,
23815 we have data points of the form @cite{(x_1,x_2,x_3,y)} and our model is
23816 @cite{y = a x_1 + b x_2 + c x_3 + d}.  These will be discussed later.)
23818 In the model formula, variables like @cite{x} and @cite{x_2} are called
23819 the @dfn{independent variables}, and @cite{y} is the @dfn{dependent
23820 variable}.  Variables like @cite{m}, @cite{a}, and @cite{b} are called
23821 the @dfn{parameters} of the model.
23823 The @kbd{a F} command takes the data set to be fitted from the stack.
23824 By default, it expects the data in the form of a matrix.  For example,
23825 for a linear or polynomial fit, this would be a @c{$2\times N$}
23826 @asis{2xN} matrix where
23827 the first row is a list of @cite{x} values and the second row has the
23828 corresponding @cite{y} values.  For the multilinear fit shown above,
23829 the matrix would have four rows (@cite{x_1}, @cite{x_2}, @cite{x_3}, and
23830 @cite{y}, respectively).
23832 If you happen to have an @c{$N\times2$}
23833 @asis{Nx2} matrix instead of a @c{$2\times N$}
23834 @asis{2xN} matrix,
23835 just press @kbd{v t} first to transpose the matrix.
23837 After you type @kbd{a F}, Calc prompts you to select a model.  For a
23838 linear fit, press the digit @kbd{1}.
23840 Calc then prompts for you to name the variables.  By default it chooses
23841 high letters like @cite{x} and @cite{y} for independent variables and
23842 low letters like @cite{a} and @cite{b} for parameters.  (The dependent
23843 variable doesn't need a name.)  The two kinds of variables are separated
23844 by a semicolon.  Since you generally care more about the names of the
23845 independent variables than of the parameters, Calc also allows you to
23846 name only those and let the parameters use default names.
23848 For example, suppose the data matrix
23850 @ifinfo
23851 @example
23852 @group
23853 [ [ 1, 2, 3, 4,  5  ]
23854   [ 5, 7, 9, 11, 13 ] ]
23855 @end group
23856 @end example
23857 @end ifinfo
23858 @tex
23859 \turnoffactive
23860 \turnoffactive
23861 \beforedisplay
23862 $$ \pmatrix{ 1 & 2 & 3 & 4  & 5  \cr
23863              5 & 7 & 9 & 11 & 13 }
23865 \afterdisplay
23866 @end tex
23868 @noindent
23869 is on the stack and we wish to do a simple linear fit.  Type
23870 @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
23871 the default names.  The result will be the formula @cite{3 + 2 x}
23872 on the stack.  Calc has created the model expression @kbd{a + b x},
23873 then found the optimal values of @cite{a} and @cite{b} to fit the
23874 data.  (In this case, it was able to find an exact fit.)  Calc then
23875 substituted those values for @cite{a} and @cite{b} in the model
23876 formula.
23878 The @kbd{a F} command puts two entries in the trail.  One is, as
23879 always, a copy of the result that went to the stack; the other is
23880 a vector of the actual parameter values, written as equations:
23881 @cite{[a = 3, b = 2]}, in case you'd rather read them in a list
23882 than pick them out of the formula.  (You can type @kbd{t y}
23883 to move this vector to the stack; see @ref{Trail Commands}.
23885 Specifying a different independent variable name will affect the
23886 resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
23887 Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
23888 the equations that go into the trail.
23890 @tex
23891 \bigskip
23892 @end tex
23894 To see what happens when the fit is not exact, we could change
23895 the number 13 in the data matrix to 14 and try the fit again.
23896 The result is:
23898 @example
23899 2.6 + 2.2 x
23900 @end example
23902 Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
23903 a reasonably close match to the y-values in the data.
23905 @example
23906 [4.8, 7., 9.2, 11.4, 13.6]
23907 @end example
23909 Since there is no line which passes through all the @var{n} data points,
23910 Calc has chosen a line that best approximates the data points using
23911 the method of least squares.  The idea is to define the @dfn{chi-square}
23912 error measure
23914 @ifinfo
23915 @example
23916 chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
23917 @end example
23918 @end ifinfo
23919 @tex
23920 \turnoffactive
23921 \beforedisplay
23922 $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
23923 \afterdisplay
23924 @end tex
23926 @noindent
23927 which is clearly zero if @cite{a + b x} exactly fits all data points,
23928 and increases as various @cite{a + b x_i} values fail to match the
23929 corresponding @cite{y_i} values.  There are several reasons why the
23930 summand is squared, one of them being to ensure that @c{$\chi^2 \ge 0$}
23931 @cite{chi^2 >= 0}.
23932 Least-squares fitting simply chooses the values of @cite{a} and @cite{b}
23933 for which the error @c{$\chi^2$}
23934 @cite{chi^2} is as small as possible.
23936 Other kinds of models do the same thing but with a different model
23937 formula in place of @cite{a + b x_i}.
23939 @tex
23940 \bigskip
23941 @end tex
23943 A numeric prefix argument causes the @kbd{a F} command to take the
23944 data in some other form than one big matrix.  A positive argument @var{n}
23945 will take @var{N} items from the stack, corresponding to the @var{n} rows
23946 of a data matrix.  In the linear case, @var{n} must be 2 since there
23947 is always one independent variable and one dependent variable.
23949 A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
23950 items from the stack, an @var{n}-row matrix of @cite{x} values, and a
23951 vector of @cite{y} values.  If there is only one independent variable,
23952 the @cite{x} values can be either a one-row matrix or a plain vector,
23953 in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
23955 @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
23956 @subsection Polynomial and Multilinear Fits
23958 @noindent
23959 To fit the data to higher-order polynomials, just type one of the
23960 digits @kbd{2} through @kbd{9} when prompted for a model.  For example,
23961 we could fit the original data matrix from the previous section
23962 (with 13, not 14) to a parabola instead of a line by typing
23963 @kbd{a F 2 @key{RET}}.
23965 @example
23966 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
23967 @end example
23969 Note that since the constant and linear terms are enough to fit the
23970 data exactly, it's no surprise that Calc chose a tiny contribution
23971 for @cite{x^2}.  (The fact that it's not exactly zero is due only
23972 to roundoff error.  Since our data are exact integers, we could get
23973 an exact answer by typing @kbd{m f} first to get fraction mode.
23974 Then the @cite{x^2} term would vanish altogether.  Usually, though,
23975 the data being fitted will be approximate floats so fraction mode
23976 won't help.)
23978 Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
23979 gives a much larger @cite{x^2} contribution, as Calc bends the
23980 line slightly to improve the fit.
23982 @example
23983 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
23984 @end example
23986 An important result from the theory of polynomial fitting is that it
23987 is always possible to fit @var{n} data points exactly using a polynomial
23988 of degree @i{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
23989 Using the modified (14) data matrix, a model number of 4 gives
23990 a polynomial that exactly matches all five data points:
23992 @example
23993 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
23994 @end example
23996 The actual coefficients we get with a precision of 12, like
23997 @cite{0.0416666663588}, clearly suffer from loss of precision.
23998 It is a good idea to increase the working precision to several
23999 digits beyond what you need when you do a fitting operation.
24000 Or, if your data are exact, use fraction mode to get exact
24001 results.
24003 You can type @kbd{i} instead of a digit at the model prompt to fit
24004 the data exactly to a polynomial.  This just counts the number of
24005 columns of the data matrix to choose the degree of the polynomial
24006 automatically.
24008 Fitting data ``exactly'' to high-degree polynomials is not always
24009 a good idea, though.  High-degree polynomials have a tendency to
24010 wiggle uncontrollably in between the fitting data points.  Also,
24011 if the exact-fit polynomial is going to be used to interpolate or
24012 extrapolate the data, it is numerically better to use the @kbd{a p}
24013 command described below.  @xref{Interpolation}.
24015 @tex
24016 \bigskip
24017 @end tex
24019 Another generalization of the linear model is to assume the
24020 @cite{y} values are a sum of linear contributions from several
24021 @cite{x} values.  This is a @dfn{multilinear} fit, and it is also
24022 selected by the @kbd{1} digit key.  (Calc decides whether the fit
24023 is linear or multilinear by counting the rows in the data matrix.)
24025 Given the data matrix,
24027 @example
24028 @group
24029 [ [  1,   2,   3,    4,   5  ]
24030   [  7,   2,   3,    5,   2  ]
24031   [ 14.5, 15, 18.5, 22.5, 24 ] ]
24032 @end group
24033 @end example
24035 @noindent
24036 the command @kbd{a F 1 @key{RET}} will call the first row @cite{x} and the
24037 second row @cite{y}, and will fit the values in the third row to the
24038 model @cite{a + b x + c y}.
24040 @example
24041 8. + 3. x + 0.5 y
24042 @end example
24044 Calc can do multilinear fits with any number of independent variables
24045 (i.e., with any number of data rows).
24047 @tex
24048 \bigskip
24049 @end tex
24051 Yet another variation is @dfn{homogeneous} linear models, in which
24052 the constant term is known to be zero.  In the linear case, this
24053 means the model formula is simply @cite{a x}; in the multilinear
24054 case, the model might be @cite{a x + b y + c z}; and in the polynomial
24055 case, the model could be @cite{a x + b x^2 + c x^3}.  You can get
24056 a homogeneous linear or multilinear model by pressing the letter
24057 @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
24059 It is certainly possible to have other constrained linear models,
24060 like @cite{2.3 + a x} or @cite{a - 4 x}.  While there is no single
24061 key to select models like these, a later section shows how to enter
24062 any desired model by hand.  In the first case, for example, you
24063 would enter @kbd{a F ' 2.3 + a x}.
24065 Another class of models that will work but must be entered by hand
24066 are multinomial fits, e.g., @cite{a + b x + c y + d x^2 + e y^2 + f x y}.
24068 @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
24069 @subsection Error Estimates for Fits
24071 @noindent
24072 @kindex H a F
24073 @tindex efit
24074 With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
24075 fitting operation as @kbd{a F}, but reports the coefficients as error
24076 forms instead of plain numbers.  Fitting our two data matrices (first
24077 with 13, then with 14) to a line with @kbd{H a F} gives the results,
24079 @example
24080 3. + 2. x
24081 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
24082 @end example
24084 In the first case the estimated errors are zero because the linear
24085 fit is perfect.  In the second case, the errors are nonzero but
24086 moderately small, because the data are still very close to linear.
24088 It is also possible for the @emph{input} to a fitting operation to
24089 contain error forms.  The data values must either all include errors
24090 or all be plain numbers.  Error forms can go anywhere but generally
24091 go on the numbers in the last row of the data matrix.  If the last
24092 row contains error forms
24093 `@var{y_i}@w{ @t{+/-} }@c{$\sigma_i$}
24094 @var{sigma_i}', then the @c{$\chi^2$}
24095 @cite{chi^2}
24096 statistic is now,
24098 @ifinfo
24099 @example
24100 chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
24101 @end example
24102 @end ifinfo
24103 @tex
24104 \turnoffactive
24105 \beforedisplay
24106 $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
24107 \afterdisplay
24108 @end tex
24110 @noindent
24111 so that data points with larger error estimates contribute less to
24112 the fitting operation.
24114 If there are error forms on other rows of the data matrix, all the
24115 errors for a given data point are combined; the square root of the
24116 sum of the squares of the errors forms the @c{$\sigma_i$}
24117 @cite{sigma_i} used for
24118 the data point.
24120 Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
24121 matrix, although if you are concerned about error analysis you will
24122 probably use @kbd{H a F} so that the output also contains error
24123 estimates.
24125 If the input contains error forms but all the @c{$\sigma_i$}
24126 @cite{sigma_i} values are
24127 the same, it is easy to see that the resulting fitted model will be
24128 the same as if the input did not have error forms at all (@c{$\chi^2$}
24129 @cite{chi^2}
24130 is simply scaled uniformly by @c{$1 / \sigma^2$}
24131 @cite{1 / sigma^2}, which doesn't affect
24132 where it has a minimum).  But there @emph{will} be a difference
24133 in the estimated errors of the coefficients reported by @kbd{H a F}.
24135 Consult any text on statistical modeling of data for a discussion
24136 of where these error estimates come from and how they should be
24137 interpreted.
24139 @tex
24140 \bigskip
24141 @end tex
24143 @kindex I a F
24144 @tindex xfit
24145 With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
24146 information.  The result is a vector of six items:
24148 @enumerate
24149 @item
24150 The model formula with error forms for its coefficients or
24151 parameters.  This is the result that @kbd{H a F} would have
24152 produced.
24154 @item
24155 A vector of ``raw'' parameter values for the model.  These are the
24156 polynomial coefficients or other parameters as plain numbers, in the
24157 same order as the parameters appeared in the final prompt of the
24158 @kbd{I a F} command.  For polynomials of degree @cite{d}, this vector
24159 will have length @cite{M = d+1} with the constant term first.
24161 @item
24162 The covariance matrix @cite{C} computed from the fit.  This is
24163 an @var{m}x@var{m} symmetric matrix; the diagonal elements
24164 @c{$C_{jj}$}
24165 @cite{C_j_j} are the variances @c{$\sigma_j^2$}
24166 @cite{sigma_j^2} of the parameters.
24167 The other elements are covariances @c{$\sigma_{ij}^2$}
24168 @cite{sigma_i_j^2} that describe the
24169 correlation between pairs of parameters.  (A related set of
24170 numbers, the @dfn{linear correlation coefficients} @c{$r_{ij}$}
24171 @cite{r_i_j},
24172 are defined as @c{$\sigma_{ij}^2 / \sigma_i \, \sigma_j$}
24173 @cite{sigma_i_j^2 / sigma_i sigma_j}.)
24175 @item
24176 A vector of @cite{M} ``parameter filter'' functions whose
24177 meanings are described below.  If no filters are necessary this
24178 will instead be an empty vector; this is always the case for the
24179 polynomial and multilinear fits described so far.
24181 @item
24182 The value of @c{$\chi^2$}
24183 @cite{chi^2} for the fit, calculated by the formulas
24184 shown above.  This gives a measure of the quality of the fit;
24185 statisticians consider @c{$\chi^2 \approx N - M$}
24186 @cite{chi^2 = N - M} to indicate a moderately good fit
24187 (where again @cite{N} is the number of data points and @cite{M}
24188 is the number of parameters).
24190 @item
24191 A measure of goodness of fit expressed as a probability @cite{Q}.
24192 This is computed from the @code{utpc} probability distribution
24193 function using @c{$\chi^2$}
24194 @cite{chi^2} with @cite{N - M} degrees of freedom.  A
24195 value of 0.5 implies a good fit; some texts recommend that often
24196 @cite{Q = 0.1} or even 0.001 can signify an acceptable fit.  In
24197 particular, @c{$\chi^2$}
24198 @cite{chi^2} statistics assume the errors in your inputs
24199 follow a normal (Gaussian) distribution; if they don't, you may
24200 have to accept smaller values of @cite{Q}.
24202 The @cite{Q} value is computed only if the input included error
24203 estimates.  Otherwise, Calc will report the symbol @code{nan}
24204 for @cite{Q}.  The reason is that in this case the @c{$\chi^2$}
24205 @cite{chi^2}
24206 value has effectively been used to estimate the original errors
24207 in the input, and thus there is no redundant information left
24208 over to use for a confidence test.
24209 @end enumerate
24211 @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
24212 @subsection Standard Nonlinear Models
24214 @noindent
24215 The @kbd{a F} command also accepts other kinds of models besides
24216 lines and polynomials.  Some common models have quick single-key
24217 abbreviations; others must be entered by hand as algebraic formulas.
24219 Here is a complete list of the standard models recognized by @kbd{a F}:
24221 @table @kbd
24222 @item 1
24223 Linear or multilinear.  @i{a + b x + c y + d z}.
24224 @item 2-9
24225 Polynomials.  @i{a + b x + c x^2 + d x^3}.
24226 @item e
24227 Exponential.  @i{a} @t{exp}@i{(b x)} @t{exp}@i{(c y)}.
24228 @item E
24229 Base-10 exponential.  @i{a} @t{10^}@i{(b x)} @t{10^}@i{(c y)}.
24230 @item x
24231 Exponential (alternate notation).  @t{exp}@i{(a + b x + c y)}.
24232 @item X
24233 Base-10 exponential (alternate).  @t{10^}@i{(a + b x + c y)}.
24234 @item l
24235 Logarithmic.  @i{a + b} @t{ln}@i{(x) + c} @t{ln}@i{(y)}.
24236 @item L
24237 Base-10 logarithmic.  @i{a + b} @t{log10}@i{(x) + c} @t{log10}@i{(y)}.
24238 @item ^
24239 General exponential.  @i{a b^x c^y}.
24240 @item p
24241 Power law.  @i{a x^b y^c}.
24242 @item q
24243 Quadratic.  @i{a + b (x-c)^2 + d (x-e)^2}.
24244 @item g
24245 Gaussian.  @c{${a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)$}
24246 @i{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
24247 @end table
24249 All of these models are used in the usual way; just press the appropriate
24250 letter at the model prompt, and choose variable names if you wish.  The
24251 result will be a formula as shown in the above table, with the best-fit
24252 values of the parameters substituted.  (You may find it easier to read
24253 the parameter values from the vector that is placed in the trail.)
24255 All models except Gaussian and polynomials can generalize as shown to any
24256 number of independent variables.  Also, all the built-in models have an
24257 additive or multiplicative parameter shown as @cite{a} in the above table
24258 which can be replaced by zero or one, as appropriate, by typing @kbd{h}
24259 before the model key.
24261 Note that many of these models are essentially equivalent, but express
24262 the parameters slightly differently.  For example, @cite{a b^x} and
24263 the other two exponential models are all algebraic rearrangements of
24264 each other.  Also, the ``quadratic'' model is just a degree-2 polynomial
24265 with the parameters expressed differently.  Use whichever form best
24266 matches the problem.
24268 The HP-28/48 calculators support four different models for curve
24269 fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
24270 These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
24271 @samp{a exp(b x)}, and @samp{a x^b}, respectively.  In each case,
24272 @cite{a} is what the HP-48 identifies as the ``intercept,'' and
24273 @cite{b} is what it calls the ``slope.''
24275 @tex
24276 \bigskip
24277 @end tex
24279 If the model you want doesn't appear on this list, press @kbd{'}
24280 (the apostrophe key) at the model prompt to enter any algebraic
24281 formula, such as @kbd{m x - b}, as the model.  (Not all models
24282 will work, though---see the next section for details.)
24284 The model can also be an equation like @cite{y = m x + b}.
24285 In this case, Calc thinks of all the rows of the data matrix on
24286 equal terms; this model effectively has two parameters
24287 (@cite{m} and @cite{b}) and two independent variables (@cite{x}
24288 and @cite{y}), with no ``dependent'' variables.  Model equations
24289 do not need to take this @cite{y =} form.  For example, the
24290 implicit line equation @cite{a x + b y = 1} works fine as a
24291 model.
24293 When you enter a model, Calc makes an alphabetical list of all
24294 the variables that appear in the model.  These are used for the
24295 default parameters, independent variables, and dependent variable
24296 (in that order).  If you enter a plain formula (not an equation),
24297 Calc assumes the dependent variable does not appear in the formula
24298 and thus does not need a name.
24300 For example, if the model formula has the variables @cite{a,mu,sigma,t,x},
24301 and the data matrix has three rows (meaning two independent variables),
24302 Calc will use @cite{a,mu,sigma} as the default parameters, and the
24303 data rows will be named @cite{t} and @cite{x}, respectively.  If you
24304 enter an equation instead of a plain formula, Calc will use @cite{a,mu}
24305 as the parameters, and @cite{sigma,t,x} as the three independent
24306 variables.
24308 You can, of course, override these choices by entering something
24309 different at the prompt.  If you leave some variables out of the list,
24310 those variables must have stored values and those stored values will
24311 be used as constants in the model.  (Stored values for the parameters
24312 and independent variables are ignored by the @kbd{a F} command.)
24313 If you list only independent variables, all the remaining variables
24314 in the model formula will become parameters.
24316 If there are @kbd{$} signs in the model you type, they will stand
24317 for parameters and all other variables (in alphabetical order)
24318 will be independent.  Use @kbd{$} for one parameter, @kbd{$$} for
24319 another, and so on.  Thus @kbd{$ x + $$} is another way to describe
24320 a linear model.
24322 If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
24323 Calc will take the model formula from the stack.  (The data must then
24324 appear at the second stack level.)  The same conventions are used to
24325 choose which variables in the formula are independent by default and
24326 which are parameters.
24328 Models taken from the stack can also be expressed as vectors of
24329 two or three elements, @cite{[@var{model}, @var{vars}]} or
24330 @cite{[@var{model}, @var{vars}, @var{params}]}.  Each of @var{vars}
24331 and @var{params} may be either a variable or a vector of variables.
24332 (If @var{params} is omitted, all variables in @var{model} except
24333 those listed as @var{vars} are parameters.)@refill
24335 When you enter a model manually with @kbd{'}, Calc puts a 3-vector
24336 describing the model in the trail so you can get it back if you wish.
24338 @tex
24339 \bigskip
24340 @end tex
24342 @vindex Model1
24343 @vindex Model2
24344 Finally, you can store a model in one of the Calc variables
24345 @code{Model1} or @code{Model2}, then use this model by typing
24346 @kbd{a F u} or @kbd{a F U} (respectively).  The value stored in
24347 the variable can be any of the formats that @kbd{a F $} would
24348 accept for a model on the stack.
24350 @tex
24351 \bigskip
24352 @end tex
24354 Calc uses the principal values of inverse functions like @code{ln}
24355 and @code{arcsin} when doing fits.  For example, when you enter
24356 the model @samp{y = sin(a t + b)} Calc actually uses the easier
24357 form @samp{arcsin(y) = a t + b}.  The @code{arcsin} function always
24358 returns results in the range from @i{-90} to 90 degrees (or the
24359 equivalent range in radians).  Suppose you had data that you
24360 believed to represent roughly three oscillations of a sine wave,
24361 so that the argument of the sine might go from zero to @c{$3\times360$}
24362 @i{3*360} degrees.
24363 The above model would appear to be a good way to determine the
24364 true frequency and phase of the sine wave, but in practice it
24365 would fail utterly.  The righthand side of the actual model
24366 @samp{arcsin(y) = a t + b} will grow smoothly with @cite{t}, but
24367 the lefthand side will bounce back and forth between @i{-90} and 90.
24368 No values of @cite{a} and @cite{b} can make the two sides match,
24369 even approximately.
24371 There is no good solution to this problem at present.  You could
24372 restrict your data to small enough ranges so that the above problem
24373 doesn't occur (i.e., not straddling any peaks in the sine wave).
24374 Or, in this case, you could use a totally different method such as
24375 Fourier analysis, which is beyond the scope of the @kbd{a F} command.
24376 (Unfortunately, Calc does not currently have any facilities for
24377 taking Fourier and related transforms.)
24379 @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
24380 @subsection Curve Fitting Details
24382 @noindent
24383 Calc's internal least-squares fitter can only handle multilinear
24384 models.  More precisely, it can handle any model of the form
24385 @cite{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @cite{a,b,c}
24386 are the parameters and @cite{x,y,z} are the independent variables
24387 (of course there can be any number of each, not just three).
24389 In a simple multilinear or polynomial fit, it is easy to see how
24390 to convert the model into this form.  For example, if the model
24391 is @cite{a + b x + c x^2}, then @cite{f(x) = 1}, @cite{g(x) = x},
24392 and @cite{h(x) = x^2} are suitable functions.
24394 For other models, Calc uses a variety of algebraic manipulations
24395 to try to put the problem into the form
24397 @smallexample
24398 Y(x,y,z) = A(a,b,c) F(x,y,z) + B(a,b,c) G(x,y,z) + C(a,b,c) H(x,y,z)
24399 @end smallexample
24401 @noindent
24402 where @cite{Y,A,B,C,F,G,H} are arbitrary functions.  It computes
24403 @cite{Y}, @cite{F}, @cite{G}, and @cite{H} for all the data points,
24404 does a standard linear fit to find the values of @cite{A}, @cite{B},
24405 and @cite{C}, then uses the equation solver to solve for @cite{a,b,c}
24406 in terms of @cite{A,B,C}.
24408 A remarkable number of models can be cast into this general form.
24409 We'll look at two examples here to see how it works.  The power-law
24410 model @cite{y = a x^b} with two independent variables and two parameters
24411 can be rewritten as follows:
24413 @example
24414 y = a x^b
24415 y = a exp(b ln(x))
24416 y = exp(ln(a) + b ln(x))
24417 ln(y) = ln(a) + b ln(x)
24418 @end example
24420 @noindent
24421 which matches the desired form with @c{$Y = \ln(y)$}
24422 @cite{Y = ln(y)}, @c{$A = \ln(a)$}
24423 @cite{A = ln(a)},
24424 @cite{F = 1}, @cite{B = b}, and @c{$G = \ln(x)$}
24425 @cite{G = ln(x)}.  Calc thus computes
24426 the logarithms of your @cite{y} and @cite{x} values, does a linear fit
24427 for @cite{A} and @cite{B}, then solves to get @c{$a = \exp(A)$}
24428 @cite{a = exp(A)} and
24429 @cite{b = B}.
24431 Another interesting example is the ``quadratic'' model, which can
24432 be handled by expanding according to the distributive law.
24434 @example
24435 y = a + b*(x - c)^2
24436 y = a + b c^2 - 2 b c x + b x^2
24437 @end example
24439 @noindent
24440 which matches with @cite{Y = y}, @cite{A = a + b c^2}, @cite{F = 1},
24441 @cite{B = -2 b c}, @cite{G = x} (the @i{-2} factor could just as easily
24442 have been put into @cite{G} instead of @cite{B}), @cite{C = b}, and
24443 @cite{H = x^2}.
24445 The Gaussian model looks quite complicated, but a closer examination
24446 shows that it's actually similar to the quadratic model but with an
24447 exponential that can be brought to the top and moved into @cite{Y}.
24449 An example of a model that cannot be put into general linear
24450 form is a Gaussian with a constant background added on, i.e.,
24451 @cite{d} + the regular Gaussian formula.  If you have a model like
24452 this, your best bet is to replace enough of your parameters with
24453 constants to make the model linearizable, then adjust the constants
24454 manually by doing a series of fits.  You can compare the fits by
24455 graphing them, by examining the goodness-of-fit measures returned by
24456 @kbd{I a F}, or by some other method suitable to your application.
24457 Note that some models can be linearized in several ways.  The
24458 Gaussian-plus-@var{d} model can be linearized by setting @cite{d}
24459 (the background) to a constant, or by setting @cite{b} (the standard
24460 deviation) and @cite{c} (the mean) to constants.
24462 To fit a model with constants substituted for some parameters, just
24463 store suitable values in those parameter variables, then omit them
24464 from the list of parameters when you answer the variables prompt.
24466 @tex
24467 \bigskip
24468 @end tex
24470 A last desperate step would be to use the general-purpose
24471 @code{minimize} function rather than @code{fit}.  After all, both
24472 functions solve the problem of minimizing an expression (the @c{$\chi^2$}
24473 @cite{chi^2}
24474 sum) by adjusting certain parameters in the expression.  The @kbd{a F}
24475 command is able to use a vastly more efficient algorithm due to its
24476 special knowledge about linear chi-square sums, but the @kbd{a N}
24477 command can do the same thing by brute force.
24479 A compromise would be to pick out a few parameters without which the
24480 fit is linearizable, and use @code{minimize} on a call to @code{fit}
24481 which efficiently takes care of the rest of the parameters.  The thing
24482 to be minimized would be the value of @c{$\chi^2$}
24483 @cite{chi^2} returned as
24484 the fifth result of the @code{xfit} function:
24486 @smallexample
24487 minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
24488 @end smallexample
24490 @noindent
24491 where @code{gaus} represents the Gaussian model with background,
24492 @code{data} represents the data matrix, and @code{guess} represents
24493 the initial guess for @cite{d} that @code{minimize} requires.
24494 This operation will only be, shall we say, extraordinarily slow
24495 rather than astronomically slow (as would be the case if @code{minimize}
24496 were used by itself to solve the problem).
24498 @tex
24499 \bigskip
24500 @end tex
24502 The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
24503 nonlinear models are used.  The second item in the result is the
24504 vector of ``raw'' parameters @cite{A}, @cite{B}, @cite{C}.  The
24505 covariance matrix is written in terms of those raw parameters.
24506 The fifth item is a vector of @dfn{filter} expressions.  This
24507 is the empty vector @samp{[]} if the raw parameters were the same
24508 as the requested parameters, i.e., if @cite{A = a}, @cite{B = b},
24509 and so on (which is always true if the model is already linear
24510 in the parameters as written, e.g., for polynomial fits).  If the
24511 parameters had to be rearranged, the fifth item is instead a vector
24512 of one formula per parameter in the original model.  The raw
24513 parameters are expressed in these ``filter'' formulas as
24514 @samp{fitdummy(1)} for @cite{A}, @samp{fitdummy(2)} for @cite{B},
24515 and so on.
24517 When Calc needs to modify the model to return the result, it replaces
24518 @samp{fitdummy(1)} in all the filters with the first item in the raw
24519 parameters list, and so on for the other raw parameters, then
24520 evaluates the resulting filter formulas to get the actual parameter
24521 values to be substituted into the original model.  In the case of
24522 @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
24523 Calc uses the square roots of the diagonal entries of the covariance
24524 matrix as error values for the raw parameters, then lets Calc's
24525 standard error-form arithmetic take it from there.
24527 If you use @kbd{I a F} with a nonlinear model, be sure to remember
24528 that the covariance matrix is in terms of the raw parameters,
24529 @emph{not} the actual requested parameters.  It's up to you to
24530 figure out how to interpret the covariances in the presence of
24531 nontrivial filter functions.
24533 Things are also complicated when the input contains error forms.
24534 Suppose there are three independent and dependent variables, @cite{x},
24535 @cite{y}, and @cite{z}, one or more of which are error forms in the
24536 data.  Calc combines all the error values by taking the square root
24537 of the sum of the squares of the errors.  It then changes @cite{x}
24538 and @cite{y} to be plain numbers, and makes @cite{z} into an error
24539 form with this combined error.  The @cite{Y(x,y,z)} part of the
24540 linearized model is evaluated, and the result should be an error
24541 form.  The error part of that result is used for @c{$\sigma_i$}
24542 @cite{sigma_i} for
24543 the data point.  If for some reason @cite{Y(x,y,z)} does not return
24544 an error form, the combined error from @cite{z} is used directly
24545 for @c{$\sigma_i$}
24546 @cite{sigma_i}.  Finally, @cite{z} is also stripped of its error
24547 for use in computing @cite{F(x,y,z)}, @cite{G(x,y,z)} and so on;
24548 the righthand side of the linearized model is computed in regular
24549 arithmetic with no error forms.
24551 (While these rules may seem complicated, they are designed to do
24552 the most reasonable thing in the typical case that @cite{Y(x,y,z)}
24553 depends only on the dependent variable @cite{z}, and in fact is
24554 often simply equal to @cite{z}.  For common cases like polynomials
24555 and multilinear models, the combined error is simply used as the
24556 @c{$\sigma$}
24557 @cite{sigma} for the data point with no further ado.)
24559 @tex
24560 \bigskip
24561 @end tex
24563 @vindex FitRules
24564 It may be the case that the model you wish to use is linearizable,
24565 but Calc's built-in rules are unable to figure it out.  Calc uses
24566 its algebraic rewrite mechanism to linearize a model.  The rewrite
24567 rules are kept in the variable @code{FitRules}.  You can edit this
24568 variable using the @kbd{s e FitRules} command; in fact, there is
24569 a special @kbd{s F} command just for editing @code{FitRules}.
24570 @xref{Operations on Variables}.
24572 @xref{Rewrite Rules}, for a discussion of rewrite rules.
24574 @ignore
24575 @starindex
24576 @end ignore
24577 @tindex fitvar
24578 @ignore
24579 @starindex
24580 @end ignore
24581 @ignore
24582 @mindex @idots
24583 @end ignore
24584 @tindex fitparam
24585 @ignore
24586 @starindex
24587 @end ignore
24588 @ignore
24589 @mindex @null
24590 @end ignore
24591 @tindex fitmodel
24592 @ignore
24593 @starindex
24594 @end ignore
24595 @ignore
24596 @mindex @null
24597 @end ignore
24598 @tindex fitsystem
24599 @ignore
24600 @starindex
24601 @end ignore
24602 @ignore
24603 @mindex @null
24604 @end ignore
24605 @tindex fitdummy
24606 Calc uses @code{FitRules} as follows.  First, it converts the model
24607 to an equation if necessary and encloses the model equation in a
24608 call to the function @code{fitmodel} (which is not actually a defined
24609 function in Calc; it is only used as a placeholder by the rewrite rules).
24610 Parameter variables are renamed to function calls @samp{fitparam(1)},
24611 @samp{fitparam(2)}, and so on, and independent variables are renamed
24612 to @samp{fitvar(1)}, @samp{fitvar(2)}, etc.  The dependent variable
24613 is the highest-numbered @code{fitvar}.  For example, the power law
24614 model @cite{a x^b} is converted to @cite{y = a x^b}, then to
24616 @smallexample
24617 @group
24618 fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
24619 @end group
24620 @end smallexample
24622 Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
24623 (The zero prefix means that rewriting should continue until no further
24624 changes are possible.)
24626 When rewriting is complete, the @code{fitmodel} call should have
24627 been replaced by a @code{fitsystem} call that looks like this:
24629 @example
24630 fitsystem(@var{Y}, @var{FGH}, @var{abc})
24631 @end example
24633 @noindent
24634 where @var{Y} is a formula that describes the function @cite{Y(x,y,z)},
24635 @var{FGH} is the vector of formulas @cite{[F(x,y,z), G(x,y,z), H(x,y,z)]},
24636 and @var{abc} is the vector of parameter filters which refer to the
24637 raw parameters as @samp{fitdummy(1)} for @cite{A}, @samp{fitdummy(2)}
24638 for @cite{B}, etc.  While the number of raw parameters (the length of
24639 the @var{FGH} vector) is usually the same as the number of original
24640 parameters (the length of the @var{abc} vector), this is not required.
24642 The power law model eventually boils down to
24644 @smallexample
24645 @group
24646 fitsystem(ln(fitvar(2)),
24647           [1, ln(fitvar(1))],
24648           [exp(fitdummy(1)), fitdummy(2)])
24649 @end group
24650 @end smallexample
24652 The actual implementation of @code{FitRules} is complicated; it
24653 proceeds in four phases.  First, common rearrangements are done
24654 to try to bring linear terms together and to isolate functions like
24655 @code{exp} and @code{ln} either all the way ``out'' (so that they
24656 can be put into @var{Y}) or all the way ``in'' (so that they can
24657 be put into @var{abc} or @var{FGH}).  In particular, all
24658 non-constant powers are converted to logs-and-exponentials form,
24659 and the distributive law is used to expand products of sums.
24660 Quotients are rewritten to use the @samp{fitinv} function, where
24661 @samp{fitinv(x)} represents @cite{1/x} while the @code{FitRules}
24662 are operating.  (The use of @code{fitinv} makes recognition of
24663 linear-looking forms easier.)  If you modify @code{FitRules}, you
24664 will probably only need to modify the rules for this phase.
24666 Phase two, whose rules can actually also apply during phases one
24667 and three, first rewrites @code{fitmodel} to a two-argument
24668 form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
24669 initially zero and @var{model} has been changed from @cite{a=b}
24670 to @cite{a-b} form.  It then tries to peel off invertible functions
24671 from the outside of @var{model} and put them into @var{Y} instead,
24672 calling the equation solver to invert the functions.  Finally, when
24673 this is no longer possible, the @code{fitmodel} is changed to a
24674 four-argument @code{fitsystem}, where the fourth argument is
24675 @var{model} and the @var{FGH} and @var{abc} vectors are initially
24676 empty.  (The last vector is really @var{ABC}, corresponding to
24677 raw parameters, for now.)
24679 Phase three converts a sum of items in the @var{model} to a sum
24680 of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
24681 terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
24682 is all factors that do not involve any variables, @var{b} is all
24683 factors that involve only parameters, and @var{c} is the factors
24684 that involve only independent variables.  (If this decomposition
24685 is not possible, the rule set will not complete and Calc will
24686 complain that the model is too complex.)  Then @code{fitpart}s
24687 with equal @var{b} or @var{c} components are merged back together
24688 using the distributive law in order to minimize the number of
24689 raw parameters needed.
24691 Phase four moves the @code{fitpart} terms into the @var{FGH} and
24692 @var{ABC} vectors.  Also, some of the algebraic expansions that
24693 were done in phase 1 are undone now to make the formulas more
24694 computationally efficient.  Finally, it calls the solver one more
24695 time to convert the @var{ABC} vector to an @var{abc} vector, and
24696 removes the fourth @var{model} argument (which by now will be zero)
24697 to obtain the three-argument @code{fitsystem} that the linear
24698 least-squares solver wants to see.
24700 @ignore
24701 @starindex
24702 @end ignore
24703 @ignore
24704 @mindex hasfit@idots
24705 @end ignore
24706 @tindex hasfitparams
24707 @ignore
24708 @starindex
24709 @end ignore
24710 @ignore
24711 @mindex @null
24712 @end ignore
24713 @tindex hasfitvars
24714 Two functions which are useful in connection with @code{FitRules}
24715 are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
24716 whether @cite{x} refers to any parameters or independent variables,
24717 respectively.  Specifically, these functions return ``true'' if the
24718 argument contains any @code{fitparam} (or @code{fitvar}) function
24719 calls, and ``false'' otherwise.  (Recall that ``true'' means a
24720 nonzero number, and ``false'' means zero.  The actual nonzero number
24721 returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
24722 or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
24724 @tex
24725 \bigskip
24726 @end tex
24728 The @code{fit} function in algebraic notation normally takes four
24729 arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
24730 where @var{model} is the model formula as it would be typed after
24731 @kbd{a F '}, @var{vars} is the independent variable or a vector of
24732 independent variables, @var{params} likewise gives the parameter(s),
24733 and @var{data} is the data matrix.  Note that the length of @var{vars}
24734 must be equal to the number of rows in @var{data} if @var{model} is
24735 an equation, or one less than the number of rows if @var{model} is
24736 a plain formula.  (Actually, a name for the dependent variable is
24737 allowed but will be ignored in the plain-formula case.)
24739 If @var{params} is omitted, the parameters are all variables in
24740 @var{model} except those that appear in @var{vars}.  If @var{vars}
24741 is also omitted, Calc sorts all the variables that appear in
24742 @var{model} alphabetically and uses the higher ones for @var{vars}
24743 and the lower ones for @var{params}.
24745 Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
24746 where @var{modelvec} is a 2- or 3-vector describing the model
24747 and variables, as discussed previously.
24749 If Calc is unable to do the fit, the @code{fit} function is left
24750 in symbolic form, ordinarily with an explanatory message.  The
24751 message will be ``Model expression is too complex'' if the
24752 linearizer was unable to put the model into the required form.
24754 The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
24755 (for @kbd{I a F}) functions are completely analogous.
24757 @node Interpolation, ,  Curve Fitting Details, Curve Fitting
24758 @subsection Polynomial Interpolation
24760 @kindex a p
24761 @pindex calc-poly-interp
24762 @tindex polint
24763 The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
24764 a polynomial interpolation at a particular @cite{x} value.  It takes
24765 two arguments from the stack:  A data matrix of the sort used by
24766 @kbd{a F}, and a single number which represents the desired @cite{x}
24767 value.  Calc effectively does an exact polynomial fit as if by @kbd{a F i},
24768 then substitutes the @cite{x} value into the result in order to get an
24769 approximate @cite{y} value based on the fit.  (Calc does not actually
24770 use @kbd{a F i}, however; it uses a direct method which is both more
24771 efficient and more numerically stable.)
24773 The result of @kbd{a p} is actually a vector of two values:  The @cite{y}
24774 value approximation, and an error measure @cite{dy} that reflects Calc's
24775 estimation of the probable error of the approximation at that value of
24776 @cite{x}.  If the input @cite{x} is equal to any of the @cite{x} values
24777 in the data matrix, the output @cite{y} will be the corresponding @cite{y}
24778 value from the matrix, and the output @cite{dy} will be exactly zero.
24780 A prefix argument of 2 causes @kbd{a p} to take separate x- and
24781 y-vectors from the stack instead of one data matrix.
24783 If @cite{x} is a vector of numbers, @kbd{a p} will return a matrix of
24784 interpolated results for each of those @cite{x} values.  (The matrix will
24785 have two columns, the @cite{y} values and the @cite{dy} values.)
24786 If @cite{x} is a formula instead of a number, the @code{polint} function
24787 remains in symbolic form; use the @kbd{a "} command to expand it out to
24788 a formula that describes the fit in symbolic terms.
24790 In all cases, the @kbd{a p} command leaves the data vectors or matrix
24791 on the stack.  Only the @cite{x} value is replaced by the result.
24793 @kindex H a p
24794 @tindex ratint
24795 The @kbd{H a p} [@code{ratint}] command does a rational function
24796 interpolation.  It is used exactly like @kbd{a p}, except that it
24797 uses as its model the quotient of two polynomials.  If there are
24798 @cite{N} data points, the numerator and denominator polynomials will
24799 each have degree @cite{N/2} (if @cite{N} is odd, the denominator will
24800 have degree one higher than the numerator).
24802 Rational approximations have the advantage that they can accurately
24803 describe functions that have poles (points at which the function's value
24804 goes to infinity, so that the denominator polynomial of the approximation
24805 goes to zero).  If @cite{x} corresponds to a pole of the fitted rational
24806 function, then the result will be a division by zero.  If Infinite mode
24807 is enabled, the result will be @samp{[uinf, uinf]}.
24809 There is no way to get the actual coefficients of the rational function
24810 used by @kbd{H a p}.  (The algorithm never generates these coefficients
24811 explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
24812 capabilities to fit.)
24814 @node Summations, Logical Operations, Curve Fitting, Algebra
24815 @section Summations
24817 @noindent
24818 @cindex Summation of a series
24819 @kindex a +
24820 @pindex calc-summation
24821 @tindex sum
24822 The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
24823 the sum of a formula over a certain range of index values.  The formula
24824 is taken from the top of the stack; the command prompts for the
24825 name of the summation index variable, the lower limit of the
24826 sum (any formula), and the upper limit of the sum.  If you
24827 enter a blank line at any of these prompts, that prompt and
24828 any later ones are answered by reading additional elements from
24829 the stack.  Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
24830 produces the result 55.
24831 @tex
24832 \turnoffactive
24833 $$ \sum_{k=1}^5 k^2 = 55 $$
24834 @end tex
24836 The choice of index variable is arbitrary, but it's best not to
24837 use a variable with a stored value.  In particular, while
24838 @code{i} is often a favorite index variable, it should be avoided
24839 in Calc because @code{i} has the imaginary constant @cite{(0, 1)}
24840 as a value.  If you pressed @kbd{=} on a sum over @code{i}, it would
24841 be changed to a nonsensical sum over the ``variable'' @cite{(0, 1)}!
24842 If you really want to use @code{i} as an index variable, use
24843 @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
24844 (@xref{Storing Variables}.)
24846 A numeric prefix argument steps the index by that amount rather
24847 than by one.  Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
24848 yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}.  A prefix
24849 argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
24850 step value, in which case you can enter any formula or enter
24851 a blank line to take the step value from the stack.  With the
24852 @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
24853 the stack:  The formula, the variable, the lower limit, the
24854 upper limit, and (at the top of the stack), the step value.
24856 Calc knows how to do certain sums in closed form.  For example,
24857 @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}.  In particular,
24858 this is possible if the formula being summed is polynomial or
24859 exponential in the index variable.  Sums of logarithms are
24860 transformed into logarithms of products.  Sums of trigonometric
24861 and hyperbolic functions are transformed to sums of exponentials
24862 and then done in closed form.  Also, of course, sums in which the
24863 lower and upper limits are both numbers can always be evaluated
24864 just by grinding them out, although Calc will use closed forms
24865 whenever it can for the sake of efficiency.
24867 The notation for sums in algebraic formulas is
24868 @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
24869 If @var{step} is omitted, it defaults to one.  If @var{high} is
24870 omitted, @var{low} is actually the upper limit and the lower limit
24871 is one.  If @var{low} is also omitted, the limits are @samp{-inf}
24872 and @samp{inf}, respectively.
24874 Infinite sums can sometimes be evaluated:  @samp{sum(.5^k, k, 1, inf)}
24875 returns @cite{1}.  This is done by evaluating the sum in closed
24876 form (to @samp{1. - 0.5^n} in this case), then evaluating this
24877 formula with @code{n} set to @code{inf}.  Calc's usual rules
24878 for ``infinite'' arithmetic can find the answer from there.  If
24879 infinite arithmetic yields a @samp{nan}, or if the sum cannot be
24880 solved in closed form, Calc leaves the @code{sum} function in
24881 symbolic form.  @xref{Infinities}.
24883 As a special feature, if the limits are infinite (or omitted, as
24884 described above) but the formula includes vectors subscripted by
24885 expressions that involve the iteration variable, Calc narrows
24886 the limits to include only the range of integers which result in
24887 legal subscripts for the vector.  For example, the sum
24888 @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
24890 The limits of a sum do not need to be integers.  For example,
24891 @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
24892 Calc computes the number of iterations using the formula
24893 @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
24894 after simplification as if by @kbd{a s}, evaluate to an integer.
24896 If the number of iterations according to the above formula does
24897 not come out to an integer, the sum is illegal and will be left
24898 in symbolic form.  However, closed forms are still supplied, and
24899 you are on your honor not to misuse the resulting formulas by
24900 substituting mismatched bounds into them.  For example,
24901 @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
24902 evaluate the closed form solution for the limits 1 and 10 to get
24903 the rather dubious answer, 29.25.
24905 If the lower limit is greater than the upper limit (assuming a
24906 positive step size), the result is generally zero.  However,
24907 Calc only guarantees a zero result when the upper limit is
24908 exactly one step less than the lower limit, i.e., if the number
24909 of iterations is @i{-1}.  Thus @samp{sum(f(k), k, n, n-1)} is zero
24910 but the sum from @samp{n} to @samp{n-2} may report a nonzero value
24911 if Calc used a closed form solution.
24913 Calc's logical predicates like @cite{a < b} return 1 for ``true''
24914 and 0 for ``false.''  @xref{Logical Operations}.  This can be
24915 used to advantage for building conditional sums.  For example,
24916 @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
24917 prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
24918 its argument is prime and 0 otherwise.  You can read this expression
24919 as ``the sum of @cite{k^2}, where @cite{k} is prime.''  Indeed,
24920 @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
24921 squared, since the limits default to plus and minus infinity, but
24922 there are no such sums that Calc's built-in rules can do in
24923 closed form.
24925 As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
24926 sum of @cite{f(k)} for all @cite{k} from 1 to @cite{n}, excluding
24927 one value @cite{k_0}.  Slightly more tricky is the summand
24928 @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
24929 the sum of all @cite{1/(k-k_0)} except at @cite{k = k_0}, where
24930 this would be a division by zero.  But at @cite{k = k_0}, this
24931 formula works out to the indeterminate form @cite{0 / 0}, which
24932 Calc will not assume is zero.  Better would be to use
24933 @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
24934 an ``if-then-else'' test:  This expression says, ``if @c{$k \ne k_0$}
24935 @cite{k != k_0},
24936 then @cite{1/(k-k_0)}, else zero.''  Now the formula @cite{1/(k-k_0)}
24937 will not even be evaluated by Calc when @cite{k = k_0}.
24939 @cindex Alternating sums
24940 @kindex a -
24941 @pindex calc-alt-summation
24942 @tindex asum
24943 The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
24944 computes an alternating sum.  Successive terms of the sequence
24945 are given alternating signs, with the first term (corresponding
24946 to the lower index value) being positive.  Alternating sums
24947 are converted to normal sums with an extra term of the form
24948 @samp{(-1)^(k-@var{low})}.  This formula is adjusted appropriately
24949 if the step value is other than one.  For example, the Taylor
24950 series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
24951 (Calc cannot evaluate this infinite series, but it can approximate
24952 it if you replace @code{inf} with any particular odd number.)
24953 Calc converts this series to a regular sum with a step of one,
24954 namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
24956 @cindex Product of a sequence
24957 @kindex a *
24958 @pindex calc-product
24959 @tindex prod
24960 The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
24961 the analogous way to take a product of many terms.  Calc also knows
24962 some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
24963 Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
24964 or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
24966 @kindex a T
24967 @pindex calc-tabulate
24968 @tindex table
24969 The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
24970 evaluates a formula at a series of iterated index values, just
24971 like @code{sum} and @code{prod}, but its result is simply a
24972 vector of the results.  For example, @samp{table(a_i, i, 1, 7, 2)}
24973 produces @samp{[a_1, a_3, a_5, a_7]}.
24975 @node Logical Operations, Rewrite Rules, Summations, Algebra
24976 @section Logical Operations
24978 @noindent
24979 The following commands and algebraic functions return true/false values,
24980 where 1 represents ``true'' and 0 represents ``false.''  In cases where
24981 a truth value is required (such as for the condition part of a rewrite
24982 rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
24983 nonzero value is accepted to mean ``true.''  (Specifically, anything
24984 for which @code{dnonzero} returns 1 is ``true,'' and anything for
24985 which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
24986 Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
24987 portion if its condition is provably true, but it will execute the
24988 ``else'' portion for any condition like @cite{a = b} that is not
24989 provably true, even if it might be true.  Algebraic functions that
24990 have conditions as arguments, like @code{? :} and @code{&&}, remain
24991 unevaluated if the condition is neither provably true nor provably
24992 false.  @xref{Declarations}.)
24994 @kindex a =
24995 @pindex calc-equal-to
24996 @tindex eq
24997 @tindex =
24998 @tindex ==
24999 The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
25000 (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
25001 formula) is true if @cite{a} and @cite{b} are equal, either because they
25002 are identical expressions, or because they are numbers which are
25003 numerically equal.  (Thus the integer 1 is considered equal to the float
25004 1.0.)  If the equality of @cite{a} and @cite{b} cannot be determined,
25005 the comparison is left in symbolic form.  Note that as a command, this
25006 operation pops two values from the stack and pushes back either a 1 or
25007 a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
25009 Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
25010 For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
25011 an equation to solve for a given variable.  The @kbd{a M}
25012 (@code{calc-map-equation}) command can be used to apply any
25013 function to both sides of an equation; for example, @kbd{2 a M *}
25014 multiplies both sides of the equation by two.  Note that just
25015 @kbd{2 *} would not do the same thing; it would produce the formula
25016 @samp{2 (a = b)} which represents 2 if the equality is true or
25017 zero if not.
25019 The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
25020 or @samp{a = b = c}) tests if all of its arguments are equal.  In
25021 algebraic notation, the @samp{=} operator is unusual in that it is
25022 neither left- nor right-associative:  @samp{a = b = c} is not the
25023 same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
25024 one variable with the 1 or 0 that results from comparing two other
25025 variables).
25027 @kindex a #
25028 @pindex calc-not-equal-to
25029 @tindex neq
25030 @tindex !=
25031 The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
25032 @samp{a != b} function, is true if @cite{a} and @cite{b} are not equal.
25033 This also works with more than two arguments; @samp{a != b != c != d}
25034 tests that all four of @cite{a}, @cite{b}, @cite{c}, and @cite{d} are
25035 distinct numbers.
25037 @kindex a <
25038 @tindex lt
25039 @ignore
25040 @mindex @idots
25041 @end ignore
25042 @kindex a >
25043 @ignore
25044 @mindex @null
25045 @end ignore
25046 @kindex a [
25047 @ignore
25048 @mindex @null
25049 @end ignore
25050 @kindex a ]
25051 @pindex calc-less-than
25052 @pindex calc-greater-than
25053 @pindex calc-less-equal
25054 @pindex calc-greater-equal
25055 @ignore
25056 @mindex @null
25057 @end ignore
25058 @tindex gt
25059 @ignore
25060 @mindex @null
25061 @end ignore
25062 @tindex leq
25063 @ignore
25064 @mindex @null
25065 @end ignore
25066 @tindex geq
25067 @ignore
25068 @mindex @null
25069 @end ignore
25070 @tindex <
25071 @ignore
25072 @mindex @null
25073 @end ignore
25074 @tindex >
25075 @ignore
25076 @mindex @null
25077 @end ignore
25078 @tindex <=
25079 @ignore
25080 @mindex @null
25081 @end ignore
25082 @tindex >=
25083 The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
25084 operation is true if @cite{a} is less than @cite{b}.  Similar functions
25085 are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
25086 @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
25087 @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
25089 While the inequality functions like @code{lt} do not accept more
25090 than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
25091 equivalent expression involving intervals: @samp{b in [a .. c)}.
25092 (See the description of @code{in} below.)  All four combinations
25093 of @samp{<} and @samp{<=} are allowed, or any of the four combinations
25094 of @samp{>} and @samp{>=}.  Four-argument constructions like
25095 @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
25096 involve both equalities and inequalities, are not allowed.
25098 @kindex a .
25099 @pindex calc-remove-equal
25100 @tindex rmeq
25101 The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
25102 the righthand side of the equation or inequality on the top of the
25103 stack.  It also works elementwise on vectors.  For example, if
25104 @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
25105 @samp{[2.34, z / 2]}.  As a special case, if the righthand side is a
25106 variable and the lefthand side is a number (as in @samp{2.34 = x}), then
25107 Calc keeps the lefthand side instead.  Finally, this command works with
25108 assignments @samp{x := 2.34} as well as equations, always taking the
25109 the righthand side, and for @samp{=>} (evaluates-to) operators, always
25110 taking the lefthand side.
25112 @kindex a &
25113 @pindex calc-logical-and
25114 @tindex land
25115 @tindex &&
25116 The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
25117 function is true if both of its arguments are true, i.e., are
25118 non-zero numbers.  In this case, the result will be either @cite{a} or
25119 @cite{b}, chosen arbitrarily.  If either argument is zero, the result is
25120 zero.  Otherwise, the formula is left in symbolic form.
25122 @kindex a |
25123 @pindex calc-logical-or
25124 @tindex lor
25125 @tindex ||
25126 The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
25127 function is true if either or both of its arguments are true (nonzero).
25128 The result is whichever argument was nonzero, choosing arbitrarily if both
25129 are nonzero.  If both @cite{a} and @cite{b} are zero, the result is
25130 zero.
25132 @kindex a !
25133 @pindex calc-logical-not
25134 @tindex lnot
25135 @tindex !
25136 The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
25137 function is true if @cite{a} is false (zero), or false if @cite{a} is
25138 true (nonzero).  It is left in symbolic form if @cite{a} is not a
25139 number.
25141 @kindex a :
25142 @pindex calc-logical-if
25143 @tindex if
25144 @ignore
25145 @mindex ? :
25146 @end ignore
25147 @tindex ?
25148 @ignore
25149 @mindex @null
25150 @end ignore
25151 @tindex :
25152 @cindex Arguments, not evaluated
25153 The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
25154 function is equal to either @cite{b} or @cite{c} if @cite{a} is a nonzero
25155 number or zero, respectively.  If @cite{a} is not a number, the test is
25156 left in symbolic form and neither @cite{b} nor @cite{c} is evaluated in
25157 any way.  In algebraic formulas, this is one of the few Calc functions
25158 whose arguments are not automatically evaluated when the function itself
25159 is evaluated.  The others are @code{lambda}, @code{quote}, and
25160 @code{condition}.
25162 One minor surprise to watch out for is that the formula @samp{a?3:4}
25163 will not work because the @samp{3:4} is parsed as a fraction instead of
25164 as three separate symbols.  Type something like @samp{a ? 3 : 4} or
25165 @samp{a?(3):4} instead.
25167 As a special case, if @cite{a} evaluates to a vector, then both @cite{b}
25168 and @cite{c} are evaluated; the result is a vector of the same length
25169 as @cite{a} whose elements are chosen from corresponding elements of
25170 @cite{b} and @cite{c} according to whether each element of @cite{a}
25171 is zero or nonzero.  Each of @cite{b} and @cite{c} must be either a
25172 vector of the same length as @cite{a}, or a non-vector which is matched
25173 with all elements of @cite{a}.
25175 @kindex a @{
25176 @pindex calc-in-set
25177 @tindex in
25178 The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
25179 the number @cite{a} is in the set of numbers represented by @cite{b}.
25180 If @cite{b} is an interval form, @cite{a} must be one of the values
25181 encompassed by the interval.  If @cite{b} is a vector, @cite{a} must be
25182 equal to one of the elements of the vector.  (If any vector elements are
25183 intervals, @cite{a} must be in any of the intervals.)  If @cite{b} is a
25184 plain number, @cite{a} must be numerically equal to @cite{b}.
25185 @xref{Set Operations}, for a group of commands that manipulate sets
25186 of this sort.
25188 @ignore
25189 @starindex
25190 @end ignore
25191 @tindex typeof
25192 The @samp{typeof(a)} function produces an integer or variable which
25193 characterizes @cite{a}.  If @cite{a} is a number, vector, or variable,
25194 the result will be one of the following numbers:
25196 @example
25197  1   Integer
25198  2   Fraction
25199  3   Floating-point number
25200  4   HMS form
25201  5   Rectangular complex number
25202  6   Polar complex number
25203  7   Error form
25204  8   Interval form
25205  9   Modulo form
25206 10   Date-only form
25207 11   Date/time form
25208 12   Infinity (inf, uinf, or nan)
25209 100  Variable
25210 101  Vector (but not a matrix)
25211 102  Matrix
25212 @end example
25214 Otherwise, @cite{a} is a formula, and the result is a variable which
25215 represents the name of the top-level function call.
25217 @ignore
25218 @starindex
25219 @end ignore
25220 @tindex integer
25221 @ignore
25222 @starindex
25223 @end ignore
25224 @tindex real
25225 @ignore
25226 @starindex
25227 @end ignore
25228 @tindex constant
25229 The @samp{integer(a)} function returns true if @cite{a} is an integer.
25230 The @samp{real(a)} function
25231 is true if @cite{a} is a real number, either integer, fraction, or
25232 float.  The @samp{constant(a)} function returns true if @cite{a} is
25233 any of the objects for which @code{typeof} would produce an integer
25234 code result except for variables, and provided that the components of
25235 an object like a vector or error form are themselves constant.
25236 Note that infinities do not satisfy any of these tests, nor do
25237 special constants like @code{pi} and @code{e}.@refill
25239 @xref{Declarations}, for a set of similar functions that recognize
25240 formulas as well as actual numbers.  For example, @samp{dint(floor(x))}
25241 is true because @samp{floor(x)} is provably integer-valued, but
25242 @samp{integer(floor(x))} does not because @samp{floor(x)} is not
25243 literally an integer constant.
25245 @ignore
25246 @starindex
25247 @end ignore
25248 @tindex refers
25249 The @samp{refers(a,b)} function is true if the variable (or sub-expression)
25250 @cite{b} appears in @cite{a}, or false otherwise.  Unlike the other
25251 tests described here, this function returns a definite ``no'' answer
25252 even if its arguments are still in symbolic form.  The only case where
25253 @code{refers} will be left unevaluated is if @cite{a} is a plain
25254 variable (different from @cite{b}).
25256 @ignore
25257 @starindex
25258 @end ignore
25259 @tindex negative
25260 The @samp{negative(a)} function returns true if @cite{a} ``looks'' negative,
25261 because it is a negative number, because it is of the form @cite{-x},
25262 or because it is a product or quotient with a term that looks negative.
25263 This is most useful in rewrite rules.  Beware that @samp{negative(a)}
25264 evaluates to 1 or 0 for @emph{any} argument @cite{a}, so it can only
25265 be stored in a formula if the default simplifications are turned off
25266 first with @kbd{m O} (or if it appears in an unevaluated context such
25267 as a rewrite rule condition).
25269 @ignore
25270 @starindex
25271 @end ignore
25272 @tindex variable
25273 The @samp{variable(a)} function is true if @cite{a} is a variable,
25274 or false if not.  If @cite{a} is a function call, this test is left
25275 in symbolic form.  Built-in variables like @code{pi} and @code{inf}
25276 are considered variables like any others by this test.
25278 @ignore
25279 @starindex
25280 @end ignore
25281 @tindex nonvar
25282 The @samp{nonvar(a)} function is true if @cite{a} is a non-variable.
25283 If its argument is a variable it is left unsimplified; it never
25284 actually returns zero.  However, since Calc's condition-testing
25285 commands consider ``false'' anything not provably true, this is
25286 often good enough.
25288 @ignore
25289 @starindex
25290 @end ignore
25291 @tindex lin
25292 @ignore
25293 @starindex
25294 @end ignore
25295 @tindex linnt
25296 @ignore
25297 @starindex
25298 @end ignore
25299 @tindex islin
25300 @ignore
25301 @starindex
25302 @end ignore
25303 @tindex islinnt
25304 @cindex Linearity testing
25305 The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
25306 check if an expression is ``linear,'' i.e., can be written in the form
25307 @cite{a + b x} for some constants @cite{a} and @cite{b}, and some
25308 variable or subformula @cite{x}.  The function @samp{islin(f,x)} checks
25309 if formula @cite{f} is linear in @cite{x}, returning 1 if so.  For
25310 example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
25311 @samp{islin(x y / 3 - 2, x)} all return 1.  The @samp{lin(f,x)} function
25312 is similar, except that instead of returning 1 it returns the vector
25313 @cite{[a, b, x]}.  For the above examples, this vector would be
25314 @cite{[0, 1, x]}, @cite{[0, -1, x]}, @cite{[3, 0, x]}, and
25315 @cite{[-2, y/3, x]}, respectively.  Both @code{lin} and @code{islin}
25316 generally remain unevaluated for expressions which are not linear,
25317 e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}.  The second
25318 argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
25319 returns true.
25321 The @code{linnt} and @code{islinnt} functions perform a similar check,
25322 but require a ``non-trivial'' linear form, which means that the
25323 @cite{b} coefficient must be non-zero.  For example, @samp{lin(2,x)}
25324 returns @cite{[2, 0, x]} and @samp{lin(y,x)} returns @cite{[y, 0, x]},
25325 but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
25326 (in other words, these formulas are considered to be only ``trivially''
25327 linear in @cite{x}).
25329 All four linearity-testing functions allow you to omit the second
25330 argument, in which case the input may be linear in any non-constant
25331 formula.  Here, the @cite{a=0}, @cite{b=1} case is also considered
25332 trivial, and only constant values for @cite{a} and @cite{b} are
25333 recognized.  Thus, @samp{lin(2 x y)} returns @cite{[0, 2, x y]},
25334 @samp{lin(2 - x y)} returns @cite{[2, -1, x y]}, and @samp{lin(x y)}
25335 returns @cite{[0, 1, x y]}.  The @code{linnt} function would allow the
25336 first two cases but not the third.  Also, neither @code{lin} nor
25337 @code{linnt} accept plain constants as linear in the one-argument
25338 case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
25340 @ignore
25341 @starindex
25342 @end ignore
25343 @tindex istrue
25344 The @samp{istrue(a)} function returns 1 if @cite{a} is a nonzero
25345 number or provably nonzero formula, or 0 if @cite{a} is anything else.
25346 Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
25347 used to make sure they are not evaluated prematurely.  (Note that
25348 declarations are used when deciding whether a formula is true;
25349 @code{istrue} returns 1 when @code{dnonzero} would return 1, and
25350 it returns 0 when @code{dnonzero} would return 0 or leave itself
25351 in symbolic form.)
25353 @node Rewrite Rules, , Logical Operations, Algebra
25354 @section Rewrite Rules
25356 @noindent
25357 @cindex Rewrite rules
25358 @cindex Transformations
25359 @cindex Pattern matching
25360 @kindex a r
25361 @pindex calc-rewrite
25362 @tindex rewrite
25363 The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
25364 substitutions in a formula according to a specified pattern or patterns
25365 known as @dfn{rewrite rules}.  Whereas @kbd{a b} (@code{calc-substitute})
25366 matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
25367 matches only the @code{sin} function applied to the variable @code{x},
25368 rewrite rules match general kinds of formulas; rewriting using the rule
25369 @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
25370 it with @code{cos} of that same argument.  The only significance of the
25371 name @code{x} is that the same name is used on both sides of the rule.
25373 Rewrite rules rearrange formulas already in Calc's memory.
25374 @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
25375 similar to algebraic rewrite rules but operate when new algebraic
25376 entries are being parsed, converting strings of characters into
25377 Calc formulas.
25379 @menu
25380 * Entering Rewrite Rules::
25381 * Basic Rewrite Rules::
25382 * Conditional Rewrite Rules::
25383 * Algebraic Properties of Rewrite Rules::
25384 * Other Features of Rewrite Rules::
25385 * Composing Patterns in Rewrite Rules::
25386 * Nested Formulas with Rewrite Rules::
25387 * Multi-Phase Rewrite Rules::
25388 * Selections with Rewrite Rules::
25389 * Matching Commands::
25390 * Automatic Rewrites::
25391 * Debugging Rewrites::
25392 * Examples of Rewrite Rules::
25393 @end menu
25395 @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
25396 @subsection Entering Rewrite Rules
25398 @noindent
25399 Rewrite rules normally use the ``assignment'' operator
25400 @samp{@var{old} := @var{new}}.
25401 This operator is equivalent to the function call @samp{assign(old, new)}.
25402 The @code{assign} function is undefined by itself in Calc, so an
25403 assignment formula such as a rewrite rule will be left alone by ordinary
25404 Calc commands.  But certain commands, like the rewrite system, interpret
25405 assignments in special ways.@refill
25407 For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
25408 every occurrence of the sine of something, squared, with one minus the
25409 square of the cosine of that same thing.  All by itself as a formula
25410 on the stack it does nothing, but when given to the @kbd{a r} command
25411 it turns that command into a sine-squared-to-cosine-squared converter.
25413 To specify a set of rules to be applied all at once, make a vector of
25414 rules.
25416 When @kbd{a r} prompts you to enter the rewrite rules, you can answer
25417 in several ways:
25419 @enumerate
25420 @item
25421 With a rule:  @kbd{f(x) := g(x) @key{RET}}.
25422 @item
25423 With a vector of rules:  @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
25424 (You can omit the enclosing square brackets if you wish.)
25425 @item
25426 With the name of a variable that contains the rule or rules vector:
25427 @kbd{myrules @key{RET}}.
25428 @item
25429 With any formula except a rule, a vector, or a variable name; this
25430 will be interpreted as the @var{old} half of a rewrite rule,
25431 and you will be prompted a second time for the @var{new} half:
25432 @kbd{f(x) @key{RET} g(x) @key{RET}}.
25433 @item
25434 With a blank line, in which case the rule, rules vector, or variable
25435 will be taken from the top of the stack (and the formula to be
25436 rewritten will come from the second-to-top position).
25437 @end enumerate
25439 If you enter the rules directly (as opposed to using rules stored
25440 in a variable), those rules will be put into the Trail so that you
25441 can retrieve them later.  @xref{Trail Commands}.
25443 It is most convenient to store rules you use often in a variable and
25444 invoke them by giving the variable name.  The @kbd{s e}
25445 (@code{calc-edit-variable}) command is an easy way to create or edit a
25446 rule set stored in a variable.  You may also wish to use @kbd{s p}
25447 (@code{calc-permanent-variable}) to save your rules permanently;
25448 @pxref{Operations on Variables}.@refill
25450 Rewrite rules are compiled into a special internal form for faster
25451 matching.  If you enter a rule set directly it must be recompiled
25452 every time.  If you store the rules in a variable and refer to them
25453 through that variable, they will be compiled once and saved away
25454 along with the variable for later reference.  This is another good
25455 reason to store your rules in a variable.
25457 Calc also accepts an obsolete notation for rules, as vectors
25458 @samp{[@var{old}, @var{new}]}.  But because it is easily confused with a
25459 vector of two rules, the use of this notation is no longer recommended.
25461 @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
25462 @subsection Basic Rewrite Rules
25464 @noindent
25465 To match a particular formula @cite{x} with a particular rewrite rule
25466 @samp{@var{old} := @var{new}}, Calc compares the structure of @cite{x} with
25467 the structure of @var{old}.  Variables that appear in @var{old} are
25468 treated as @dfn{meta-variables}; the corresponding positions in @cite{x}
25469 may contain any sub-formulas.  For example, the pattern @samp{f(x,y)}
25470 would match the expression @samp{f(12, a+1)} with the meta-variable
25471 @samp{x} corresponding to 12 and with @samp{y} corresponding to
25472 @samp{a+1}.  However, this pattern would not match @samp{f(12)} or
25473 @samp{g(12, a+1)}, since there is no assignment of the meta-variables
25474 that will make the pattern match these expressions.  Notice that if
25475 the pattern is a single meta-variable, it will match any expression.
25477 If a given meta-variable appears more than once in @var{old}, the
25478 corresponding sub-formulas of @cite{x} must be identical.  Thus
25479 the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
25480 @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
25481 (@xref{Conditional Rewrite Rules}, for a way to match the latter.)
25483 Things other than variables must match exactly between the pattern
25484 and the target formula.  To match a particular variable exactly, use
25485 the pseudo-function @samp{quote(v)} in the pattern.  For example, the
25486 pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
25487 @samp{sin(a)+y}.
25489 The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
25490 @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
25491 literally.  Thus the pattern @samp{sin(d + e + f)} acts exactly like
25492 @samp{sin(d + quote(e) + f)}.
25494 If the @var{old} pattern is found to match a given formula, that
25495 formula is replaced by @var{new}, where any occurrences in @var{new}
25496 of meta-variables from the pattern are replaced with the sub-formulas
25497 that they matched.  Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
25498 to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
25500 The normal @kbd{a r} command applies rewrite rules over and over
25501 throughout the target formula until no further changes are possible
25502 (up to a limit of 100 times).  Use @kbd{C-u 1 a r} to make only one
25503 change at a time.
25505 @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
25506 @subsection Conditional Rewrite Rules
25508 @noindent
25509 A rewrite rule can also be @dfn{conditional}, written in the form
25510 @samp{@var{old} := @var{new} :: @var{cond}}.  (There is also the obsolete
25511 form @samp{[@var{old}, @var{new}, @var{cond}]}.)  If a @var{cond} part
25512 is present in the
25513 rule, this is an additional condition that must be satisfied before
25514 the rule is accepted.  Once @var{old} has been successfully matched
25515 to the target expression, @var{cond} is evaluated (with all the
25516 meta-variables substituted for the values they matched) and simplified
25517 with @kbd{a s} (@code{calc-simplify}).  If the result is a nonzero
25518 number or any other object known to be nonzero (@pxref{Declarations}),
25519 the rule is accepted.  If the result is zero or if it is a symbolic
25520 formula that is not known to be nonzero, the rule is rejected.
25521 @xref{Logical Operations}, for a number of functions that return
25522 1 or 0 according to the results of various tests.@refill
25524 For example, the formula @samp{n > 0} simplifies to 1 or 0 if @cite{n}
25525 is replaced by a positive or nonpositive number, respectively (or if
25526 @cite{n} has been declared to be positive or nonpositive).  Thus,
25527 the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
25528 @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
25529 (assuming no outstanding declarations for @cite{a}).  In the case of
25530 @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
25531 the case of @samp{f(12, a+1)}, the condition merely cannot be shown
25532 to be satisfied, but that is enough to reject the rule.
25534 While Calc will use declarations to reason about variables in the
25535 formula being rewritten, declarations do not apply to meta-variables.
25536 For example, the rule @samp{f(a) := g(a+1)} will match for any values
25537 of @samp{a}, such as complex numbers, vectors, or formulas, even if
25538 @samp{a} has been declared to be real or scalar.  If you want the
25539 meta-variable @samp{a} to match only literal real numbers, use
25540 @samp{f(a) := g(a+1) :: real(a)}.  If you want @samp{a} to match only
25541 reals and formulas which are provably real, use @samp{dreal(a)} as
25542 the condition.
25544 The @samp{::} operator is a shorthand for the @code{condition}
25545 function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
25546 the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
25548 If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
25549 or @samp{... :: c1 && c2 && c3}.  The two are entirely equivalent.
25551 It is also possible to embed conditions inside the pattern:
25552 @samp{f(x :: x>0, y) := g(y+x, x)}.  This is purely a notational
25553 convenience, though; where a condition appears in a rule has no
25554 effect on when it is tested.  The rewrite-rule compiler automatically
25555 decides when it is best to test each condition while a rule is being
25556 matched.
25558 Certain conditions are handled as special cases by the rewrite rule
25559 system and are tested very efficiently:  Where @cite{x} is any
25560 meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
25561 @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @cite{y}
25562 is either a constant or another meta-variable and @samp{>=} may be
25563 replaced by any of the six relational operators, and @samp{x % a = b}
25564 where @cite{a} and @cite{b} are constants.  Other conditions, like
25565 @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
25566 since Calc must bring the whole evaluator and simplifier into play.
25568 An interesting property of @samp{::} is that neither of its arguments
25569 will be touched by Calc's default simplifications.  This is important
25570 because conditions often are expressions that cannot safely be
25571 evaluated early.  For example, the @code{typeof} function never
25572 remains in symbolic form; entering @samp{typeof(a)} will put the
25573 number 100 (the type code for variables like @samp{a}) on the stack.
25574 But putting the condition @samp{... :: typeof(a) = 6} on the stack
25575 is safe since @samp{::} prevents the @code{typeof} from being
25576 evaluated until the condition is actually used by the rewrite system.
25578 Since @samp{::} protects its lefthand side, too, you can use a dummy
25579 condition to protect a rule that must itself not evaluate early.
25580 For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
25581 the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
25582 where the meta-variable-ness of @code{f} on the righthand side has been
25583 lost.  But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
25584 the condition @samp{1} is always true (nonzero) so it has no effect on
25585 the functioning of the rule.  (The rewrite compiler will ensure that
25586 it doesn't even impact the speed of matching the rule.)
25588 @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
25589 @subsection Algebraic Properties of Rewrite Rules
25591 @noindent
25592 The rewrite mechanism understands the algebraic properties of functions
25593 like @samp{+} and @samp{*}.  In particular, pattern matching takes
25594 the associativity and commutativity of the following functions into
25595 account:
25597 @smallexample
25598 + - *  = !=  && ||  and or xor  vint vunion vxor  gcd lcm  max min  beta
25599 @end smallexample
25601 For example, the rewrite rule:
25603 @example
25604 a x + b x  :=  (a + b) x
25605 @end example
25607 @noindent
25608 will match formulas of the form,
25610 @example
25611 a x + b x,  x a + x b,  a x + x b,  x a + b x
25612 @end example
25614 Rewrites also understand the relationship between the @samp{+} and @samp{-}
25615 operators.  The above rewrite rule will also match the formulas,
25617 @example
25618 a x - b x,  x a - x b,  a x - x b,  x a - b x
25619 @end example
25621 @noindent
25622 by matching @samp{b} in the pattern to @samp{-b} from the formula.
25624 Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
25625 pattern will check all pairs of terms for possible matches.  The rewrite
25626 will take whichever suitable pair it discovers first.
25628 In general, a pattern using an associative operator like @samp{a + b}
25629 will try @var{2 n} different ways to match a sum of @var{n} terms
25630 like @samp{x + y + z - w}.  First, @samp{a} is matched against each
25631 of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
25632 being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
25633 If none of these succeed, then @samp{b} is matched against each of the
25634 four terms with @samp{a} matching the remainder.  Half-and-half matches,
25635 like @samp{(x + y) + (z - w)}, are not tried.
25637 Note that @samp{*} is not commutative when applied to matrices, but
25638 rewrite rules pretend that it is.  If you type @kbd{m v} to enable
25639 matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
25640 literally, ignoring its usual commutativity property.  (In the
25641 current implementation, the associativity also vanishes---it is as
25642 if the pattern had been enclosed in a @code{plain} marker; see below.)
25643 If you are applying rewrites to formulas with matrices, it's best to
25644 enable matrix mode first to prevent algebraically incorrect rewrites
25645 from occurring.
25647 The pattern @samp{-x} will actually match any expression.  For example,
25648 the rule
25650 @example
25651 f(-x)  :=  -f(x)
25652 @end example
25654 @noindent
25655 will rewrite @samp{f(a)} to @samp{-f(-a)}.  To avoid this, either use
25656 a @code{plain} marker as described below, or add a @samp{negative(x)}
25657 condition.  The @code{negative} function is true if its argument
25658 ``looks'' negative, for example, because it is a negative number or
25659 because it is a formula like @samp{-x}.  The new rule using this
25660 condition is:
25662 @example
25663 f(x)  :=  -f(-x)  :: negative(x)    @r{or, equivalently,}
25664 f(-x)  :=  -f(x)  :: negative(-x)
25665 @end example
25667 In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
25668 by matching @samp{y} to @samp{-b}.
25670 The pattern @samp{a b} will also match the formula @samp{x/y} if
25671 @samp{y} is a number.  Thus the rule @samp{a x + @w{b x} := (a+b) x}
25672 will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
25673 @samp{(a + 1:2) x}, depending on the current fraction mode).
25675 Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
25676 @samp{^}.  For example, the pattern @samp{f(a b)} will not match
25677 @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
25678 though conceivably these patterns could match with @samp{a = b = x}.
25679 Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
25680 constant, even though it could be considered to match with @samp{a = x}
25681 and @samp{b = 1/y}.  The reasons are partly for efficiency, and partly
25682 because while few mathematical operations are substantively different
25683 for addition and subtraction, often it is preferable to treat the cases
25684 of multiplication, division, and integer powers separately.
25686 Even more subtle is the rule set
25688 @example
25689 [ f(a) + f(b) := f(a + b),  -f(a) := f(-a) ]
25690 @end example
25692 @noindent
25693 attempting to match @samp{f(x) - f(y)}.  You might think that Calc
25694 will view this subtraction as @samp{f(x) + (-f(y))} and then apply
25695 the above two rules in turn, but actually this will not work because
25696 Calc only does this when considering rules for @samp{+} (like the
25697 first rule in this set).  So it will see first that @samp{f(x) + (-f(y))}
25698 does not match @samp{f(a) + f(b)} for any assignments of the
25699 meta-variables, and then it will see that @samp{f(x) - f(y)} does
25700 not match @samp{-f(a)} for any assignment of @samp{a}.  Because Calc
25701 tries only one rule at a time, it will not be able to rewrite
25702 @samp{f(x) - f(y)} with this rule set.  An explicit @samp{f(a) - f(b)}
25703 rule will have to be added.
25705 Another thing patterns will @emph{not} do is break up complex numbers.
25706 The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
25707 involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
25708 it will not match actual complex numbers like @samp{(3, -4)}.  A version
25709 of the above rule for complex numbers would be
25711 @example
25712 myconj(a)  :=  re(a) - im(a) (0,1)  :: im(a) != 0
25713 @end example
25715 @noindent
25716 (Because the @code{re} and @code{im} functions understand the properties
25717 of the special constant @samp{i}, this rule will also work for
25718 @samp{3 - 4 i}.  In fact, this particular rule would probably be better
25719 without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
25720 righthand side of the rule will still give the correct answer for the
25721 conjugate of a real number.)
25723 It is also possible to specify optional arguments in patterns.  The rule
25725 @example
25726 opt(a) x + opt(b) (x^opt(c) + opt(d))  :=  f(a, b, c, d)
25727 @end example
25729 @noindent
25730 will match the formula
25732 @example
25733 5 (x^2 - 4) + 3 x
25734 @end example
25736 @noindent
25737 in a fairly straightforward manner, but it will also match reduced
25738 formulas like
25740 @example
25741 x + x^2,    2(x + 1) - x,    x + x
25742 @end example
25744 @noindent
25745 producing, respectively,
25747 @example
25748 f(1, 1, 2, 0),   f(-1, 2, 1, 1),   f(1, 1, 1, 0)
25749 @end example
25751 (The latter two formulas can be entered only if default simplifications
25752 have been turned off with @kbd{m O}.)
25754 The default value for a term of a sum is zero.  The default value
25755 for a part of a product, for a power, or for the denominator of a
25756 quotient, is one.  Also, @samp{-x} matches the pattern @samp{opt(a) b}
25757 with @samp{a = -1}.
25759 In particular, the distributive-law rule can be refined to
25761 @example
25762 opt(a) x + opt(b) x  :=  (a + b) x
25763 @end example
25765 @noindent
25766 so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
25768 The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
25769 are linear in @samp{x}.  You can also use the @code{lin} and @code{islin}
25770 functions with rewrite conditions to test for this; @pxref{Logical
25771 Operations}.  These functions are not as convenient to use in rewrite
25772 rules, but they recognize more kinds of formulas as linear:
25773 @samp{x/z} is considered linear with @cite{b = 1/z} by @code{lin},
25774 but it will not match the above pattern because that pattern calls
25775 for a multiplication, not a division.
25777 As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
25778 by 1,
25780 @example
25781 sin(x)^2 + cos(x)^2  :=  1
25782 @end example
25784 @noindent
25785 misses many cases because the sine and cosine may both be multiplied by
25786 an equal factor.  Here's a more successful rule:
25788 @example
25789 opt(a) sin(x)^2 + opt(a) cos(x)^2  :=  a
25790 @end example
25792 Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
25793 because one @cite{a} would have ``matched'' 1 while the other matched 6.
25795 Calc automatically converts a rule like
25797 @example
25798 f(x-1, x)  :=  g(x)
25799 @end example
25801 @noindent
25802 into the form
25804 @example
25805 f(temp, x)  :=  g(x)  :: temp = x-1
25806 @end example
25808 @noindent
25809 (where @code{temp} stands for a new, invented meta-variable that
25810 doesn't actually have a name).  This modified rule will successfully
25811 match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
25812 respectively, then verifying that they differ by one even though
25813 @samp{6} does not superficially look like @samp{x-1}.
25815 However, Calc does not solve equations to interpret a rule.  The
25816 following rule,
25818 @example
25819 f(x-1, x+1)  :=  g(x)
25820 @end example
25822 @noindent
25823 will not work.  That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
25824 but not @samp{f(6, 8)}.  Calc always interprets at least one occurrence
25825 of a variable by literal matching.  If the variable appears ``isolated''
25826 then Calc is smart enough to use it for literal matching.  But in this
25827 last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
25828 := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
25829 actual ``something-minus-one'' in the target formula.
25831 A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
25832 You could make this resemble the original form more closely by using
25833 @code{let} notation, which is described in the next section:
25835 @example
25836 f(xm1, x+1)  :=  g(x)  :: let(x := xm1+1)
25837 @end example
25839 Calc does this rewriting or ``conditionalizing'' for any sub-pattern
25840 which involves only the functions in the following list, operating
25841 only on constants and meta-variables which have already been matched
25842 elsewhere in the pattern.  When matching a function call, Calc is
25843 careful to match arguments which are plain variables before arguments
25844 which are calls to any of the functions below, so that a pattern like
25845 @samp{f(x-1, x)} can be conditionalized even though the isolated
25846 @samp{x} comes after the @samp{x-1}.
25848 @smallexample
25849 + - * / \ % ^  abs sign  round rounde roundu trunc floor ceil
25850 max min  re im conj arg
25851 @end smallexample
25853 You can suppress all of the special treatments described in this
25854 section by surrounding a function call with a @code{plain} marker.
25855 This marker causes the function call which is its argument to be
25856 matched literally, without regard to commutativity, associativity,
25857 negation, or conditionalization.  When you use @code{plain}, the
25858 ``deep structure'' of the formula being matched can show through.
25859 For example,
25861 @example
25862 plain(a - a b)  :=  f(a, b)
25863 @end example
25865 @noindent
25866 will match only literal subtractions.  However, the @code{plain}
25867 marker does not affect its arguments' arguments.  In this case,
25868 commutativity and associativity is still considered while matching
25869 the @w{@samp{a b}} sub-pattern, so the whole pattern will match
25870 @samp{x - y x} as well as @samp{x - x y}.  We could go still
25871 further and use
25873 @example
25874 plain(a - plain(a b))  :=  f(a, b)
25875 @end example
25877 @noindent
25878 which would do a completely strict match for the pattern.
25880 By contrast, the @code{quote} marker means that not only the
25881 function name but also the arguments must be literally the same.
25882 The above pattern will match @samp{x - x y} but
25884 @example
25885 quote(a - a b)  :=  f(a, b)
25886 @end example
25888 @noindent
25889 will match only the single formula @samp{a - a b}.  Also,
25891 @example
25892 quote(a - quote(a b))  :=  f(a, b)
25893 @end example
25895 @noindent
25896 will match only @samp{a - quote(a b)}---probably not the desired
25897 effect!
25899 A certain amount of algebra is also done when substituting the
25900 meta-variables on the righthand side of a rule.  For example,
25901 in the rule
25903 @example
25904 a + f(b)  :=  f(a + b)
25905 @end example
25907 @noindent
25908 matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
25909 taken literally, but the rewrite mechanism will simplify the
25910 righthand side to @samp{f(x - y)} automatically.  (Of course,
25911 the default simplifications would do this anyway, so this
25912 special simplification is only noticeable if you have turned the
25913 default simplifications off.)  This rewriting is done only when
25914 a meta-variable expands to a ``negative-looking'' expression.
25915 If this simplification is not desirable, you can use a @code{plain}
25916 marker on the righthand side:
25918 @example
25919 a + f(b)  :=  f(plain(a + b))
25920 @end example
25922 @noindent
25923 In this example, we are still allowing the pattern-matcher to
25924 use all the algebra it can muster, but the righthand side will
25925 always simplify to a literal addition like @samp{f((-y) + x)}.
25927 @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
25928 @subsection Other Features of Rewrite Rules
25930 @noindent
25931 Certain ``function names'' serve as markers in rewrite rules.
25932 Here is a complete list of these markers.  First are listed the
25933 markers that work inside a pattern; then come the markers that
25934 work in the righthand side of a rule.
25936 @ignore
25937 @starindex
25938 @end ignore
25939 @tindex import
25940 One kind of marker, @samp{import(x)}, takes the place of a whole
25941 rule.  Here @cite{x} is the name of a variable containing another
25942 rule set; those rules are ``spliced into'' the rule set that
25943 imports them.  For example, if @samp{[f(a+b) := f(a) + f(b),
25944 f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
25945 then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
25946 all three rules.  It is possible to modify the imported rules
25947 slightly:  @samp{import(x, v1, x1, v2, x2, @dots{})} imports
25948 the rule set @cite{x} with all occurrences of @c{$v_1$}
25949 @cite{v1}, as either
25950 a variable name or a function name, replaced with @c{$x_1$}
25951 @cite{x1} and
25952 so on.  (If @c{$v_1$}
25953 @cite{v1} is used as a function name, then @c{$x_1$}
25954 @cite{x1}
25955 must be either a function name itself or a @w{@samp{< >}} nameless
25956 function; @pxref{Specifying Operators}.)  For example, @samp{[g(0) := 0,
25957 import(linearF, f, g)]} applies the linearity rules to the function
25958 @samp{g} instead of @samp{f}.  Imports can be nested, but the
25959 import-with-renaming feature may fail to rename sub-imports properly.
25961 The special functions allowed in patterns are:
25963 @table @samp
25964 @item quote(x)
25965 @ignore
25966 @starindex
25967 @end ignore
25968 @tindex quote
25969 This pattern matches exactly @cite{x}; variable names in @cite{x} are
25970 not interpreted as meta-variables.  The only flexibility is that
25971 numbers are compared for numeric equality, so that the pattern
25972 @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
25973 (Numbers are always treated this way by the rewrite mechanism:
25974 The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
25975 The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
25976 as a result in this case.)
25978 @item plain(x)
25979 @ignore
25980 @starindex
25981 @end ignore
25982 @tindex plain
25983 Here @cite{x} must be a function call @samp{f(x1,x2,@dots{})}.  This
25984 pattern matches a call to function @cite{f} with the specified
25985 argument patterns.  No special knowledge of the properties of the
25986 function @cite{f} is used in this case; @samp{+} is not commutative or
25987 associative.  Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
25988 are treated as patterns.  If you wish them to be treated ``plainly''
25989 as well, you must enclose them with more @code{plain} markers:
25990 @samp{plain(plain(@w{-a}) + plain(b c))}.
25992 @item opt(x,def)
25993 @ignore
25994 @starindex
25995 @end ignore
25996 @tindex opt
25997 Here @cite{x} must be a variable name.  This must appear as an
25998 argument to a function or an element of a vector; it specifies that
25999 the argument or element is optional.
26000 As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
26001 or as the second argument to @samp{/} or @samp{^}, the value @var{def}
26002 may be omitted.  The pattern @samp{x + opt(y)} matches a sum by
26003 binding one summand to @cite{x} and the other to @cite{y}, and it
26004 matches anything else by binding the whole expression to @cite{x} and
26005 zero to @cite{y}.  The other operators above work similarly.@refill
26007 For general miscellaneous functions, the default value @code{def}
26008 must be specified.  Optional arguments are dropped starting with
26009 the rightmost one during matching.  For example, the pattern
26010 @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
26011 or @samp{f(a,b,c)}.  Default values of zero and @cite{b} are
26012 supplied in this example for the omitted arguments.  Note that
26013 the literal variable @cite{b} will be the default in the latter
26014 case, @emph{not} the value that matched the meta-variable @cite{b}.
26015 In other words, the default @var{def} is effectively quoted.
26017 @item condition(x,c)
26018 @ignore
26019 @starindex
26020 @end ignore
26021 @tindex condition
26022 @tindex ::
26023 This matches the pattern @cite{x}, with the attached condition
26024 @cite{c}.  It is the same as @samp{x :: c}.
26026 @item pand(x,y)
26027 @ignore
26028 @starindex
26029 @end ignore
26030 @tindex pand
26031 @tindex &&&
26032 This matches anything that matches both pattern @cite{x} and
26033 pattern @cite{y}.  It is the same as @samp{x &&& y}.
26034 @pxref{Composing Patterns in Rewrite Rules}.
26036 @item por(x,y)
26037 @ignore
26038 @starindex
26039 @end ignore
26040 @tindex por
26041 @tindex |||
26042 This matches anything that matches either pattern @cite{x} or
26043 pattern @cite{y}.  It is the same as @w{@samp{x ||| y}}.
26045 @item pnot(x)
26046 @ignore
26047 @starindex
26048 @end ignore
26049 @tindex pnot
26050 @tindex !!!
26051 This matches anything that does not match pattern @cite{x}.
26052 It is the same as @samp{!!! x}.
26054 @item cons(h,t)
26055 @ignore
26056 @mindex cons
26057 @end ignore
26058 @tindex cons (rewrites)
26059 This matches any vector of one or more elements.  The first
26060 element is matched to @cite{h}; a vector of the remaining
26061 elements is matched to @cite{t}.  Note that vectors of fixed
26062 length can also be matched as actual vectors:  The rule
26063 @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
26064 to the rule @samp{[a,b] := [a+b]}.
26066 @item rcons(t,h)
26067 @ignore
26068 @mindex rcons
26069 @end ignore
26070 @tindex rcons (rewrites)
26071 This is like @code{cons}, except that the @emph{last} element
26072 is matched to @cite{h}, with the remaining elements matched
26073 to @cite{t}.
26075 @item apply(f,args)
26076 @ignore
26077 @mindex apply
26078 @end ignore
26079 @tindex apply (rewrites)
26080 This matches any function call.  The name of the function, in
26081 the form of a variable, is matched to @cite{f}.  The arguments
26082 of the function, as a vector of zero or more objects, are
26083 matched to @samp{args}.  Constants, variables, and vectors
26084 do @emph{not} match an @code{apply} pattern.  For example,
26085 @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
26086 matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
26087 matches any function call with exactly two arguments, and
26088 @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
26089 to the function @samp{f} with two or more arguments.  Another
26090 way to implement the latter, if the rest of the rule does not
26091 need to refer to the first two arguments of @samp{f} by name,
26092 would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
26093 Here's a more interesting sample use of @code{apply}:
26095 @example
26096 apply(f,[x+n])  :=  n + apply(f,[x])
26097    :: in(f, [floor,ceil,round,trunc]) :: integer(n)
26098 @end example
26100 Note, however, that this will be slower to match than a rule
26101 set with four separate rules.  The reason is that Calc sorts
26102 the rules of a rule set according to top-level function name;
26103 if the top-level function is @code{apply}, Calc must try the
26104 rule for every single formula and sub-formula.  If the top-level
26105 function in the pattern is, say, @code{floor}, then Calc invokes
26106 the rule only for sub-formulas which are calls to @code{floor}.
26108 Formulas normally written with operators like @code{+} are still
26109 considered function calls:  @code{apply(f,x)} matches @samp{a+b}
26110 with @samp{f = add}, @samp{x = [a,b]}.
26112 You must use @code{apply} for meta-variables with function names
26113 on both sides of a rewrite rule:  @samp{apply(f, [x]) := f(x+1)}
26114 is @emph{not} correct, because it rewrites @samp{spam(6)} into
26115 @samp{f(7)}.  The righthand side should be @samp{apply(f, [x+1])}.
26116 Also note that you will have to use no-simplify (@kbd{m O})
26117 mode when entering this rule so that the @code{apply} isn't
26118 evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
26119 Or, use @kbd{s e} to enter the rule without going through the stack,
26120 or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
26121 @xref{Conditional Rewrite Rules}.
26123 @item select(x)
26124 @ignore
26125 @starindex
26126 @end ignore
26127 @tindex select
26128 This is used for applying rules to formulas with selections;
26129 @pxref{Selections with Rewrite Rules}.
26130 @end table
26132 Special functions for the righthand sides of rules are:
26134 @table @samp
26135 @item quote(x)
26136 The notation @samp{quote(x)} is changed to @samp{x} when the
26137 righthand side is used.  As far as the rewrite rule is concerned,
26138 @code{quote} is invisible.  However, @code{quote} has the special
26139 property in Calc that its argument is not evaluated.  Thus,
26140 while it will not work to put the rule @samp{t(a) := typeof(a)}
26141 on the stack because @samp{typeof(a)} is evaluated immediately
26142 to produce @samp{t(a) := 100}, you can use @code{quote} to
26143 protect the righthand side:  @samp{t(a) := quote(typeof(a))}.
26144 (@xref{Conditional Rewrite Rules}, for another trick for
26145 protecting rules from evaluation.)
26147 @item plain(x)
26148 Special properties of and simplifications for the function call
26149 @cite{x} are not used.  One interesting case where @code{plain}
26150 is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
26151 shorthand notation for the @code{quote} function.  This rule will
26152 not work as shown; instead of replacing @samp{q(foo)} with
26153 @samp{quote(foo)}, it will replace it with @samp{foo}!  The correct
26154 rule would be @samp{q(x) := plain(quote(x))}.
26156 @item cons(h,t)
26157 Where @cite{t} is a vector, this is converted into an expanded
26158 vector during rewrite processing.  Note that @code{cons} is a regular
26159 Calc function which normally does this anyway; the only way @code{cons}
26160 is treated specially by rewrites is that @code{cons} on the righthand
26161 side of a rule will be evaluated even if default simplifications
26162 have been turned off.
26164 @item rcons(t,h)
26165 Analogous to @code{cons} except putting @cite{h} at the @emph{end} of
26166 the vector @cite{t}.
26168 @item apply(f,args)
26169 Where @cite{f} is a variable and @var{args} is a vector, this
26170 is converted to a function call.  Once again, note that @code{apply}
26171 is also a regular Calc function.
26173 @item eval(x)
26174 @ignore
26175 @starindex
26176 @end ignore
26177 @tindex eval
26178 The formula @cite{x} is handled in the usual way, then the
26179 default simplifications are applied to it even if they have
26180 been turned off normally.  This allows you to treat any function
26181 similarly to the way @code{cons} and @code{apply} are always
26182 treated.  However, there is a slight difference:  @samp{cons(2+3, [])}
26183 with default simplifications off will be converted to @samp{[2+3]},
26184 whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
26186 @item evalsimp(x)
26187 @ignore
26188 @starindex
26189 @end ignore
26190 @tindex evalsimp
26191 The formula @cite{x} has meta-variables substituted in the usual
26192 way, then algebraically simplified as if by the @kbd{a s} command.
26194 @item evalextsimp(x)
26195 @ignore
26196 @starindex
26197 @end ignore
26198 @tindex evalextsimp
26199 The formula @cite{x} has meta-variables substituted in the normal
26200 way, then ``extendedly'' simplified as if by the @kbd{a e} command.
26202 @item select(x)
26203 @xref{Selections with Rewrite Rules}.
26204 @end table
26206 There are also some special functions you can use in conditions.
26208 @table @samp
26209 @item let(v := x)
26210 @ignore
26211 @starindex
26212 @end ignore
26213 @tindex let
26214 The expression @cite{x} is evaluated with meta-variables substituted.
26215 The @kbd{a s} command's simplifications are @emph{not} applied by
26216 default, but @cite{x} can include calls to @code{evalsimp} or
26217 @code{evalextsimp} as described above to invoke higher levels
26218 of simplification.  The
26219 result of @cite{x} is then bound to the meta-variable @cite{v}.  As
26220 usual, if this meta-variable has already been matched to something
26221 else the two values must be equal; if the meta-variable is new then
26222 it is bound to the result of the expression.  This variable can then
26223 appear in later conditions, and on the righthand side of the rule.
26224 In fact, @cite{v} may be any pattern in which case the result of
26225 evaluating @cite{x} is matched to that pattern, binding any
26226 meta-variables that appear in that pattern.  Note that @code{let}
26227 can only appear by itself as a condition, or as one term of an
26228 @samp{&&} which is a whole condition:  It cannot be inside
26229 an @samp{||} term or otherwise buried.@refill
26231 The alternate, equivalent form @samp{let(v, x)} is also recognized.
26232 Note that the use of @samp{:=} by @code{let}, while still being
26233 assignment-like in character, is unrelated to the use of @samp{:=}
26234 in the main part of a rewrite rule.
26236 As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
26237 replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
26238 that inverse exists and is constant.  For example, if @samp{a} is a
26239 singular matrix the operation @samp{1/a} is left unsimplified and
26240 @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
26241 then the rule succeeds.  Without @code{let} there would be no way
26242 to express this rule that didn't have to invert the matrix twice.
26243 Note that, because the meta-variable @samp{ia} is otherwise unbound
26244 in this rule, the @code{let} condition itself always ``succeeds''
26245 because no matter what @samp{1/a} evaluates to, it can successfully
26246 be bound to @code{ia}.@refill
26248 Here's another example, for integrating cosines of linear
26249 terms:  @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
26250 The @code{lin} function returns a 3-vector if its argument is linear,
26251 or leaves itself unevaluated if not.  But an unevaluated @code{lin}
26252 call will not match the 3-vector on the lefthand side of the @code{let},
26253 so this @code{let} both verifies that @code{y} is linear, and binds
26254 the coefficients @code{a} and @code{b} for use elsewhere in the rule.
26255 (It would have been possible to use @samp{sin(a x + b)/b} for the
26256 righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
26257 rearrangement of the argument of the sine.)@refill
26259 @ignore
26260 @starindex
26261 @end ignore
26262 @tindex ierf
26263 Similarly, here is a rule that implements an inverse-@code{erf}
26264 function.  It uses @code{root} to search for a solution.  If
26265 @code{root} succeeds, it will return a vector of two numbers
26266 where the first number is the desired solution.  If no solution
26267 is found, @code{root} remains in symbolic form.  So we use
26268 @code{let} to check that the result was indeed a vector.
26270 @example
26271 ierf(x)  :=  y  :: let([y,z] := root(erf(a) = x, a, .5))
26272 @end example
26274 @item matches(v,p)
26275 The meta-variable @var{v}, which must already have been matched
26276 to something elsewhere in the rule, is compared against pattern
26277 @var{p}.  Since @code{matches} is a standard Calc function, it
26278 can appear anywhere in a condition.  But if it appears alone or
26279 as a term of a top-level @samp{&&}, then you get the special
26280 extra feature that meta-variables which are bound to things
26281 inside @var{p} can be used elsewhere in the surrounding rewrite
26282 rule.
26284 The only real difference between @samp{let(p := v)} and
26285 @samp{matches(v, p)} is that the former evaluates @samp{v} using
26286 the default simplifications, while the latter does not.
26288 @item remember
26289 @vindex remember
26290 This is actually a variable, not a function.  If @code{remember}
26291 appears as a condition in a rule, then when that rule succeeds
26292 the original expression and rewritten expression are added to the
26293 front of the rule set that contained the rule.  If the rule set
26294 was not stored in a variable, @code{remember} is ignored.  The
26295 lefthand side is enclosed in @code{quote} in the added rule if it
26296 contains any variables.
26298 For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
26299 to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
26300 of the rule set.  The rule set @code{EvalRules} works slightly
26301 differently:  There, the evaluation of @samp{f(6)} will complete before
26302 the result is added to the rule set, in this case as @samp{f(7) := 5040}.
26303 Thus @code{remember} is most useful inside @code{EvalRules}.
26305 It is up to you to ensure that the optimization performed by
26306 @code{remember} is safe.  For example, the rule @samp{foo(n) := n
26307 :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
26308 the function equivalent of the @kbd{=} command); if the variable
26309 @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
26310 be added to the rule set and will continue to operate even if
26311 @code{eatfoo} is later changed to 0.
26313 @item remember(c)
26314 @ignore
26315 @starindex
26316 @end ignore
26317 @tindex remember
26318 Remember the match as described above, but only if condition @cite{c}
26319 is true.  For example, @samp{remember(n % 4 = 0)} in the above factorial
26320 rule remembers only every fourth result.  Note that @samp{remember(1)}
26321 is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
26322 @end table
26324 @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
26325 @subsection Composing Patterns in Rewrite Rules
26327 @noindent
26328 There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
26329 that combine rewrite patterns to make larger patterns.  The
26330 combinations are ``and,'' ``or,'' and ``not,'' respectively, and
26331 these operators are the pattern equivalents of @samp{&&}, @samp{||}
26332 and @samp{!} (which operate on zero-or-nonzero logical values).
26334 Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
26335 form by all regular Calc features; they have special meaning only in
26336 the context of rewrite rule patterns.
26338 The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
26339 matches both @var{p1} and @var{p2}.  One especially useful case is
26340 when one of @var{p1} or @var{p2} is a meta-variable.  For example,
26341 here is a rule that operates on error forms:
26343 @example
26344 f(x &&& a +/- b, x)  :=  g(x)
26345 @end example
26347 This does the same thing, but is arguably simpler than, the rule
26349 @example
26350 f(a +/- b, a +/- b)  :=  g(a +/- b)
26351 @end example
26353 @ignore
26354 @starindex
26355 @end ignore
26356 @tindex ends
26357 Here's another interesting example:
26359 @example
26360 ends(cons(a, x) &&& rcons(y, b))  :=  [a, b]
26361 @end example
26363 @noindent
26364 which effectively clips out the middle of a vector leaving just
26365 the first and last elements.  This rule will change a one-element
26366 vector @samp{[a]} to @samp{[a, a]}.  The similar rule
26368 @example
26369 ends(cons(a, rcons(y, b)))  :=  [a, b]
26370 @end example
26372 @noindent
26373 would do the same thing except that it would fail to match a
26374 one-element vector.
26376 @tex
26377 \bigskip
26378 @end tex
26380 The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
26381 matches either @var{p1} or @var{p2}.  Calc first tries matching
26382 against @var{p1}; if that fails, it goes on to try @var{p2}.
26384 @ignore
26385 @starindex
26386 @end ignore
26387 @tindex curve
26388 A simple example of @samp{|||} is
26390 @example
26391 curve(inf ||| -inf)  :=  0
26392 @end example
26394 @noindent
26395 which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
26397 Here is a larger example:
26399 @example
26400 log(a, b) ||| (ln(a) :: let(b := e))  :=  mylog(a, b)
26401 @end example
26403 This matches both generalized and natural logarithms in a single rule.
26404 Note that the @samp{::} term must be enclosed in parentheses because
26405 that operator has lower precedence than @samp{|||} or @samp{:=}.
26407 (In practice this rule would probably include a third alternative,
26408 omitted here for brevity, to take care of @code{log10}.)
26410 While Calc generally treats interior conditions exactly the same as
26411 conditions on the outside of a rule, it does guarantee that if all the
26412 variables in the condition are special names like @code{e}, or already
26413 bound in the pattern to which the condition is attached (say, if
26414 @samp{a} had appeared in this condition), then Calc will process this
26415 condition right after matching the pattern to the left of the @samp{::}.
26416 Thus, we know that @samp{b} will be bound to @samp{e} only if the
26417 @code{ln} branch of the @samp{|||} was taken.
26419 Note that this rule was careful to bind the same set of meta-variables
26420 on both sides of the @samp{|||}.  Calc does not check this, but if
26421 you bind a certain meta-variable only in one branch and then use that
26422 meta-variable elsewhere in the rule, results are unpredictable:
26424 @example
26425 f(a,b) ||| g(b)  :=  h(a,b)
26426 @end example
26428 Here if the pattern matches @samp{g(17)}, Calc makes no promises about
26429 the value that will be substituted for @samp{a} on the righthand side.
26431 @tex
26432 \bigskip
26433 @end tex
26435 The pattern @samp{!!! @var{pat}} matches anything that does not
26436 match @var{pat}.  Any meta-variables that are bound while matching
26437 @var{pat} remain unbound outside of @var{pat}.
26439 For example,
26441 @example
26442 f(x &&& !!! a +/- b, !!![])  :=  g(x)
26443 @end example
26445 @noindent
26446 converts @code{f} whose first argument is anything @emph{except} an
26447 error form, and whose second argument is not the empty vector, into
26448 a similar call to @code{g} (but without the second argument).
26450 If we know that the second argument will be a vector (empty or not),
26451 then an equivalent rule would be:
26453 @example
26454 f(x, y)  :=  g(x)  :: typeof(x) != 7 :: vlen(y) > 0
26455 @end example
26457 @noindent
26458 where of course 7 is the @code{typeof} code for error forms.
26459 Another final condition, that works for any kind of @samp{y},
26460 would be @samp{!istrue(y == [])}.  (The @code{istrue} function
26461 returns an explicit 0 if its argument was left in symbolic form;
26462 plain @samp{!(y == [])} or @samp{y != []} would not work to replace
26463 @samp{!!![]} since these would be left unsimplified, and thus cause
26464 the rule to fail, if @samp{y} was something like a variable name.)
26466 It is possible for a @samp{!!!} to refer to meta-variables bound
26467 elsewhere in the pattern.  For example,
26469 @example
26470 f(a, !!!a)  :=  g(a)
26471 @end example
26473 @noindent
26474 matches any call to @code{f} with different arguments, changing
26475 this to @code{g} with only the first argument.
26477 If a function call is to be matched and one of the argument patterns
26478 contains a @samp{!!!} somewhere inside it, that argument will be
26479 matched last.  Thus
26481 @example
26482 f(!!!a, a)  :=  g(a)
26483 @end example
26485 @noindent
26486 will be careful to bind @samp{a} to the second argument of @code{f}
26487 before testing the first argument.  If Calc had tried to match the
26488 first argument of @code{f} first, the results would have been
26489 disastrous: since @code{a} was unbound so far, the pattern @samp{a}
26490 would have matched anything at all, and the pattern @samp{!!!a}
26491 therefore would @emph{not} have matched anything at all!
26493 @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
26494 @subsection Nested Formulas with Rewrite Rules
26496 @noindent
26497 When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
26498 the top of the stack and attempts to match any of the specified rules
26499 to any part of the expression, starting with the whole expression
26500 and then, if that fails, trying deeper and deeper sub-expressions.
26501 For each part of the expression, the rules are tried in the order
26502 they appear in the rules vector.  The first rule to match the first
26503 sub-expression wins; it replaces the matched sub-expression according
26504 to the @var{new} part of the rule.
26506 Often, the rule set will match and change the formula several times.
26507 The top-level formula is first matched and substituted repeatedly until
26508 it no longer matches the pattern; then, sub-formulas are tried, and
26509 so on.  Once every part of the formula has gotten its chance, the
26510 rewrite mechanism starts over again with the top-level formula
26511 (in case a substitution of one of its arguments has caused it again
26512 to match).  This continues until no further matches can be made
26513 anywhere in the formula.
26515 It is possible for a rule set to get into an infinite loop.  The
26516 most obvious case, replacing a formula with itself, is not a problem
26517 because a rule is not considered to ``succeed'' unless the righthand
26518 side actually comes out to something different than the original
26519 formula or sub-formula that was matched.  But if you accidentally
26520 had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
26521 @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
26522 run forever switching a formula back and forth between the two
26523 forms.
26525 To avoid disaster, Calc normally stops after 100 changes have been
26526 made to the formula.  This will be enough for most multiple rewrites,
26527 but it will keep an endless loop of rewrites from locking up the
26528 computer forever.  (On most systems, you can also type @kbd{C-g} to
26529 halt any Emacs command prematurely.)
26531 To change this limit, give a positive numeric prefix argument.
26532 In particular, @kbd{M-1 a r} applies only one rewrite at a time,
26533 useful when you are first testing your rule (or just if repeated
26534 rewriting is not what is called for by your application).
26536 @ignore
26537 @starindex
26538 @end ignore
26539 @ignore
26540 @mindex iter@idots
26541 @end ignore
26542 @tindex iterations
26543 You can also put a ``function call'' @samp{iterations(@var{n})}
26544 in place of a rule anywhere in your rules vector (but usually at
26545 the top).  Then, @var{n} will be used instead of 100 as the default
26546 number of iterations for this rule set.  You can use
26547 @samp{iterations(inf)} if you want no iteration limit by default.
26548 A prefix argument will override the @code{iterations} limit in the
26549 rule set.
26551 @example
26552 [ iterations(1),
26553   f(x) := f(x+1) ]
26554 @end example
26556 More precisely, the limit controls the number of ``iterations,''
26557 where each iteration is a successful matching of a rule pattern whose
26558 righthand side, after substituting meta-variables and applying the
26559 default simplifications, is different from the original sub-formula
26560 that was matched.
26562 A prefix argument of zero sets the limit to infinity.  Use with caution!
26564 Given a negative numeric prefix argument, @kbd{a r} will match and
26565 substitute the top-level expression up to that many times, but
26566 will not attempt to match the rules to any sub-expressions.
26568 In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
26569 does a rewriting operation.  Here @var{expr} is the expression
26570 being rewritten, @var{rules} is the rule, vector of rules, or
26571 variable containing the rules, and @var{n} is the optional
26572 iteration limit, which may be a positive integer, a negative
26573 integer, or @samp{inf} or @samp{-inf}.  If @var{n} is omitted
26574 the @code{iterations} value from the rule set is used; if both
26575 are omitted, 100 is used.
26577 @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
26578 @subsection Multi-Phase Rewrite Rules
26580 @noindent
26581 It is possible to separate a rewrite rule set into several @dfn{phases}.
26582 During each phase, certain rules will be enabled while certain others
26583 will be disabled.  A @dfn{phase schedule} controls the order in which
26584 phases occur during the rewriting process.
26586 @ignore
26587 @starindex
26588 @end ignore
26589 @tindex phase
26590 @vindex all
26591 If a call to the marker function @code{phase} appears in the rules
26592 vector in place of a rule, all rules following that point will be
26593 members of the phase(s) identified in the arguments to @code{phase}.
26594 Phases are given integer numbers.  The markers @samp{phase()} and
26595 @samp{phase(all)} both mean the following rules belong to all phases;
26596 this is the default at the start of the rule set.
26598 If you do not explicitly schedule the phases, Calc sorts all phase
26599 numbers that appear in the rule set and executes the phases in
26600 ascending order.  For example, the rule set
26602 @example
26603 @group
26604 [ f0(x) := g0(x),
26605   phase(1),
26606   f1(x) := g1(x),
26607   phase(2),
26608   f2(x) := g2(x),
26609   phase(3),
26610   f3(x) := g3(x),
26611   phase(1,2),
26612   f4(x) := g4(x) ]
26613 @end group
26614 @end example
26616 @noindent
26617 has three phases, 1 through 3.  Phase 1 consists of the @code{f0},
26618 @code{f1}, and @code{f4} rules (in that order).  Phase 2 consists of
26619 @code{f0}, @code{f2}, and @code{f4}.  Phase 3 consists of @code{f0}
26620 and @code{f3}.
26622 When Calc rewrites a formula using this rule set, it first rewrites
26623 the formula using only the phase 1 rules until no further changes are
26624 possible.  Then it switches to the phase 2 rule set and continues
26625 until no further changes occur, then finally rewrites with phase 3.
26626 When no more phase 3 rules apply, rewriting finishes.  (This is
26627 assuming @kbd{a r} with a large enough prefix argument to allow the
26628 rewriting to run to completion; the sequence just described stops
26629 early if the number of iterations specified in the prefix argument,
26630 100 by default, is reached.)
26632 During each phase, Calc descends through the nested levels of the
26633 formula as described previously.  (@xref{Nested Formulas with Rewrite
26634 Rules}.)  Rewriting starts at the top of the formula, then works its
26635 way down to the parts, then goes back to the top and works down again.
26636 The phase 2 rules do not begin until no phase 1 rules apply anywhere
26637 in the formula.
26639 @ignore
26640 @starindex
26641 @end ignore
26642 @tindex schedule
26643 A @code{schedule} marker appearing in the rule set (anywhere, but
26644 conventionally at the top) changes the default schedule of phases.
26645 In the simplest case, @code{schedule} has a sequence of phase numbers
26646 for arguments; each phase number is invoked in turn until the
26647 arguments to @code{schedule} are exhausted.  Thus adding
26648 @samp{schedule(3,2,1)} at the top of the above rule set would
26649 reverse the order of the phases; @samp{schedule(1,2,3)} would have
26650 no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
26651 would give phase 1 a second chance after phase 2 has completed, before
26652 moving on to phase 3.
26654 Any argument to @code{schedule} can instead be a vector of phase
26655 numbers (or even of sub-vectors).  Then the sub-sequence of phases
26656 described by the vector are tried repeatedly until no change occurs
26657 in any phase in the sequence.  For example, @samp{schedule([1, 2], 3)}
26658 tries phase 1, then phase 2, then, if either phase made any changes
26659 to the formula, repeats these two phases until they can make no
26660 further progress.  Finally, it goes on to phase 3 for finishing
26661 touches.
26663 Also, items in @code{schedule} can be variable names as well as
26664 numbers.  A variable name is interpreted as the name of a function
26665 to call on the whole formula.  For example, @samp{schedule(1, simplify)}
26666 says to apply the phase-1 rules (presumably, all of them), then to
26667 call @code{simplify} which is the function name equivalent of @kbd{a s}.
26668 Likewise, @samp{schedule([1, simplify])} says to alternate between
26669 phase 1 and @kbd{a s} until no further changes occur.
26671 Phases can be used purely to improve efficiency; if it is known that
26672 a certain group of rules will apply only at the beginning of rewriting,
26673 and a certain other group will apply only at the end, then rewriting
26674 will be faster if these groups are identified as separate phases.
26675 Once the phase 1 rules are done, Calc can put them aside and no longer
26676 spend any time on them while it works on phase 2.
26678 There are also some problems that can only be solved with several
26679 rewrite phases.  For a real-world example of a multi-phase rule set,
26680 examine the set @code{FitRules}, which is used by the curve-fitting
26681 command to convert a model expression to linear form.
26682 @xref{Curve Fitting Details}.  This set is divided into four phases.
26683 The first phase rewrites certain kinds of expressions to be more
26684 easily linearizable, but less computationally efficient.  After the
26685 linear components have been picked out, the final phase includes the
26686 opposite rewrites to put each component back into an efficient form.
26687 If both sets of rules were included in one big phase, Calc could get
26688 into an infinite loop going back and forth between the two forms.
26690 Elsewhere in @code{FitRules}, the components are first isolated,
26691 then recombined where possible to reduce the complexity of the linear
26692 fit, then finally packaged one component at a time into vectors.
26693 If the packaging rules were allowed to begin before the recombining
26694 rules were finished, some components might be put away into vectors
26695 before they had a chance to recombine.  By putting these rules in
26696 two separate phases, this problem is neatly avoided.
26698 @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
26699 @subsection Selections with Rewrite Rules
26701 @noindent
26702 If a sub-formula of the current formula is selected (as by @kbd{j s};
26703 @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
26704 command applies only to that sub-formula.  Together with a negative
26705 prefix argument, you can use this fact to apply a rewrite to one
26706 specific part of a formula without affecting any other parts.
26708 @kindex j r
26709 @pindex calc-rewrite-selection
26710 The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
26711 sophisticated operations on selections.  This command prompts for
26712 the rules in the same way as @kbd{a r}, but it then applies those
26713 rules to the whole formula in question even though a sub-formula
26714 of it has been selected.  However, the selected sub-formula will
26715 first have been surrounded by a @samp{select( )} function call.
26716 (Calc's evaluator does not understand the function name @code{select};
26717 this is only a tag used by the @kbd{j r} command.)
26719 For example, suppose the formula on the stack is @samp{2 (a + b)^2}
26720 and the sub-formula @samp{a + b} is selected.  This formula will
26721 be rewritten to @samp{2 select(a + b)^2} and then the rewrite
26722 rules will be applied in the usual way.  The rewrite rules can
26723 include references to @code{select} to tell where in the pattern
26724 the selected sub-formula should appear.
26726 If there is still exactly one @samp{select( )} function call in
26727 the formula after rewriting is done, it indicates which part of
26728 the formula should be selected afterwards.  Otherwise, the
26729 formula will be unselected.
26731 You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
26732 of the rewrite rule with @samp{select()}.  However, @kbd{j r}
26733 allows you to use the current selection in more flexible ways.
26734 Suppose you wished to make a rule which removed the exponent from
26735 the selected term; the rule @samp{select(a)^x := select(a)} would
26736 work.  In the above example, it would rewrite @samp{2 select(a + b)^2}
26737 to @samp{2 select(a + b)}.  This would then be returned to the
26738 stack as @samp{2 (a + b)} with the @samp{a + b} selected.
26740 The @kbd{j r} command uses one iteration by default, unlike
26741 @kbd{a r} which defaults to 100 iterations.  A numeric prefix
26742 argument affects @kbd{j r} in the same way as @kbd{a r}.
26743 @xref{Nested Formulas with Rewrite Rules}.
26745 As with other selection commands, @kbd{j r} operates on the stack
26746 entry that contains the cursor.  (If the cursor is on the top-of-stack
26747 @samp{.} marker, it works as if the cursor were on the formula
26748 at stack level 1.)
26750 If you don't specify a set of rules, the rules are taken from the
26751 top of the stack, just as with @kbd{a r}.  In this case, the
26752 cursor must indicate stack entry 2 or above as the formula to be
26753 rewritten (otherwise the same formula would be used as both the
26754 target and the rewrite rules).
26756 If the indicated formula has no selection, the cursor position within
26757 the formula temporarily selects a sub-formula for the purposes of this
26758 command.  If the cursor is not on any sub-formula (e.g., it is in
26759 the line-number area to the left of the formula), the @samp{select( )}
26760 markers are ignored by the rewrite mechanism and the rules are allowed
26761 to apply anywhere in the formula.
26763 As a special feature, the normal @kbd{a r} command also ignores
26764 @samp{select( )} calls in rewrite rules.  For example, if you used the
26765 above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
26766 the rule as if it were @samp{a^x := a}.  Thus, you can write general
26767 purpose rules with @samp{select( )} hints inside them so that they
26768 will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
26769 both with and without selections.
26771 @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
26772 @subsection Matching Commands
26774 @noindent
26775 @kindex a m
26776 @pindex calc-match
26777 @tindex match
26778 The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
26779 vector of formulas and a rewrite-rule-style pattern, and produces
26780 a vector of all formulas which match the pattern.  The command
26781 prompts you to enter the pattern; as for @kbd{a r}, you can enter
26782 a single pattern (i.e., a formula with meta-variables), or a
26783 vector of patterns, or a variable which contains patterns, or
26784 you can give a blank response in which case the patterns are taken
26785 from the top of the stack.  The pattern set will be compiled once
26786 and saved if it is stored in a variable.  If there are several
26787 patterns in the set, vector elements are kept if they match any
26788 of the patterns.
26790 For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
26791 will return @samp{[x+y, x-y, x+y+z]}.
26793 The @code{import} mechanism is not available for pattern sets.
26795 The @kbd{a m} command can also be used to extract all vector elements
26796 which satisfy any condition:  The pattern @samp{x :: x>0} will select
26797 all the positive vector elements.
26799 @kindex I a m
26800 @tindex matchnot
26801 With the Inverse flag [@code{matchnot}], this command extracts all
26802 vector elements which do @emph{not} match the given pattern.
26804 @ignore
26805 @starindex
26806 @end ignore
26807 @tindex matches
26808 There is also a function @samp{matches(@var{x}, @var{p})} which
26809 evaluates to 1 if expression @var{x} matches pattern @var{p}, or
26810 to 0 otherwise.  This is sometimes useful for including into the
26811 conditional clauses of other rewrite rules.
26813 @ignore
26814 @starindex
26815 @end ignore
26816 @tindex vmatches
26817 The function @code{vmatches} is just like @code{matches}, except
26818 that if the match succeeds it returns a vector of assignments to
26819 the meta-variables instead of the number 1.  For example,
26820 @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
26821 If the match fails, the function returns the number 0.
26823 @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
26824 @subsection Automatic Rewrites
26826 @noindent
26827 @cindex @code{EvalRules} variable
26828 @vindex EvalRules
26829 It is possible to get Calc to apply a set of rewrite rules on all
26830 results, effectively adding to the built-in set of default
26831 simplifications.  To do this, simply store your rule set in the
26832 variable @code{EvalRules}.  There is a convenient @kbd{s E} command
26833 for editing @code{EvalRules}; @pxref{Operations on Variables}.
26835 For example, suppose you want @samp{sin(a + b)} to be expanded out
26836 to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
26837 similarly for @samp{cos(a + b)}.  The corresponding rewrite rule
26838 set would be,
26840 @smallexample
26841 @group
26842 [ sin(a + b)  :=  cos(a) sin(b) + sin(a) cos(b),
26843   cos(a + b)  :=  cos(a) cos(b) - sin(a) sin(b) ]
26844 @end group
26845 @end smallexample
26847 To apply these manually, you could put them in a variable called
26848 @code{trigexp} and then use @kbd{a r trigexp} every time you wanted
26849 to expand trig functions.  But if instead you store them in the
26850 variable @code{EvalRules}, they will automatically be applied to all
26851 sines and cosines of sums.  Then, with @samp{2 x} and @samp{45} on
26852 the stack, typing @kbd{+ S} will (assuming degrees mode) result in
26853 @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
26855 As each level of a formula is evaluated, the rules from
26856 @code{EvalRules} are applied before the default simplifications.
26857 Rewriting continues until no further @code{EvalRules} apply.
26858 Note that this is different from the usual order of application of
26859 rewrite rules:  @code{EvalRules} works from the bottom up, simplifying
26860 the arguments to a function before the function itself, while @kbd{a r}
26861 applies rules from the top down.
26863 Because the @code{EvalRules} are tried first, you can use them to
26864 override the normal behavior of any built-in Calc function.
26866 It is important not to write a rule that will get into an infinite
26867 loop.  For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
26868 appears to be a good definition of a factorial function, but it is
26869 unsafe.  Imagine what happens if @samp{f(2.5)} is simplified.  Calc
26870 will continue to subtract 1 from this argument forever without reaching
26871 zero.  A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
26872 Another dangerous rule is @samp{g(x, y) := g(y, x)}.  Rewriting
26873 @samp{g(2, 4)}, this would bounce back and forth between that and
26874 @samp{g(4, 2)} forever.  If an infinite loop in @code{EvalRules}
26875 occurs, Emacs will eventually stop with a ``Computation got stuck
26876 or ran too long'' message.
26878 Another subtle difference between @code{EvalRules} and regular rewrites
26879 concerns rules that rewrite a formula into an identical formula.  For
26880 example, @samp{f(n) := f(floor(n))} ``fails to match'' when @cite{n} is
26881 already an integer.  But in @code{EvalRules} this case is detected only
26882 if the righthand side literally becomes the original formula before any
26883 further simplification.  This means that @samp{f(n) := f(floor(n))} will
26884 get into an infinite loop if it occurs in @code{EvalRules}.  Calc will
26885 replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
26886 @samp{f(6)}, so it will consider the rule to have matched and will
26887 continue simplifying that formula; first the argument is simplified
26888 to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
26889 again, ad infinitum.  A much safer rule would check its argument first,
26890 say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
26892 (What really happens is that the rewrite mechanism substitutes the
26893 meta-variables in the righthand side of a rule, compares to see if the
26894 result is the same as the original formula and fails if so, then uses
26895 the default simplifications to simplify the result and compares again
26896 (and again fails if the formula has simplified back to its original
26897 form).  The only special wrinkle for the @code{EvalRules} is that the
26898 same rules will come back into play when the default simplifications
26899 are used.  What Calc wants to do is build @samp{f(floor(6))}, see that
26900 this is different from the original formula, simplify to @samp{f(6)},
26901 see that this is the same as the original formula, and thus halt the
26902 rewriting.  But while simplifying, @samp{f(6)} will again trigger
26903 the same @code{EvalRules} rule and Calc will get into a loop inside
26904 the rewrite mechanism itself.)
26906 The @code{phase}, @code{schedule}, and @code{iterations} markers do
26907 not work in @code{EvalRules}.  If the rule set is divided into phases,
26908 only the phase 1 rules are applied, and the schedule is ignored.
26909 The rules are always repeated as many times as possible.
26911 The @code{EvalRules} are applied to all function calls in a formula,
26912 but not to numbers (and other number-like objects like error forms),
26913 nor to vectors or individual variable names.  (Though they will apply
26914 to @emph{components} of vectors and error forms when appropriate.)  You
26915 might try to make a variable @code{phihat} which automatically expands
26916 to its definition without the need to press @kbd{=} by writing the
26917 rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
26918 will not work as part of @code{EvalRules}.
26920 Finally, another limitation is that Calc sometimes calls its built-in
26921 functions directly rather than going through the default simplifications.
26922 When it does this, @code{EvalRules} will not be able to override those
26923 functions.  For example, when you take the absolute value of the complex
26924 number @cite{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
26925 the multiplication, addition, and square root functions directly rather
26926 than applying the default simplifications to this formula.  So an
26927 @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
26928 would not apply.  (However, if you put Calc into symbolic mode so that
26929 @samp{sqrt(13)} will be left in symbolic form by the built-in square
26930 root function, your rule will be able to apply.  But if the complex
26931 number were @cite{(3,4)}, so that @samp{sqrt(25)} must be calculated,
26932 then symbolic mode will not help because @samp{sqrt(25)} can be
26933 evaluated exactly to 5.)
26935 One subtle restriction that normally only manifests itself with
26936 @code{EvalRules} is that while a given rewrite rule is in the process
26937 of being checked, that same rule cannot be recursively applied.  Calc
26938 effectively removes the rule from its rule set while checking the rule,
26939 then puts it back once the match succeeds or fails.  (The technical
26940 reason for this is that compiled pattern programs are not reentrant.)
26941 For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
26942 attempting to match @samp{foo(8)}.  This rule will be inactive while
26943 the condition @samp{foo(4) > 0} is checked, even though it might be
26944 an integral part of evaluating that condition.  Note that this is not
26945 a problem for the more usual recursive type of rule, such as
26946 @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
26947 been reactivated by the time the righthand side is evaluated.
26949 If @code{EvalRules} has no stored value (its default state), or if
26950 anything but a vector is stored in it, then it is ignored.
26952 Even though Calc's rewrite mechanism is designed to compare rewrite
26953 rules to formulas as quickly as possible, storing rules in
26954 @code{EvalRules} may make Calc run substantially slower.  This is
26955 particularly true of rules where the top-level call is a commonly used
26956 function, or is not fixed.  The rule @samp{f(n) := n f(n-1) :: n>0} will
26957 only activate the rewrite mechanism for calls to the function @code{f},
26958 but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
26960 @smallexample
26961 apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
26962 @end smallexample
26964 @noindent
26965 may seem more ``efficient'' than two separate rules for @code{ln} and
26966 @code{log10}, but actually it is vastly less efficient because rules
26967 with @code{apply} as the top-level pattern must be tested against
26968 @emph{every} function call that is simplified.
26970 @cindex @code{AlgSimpRules} variable
26971 @vindex AlgSimpRules
26972 Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
26973 but only when @kbd{a s} is used to simplify the formula.  The variable
26974 @code{AlgSimpRules} holds rules for this purpose.  The @kbd{a s} command
26975 will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as
26976 well as all of its built-in simplifications.
26978 Most of the special limitations for @code{EvalRules} don't apply to
26979 @code{AlgSimpRules}.  Calc simply does an @kbd{a r AlgSimpRules}
26980 command with an infinite repeat count as the first step of @kbd{a s}.
26981 It then applies its own built-in simplifications throughout the
26982 formula, and then repeats these two steps (along with applying the
26983 default simplifications) until no further changes are possible.
26985 @cindex @code{ExtSimpRules} variable
26986 @cindex @code{UnitSimpRules} variable
26987 @vindex ExtSimpRules
26988 @vindex UnitSimpRules
26989 There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
26990 that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
26991 also apply @code{EvalRules} and @code{AlgSimpRules}.  The variable
26992 @code{IntegSimpRules} contains simplification rules that are used
26993 only during integration by @kbd{a i}.
26995 @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
26996 @subsection Debugging Rewrites
26998 @noindent
26999 If a buffer named @samp{*Trace*} exists, the rewrite mechanism will
27000 record some useful information there as it operates.  The original
27001 formula is written there, as is the result of each successful rewrite,
27002 and the final result of the rewriting.  All phase changes are also
27003 noted.
27005 Calc always appends to @samp{*Trace*}.  You must empty this buffer
27006 yourself periodically if it is in danger of growing unwieldy.
27008 Note that the rewriting mechanism is substantially slower when the
27009 @samp{*Trace*} buffer exists, even if the buffer is not visible on
27010 the screen.  Once you are done, you will probably want to kill this
27011 buffer (with @kbd{C-x k *Trace* @key{RET}}).  If you leave it in
27012 existence and forget about it, all your future rewrite commands will
27013 be needlessly slow.
27015 @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
27016 @subsection Examples of Rewrite Rules
27018 @noindent
27019 Returning to the example of substituting the pattern
27020 @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
27021 @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
27022 finding suitable cases.  Another solution would be to use the rule
27023 @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
27024 if necessary.  This rule will be the most effective way to do the job,
27025 but at the expense of making some changes that you might not desire.@refill
27027 Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
27028 To make this work with the @w{@kbd{j r}} command so that it can be
27029 easily targeted to a particular exponential in a large formula,
27030 you might wish to write the rule as @samp{select(exp(x+y)) :=
27031 select(exp(x) exp(y))}.  The @samp{select} markers will be
27032 ignored by the regular @kbd{a r} command
27033 (@pxref{Selections with Rewrite Rules}).@refill
27035 A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
27036 This will simplify the formula whenever @cite{b} and/or @cite{c} can
27037 be made simpler by squaring.  For example, applying this rule to
27038 @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
27039 Symbolic Mode has been enabled to keep the square root from being
27040 evaluated to a floating-point approximation).  This rule is also
27041 useful when working with symbolic complex numbers, e.g.,
27042 @samp{(a + b i) / (c + d i)}.
27044 As another example, we could define our own ``triangular numbers'' function
27045 with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}.  Enter
27046 this vector and store it in a variable:  @kbd{@w{s t} trirules}.  Now, given
27047 a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
27048 to apply these rules repeatedly.  After six applications, @kbd{a r} will
27049 stop with 15 on the stack.  Once these rules are debugged, it would probably
27050 be most useful to add them to @code{EvalRules} so that Calc will evaluate
27051 the new @code{tri} function automatically.  We could then use @kbd{Z K} on
27052 the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
27053 @code{tri} to the value on the top of the stack.  @xref{Programming}.
27055 @cindex Quaternions
27056 The following rule set, contributed by @c{Fran\c cois}
27057 @asis{Francois} Pinard, implements
27058 @dfn{quaternions}, a generalization of the concept of complex numbers.
27059 Quaternions have four components, and are here represented by function
27060 calls @samp{quat(@var{w}, [@var{x}, @var{y}, @var{z}])} with ``real
27061 part'' @var{w} and the three ``imaginary'' parts collected into a
27062 vector.  Various arithmetical operations on quaternions are supported.
27063 To use these rules, either add them to @code{EvalRules}, or create a
27064 command based on @kbd{a r} for simplifying quaternion formulas.
27065 A convenient way to enter quaternions would be a command defined by
27066 a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $]) @key{RET}}.
27068 @smallexample
27069 [ quat(w, x, y, z) := quat(w, [x, y, z]),
27070   quat(w, [0, 0, 0]) := w,
27071   abs(quat(w, v)) := hypot(w, v),
27072   -quat(w, v) := quat(-w, -v),
27073   r + quat(w, v) := quat(r + w, v) :: real(r),
27074   r - quat(w, v) := quat(r - w, -v) :: real(r),
27075   quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
27076   r * quat(w, v) := quat(r * w, r * v) :: real(r),
27077   plain(quat(w1, v1) * quat(w2, v2))
27078      := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
27079   quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
27080   z / quat(w, v) := z * quatinv(quat(w, v)),
27081   quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
27082   quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
27083   quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
27084                :: integer(k) :: k > 0 :: k % 2 = 0,
27085   quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
27086                :: integer(k) :: k > 2,
27087   quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
27088 @end smallexample
27090 Quaternions, like matrices, have non-commutative multiplication.
27091 In other words, @cite{q1 * q2 = q2 * q1} is not necessarily true if
27092 @cite{q1} and @cite{q2} are @code{quat} forms.  The @samp{quat*quat}
27093 rule above uses @code{plain} to prevent Calc from rearranging the
27094 product.  It may also be wise to add the line @samp{[quat(), matrix]}
27095 to the @code{Decls} matrix, to ensure that Calc's other algebraic
27096 operations will not rearrange a quaternion product.  @xref{Declarations}.
27098 These rules also accept a four-argument @code{quat} form, converting
27099 it to the preferred form in the first rule.  If you would rather see
27100 results in the four-argument form, just append the two items
27101 @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
27102 of the rule set.  (But remember that multi-phase rule sets don't work
27103 in @code{EvalRules}.)
27105 @node Units, Store and Recall, Algebra, Top
27106 @chapter Operating on Units
27108 @noindent
27109 One special interpretation of algebraic formulas is as numbers with units.
27110 For example, the formula @samp{5 m / s^2} can be read ``five meters
27111 per second squared.''  The commands in this chapter help you
27112 manipulate units expressions in this form.  Units-related commands
27113 begin with the @kbd{u} prefix key.
27115 @menu
27116 * Basic Operations on Units::
27117 * The Units Table::
27118 * Predefined Units::
27119 * User-Defined Units::
27120 @end menu
27122 @node Basic Operations on Units, The Units Table, Units, Units
27123 @section Basic Operations on Units
27125 @noindent
27126 A @dfn{units expression} is a formula which is basically a number
27127 multiplied and/or divided by one or more @dfn{unit names}, which may
27128 optionally be raised to integer powers.  Actually, the value part need not
27129 be a number; any product or quotient involving unit names is a units
27130 expression.  Many of the units commands will also accept any formula,
27131 where the command applies to all units expressions which appear in the
27132 formula.
27134 A unit name is a variable whose name appears in the @dfn{unit table},
27135 or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
27136 or @samp{u} (for ``micro'') followed by a name in the unit table.
27137 A substantial table of built-in units is provided with Calc;
27138 @pxref{Predefined Units}.  You can also define your own unit names;
27139 @pxref{User-Defined Units}.@refill
27141 Note that if the value part of a units expression is exactly @samp{1},
27142 it will be removed by the Calculator's automatic algebra routines:  The
27143 formula @samp{1 mm} is ``simplified'' to @samp{mm}.  This is only a
27144 display anomaly, however; @samp{mm} will work just fine as a
27145 representation of one millimeter.@refill
27147 You may find that Algebraic Mode (@pxref{Algebraic Entry}) makes working
27148 with units expressions easier.  Otherwise, you will have to remember
27149 to hit the apostrophe key every time you wish to enter units.
27151 @kindex u s
27152 @pindex calc-simplify-units
27153 @ignore
27154 @mindex usimpl@idots
27155 @end ignore
27156 @tindex usimplify
27157 The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
27158 simplifies a units
27159 expression.  It uses @kbd{a s} (@code{calc-simplify}) to simplify the
27160 expression first as a regular algebraic formula; it then looks for
27161 features that can be further simplified by converting one object's units
27162 to be compatible with another's.  For example, @samp{5 m + 23 mm} will
27163 simplify to @samp{5.023 m}.  When different but compatible units are
27164 added, the righthand term's units are converted to match those of the
27165 lefthand term.  @xref{Simplification Modes}, for a way to have this done
27166 automatically at all times.@refill
27168 Units simplification also handles quotients of two units with the same
27169 dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
27170 powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
27171 @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
27172 @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
27173 @code{float}, @code{frac}, @code{abs}, and @code{clean}
27174 applied to units expressions, in which case
27175 the operation in question is applied only to the numeric part of the
27176 expression.  Finally, trigonometric functions of quantities with units
27177 of angle are evaluated, regardless of the current angular mode.@refill
27179 @kindex u c
27180 @pindex calc-convert-units
27181 The @kbd{u c} (@code{calc-convert-units}) command converts a units
27182 expression to new, compatible units.  For example, given the units
27183 expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
27184 @samp{24.5872 m/s}.  If the units you request are inconsistent with
27185 the original units, the number will be converted into your units
27186 times whatever ``remainder'' units are left over.  For example,
27187 converting @samp{55 mph} into acres produces @samp{6.08e-3 acre / m s}.
27188 (Recall that multiplication binds more strongly than division in Calc
27189 formulas, so the units here are acres per meter-second.)  Remainder
27190 units are expressed in terms of ``fundamental'' units like @samp{m} and
27191 @samp{s}, regardless of the input units.
27193 One special exception is that if you specify a single unit name, and
27194 a compatible unit appears somewhere in the units expression, then
27195 that compatible unit will be converted to the new unit and the
27196 remaining units in the expression will be left alone.  For example,
27197 given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
27198 change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
27199 The ``remainder unit'' @samp{cm} is left alone rather than being
27200 changed to the base unit @samp{m}.
27202 You can use explicit unit conversion instead of the @kbd{u s} command
27203 to gain more control over the units of the result of an expression.
27204 For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
27205 @kbd{u c mm} to express the result in either meters or millimeters.
27206 (For that matter, you could type @kbd{u c fath} to express the result
27207 in fathoms, if you preferred!)
27209 In place of a specific set of units, you can also enter one of the
27210 units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
27211 For example, @kbd{u c si @key{RET}} converts the expression into
27212 International System of Units (SI) base units.  Also, @kbd{u c base}
27213 converts to Calc's base units, which are the same as @code{si} units
27214 except that @code{base} uses @samp{g} as the fundamental unit of mass
27215 whereas @code{si} uses @samp{kg}.
27217 @cindex Composite units
27218 The @kbd{u c} command also accepts @dfn{composite units}, which
27219 are expressed as the sum of several compatible unit names.  For
27220 example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
27221 feet, and inches) produces @samp{2 ft + 6.5 in}.  Calc first
27222 sorts the unit names into order of decreasing relative size.
27223 It then accounts for as much of the input quantity as it can
27224 using an integer number times the largest unit, then moves on
27225 to the next smaller unit, and so on.  Only the smallest unit
27226 may have a non-integer amount attached in the result.  A few
27227 standard unit names exist for common combinations, such as
27228 @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
27229 Composite units are expanded as if by @kbd{a x}, so that
27230 @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
27232 If the value on the stack does not contain any units, @kbd{u c} will
27233 prompt first for the old units which this value should be considered
27234 to have, then for the new units.  Assuming the old and new units you
27235 give are consistent with each other, the result also will not contain
27236 any units.  For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts the number
27237 2 on the stack to 5.08.
27239 @kindex u b
27240 @pindex calc-base-units
27241 The @kbd{u b} (@code{calc-base-units}) command is shorthand for
27242 @kbd{u c base}; it converts the units expression on the top of the
27243 stack into @code{base} units.  If @kbd{u s} does not simplify a
27244 units expression as far as you would like, try @kbd{u b}.
27246 The @kbd{u c} and @kbd{u b} commands treat temperature units (like
27247 @samp{degC} and @samp{K}) as relative temperatures.  For example,
27248 @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10
27249 degrees Celsius corresponds to a change of 18 degrees Fahrenheit.
27251 @kindex u t
27252 @pindex calc-convert-temperature
27253 @cindex Temperature conversion
27254 The @kbd{u t} (@code{calc-convert-temperature}) command converts
27255 absolute temperatures.  The value on the stack must be a simple units
27256 expression with units of temperature only.  This command would convert
27257 @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the
27258 Fahrenheit scale.@refill
27260 @kindex u r
27261 @pindex calc-remove-units
27262 @kindex u x
27263 @pindex calc-extract-units
27264 The @kbd{u r} (@code{calc-remove-units}) command removes units from the
27265 formula at the top of the stack.  The @kbd{u x}
27266 (@code{calc-extract-units}) command extracts only the units portion of a
27267 formula.  These commands essentially replace every term of the formula
27268 that does or doesn't (respectively) look like a unit name by the
27269 constant 1, then resimplify the formula.@refill
27271 @kindex u a
27272 @pindex calc-autorange-units
27273 The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
27274 mode in which unit prefixes like @code{k} (``kilo'') are automatically
27275 applied to keep the numeric part of a units expression in a reasonable
27276 range.  This mode affects @kbd{u s} and all units conversion commands
27277 except @kbd{u b}.  For example, with autoranging on, @samp{12345 Hz}
27278 will be simplified to @samp{12.345 kHz}.  Autoranging is useful for
27279 some kinds of units (like @code{Hz} and @code{m}), but is probably
27280 undesirable for non-metric units like @code{ft} and @code{tbsp}.
27281 (Composite units are more appropriate for those; see above.)
27283 Autoranging always applies the prefix to the leftmost unit name.
27284 Calc chooses the largest prefix that causes the number to be greater
27285 than or equal to 1.0.  Thus an increasing sequence of adjusted times
27286 would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
27287 Generally the rule of thumb is that the number will be adjusted
27288 to be in the interval @samp{[1 .. 1000)}, although there are several
27289 exceptions to this rule.  First, if the unit has a power then this
27290 is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
27291 Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
27292 but will not apply to other units.  The ``deci-,'' ``deka-,'' and
27293 ``hecto-'' prefixes are never used.  Thus the allowable interval is
27294 @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
27295 Finally, a prefix will not be added to a unit if the resulting name
27296 is also the actual name of another unit; @samp{1e-15 t} would normally
27297 be considered a ``femto-ton,'' but it is written as @samp{1000 at}
27298 (1000 atto-tons) instead because @code{ft} would be confused with feet.
27300 @node The Units Table, Predefined Units, Basic Operations on Units, Units
27301 @section The Units Table
27303 @noindent
27304 @kindex u v
27305 @pindex calc-enter-units-table
27306 The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
27307 in another buffer called @code{*Units Table*}.  Each entry in this table
27308 gives the unit name as it would appear in an expression, the definition
27309 of the unit in terms of simpler units, and a full name or description of
27310 the unit.  Fundamental units are defined as themselves; these are the
27311 units produced by the @kbd{u b} command.  The fundamental units are
27312 meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
27313 and steradians.
27315 The Units Table buffer also displays the Unit Prefix Table.  Note that
27316 two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
27317 prefix letters.  @samp{Meg} is also accepted as a synonym for the @samp{M}
27318 prefix.  Whenever a unit name can be interpreted as either a built-in name
27319 or a prefix followed by another built-in name, the former interpretation
27320 wins.  For example, @samp{2 pt} means two pints, not two pico-tons.
27322 The Units Table buffer, once created, is not rebuilt unless you define
27323 new units.  To force the buffer to be rebuilt, give any numeric prefix
27324 argument to @kbd{u v}.
27326 @kindex u V
27327 @pindex calc-view-units-table
27328 The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
27329 that the cursor is not moved into the Units Table buffer.  You can
27330 type @kbd{u V} again to remove the Units Table from the display.  To
27331 return from the Units Table buffer after a @kbd{u v}, type @kbd{M-# c}
27332 again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
27333 command.  You can also kill the buffer with @kbd{C-x k} if you wish;
27334 the actual units table is safely stored inside the Calculator.
27336 @kindex u g
27337 @pindex calc-get-unit-definition
27338 The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
27339 defining expression and pushes it onto the Calculator stack.  For example,
27340 @kbd{u g in} will produce the expression @samp{2.54 cm}.  This is the
27341 same definition for the unit that would appear in the Units Table buffer.
27342 Note that this command works only for actual unit names; @kbd{u g km}
27343 will report that no such unit exists, for example, because @code{km} is
27344 really the unit @code{m} with a @code{k} (``kilo'') prefix.  To see a
27345 definition of a unit in terms of base units, it is easier to push the
27346 unit name on the stack and then reduce it to base units with @kbd{u b}.
27348 @kindex u e
27349 @pindex calc-explain-units
27350 The @kbd{u e} (@code{calc-explain-units}) command displays an English
27351 description of the units of the expression on the stack.  For example,
27352 for the expression @samp{62 km^2 g / s^2 mol K}, the description is
27353 ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).''  This
27354 command uses the English descriptions that appear in the righthand
27355 column of the Units Table.
27357 @node Predefined Units, User-Defined Units, The Units Table, Units
27358 @section Predefined Units
27360 @noindent
27361 Since the exact definitions of many kinds of units have evolved over the
27362 years, and since certain countries sometimes have local differences in
27363 their definitions, it is a good idea to examine Calc's definition of a
27364 unit before depending on its exact value.  For example, there are three
27365 different units for gallons, corresponding to the US (@code{gal}),
27366 Canadian (@code{galC}), and British (@code{galUK}) definitions.  Also,
27367 note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
27368 ounce, and @code{ozfl} is a fluid ounce.
27370 The temperature units corresponding to degrees Kelvin and Centigrade
27371 (Celsius) are the same in this table, since most units commands treat
27372 temperatures as being relative.  The @code{calc-convert-temperature}
27373 command has special rules for handling the different absolute magnitudes
27374 of the various temperature scales.
27376 The unit of volume ``liters'' can be referred to by either the lower-case
27377 @code{l} or the upper-case @code{L}.
27379 The unit @code{A} stands for Amperes; the name @code{Ang} is used
27380 @tex
27381 for \AA ngstroms.
27382 @end tex
27383 @ifinfo
27384 for Angstroms.
27385 @end ifinfo
27387 The unit @code{pt} stands for pints; the name @code{point} stands for
27388 a typographical point, defined by @samp{72 point = 1 in}.  There is
27389 also @code{tpt}, which stands for a printer's point as defined by the
27390 @TeX{} typesetting system:  @samp{72.27 tpt = 1 in}.
27392 The unit @code{e} stands for the elementary (electron) unit of charge;
27393 because algebra command could mistake this for the special constant
27394 @cite{e}, Calc provides the alternate unit name @code{ech} which is
27395 preferable to @code{e}.
27397 The name @code{g} stands for one gram of mass; there is also @code{gf},
27398 one gram of force.  (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
27399 Meanwhile, one ``@cite{g}'' of acceleration is denoted @code{ga}.
27401 The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
27402 a metric ton of @samp{1000 kg}.
27404 The names @code{s} (or @code{sec}) and @code{min} refer to units of
27405 time; @code{arcsec} and @code{arcmin} are units of angle.
27407 Some ``units'' are really physical constants; for example, @code{c}
27408 represents the speed of light, and @code{h} represents Planck's
27409 constant.  You can use these just like other units: converting
27410 @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
27411 meters per second.  You can also use this merely as a handy reference;
27412 the @kbd{u g} command gets the definition of one of these constants
27413 in its normal terms, and @kbd{u b} expresses the definition in base
27414 units.
27416 Two units, @code{pi} and @code{fsc} (the fine structure constant,
27417 approximately @i{1/137}) are dimensionless.  The units simplification
27418 commands simply treat these names as equivalent to their corresponding
27419 values.  However you can, for example, use @kbd{u c} to convert a pure
27420 number into multiples of the fine structure constant, or @kbd{u b} to
27421 convert this back into a pure number.  (When @kbd{u c} prompts for the
27422 ``old units,'' just enter a blank line to signify that the value
27423 really is unitless.)
27425 @c Describe angular units, luminosity vs. steradians problem.
27427 @node User-Defined Units, , Predefined Units, Units
27428 @section User-Defined Units
27430 @noindent
27431 Calc provides ways to get quick access to your selected ``favorite''
27432 units, as well as ways to define your own new units.
27434 @kindex u 0-9
27435 @pindex calc-quick-units
27436 @vindex Units
27437 @cindex @code{Units} variable
27438 @cindex Quick units
27439 To select your favorite units, store a vector of unit names or
27440 expressions in the Calc variable @code{Units}.  The @kbd{u 1}
27441 through @kbd{u 9} commands (@code{calc-quick-units}) provide access
27442 to these units.  If the value on the top of the stack is a plain
27443 number (with no units attached), then @kbd{u 1} gives it the
27444 specified units.  (Basically, it multiplies the number by the
27445 first item in the @code{Units} vector.)  If the number on the
27446 stack @emph{does} have units, then @kbd{u 1} converts that number
27447 to the new units.  For example, suppose the vector @samp{[in, ft]}
27448 is stored in @code{Units}.  Then @kbd{30 u 1} will create the
27449 expression @samp{30 in}, and @kbd{u 2} will convert that expression
27450 to @samp{2.5 ft}.
27452 The @kbd{u 0} command accesses the tenth element of @code{Units}.
27453 Only ten quick units may be defined at a time.  If the @code{Units}
27454 variable has no stored value (the default), or if its value is not
27455 a vector, then the quick-units commands will not function.  The
27456 @kbd{s U} command is a convenient way to edit the @code{Units}
27457 variable; @pxref{Operations on Variables}.
27459 @kindex u d
27460 @pindex calc-define-unit
27461 @cindex User-defined units
27462 The @kbd{u d} (@code{calc-define-unit}) command records the units
27463 expression on the top of the stack as the definition for a new,
27464 user-defined unit.  For example, putting @samp{16.5 ft} on the stack and
27465 typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
27466 16.5 feet.  The unit conversion and simplification commands will now
27467 treat @code{rod} just like any other unit of length.  You will also be
27468 prompted for an optional English description of the unit, which will
27469 appear in the Units Table.
27471 @kindex u u
27472 @pindex calc-undefine-unit
27473 The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
27474 unit.  It is not possible to remove one of the predefined units,
27475 however.
27477 If you define a unit with an existing unit name, your new definition
27478 will replace the original definition of that unit.  If the unit was a
27479 predefined unit, the old definition will not be replaced, only
27480 ``shadowed.''  The built-in definition will reappear if you later use
27481 @kbd{u u} to remove the shadowing definition.
27483 To create a new fundamental unit, use either 1 or the unit name itself
27484 as the defining expression.  Otherwise the expression can involve any
27485 other units that you like (except for composite units like @samp{mfi}).
27486 You can create a new composite unit with a sum of other units as the
27487 defining expression.  The next unit operation like @kbd{u c} or @kbd{u v}
27488 will rebuild the internal unit table incorporating your modifications.
27489 Note that erroneous definitions (such as two units defined in terms of
27490 each other) will not be detected until the unit table is next rebuilt;
27491 @kbd{u v} is a convenient way to force this to happen.
27493 Temperature units are treated specially inside the Calculator; it is not
27494 possible to create user-defined temperature units.
27496 @kindex u p
27497 @pindex calc-permanent-units
27498 @cindex @file{.emacs} file, user-defined units
27499 The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
27500 units in your @file{.emacs} file, so that the units will still be
27501 available in subsequent Emacs sessions.  If there was already a set of
27502 user-defined units in your @file{.emacs} file, it is replaced by the
27503 new set.  (@xref{General Mode Commands}, for a way to tell Calc to use
27504 a different file instead of @file{.emacs}.)
27506 @node Store and Recall, Graphics, Units, Top
27507 @chapter Storing and Recalling
27509 @noindent
27510 Calculator variables are really just Lisp variables that contain numbers
27511 or formulas in a form that Calc can understand.  The commands in this
27512 section allow you to manipulate variables conveniently.  Commands related
27513 to variables use the @kbd{s} prefix key.
27515 @menu
27516 * Storing Variables::
27517 * Recalling Variables::
27518 * Operations on Variables::
27519 * Let Command::
27520 * Evaluates-To Operator::
27521 @end menu
27523 @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
27524 @section Storing Variables
27526 @noindent
27527 @kindex s s
27528 @pindex calc-store
27529 @cindex Storing variables
27530 @cindex Quick variables
27531 @vindex q0
27532 @vindex q9
27533 The @kbd{s s} (@code{calc-store}) command stores the value at the top of
27534 the stack into a specified variable.  It prompts you to enter the
27535 name of the variable.  If you press a single digit, the value is stored
27536 immediately in one of the ``quick'' variables @code{var-q0} through
27537 @code{var-q9}.  Or you can enter any variable name.  The prefix @samp{var-}
27538 is supplied for you; when a name appears in a formula (as in @samp{a+q2})
27539 the prefix @samp{var-} is also supplied there, so normally you can simply
27540 forget about @samp{var-} everywhere.  Its only purpose is to enable you to
27541 use Calc variables without fear of accidentally clobbering some variable in
27542 another Emacs package.  If you really want to store in an arbitrary Lisp
27543 variable, just backspace over the @samp{var-}.
27545 @kindex s t
27546 @pindex calc-store-into
27547 The @kbd{s s} command leaves the stored value on the stack.  There is
27548 also an @kbd{s t} (@code{calc-store-into}) command, which removes a
27549 value from the stack and stores it in a variable.
27551 If the top of stack value is an equation @samp{a = 7} or assignment
27552 @samp{a := 7} with a variable on the lefthand side, then Calc will
27553 assign that variable with that value by default, i.e., if you type
27554 @kbd{s s @key{RET}} or @kbd{s t @key{RET}}.  In this example, the
27555 value 7 would be stored in the variable @samp{a}.  (If you do type
27556 a variable name at the prompt, the top-of-stack value is stored in
27557 its entirety, even if it is an equation:  @samp{s s b @key{RET}}
27558 with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
27560 In fact, the top of stack value can be a vector of equations or
27561 assignments with different variables on their lefthand sides; the
27562 default will be to store all the variables with their corresponding
27563 righthand sides simultaneously.
27565 It is also possible to type an equation or assignment directly at
27566 the prompt for the @kbd{s s} or @kbd{s t} command:  @kbd{s s foo = 7}.
27567 In this case the expression to the right of the @kbd{=} or @kbd{:=}
27568 symbol is evaluated as if by the @kbd{=} command, and that value is
27569 stored in the variable.  No value is taken from the stack; @kbd{s s}
27570 and @kbd{s t} are equivalent when used in this way.
27572 @kindex s 0-9
27573 @kindex t 0-9
27574 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
27575 digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
27576 equivalent to @kbd{s t 9}.  (The @kbd{t} prefix is otherwise used
27577 for trail and time/date commands.)
27579 @kindex s +
27580 @kindex s -
27581 @ignore
27582 @mindex @idots
27583 @end ignore
27584 @kindex s *
27585 @ignore
27586 @mindex @null
27587 @end ignore
27588 @kindex s /
27589 @ignore
27590 @mindex @null
27591 @end ignore
27592 @kindex s ^
27593 @ignore
27594 @mindex @null
27595 @end ignore
27596 @kindex s |
27597 @ignore
27598 @mindex @null
27599 @end ignore
27600 @kindex s n
27601 @ignore
27602 @mindex @null
27603 @end ignore
27604 @kindex s &
27605 @ignore
27606 @mindex @null
27607 @end ignore
27608 @kindex s [
27609 @ignore
27610 @mindex @null
27611 @end ignore
27612 @kindex s ]
27613 @pindex calc-store-plus
27614 @pindex calc-store-minus
27615 @pindex calc-store-times
27616 @pindex calc-store-div
27617 @pindex calc-store-power
27618 @pindex calc-store-concat
27619 @pindex calc-store-neg
27620 @pindex calc-store-inv
27621 @pindex calc-store-decr
27622 @pindex calc-store-incr
27623 There are also several ``arithmetic store'' commands.  For example,
27624 @kbd{s +} removes a value from the stack and adds it to the specified
27625 variable.  The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
27626 @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
27627 @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
27628 and @kbd{s ]} which decrease or increase a variable by one.
27630 All the arithmetic stores accept the Inverse prefix to reverse the
27631 order of the operands.  If @cite{v} represents the contents of the
27632 variable, and @cite{a} is the value drawn from the stack, then regular
27633 @w{@kbd{s -}} assigns @c{$v \coloneq v - a$}
27634 @cite{v := v - a}, but @kbd{I s -} assigns
27635 @c{$v \coloneq a - v$}
27636 @cite{v := a - v}.  While @kbd{I s *} might seem pointless, it is
27637 useful if matrix multiplication is involved.  Actually, all the
27638 arithmetic stores use formulas designed to behave usefully both
27639 forwards and backwards:
27641 @example
27642 @group
27643 s +        v := v + a          v := a + v
27644 s -        v := v - a          v := a - v
27645 s *        v := v * a          v := a * v
27646 s /        v := v / a          v := a / v
27647 s ^        v := v ^ a          v := a ^ v
27648 s |        v := v | a          v := a | v
27649 s n        v := v / (-1)       v := (-1) / v
27650 s &        v := v ^ (-1)       v := (-1) ^ v
27651 s [        v := v - 1          v := 1 - v
27652 s ]        v := v - (-1)       v := (-1) - v
27653 @end group
27654 @end example
27656 In the last four cases, a numeric prefix argument will be used in
27657 place of the number one.  (For example, @kbd{M-2 s ]} increases
27658 a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
27659 minus-two minus the variable.
27661 The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
27662 etc.  The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
27663 arithmetic stores that don't remove the value @cite{a} from the stack.
27665 All arithmetic stores report the new value of the variable in the
27666 Trail for your information.  They signal an error if the variable
27667 previously had no stored value.  If default simplifications have been
27668 turned off, the arithmetic stores temporarily turn them on for numeric
27669 arguments only (i.e., they temporarily do an @kbd{m N} command).
27670 @xref{Simplification Modes}.  Large vectors put in the trail by
27671 these commands always use abbreviated (@kbd{t .}) mode.
27673 @kindex s m
27674 @pindex calc-store-map
27675 The @kbd{s m} command is a general way to adjust a variable's value
27676 using any Calc function.  It is a ``mapping'' command analogous to
27677 @kbd{V M}, @kbd{V R}, etc.  @xref{Reducing and Mapping}, to see
27678 how to specify a function for a mapping command.  Basically,
27679 all you do is type the Calc command key that would invoke that
27680 function normally.  For example, @kbd{s m n} applies the @kbd{n}
27681 key to negate the contents of the variable, so @kbd{s m n} is
27682 equivalent to @kbd{s n}.  Also, @kbd{s m Q} takes the square root
27683 of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
27684 reverse the vector stored in the variable, and @kbd{s m H I S}
27685 takes the hyperbolic arcsine of the variable contents.
27687 If the mapping function takes two or more arguments, the additional
27688 arguments are taken from the stack; the old value of the variable
27689 is provided as the first argument.  Thus @kbd{s m -} with @cite{a}
27690 on the stack computes @cite{v - a}, just like @kbd{s -}.  With the
27691 Inverse prefix, the variable's original value becomes the @emph{last}
27692 argument instead of the first.  Thus @kbd{I s m -} is also
27693 equivalent to @kbd{I s -}.
27695 @kindex s x
27696 @pindex calc-store-exchange
27697 The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
27698 of a variable with the value on the top of the stack.  Naturally, the
27699 variable must already have a stored value for this to work.
27701 You can type an equation or assignment at the @kbd{s x} prompt.  The
27702 command @kbd{s x a=6} takes no values from the stack; instead, it
27703 pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
27705 @kindex s u
27706 @pindex calc-unstore
27707 @cindex Void variables
27708 @cindex Un-storing variables
27709 Until you store something in them, variables are ``void,'' that is, they
27710 contain no value at all.  If they appear in an algebraic formula they
27711 will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
27712 The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
27713 void state.@refill
27715 The only variables with predefined values are the ``special constants''
27716 @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}.  You are free
27717 to unstore these variables or to store new values into them if you like,
27718 although some of the algebraic-manipulation functions may assume these
27719 variables represent their standard values.  Calc displays a warning if
27720 you change the value of one of these variables, or of one of the other
27721 special variables @code{inf}, @code{uinf}, and @code{nan} (which are
27722 normally void).
27724 Note that @code{var-pi} doesn't actually have 3.14159265359 stored
27725 in it, but rather a special magic value that evaluates to @c{$\pi$}
27726 @cite{pi}
27727 at the current precision.  Likewise @code{var-e}, @code{var-i}, and
27728 @code{var-phi} evaluate according to the current precision or polar mode.
27729 If you recall a value from @code{pi} and store it back, this magic
27730 property will be lost.
27732 @kindex s c
27733 @pindex calc-copy-variable
27734 The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
27735 value of one variable to another.  It differs from a simple @kbd{s r}
27736 followed by an @kbd{s t} in two important ways.  First, the value never
27737 goes on the stack and thus is never rounded, evaluated, or simplified
27738 in any way; it is not even rounded down to the current precision.
27739 Second, the ``magic'' contents of a variable like @code{var-e} can
27740 be copied into another variable with this command, perhaps because
27741 you need to unstore @code{var-e} right now but you wish to put it
27742 back when you're done.  The @kbd{s c} command is the only way to
27743 manipulate these magic values intact.
27745 @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
27746 @section Recalling Variables
27748 @noindent
27749 @kindex s r
27750 @pindex calc-recall
27751 @cindex Recalling variables
27752 The most straightforward way to extract the stored value from a variable
27753 is to use the @kbd{s r} (@code{calc-recall}) command.  This command prompts
27754 for a variable name (similarly to @code{calc-store}), looks up the value
27755 of the specified variable, and pushes that value onto the stack.  It is
27756 an error to try to recall a void variable.
27758 It is also possible to recall the value from a variable by evaluating a
27759 formula containing that variable.  For example, @kbd{' a @key{RET} =} is
27760 the same as @kbd{s r a @key{RET}} except that if the variable is void, the
27761 former will simply leave the formula @samp{a} on the stack whereas the
27762 latter will produce an error message.
27764 @kindex r 0-9
27765 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
27766 equivalent to @kbd{s r 9}.  (The @kbd{r} prefix is otherwise unused
27767 in the current version of Calc.)
27769 @node Operations on Variables, Let Command, Recalling Variables, Store and Recall
27770 @section Other Operations on Variables
27772 @noindent
27773 @kindex s e
27774 @pindex calc-edit-variable
27775 The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
27776 value of a variable without ever putting that value on the stack
27777 or simplifying or evaluating the value.  It prompts for the name of
27778 the variable to edit.  If the variable has no stored value, the
27779 editing buffer will start out empty.  If the editing buffer is
27780 empty when you press @kbd{M-# M-#} to finish, the variable will
27781 be made void.  @xref{Editing Stack Entries}, for a general
27782 description of editing.
27784 The @kbd{s e} command is especially useful for creating and editing
27785 rewrite rules which are stored in variables.  Sometimes these rules
27786 contain formulas which must not be evaluated until the rules are
27787 actually used.  (For example, they may refer to @samp{deriv(x,y)},
27788 where @code{x} will someday become some expression involving @code{y};
27789 if you let Calc evaluate the rule while you are defining it, Calc will
27790 replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
27791 not itself refer to @code{y}.)  By contrast, recalling the variable,
27792 editing with @kbd{`}, and storing will evaluate the variable's value
27793 as a side effect of putting the value on the stack.
27795 @kindex s A
27796 @kindex s D
27797 @ignore
27798 @mindex @idots
27799 @end ignore
27800 @kindex s E
27801 @ignore
27802 @mindex @null
27803 @end ignore
27804 @kindex s F
27805 @ignore
27806 @mindex @null
27807 @end ignore
27808 @kindex s G
27809 @ignore
27810 @mindex @null
27811 @end ignore
27812 @kindex s H
27813 @ignore
27814 @mindex @null
27815 @end ignore
27816 @kindex s I
27817 @ignore
27818 @mindex @null
27819 @end ignore
27820 @kindex s L
27821 @ignore
27822 @mindex @null
27823 @end ignore
27824 @kindex s P
27825 @ignore
27826 @mindex @null
27827 @end ignore
27828 @kindex s R
27829 @ignore
27830 @mindex @null
27831 @end ignore
27832 @kindex s T
27833 @ignore
27834 @mindex @null
27835 @end ignore
27836 @kindex s U
27837 @ignore
27838 @mindex @null
27839 @end ignore
27840 @kindex s X
27841 @pindex calc-store-AlgSimpRules
27842 @pindex calc-store-Decls
27843 @pindex calc-store-EvalRules
27844 @pindex calc-store-FitRules
27845 @pindex calc-store-GenCount
27846 @pindex calc-store-Holidays
27847 @pindex calc-store-IntegLimit
27848 @pindex calc-store-LineStyles
27849 @pindex calc-store-PointStyles
27850 @pindex calc-store-PlotRejects
27851 @pindex calc-store-TimeZone
27852 @pindex calc-store-Units
27853 @pindex calc-store-ExtSimpRules
27854 There are several special-purpose variable-editing commands that
27855 use the @kbd{s} prefix followed by a shifted letter:
27857 @table @kbd
27858 @item s A
27859 Edit @code{AlgSimpRules}.  @xref{Algebraic Simplifications}.
27860 @item s D
27861 Edit @code{Decls}.  @xref{Declarations}.
27862 @item s E
27863 Edit @code{EvalRules}.  @xref{Default Simplifications}.
27864 @item s F
27865 Edit @code{FitRules}.  @xref{Curve Fitting}.
27866 @item s G
27867 Edit @code{GenCount}.  @xref{Solving Equations}.
27868 @item s H
27869 Edit @code{Holidays}.  @xref{Business Days}.
27870 @item s I
27871 Edit @code{IntegLimit}.  @xref{Calculus}.
27872 @item s L
27873 Edit @code{LineStyles}.  @xref{Graphics}.
27874 @item s P
27875 Edit @code{PointStyles}.  @xref{Graphics}.
27876 @item s R
27877 Edit @code{PlotRejects}.  @xref{Graphics}.
27878 @item s T
27879 Edit @code{TimeZone}.  @xref{Time Zones}.
27880 @item s U
27881 Edit @code{Units}.  @xref{User-Defined Units}.
27882 @item s X
27883 Edit @code{ExtSimpRules}.  @xref{Unsafe Simplifications}.
27884 @end table
27886 These commands are just versions of @kbd{s e} that use fixed variable
27887 names rather than prompting for the variable name.
27889 @kindex s p
27890 @pindex calc-permanent-variable
27891 @cindex Storing variables
27892 @cindex Permanent variables
27893 @cindex @file{.emacs} file, variables
27894 The @kbd{s p} (@code{calc-permanent-variable}) command saves a
27895 variable's value permanently in your @file{.emacs} file, so that its
27896 value will still be available in future Emacs sessions.  You can
27897 re-execute @w{@kbd{s p}} later on to update the saved value, but the
27898 only way to remove a saved variable is to edit your @file{.emacs} file
27899 by hand.  (@xref{General Mode Commands}, for a way to tell Calc to
27900 use a different file instead of @file{.emacs}.)
27902 If you do not specify the name of a variable to save (i.e.,
27903 @kbd{s p @key{RET}}), all @samp{var-} variables with defined values
27904 are saved except for the special constants @code{pi}, @code{e},
27905 @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
27906 and @code{PlotRejects};
27907 @code{FitRules}, @code{DistribRules}, and other built-in rewrite
27908 rules; and @code{PlotData@var{n}} variables generated
27909 by the graphics commands.  (You can still save these variables by
27910 explicitly naming them in an @kbd{s p} command.)@refill
27912 @kindex s i
27913 @pindex calc-insert-variables
27914 The @kbd{s i} (@code{calc-insert-variables}) command writes
27915 the values of all @samp{var-} variables into a specified buffer.
27916 The variables are written in the form of Lisp @code{setq} commands
27917 which store the values in string form.  You can place these commands
27918 in your @file{.emacs} buffer if you wish, though in this case it
27919 would be easier to use @kbd{s p @key{RET}}.  (Note that @kbd{s i}
27920 omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
27921 is that @kbd{s i} will store the variables in any buffer, and it also
27922 stores in a more human-readable format.)
27924 @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
27925 @section The Let Command
27927 @noindent
27928 @kindex s l
27929 @pindex calc-let
27930 @cindex Variables, temporary assignment
27931 @cindex Temporary assignment to variables
27932 If you have an expression like @samp{a+b^2} on the stack and you wish to
27933 compute its value where @cite{b=3}, you can simply store 3 in @cite{b} and
27934 then press @kbd{=} to reevaluate the formula.  This has the side-effect
27935 of leaving the stored value of 3 in @cite{b} for future operations.
27937 The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
27938 @emph{temporary} assignment of a variable.  It stores the value on the
27939 top of the stack into the specified variable, then evaluates the
27940 second-to-top stack entry, then restores the original value (or lack of one)
27941 in the variable.  Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
27942 the stack will contain the formula @samp{a + 9}.  The subsequent command
27943 @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
27944 The variables @samp{a} and @samp{b} are not permanently affected in any way
27945 by these commands.
27947 The value on the top of the stack may be an equation or assignment, or
27948 a vector of equations or assignments, in which case the default will be
27949 analogous to the case of @kbd{s t @key{RET}}.  @xref{Storing Variables}.
27951 Also, you can answer the variable-name prompt with an equation or
27952 assignment:  @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
27953 and typing @kbd{s l b @key{RET}}.
27955 The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
27956 a variable with a value in a formula.  It does an actual substitution
27957 rather than temporarily assigning the variable and evaluating.  For
27958 example, letting @cite{n=2} in @samp{f(n pi)} with @kbd{a b} will
27959 produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
27960 since the evaluation step will also evaluate @code{pi}.
27962 @node Evaluates-To Operator, , Let Command, Store and Recall
27963 @section The Evaluates-To Operator
27965 @noindent
27966 @tindex evalto
27967 @tindex =>
27968 @cindex Evaluates-to operator
27969 @cindex @samp{=>} operator
27970 The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
27971 operator}.  (It will show up as an @code{evalto} function call in
27972 other language modes like Pascal and @TeX{}.)  This is a binary
27973 operator, that is, it has a lefthand and a righthand argument,
27974 although it can be entered with the righthand argument omitted.
27976 A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
27977 follows:  First, @var{a} is not simplified or modified in any
27978 way.  The previous value of argument @var{b} is thrown away; the
27979 formula @var{a} is then copied and evaluated as if by the @kbd{=}
27980 command according to all current modes and stored variable values,
27981 and the result is installed as the new value of @var{b}.
27983 For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
27984 The number 17 is ignored, and the lefthand argument is left in its
27985 unevaluated form; the result is the formula @samp{2 + 3 => 5}.
27987 @kindex s =
27988 @pindex calc-evalto
27989 You can enter an @samp{=>} formula either directly using algebraic
27990 entry (in which case the righthand side may be omitted since it is
27991 going to be replaced right away anyhow), or by using the @kbd{s =}
27992 (@code{calc-evalto}) command, which takes @var{a} from the stack
27993 and replaces it with @samp{@var{a} => @var{b}}.
27995 Calc keeps track of all @samp{=>} operators on the stack, and
27996 recomputes them whenever anything changes that might affect their
27997 values, i.e., a mode setting or variable value.  This occurs only
27998 if the @samp{=>} operator is at the top level of the formula, or
27999 if it is part of a top-level vector.  In other words, pushing
28000 @samp{2 + (a => 17)} will change the 17 to the actual value of
28001 @samp{a} when you enter the formula, but the result will not be
28002 dynamically updated when @samp{a} is changed later because the
28003 @samp{=>} operator is buried inside a sum.  However, a vector
28004 of @samp{=>} operators will be recomputed, since it is convenient
28005 to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
28006 make a concise display of all the variables in your problem.
28007 (Another way to do this would be to use @samp{[a, b, c] =>},
28008 which provides a slightly different format of display.  You
28009 can use whichever you find easiest to read.)
28011 @kindex m C
28012 @pindex calc-auto-recompute
28013 The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
28014 turn this automatic recomputation on or off.  If you turn
28015 recomputation off, you must explicitly recompute an @samp{=>}
28016 operator on the stack in one of the usual ways, such as by
28017 pressing @kbd{=}.  Turning recomputation off temporarily can save
28018 a lot of time if you will be changing several modes or variables
28019 before you look at the @samp{=>} entries again.
28021 Most commands are not especially useful with @samp{=>} operators
28022 as arguments.  For example, given @samp{x + 2 => 17}, it won't
28023 work to type @kbd{1 +} to get @samp{x + 3 => 18}.  If you want
28024 to operate on the lefthand side of the @samp{=>} operator on
28025 the top of the stack, type @kbd{j 1} (that's the digit ``one'')
28026 to select the lefthand side, execute your commands, then type
28027 @kbd{j u} to unselect.
28029 All current modes apply when an @samp{=>} operator is computed,
28030 including the current simplification mode.  Recall that the
28031 formula @samp{x + y + x} is not handled by Calc's default
28032 simplifications, but the @kbd{a s} command will reduce it to
28033 the simpler form @samp{y + 2 x}.  You can also type @kbd{m A}
28034 to enable an algebraic-simplification mode in which the
28035 equivalent of @kbd{a s} is used on all of Calc's results.
28036 If you enter @samp{x + y + x =>} normally, the result will
28037 be @samp{x + y + x => x + y + x}.  If you change to
28038 algebraic-simplification mode, the result will be
28039 @samp{x + y + x => y + 2 x}.  However, just pressing @kbd{a s}
28040 once will have no effect on @samp{x + y + x => x + y + x},
28041 because the righthand side depends only on the lefthand side
28042 and the current mode settings, and the lefthand side is not
28043 affected by commands like @kbd{a s}.
28045 The ``let'' command (@kbd{s l}) has an interesting interaction
28046 with the @samp{=>} operator.  The @kbd{s l} command evaluates the
28047 second-to-top stack entry with the top stack entry supplying
28048 a temporary value for a given variable.  As you might expect,
28049 if that stack entry is an @samp{=>} operator its righthand
28050 side will temporarily show this value for the variable.  In
28051 fact, all @samp{=>}s on the stack will be updated if they refer
28052 to that variable.  But this change is temporary in the sense
28053 that the next command that causes Calc to look at those stack
28054 entries will make them revert to the old variable value.
28056 @smallexample
28057 @group
28058 2:  a => a             2:  a => 17         2:  a => a
28059 1:  a + 1 => a + 1     1:  a + 1 => 18     1:  a + 1 => a + 1
28060     .                      .                   .
28062                            17 s l a @key{RET}        p 8 @key{RET}
28063 @end group
28064 @end smallexample
28066 Here the @kbd{p 8} command changes the current precision,
28067 thus causing the @samp{=>} forms to be recomputed after the
28068 influence of the ``let'' is gone.  The @kbd{d @key{SPC}} command
28069 (@code{calc-refresh}) is a handy way to force the @samp{=>}
28070 operators on the stack to be recomputed without any other
28071 side effects.
28073 @kindex s :
28074 @pindex calc-assign
28075 @tindex assign
28076 @tindex :=
28077 Embedded Mode also uses @samp{=>} operators.  In embedded mode,
28078 the lefthand side of an @samp{=>} operator can refer to variables
28079 assigned elsewhere in the file by @samp{:=} operators.  The
28080 assignment operator @samp{a := 17} does not actually do anything
28081 by itself.  But Embedded Mode recognizes it and marks it as a sort
28082 of file-local definition of the variable.  You can enter @samp{:=}
28083 operators in algebraic mode, or by using the @kbd{s :}
28084 (@code{calc-assign}) [@code{assign}] command which takes a variable
28085 and value from the stack and replaces them with an assignment.
28087 @xref{TeX Language Mode}, for the way @samp{=>} appears in
28088 @TeX{} language output.  The @dfn{eqn} mode gives similar
28089 treatment to @samp{=>}.
28091 @node Graphics, Kill and Yank, Store and Recall, Top
28092 @chapter Graphics
28094 @noindent
28095 The commands for graphing data begin with the @kbd{g} prefix key.  Calc
28096 uses GNUPLOT 2.0 or 3.0 to do graphics.  These commands will only work
28097 if GNUPLOT is available on your system.  (While GNUPLOT sounds like
28098 a relative of GNU Emacs, it is actually completely unrelated.
28099 However, it is free software and can be obtained from the Free
28100 Software Foundation's machine @samp{prep.ai.mit.edu}.)
28102 @vindex calc-gnuplot-name
28103 If you have GNUPLOT installed on your system but Calc is unable to
28104 find it, you may need to set the @code{calc-gnuplot-name} variable
28105 in your @file{.emacs} file.  You may also need to set some Lisp
28106 variables to show Calc how to run GNUPLOT on your system; these
28107 are described under @kbd{g D} and @kbd{g O} below.  If you are
28108 using the X window system, Calc will configure GNUPLOT for you
28109 automatically.  If you have GNUPLOT 3.0 and you are not using X,
28110 Calc will configure GNUPLOT to display graphs using simple character
28111 graphics that will work on any terminal.
28113 @menu
28114 * Basic Graphics::
28115 * Three Dimensional Graphics::
28116 * Managing Curves::
28117 * Graphics Options::
28118 * Devices::
28119 @end menu
28121 @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
28122 @section Basic Graphics
28124 @noindent
28125 @kindex g f
28126 @pindex calc-graph-fast
28127 The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
28128 This command takes two vectors of equal length from the stack.
28129 The vector at the top of the stack represents the ``y'' values of
28130 the various data points.  The vector in the second-to-top position
28131 represents the corresponding ``x'' values.  This command runs
28132 GNUPLOT (if it has not already been started by previous graphing
28133 commands) and displays the set of data points.  The points will
28134 be connected by lines, and there will also be some kind of symbol
28135 to indicate the points themselves.
28137 The ``x'' entry may instead be an interval form, in which case suitable
28138 ``x'' values are interpolated between the minimum and maximum values of
28139 the interval (whether the interval is open or closed is ignored).
28141 The ``x'' entry may also be a number, in which case Calc uses the
28142 sequence of ``x'' values @cite{x}, @cite{x+1}, @cite{x+2}, etc.
28143 (Generally the number 0 or 1 would be used for @cite{x} in this case.)
28145 The ``y'' entry may be any formula instead of a vector.  Calc effectively
28146 uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
28147 the result of this must be a formula in a single (unassigned) variable.
28148 The formula is plotted with this variable taking on the various ``x''
28149 values.  Graphs of formulas by default use lines without symbols at the
28150 computed data points.  Note that if neither ``x'' nor ``y'' is a vector,
28151 Calc guesses at a reasonable number of data points to use.  See the
28152 @kbd{g N} command below.  (The ``x'' values must be either a vector
28153 or an interval if ``y'' is a formula.)
28155 @ignore
28156 @starindex
28157 @end ignore
28158 @tindex xy
28159 If ``y'' is (or evaluates to) a formula of the form
28160 @samp{xy(@var{x}, @var{y})} then the result is a
28161 parametric plot.  The two arguments of the fictitious @code{xy} function
28162 are used as the ``x'' and ``y'' coordinates of the curve, respectively.
28163 In this case the ``x'' vector or interval you specified is not directly
28164 visible in the graph.  For example, if ``x'' is the interval @samp{[0..360]}
28165 and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
28166 will be a circle.@refill
28168 Also, ``x'' and ``y'' may each be variable names, in which case Calc
28169 looks for suitable vectors, intervals, or formulas stored in those
28170 variables.
28172 The ``x'' and ``y'' values for the data points (as pulled from the vectors,
28173 calculated from the formulas, or interpolated from the intervals) should
28174 be real numbers (integers, fractions, or floats).  If either the ``x''
28175 value or the ``y'' value of a given data point is not a real number, that
28176 data point will be omitted from the graph.  The points on either side
28177 of the invalid point will @emph{not} be connected by a line.
28179 See the documentation for @kbd{g a} below for a description of the way
28180 numeric prefix arguments affect @kbd{g f}.
28182 @cindex @code{PlotRejects} variable
28183 @vindex PlotRejects
28184 If you store an empty vector in the variable @code{PlotRejects}
28185 (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
28186 this vector for every data point which was rejected because its
28187 ``x'' or ``y'' values were not real numbers.  The result will be
28188 a matrix where each row holds the curve number, data point number,
28189 ``x'' value, and ``y'' value for a rejected data point.
28190 @xref{Evaluates-To Operator}, for a handy way to keep tabs on the
28191 current value of @code{PlotRejects}.  @xref{Operations on Variables},
28192 for the @kbd{s R} command which is another easy way to examine
28193 @code{PlotRejects}.
28195 @kindex g c
28196 @pindex calc-graph-clear
28197 To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
28198 If the GNUPLOT output device is an X window, the window will go away.
28199 Effects on other kinds of output devices will vary.  You don't need
28200 to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
28201 or @kbd{g p} command later on, it will reuse the existing graphics
28202 window if there is one.
28204 @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
28205 @section Three-Dimensional Graphics
28207 @kindex g F
28208 @pindex calc-graph-fast-3d
28209 The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
28210 graph.  It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
28211 you will see a GNUPLOT error message if you try this command.
28213 The @kbd{g F} command takes three values from the stack, called ``x'',
28214 ``y'', and ``z'', respectively.  As was the case for 2D graphs, there
28215 are several options for these values.
28217 In the first case, ``x'' and ``y'' are each vectors (not necessarily of
28218 the same length); either or both may instead be interval forms.  The
28219 ``z'' value must be a matrix with the same number of rows as elements
28220 in ``x'', and the same number of columns as elements in ``y''.  The
28221 result is a surface plot where @c{$z_{ij}$}
28222 @cite{z_ij} is the height of the point
28223 at coordinate @cite{(x_i, y_j)} on the surface.  The 3D graph will
28224 be displayed from a certain default viewpoint; you can change this
28225 viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*}
28226 buffer as described later.  See the GNUPLOT 3.0 documentation for a
28227 description of the @samp{set view} command.
28229 Each point in the matrix will be displayed as a dot in the graph,
28230 and these points will be connected by a grid of lines (@dfn{isolines}).
28232 In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
28233 length.  The resulting graph displays a 3D line instead of a surface,
28234 where the coordinates of points along the line are successive triplets
28235 of values from the input vectors.
28237 In the third case, ``x'' and ``y'' are vectors or interval forms, and
28238 ``z'' is any formula involving two variables (not counting variables
28239 with assigned values).  These variables are sorted into alphabetical
28240 order; the first takes on values from ``x'' and the second takes on
28241 values from ``y'' to form a matrix of results that are graphed as a
28242 3D surface.
28244 @ignore
28245 @starindex
28246 @end ignore
28247 @tindex xyz
28248 If the ``z'' formula evaluates to a call to the fictitious function
28249 @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
28250 ``parametric surface.''  In this case, the axes of the graph are
28251 taken from the @var{x} and @var{y} values in these calls, and the
28252 ``x'' and ``y'' values from the input vectors or intervals are used only
28253 to specify the range of inputs to the formula.  For example, plotting
28254 @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
28255 will draw a sphere.  (Since the default resolution for 3D plots is
28256 5 steps in each of ``x'' and ``y'', this will draw a very crude
28257 sphere.  You could use the @kbd{g N} command, described below, to
28258 increase this resolution, or specify the ``x'' and ``y'' values as
28259 vectors with more than 5 elements.
28261 It is also possible to have a function in a regular @kbd{g f} plot
28262 evaluate to an @code{xyz} call.  Since @kbd{g f} plots a line, not
28263 a surface, the result will be a 3D parametric line.  For example,
28264 @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
28265 helix (a three-dimensional spiral).
28267 As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
28268 variables containing the relevant data.
28270 @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
28271 @section Managing Curves
28273 @noindent
28274 The @kbd{g f} command is really shorthand for the following commands:
28275 @kbd{C-u g d  g a  g p}.  Likewise, @w{@kbd{g F}} is shorthand for
28276 @kbd{C-u g d  g A  g p}.  You can gain more control over your graph
28277 by using these commands directly.
28279 @kindex g a
28280 @pindex calc-graph-add
28281 The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
28282 represented by the two values on the top of the stack to the current
28283 graph.  You can have any number of curves in the same graph.  When
28284 you give the @kbd{g p} command, all the curves will be drawn superimposed
28285 on the same axes.
28287 The @kbd{g a} command (and many others that affect the current graph)
28288 will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed
28289 in another window.  This buffer is a template of the commands that will
28290 be sent to GNUPLOT when it is time to draw the graph.  The first
28291 @kbd{g a} command adds a @code{plot} command to this buffer.  Succeeding
28292 @kbd{g a} commands add extra curves onto that @code{plot} command.
28293 Other graph-related commands put other GNUPLOT commands into this
28294 buffer.  In normal usage you never need to work with this buffer
28295 directly, but you can if you wish.  The only constraint is that there
28296 must be only one @code{plot} command, and it must be the last command
28297 in the buffer.  If you want to save and later restore a complete graph
28298 configuration, you can use regular Emacs commands to save and restore
28299 the contents of the @samp{*Gnuplot Commands*} buffer.
28301 @vindex PlotData1
28302 @vindex PlotData2
28303 If the values on the stack are not variable names, @kbd{g a} will invent
28304 variable names for them (of the form @samp{PlotData@var{n}}) and store
28305 the values in those variables.  The ``x'' and ``y'' variables are what
28306 go into the @code{plot} command in the template.  If you add a curve
28307 that uses a certain variable and then later change that variable, you
28308 can replot the graph without having to delete and re-add the curve.
28309 That's because the variable name, not the vector, interval or formula
28310 itself, is what was added by @kbd{g a}.
28312 A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
28313 stack entries are interpreted as curves.  With a positive prefix
28314 argument @cite{n}, the top @cite{n} stack entries are ``y'' values
28315 for @cite{n} different curves which share a common ``x'' value in
28316 the @cite{n+1}st stack entry.  (Thus @kbd{g a} with no prefix
28317 argument is equivalent to @kbd{C-u 1 g a}.)
28319 A prefix of zero or plain @kbd{C-u} means to take two stack entries,
28320 ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
28321 ``y'' values for several curves that share a common ``x''.
28323 A negative prefix argument tells Calc to read @cite{n} vectors from
28324 the stack; each vector @cite{[x, y]} describes an independent curve.
28325 This is the only form of @kbd{g a} that creates several curves at once
28326 that don't have common ``x'' values.  (Of course, the range of ``x''
28327 values covered by all the curves ought to be roughly the same if
28328 they are to look nice on the same graph.)
28330 For example, to plot @c{$\sin n x$}
28331 @cite{sin(n x)} for integers @cite{n}
28332 from 1 to 5, you could use @kbd{v x} to create a vector of integers
28333 (@cite{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
28334 across this vector.  The resulting vector of formulas is suitable
28335 for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
28336 command.
28338 @kindex g A
28339 @pindex calc-graph-add-3d
28340 The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
28341 to the graph.  It is not legal to intermix 2D and 3D curves in a
28342 single graph.  This command takes three arguments, ``x'', ``y'',
28343 and ``z'', from the stack.  With a positive prefix @cite{n}, it
28344 takes @cite{n+2} arguments (common ``x'' and ``y'', plus @cite{n}
28345 separate ``z''s).  With a zero prefix, it takes three stack entries
28346 but the ``z'' entry is a vector of curve values.  With a negative
28347 prefix @cite{-n}, it takes @cite{n} vectors of the form @cite{[x, y, z]}.
28348 The @kbd{g A} command works by adding a @code{splot} (surface-plot)
28349 command to the @samp{*Gnuplot Commands*} buffer.
28351 (Although @kbd{g a} adds a 2D @code{plot} command to the
28352 @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
28353 before sending it to GNUPLOT if it notices that the data points are
28354 evaluating to @code{xyz} calls.  It will not work to mix 2D and 3D
28355 @kbd{g a} curves in a single graph, although Calc does not currently
28356 check for this.)
28358 @kindex g d
28359 @pindex calc-graph-delete
28360 The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
28361 recently added curve from the graph.  It has no effect if there are
28362 no curves in the graph.  With a numeric prefix argument of any kind,
28363 it deletes all of the curves from the graph.
28365 @kindex g H
28366 @pindex calc-graph-hide
28367 The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
28368 the most recently added curve.  A hidden curve will not appear in
28369 the actual plot, but information about it such as its name and line and
28370 point styles will be retained.
28372 @kindex g j
28373 @pindex calc-graph-juggle
28374 The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
28375 at the end of the list (the ``most recently added curve'') to the
28376 front of the list.  The next-most-recent curve is thus exposed for
28377 @w{@kbd{g d}} or similar commands to use.  With @kbd{g j} you can work
28378 with any curve in the graph even though curve-related commands only
28379 affect the last curve in the list.
28381 @kindex g p
28382 @pindex calc-graph-plot
28383 The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
28384 the graph described in the @samp{*Gnuplot Commands*} buffer.  Any
28385 GNUPLOT parameters which are not defined by commands in this buffer
28386 are reset to their default values.  The variables named in the @code{plot}
28387 command are written to a temporary data file and the variable names
28388 are then replaced by the file name in the template.  The resulting
28389 plotting commands are fed to the GNUPLOT program.  See the documentation
28390 for the GNUPLOT program for more specific information.  All temporary
28391 files are removed when Emacs or GNUPLOT exits.
28393 If you give a formula for ``y'', Calc will remember all the values that
28394 it calculates for the formula so that later plots can reuse these values.
28395 Calc throws out these saved values when you change any circumstances
28396 that may affect the data, such as switching from Degrees to Radians
28397 mode, or changing the value of a parameter in the formula.  You can
28398 force Calc to recompute the data from scratch by giving a negative
28399 numeric prefix argument to @kbd{g p}.
28401 Calc uses a fairly rough step size when graphing formulas over intervals.
28402 This is to ensure quick response.  You can ``refine'' a plot by giving
28403 a positive numeric prefix argument to @kbd{g p}.  Calc goes through
28404 the data points it has computed and saved from previous plots of the
28405 function, and computes and inserts a new data point midway between
28406 each of the existing points.  You can refine a plot any number of times,
28407 but beware that the amount of calculation involved doubles each time.
28409 Calc does not remember computed values for 3D graphs.  This means the
28410 numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
28411 the current graph is three-dimensional.
28413 @kindex g P
28414 @pindex calc-graph-print
28415 The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
28416 except that it sends the output to a printer instead of to the
28417 screen.  More precisely, @kbd{g p} looks for @samp{set terminal}
28418 or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer;
28419 lacking these it uses the default settings.  However, @kbd{g P}
28420 ignores @samp{set terminal} and @samp{set output} commands and
28421 uses a different set of default values.  All of these values are
28422 controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
28423 Provided everything is set up properly, @kbd{g p} will plot to
28424 the screen unless you have specified otherwise and @kbd{g P} will
28425 always plot to the printer.
28427 @node Graphics Options, Devices, Managing Curves, Graphics
28428 @section Graphics Options
28430 @noindent
28431 @kindex g g
28432 @pindex calc-graph-grid
28433 The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
28434 on and off.  It is off by default; tick marks appear only at the
28435 edges of the graph.  With the grid turned on, dotted lines appear
28436 across the graph at each tick mark.  Note that this command only
28437 changes the setting in @samp{*Gnuplot Commands*}; to see the effects
28438 of the change you must give another @kbd{g p} command.
28440 @kindex g b
28441 @pindex calc-graph-border
28442 The @kbd{g b} (@code{calc-graph-border}) command turns the border
28443 (the box that surrounds the graph) on and off.  It is on by default.
28444 This command will only work with GNUPLOT 3.0 and later versions.
28446 @kindex g k
28447 @pindex calc-graph-key
28448 The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
28449 on and off.  The key is a chart in the corner of the graph that
28450 shows the correspondence between curves and line styles.  It is
28451 off by default, and is only really useful if you have several
28452 curves on the same graph.
28454 @kindex g N
28455 @pindex calc-graph-num-points
28456 The @kbd{g N} (@code{calc-graph-num-points}) command allows you
28457 to select the number of data points in the graph.  This only affects
28458 curves where neither ``x'' nor ``y'' is specified as a vector.
28459 Enter a blank line to revert to the default value (initially 15).
28460 With no prefix argument, this command affects only the current graph.
28461 With a positive prefix argument this command changes or, if you enter
28462 a blank line, displays the default number of points used for all
28463 graphs created by @kbd{g a} that don't specify the resolution explicitly.
28464 With a negative prefix argument, this command changes or displays
28465 the default value (initially 5) used for 3D graphs created by @kbd{g A}.
28466 Note that a 3D setting of 5 means that a total of @cite{5^2 = 25} points
28467 will be computed for the surface.
28469 Data values in the graph of a function are normally computed to a
28470 precision of five digits, regardless of the current precision at the
28471 time. This is usually more than adequate, but there are cases where
28472 it will not be.  For example, plotting @cite{1 + x} with @cite{x} in the
28473 interval @samp{[0 ..@: 1e-6]} will round all the data points down
28474 to 1.0!  Putting the command @samp{set precision @var{n}} in the
28475 @samp{*Gnuplot Commands*} buffer will cause the data to be computed
28476 at precision @var{n} instead of 5.  Since this is such a rare case,
28477 there is no keystroke-based command to set the precision.
28479 @kindex g h
28480 @pindex calc-graph-header
28481 The @kbd{g h} (@code{calc-graph-header}) command sets the title
28482 for the graph.  This will show up centered above the graph.
28483 The default title is blank (no title).
28485 @kindex g n
28486 @pindex calc-graph-name
28487 The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
28488 individual curve.  Like the other curve-manipulating commands, it
28489 affects the most recently added curve, i.e., the last curve on the
28490 list in the @samp{*Gnuplot Commands*} buffer.  To set the title of
28491 the other curves you must first juggle them to the end of the list
28492 with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand.
28493 Curve titles appear in the key; if the key is turned off they are
28494 not used.
28496 @kindex g t
28497 @kindex g T
28498 @pindex calc-graph-title-x
28499 @pindex calc-graph-title-y
28500 The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
28501 (@code{calc-graph-title-y}) commands set the titles on the ``x''
28502 and ``y'' axes, respectively.  These titles appear next to the
28503 tick marks on the left and bottom edges of the graph, respectively.
28504 Calc does not have commands to control the tick marks themselves,
28505 but you can edit them into the @samp{*Gnuplot Commands*} buffer if
28506 you wish.  See the GNUPLOT documentation for details.
28508 @kindex g r
28509 @kindex g R
28510 @pindex calc-graph-range-x
28511 @pindex calc-graph-range-y
28512 The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
28513 (@code{calc-graph-range-y}) commands set the range of values on the
28514 ``x'' and ``y'' axes, respectively.  You are prompted to enter a
28515 suitable range.  This should be either a pair of numbers of the
28516 form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
28517 default behavior of setting the range based on the range of values
28518 in the data, or @samp{$} to take the range from the top of the stack.
28519 Ranges on the stack can be represented as either interval forms or
28520 vectors:  @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
28522 @kindex g l
28523 @kindex g L
28524 @pindex calc-graph-log-x
28525 @pindex calc-graph-log-y
28526 The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
28527 commands allow you to set either or both of the axes of the graph to
28528 be logarithmic instead of linear.
28530 @kindex g C-l
28531 @kindex g C-r
28532 @kindex g C-t
28533 @pindex calc-graph-log-z
28534 @pindex calc-graph-range-z
28535 @pindex calc-graph-title-z
28536 For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
28537 letters with the Control key held down) are the corresponding commands
28538 for the ``z'' axis.
28540 @kindex g z
28541 @kindex g Z
28542 @pindex calc-graph-zero-x
28543 @pindex calc-graph-zero-y
28544 The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
28545 (@code{calc-graph-zero-y}) commands control whether a dotted line is
28546 drawn to indicate the ``x'' and/or ``y'' zero axes.  (These are the same
28547 dotted lines that would be drawn there anyway if you used @kbd{g g} to
28548 turn the ``grid'' feature on.)  Zero-axis lines are on by default, and
28549 may be turned off only in GNUPLOT 3.0 and later versions.  They are
28550 not available for 3D plots.
28552 @kindex g s
28553 @pindex calc-graph-line-style
28554 The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
28555 lines on or off for the most recently added curve, and optionally selects
28556 the style of lines to be used for that curve.  Plain @kbd{g s} simply
28557 toggles the lines on and off.  With a numeric prefix argument, @kbd{g s}
28558 turns lines on and sets a particular line style.  Line style numbers
28559 start at one and their meanings vary depending on the output device.
28560 GNUPLOT guarantees that there will be at least six different line styles
28561 available for any device.
28563 @kindex g S
28564 @pindex calc-graph-point-style
28565 The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
28566 the symbols at the data points on or off, or sets the point style.
28567 If you turn both lines and points off, the data points will show as
28568 tiny dots.
28570 @cindex @code{LineStyles} variable
28571 @cindex @code{PointStyles} variable
28572 @vindex LineStyles
28573 @vindex PointStyles
28574 Another way to specify curve styles is with the @code{LineStyles} and
28575 @code{PointStyles} variables.  These variables initially have no stored
28576 values, but if you store a vector of integers in one of these variables,
28577 the @kbd{g a} and @kbd{g f} commands will use those style numbers
28578 instead of the defaults for new curves that are added to the graph.
28579 An entry should be a positive integer for a specific style, or 0 to let
28580 the style be chosen automatically, or @i{-1} to turn off lines or points
28581 altogether.  If there are more curves than elements in the vector, the
28582 last few curves will continue to have the default styles.  Of course,
28583 you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
28585 For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
28586 to have lines in style number 2, the second curve to have no connecting
28587 lines, and the third curve to have lines in style 3.  Point styles will
28588 still be assigned automatically, but you could store another vector in
28589 @code{PointStyles} to define them, too.
28591 @node Devices, , Graphics Options, Graphics
28592 @section Graphical Devices
28594 @noindent
28595 @kindex g D
28596 @pindex calc-graph-device
28597 The @kbd{g D} (@code{calc-graph-device}) command sets the device name
28598 (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
28599 on this graph.  It does not affect the permanent default device name.
28600 If you enter a blank name, the device name reverts to the default.
28601 Enter @samp{?} to see a list of supported devices.
28603 With a positive numeric prefix argument, @kbd{g D} instead sets
28604 the default device name, used by all plots in the future which do
28605 not override it with a plain @kbd{g D} command.  If you enter a
28606 blank line this command shows you the current default.  The special
28607 name @code{default} signifies that Calc should choose @code{x11} if
28608 the X window system is in use (as indicated by the presence of a
28609 @code{DISPLAY} environment variable), or otherwise @code{dumb} under
28610 GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0.
28611 This is the initial default value.
28613 The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
28614 terminals with no special graphics facilities.  It writes a crude
28615 picture of the graph composed of characters like @code{-} and @code{|}
28616 to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays.
28617 The graph is made the same size as the Emacs screen, which on most
28618 dumb terminals will be @c{$80\times24$}
28619 @asis{80x24} characters.  The graph is displayed in
28620 an Emacs ``recursive edit''; type @kbd{q} or @kbd{M-# M-#} to exit
28621 the recursive edit and return to Calc.  Note that the @code{dumb}
28622 device is present only in GNUPLOT 3.0 and later versions.
28624 The word @code{dumb} may be followed by two numbers separated by
28625 spaces.  These are the desired width and height of the graph in
28626 characters.  Also, the device name @code{big} is like @code{dumb}
28627 but creates a graph four times the width and height of the Emacs
28628 screen.  You will then have to scroll around to view the entire
28629 graph.  In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
28630 @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
28631 of the four directions.
28633 With a negative numeric prefix argument, @kbd{g D} sets or displays
28634 the device name used by @kbd{g P} (@code{calc-graph-print}).  This
28635 is initially @code{postscript}.  If you don't have a PostScript
28636 printer, you may decide once again to use @code{dumb} to create a
28637 plot on any text-only printer.
28639 @kindex g O
28640 @pindex calc-graph-output
28641 The @kbd{g O} (@code{calc-graph-output}) command sets the name of
28642 the output file used by GNUPLOT.  For some devices, notably @code{x11},
28643 there is no output file and this information is not used.  Many other
28644 ``devices'' are really file formats like @code{postscript}; in these
28645 cases the output in the desired format goes into the file you name
28646 with @kbd{g O}.  Type @kbd{g O stdout @key{RET}} to set GNUPLOT to write
28647 to its standard output stream, i.e., to @samp{*Gnuplot Trail*}.
28648 This is the default setting.
28650 Another special output name is @code{tty}, which means that GNUPLOT
28651 is going to write graphics commands directly to its standard output,
28652 which you wish Emacs to pass through to your terminal.  Tektronix
28653 graphics terminals, among other devices, operate this way.  Calc does
28654 this by telling GNUPLOT to write to a temporary file, then running a
28655 sub-shell executing the command @samp{cat tempfile >/dev/tty}.  On
28656 typical Unix systems, this will copy the temporary file directly to
28657 the terminal, bypassing Emacs entirely.  You will have to type @kbd{C-l}
28658 to Emacs afterwards to refresh the screen.
28660 Once again, @kbd{g O} with a positive or negative prefix argument
28661 sets the default or printer output file names, respectively.  In each
28662 case you can specify @code{auto}, which causes Calc to invent a temporary
28663 file name for each @kbd{g p} (or @kbd{g P}) command.  This temporary file
28664 will be deleted once it has been displayed or printed.  If the output file
28665 name is not @code{auto}, the file is not automatically deleted.
28667 The default and printer devices and output files can be saved
28668 permanently by the @kbd{m m} (@code{calc-save-modes}) command.  The
28669 default number of data points (see @kbd{g N}) and the X geometry
28670 (see @kbd{g X}) are also saved.  Other graph information is @emph{not}
28671 saved; you can save a graph's configuration simply by saving the contents
28672 of the @samp{*Gnuplot Commands*} buffer.
28674 @vindex calc-gnuplot-plot-command
28675 @vindex calc-gnuplot-default-device
28676 @vindex calc-gnuplot-default-output
28677 @vindex calc-gnuplot-print-command
28678 @vindex calc-gnuplot-print-device
28679 @vindex calc-gnuplot-print-output
28680 If you are installing Calc you may wish to configure the default and
28681 printer devices and output files for the whole system.  The relevant
28682 Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
28683 and @code{calc-gnuplot-print-device} and @code{-output}.  The output
28684 file names must be either strings as described above, or Lisp
28685 expressions which are evaluated on the fly to get the output file names.
28687 Other important Lisp variables are @code{calc-gnuplot-plot-command} and
28688 @code{calc-gnuplot-print-command}, which give the system commands to
28689 display or print the output of GNUPLOT, respectively.  These may be
28690 @code{nil} if no command is necessary, or strings which can include
28691 @samp{%s} to signify the name of the file to be displayed or printed.
28692 Or, these variables may contain Lisp expressions which are evaluated
28693 to display or print the output.
28695 @kindex g x
28696 @pindex calc-graph-display
28697 The @kbd{g x} (@code{calc-graph-display}) command lets you specify
28698 on which X window system display your graphs should be drawn.  Enter
28699 a blank line to see the current display name.  This command has no
28700 effect unless the current device is @code{x11}.
28702 @kindex g X
28703 @pindex calc-graph-geometry
28704 The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
28705 command for specifying the position and size of the X window.
28706 The normal value is @code{default}, which generally means your
28707 window manager will let you place the window interactively.
28708 Entering @samp{800x500+0+0} would create an 800-by-500 pixel
28709 window in the upper-left corner of the screen.
28711 The buffer called @samp{*Gnuplot Trail*} holds a transcript of the
28712 session with GNUPLOT.  This shows the commands Calc has ``typed'' to
28713 GNUPLOT and the responses it has received.  Calc tries to notice when an
28714 error message has appeared here and display the buffer for you when
28715 this happens.  You can check this buffer yourself if you suspect
28716 something has gone wrong.
28718 @kindex g C
28719 @pindex calc-graph-command
28720 The @kbd{g C} (@code{calc-graph-command}) command prompts you to
28721 enter any line of text, then simply sends that line to the current
28722 GNUPLOT process.  The @samp{*Gnuplot Trail*} buffer looks deceptively
28723 like a Shell buffer but you can't type commands in it yourself.
28724 Instead, you must use @kbd{g C} for this purpose.
28726 @kindex g v
28727 @kindex g V
28728 @pindex calc-graph-view-commands
28729 @pindex calc-graph-view-trail
28730 The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
28731 (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*}
28732 and @samp{*Gnuplot Trail*} buffers, respectively, in another window.
28733 This happens automatically when Calc thinks there is something you
28734 will want to see in either of these buffers.  If you type @kbd{g v}
28735 or @kbd{g V} when the relevant buffer is already displayed, the
28736 buffer is hidden again.
28738 One reason to use @kbd{g v} is to add your own commands to the
28739 @samp{*Gnuplot Commands*} buffer.  Press @kbd{g v}, then use
28740 @kbd{C-x o} to switch into that window.  For example, GNUPLOT has
28741 @samp{set label} and @samp{set arrow} commands that allow you to
28742 annotate your plots.  Since Calc doesn't understand these commands,
28743 you have to add them to the @samp{*Gnuplot Commands*} buffer
28744 yourself, then use @w{@kbd{g p}} to replot using these new commands.  Note
28745 that your commands must appear @emph{before} the @code{plot} command.
28746 To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
28747 You may have to type @kbd{g C @key{RET}} a few times to clear the
28748 ``press return for more'' or ``subtopic of @dots{}'' requests.
28749 Note that Calc always sends commands (like @samp{set nolabel}) to
28750 reset all plotting parameters to the defaults before each plot, so
28751 to delete a label all you need to do is delete the @samp{set label}
28752 line you added (or comment it out with @samp{#}) and then replot
28753 with @kbd{g p}.
28755 @kindex g q
28756 @pindex calc-graph-quit
28757 You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
28758 process that is running.  The next graphing command you give will
28759 start a fresh GNUPLOT process.  The word @samp{Graph} appears in
28760 the Calc window's mode line whenever a GNUPLOT process is currently
28761 running.  The GNUPLOT process is automatically killed when you
28762 exit Emacs if you haven't killed it manually by then.
28764 @kindex g K
28765 @pindex calc-graph-kill
28766 The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
28767 except that it also views the @samp{*Gnuplot Trail*} buffer so that
28768 you can see the process being killed.  This is better if you are
28769 killing GNUPLOT because you think it has gotten stuck.
28771 @node Kill and Yank, Keypad Mode, Graphics, Top
28772 @chapter Kill and Yank Functions
28774 @noindent
28775 The commands in this chapter move information between the Calculator and
28776 other Emacs editing buffers.
28778 In many cases Embedded Mode is an easier and more natural way to
28779 work with Calc from a regular editing buffer.  @xref{Embedded Mode}.
28781 @menu
28782 * Killing From Stack::
28783 * Yanking Into Stack::
28784 * Grabbing From Buffers::
28785 * Yanking Into Buffers::
28786 * X Cut and Paste::
28787 @end menu
28789 @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
28790 @section Killing from the Stack
28792 @noindent
28793 @kindex C-k
28794 @pindex calc-kill
28795 @kindex M-k
28796 @pindex calc-copy-as-kill
28797 @kindex C-w
28798 @pindex calc-kill-region
28799 @kindex M-w
28800 @pindex calc-copy-region-as-kill
28801 @cindex Kill ring
28802 @dfn{Kill} commands are Emacs commands that insert text into the
28803 ``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y}
28804 command.  Three common kill commands in normal Emacs are @kbd{C-k}, which
28805 kills one line, @kbd{C-w}, which kills the region between mark and point,
28806 and @kbd{M-w}, which puts the region into the kill ring without actually
28807 deleting it.  All of these commands work in the Calculator, too.  Also,
28808 @kbd{M-k} has been provided to complete the set; it puts the current line
28809 into the kill ring without deleting anything.
28811 The kill commands are unusual in that they pay attention to the location
28812 of the cursor in the Calculator buffer.  If the cursor is on or below the
28813 bottom line, the kill commands operate on the top of the stack.  Otherwise,
28814 they operate on whatever stack element the cursor is on.  Calc's kill
28815 commands always operate on whole stack entries.  (They act the same as their
28816 standard Emacs cousins except they ``round up'' the specified region to
28817 encompass full lines.)  The text is copied into the kill ring exactly as
28818 it appears on the screen, including line numbers if they are enabled.
28820 A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
28821 of lines killed.  A positive argument kills the current line and @cite{n-1}
28822 lines below it.  A negative argument kills the @cite{-n} lines above the
28823 current line.  Again this mirrors the behavior of the standard Emacs
28824 @kbd{C-k} command.  Although a whole line is always deleted, @kbd{C-k}
28825 with no argument copies only the number itself into the kill ring, whereas
28826 @kbd{C-k} with a prefix argument of 1 copies the number with its trailing
28827 newline.
28829 @node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank
28830 @section Yanking into the Stack
28832 @noindent
28833 @kindex C-y
28834 @pindex calc-yank
28835 The @kbd{C-y} command yanks the most recently killed text back into the
28836 Calculator.  It pushes this value onto the top of the stack regardless of
28837 the cursor position.  In general it re-parses the killed text as a number
28838 or formula (or a list of these separated by commas or newlines).  However if
28839 the thing being yanked is something that was just killed from the Calculator
28840 itself, its full internal structure is yanked.  For example, if you have
28841 set the floating-point display mode to show only four significant digits,
28842 then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
28843 full 3.14159, even though yanking it into any other buffer would yank the
28844 number in its displayed form, 3.142.  (Since the default display modes
28845 show all objects to their full precision, this feature normally makes no
28846 difference.)
28848 @node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank
28849 @section Grabbing from Other Buffers
28851 @noindent
28852 @kindex M-# g
28853 @pindex calc-grab-region
28854 The @kbd{M-# g} (@code{calc-grab-region}) command takes the text between
28855 point and mark in the current buffer and attempts to parse it as a
28856 vector of values.  Basically, it wraps the text in vector brackets
28857 @samp{[ ]} unless the text already is enclosed in vector brackets,
28858 then reads the text as if it were an algebraic entry.  The contents
28859 of the vector may be numbers, formulas, or any other Calc objects.
28860 If the @kbd{M-# g} command works successfully, it does an automatic
28861 @kbd{M-# c} to enter the Calculator buffer.
28863 A numeric prefix argument grabs the specified number of lines around
28864 point, ignoring the mark.  A positive prefix grabs from point to the
28865 @cite{n}th following newline (so that @kbd{M-1 M-# g} grabs from point
28866 to the end of the current line); a negative prefix grabs from point
28867 back to the @cite{n+1}st preceding newline.  In these cases the text
28868 that is grabbed is exactly the same as the text that @kbd{C-k} would
28869 delete given that prefix argument.
28871 A prefix of zero grabs the current line; point may be anywhere on the
28872 line.
28874 A plain @kbd{C-u} prefix interprets the region between point and mark
28875 as a single number or formula rather than a vector.  For example,
28876 @kbd{M-# g} on the text @samp{2 a b} produces the vector of three
28877 values @samp{[2, a, b]}, but @kbd{C-u M-# g} on the same region
28878 reads a formula which is a product of three things:  @samp{2 a b}.
28879 (The text @samp{a + b}, on the other hand, will be grabbed as a
28880 vector of one element by plain @kbd{M-# g} because the interpretation
28881 @samp{[a, +, b]} would be a syntax error.)
28883 If a different language has been specified (@pxref{Language Modes}),
28884 the grabbed text will be interpreted according to that language.
28886 @kindex M-# r
28887 @pindex calc-grab-rectangle
28888 The @kbd{M-# r} (@code{calc-grab-rectangle}) command takes the text between
28889 point and mark and attempts to parse it as a matrix.  If point and mark
28890 are both in the leftmost column, the lines in between are parsed in their
28891 entirety.  Otherwise, point and mark define the corners of a rectangle
28892 whose contents are parsed.
28894 Each line of the grabbed area becomes a row of the matrix.  The result
28895 will actually be a vector of vectors, which Calc will treat as a matrix
28896 only if every row contains the same number of values.
28898 If a line contains a portion surrounded by square brackets (or curly
28899 braces), that portion is interpreted as a vector which becomes a row
28900 of the matrix.  Any text surrounding the bracketed portion on the line
28901 is ignored.
28903 Otherwise, the entire line is interpreted as a row vector as if it
28904 were surrounded by square brackets.  Leading line numbers (in the
28905 format used in the Calc stack buffer) are ignored.  If you wish to
28906 force this interpretation (even if the line contains bracketed
28907 portions), give a negative numeric prefix argument to the
28908 @kbd{M-# r} command.
28910 If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
28911 line is instead interpreted as a single formula which is converted into
28912 a one-element vector.  Thus the result of @kbd{C-u M-# r} will be a
28913 one-column matrix.  For example, suppose one line of the data is the
28914 expression @samp{2 a}.  A plain @w{@kbd{M-# r}} will interpret this as
28915 @samp{[2 a]}, which in turn is read as a two-element vector that forms
28916 one row of the matrix.  But a @kbd{C-u M-# r} will interpret this row
28917 as @samp{[2*a]}.
28919 If you give a positive numeric prefix argument @var{n}, then each line
28920 will be split up into columns of width @var{n}; each column is parsed
28921 separately as a matrix element.  If a line contained
28922 @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
28923 would correctly split the line into two error forms.@refill
28925 @xref{Matrix Functions}, to see how to pull the matrix apart into its
28926 constituent rows and columns.  (If it is a @c{$1\times1$}
28927 @asis{1x1} matrix, just hit @kbd{v u}
28928 (@code{calc-unpack}) twice.)
28930 @kindex M-# :
28931 @kindex M-# _
28932 @pindex calc-grab-sum-across
28933 @pindex calc-grab-sum-down
28934 @cindex Summing rows and columns of data
28935 The @kbd{M-# :} (@code{calc-grab-sum-down}) command is a handy way to
28936 grab a rectangle of data and sum its columns.  It is equivalent to
28937 typing @kbd{M-# r}, followed by @kbd{V R : +} (the vector reduction
28938 command that sums the columns of a matrix; @pxref{Reducing}).  The
28939 result of the command will be a vector of numbers, one for each column
28940 in the input data.  The @kbd{M-# _} (@code{calc-grab-sum-across}) command
28941 similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
28943 As well as being more convenient, @kbd{M-# :} and @kbd{M-# _} are also
28944 much faster because they don't actually place the grabbed vector on
28945 the stack.  In a @kbd{M-# r V R : +} sequence, formatting the vector
28946 for display on the stack takes a large fraction of the total time
28947 (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
28949 For example, suppose we have a column of numbers in a file which we
28950 wish to sum.  Go to one corner of the column and press @kbd{C-@@} to
28951 set the mark; go to the other corner and type @kbd{M-# :}.  Since there
28952 is only one column, the result will be a vector of one number, the sum.
28953 (You can type @kbd{v u} to unpack this vector into a plain number if
28954 you want to do further arithmetic with it.)
28956 To compute the product of the column of numbers, we would have to do
28957 it ``by hand'' since there's no special grab-and-multiply command.
28958 Use @kbd{M-# r} to grab the column of numbers into the calculator in
28959 the form of a column matrix.  The statistics command @kbd{u *} is a
28960 handy way to find the product of a vector or matrix of numbers.
28961 @xref{Statistical Operations}.  Another approach would be to use
28962 an explicit column reduction command, @kbd{V R : *}.
28964 @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
28965 @section Yanking into Other Buffers
28967 @noindent
28968 @kindex y
28969 @pindex calc-copy-to-buffer
28970 The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
28971 at the top of the stack into the most recently used normal editing buffer.
28972 (More specifically, this is the most recently used buffer which is displayed
28973 in a window and whose name does not begin with @samp{*}.  If there is no
28974 such buffer, this is the most recently used buffer except for Calculator
28975 and Calc Trail buffers.)  The number is inserted exactly as it appears and
28976 without a newline.  (If line-numbering is enabled, the line number is
28977 normally not included.)  The number is @emph{not} removed from the stack.
28979 With a prefix argument, @kbd{y} inserts several numbers, one per line.
28980 A positive argument inserts the specified number of values from the top
28981 of the stack.  A negative argument inserts the @cite{n}th value from the
28982 top of the stack.  An argument of zero inserts the entire stack.  Note
28983 that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
28984 with no argument; the former always copies full lines, whereas the
28985 latter strips off the trailing newline.
28987 With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
28988 region in the other buffer with the yanked text, then quits the
28989 Calculator, leaving you in that buffer.  A typical use would be to use
28990 @kbd{M-# g} to read a region of data into the Calculator, operate on the
28991 data to produce a new matrix, then type @kbd{C-u y} to replace the
28992 original data with the new data.  One might wish to alter the matrix
28993 display style (@pxref{Vector and Matrix Formats}) or change the current
28994 display language (@pxref{Language Modes}) before doing this.  Also, note
28995 that this command replaces a linear region of text (as grabbed by
28996 @kbd{M-# g}), not a rectangle (as grabbed by @kbd{M-# r}).@refill
28998 If the editing buffer is in overwrite (as opposed to insert) mode,
28999 and the @kbd{C-u} prefix was not used, then the yanked number will
29000 overwrite the characters following point rather than being inserted
29001 before those characters.  The usual conventions of overwrite mode
29002 are observed; for example, characters will be inserted at the end of
29003 a line rather than overflowing onto the next line.  Yanking a multi-line
29004 object such as a matrix in overwrite mode overwrites the next @var{n}
29005 lines in the buffer, lengthening or shortening each line as necessary.
29006 Finally, if the thing being yanked is a simple integer or floating-point
29007 number (like @samp{-1.2345e-3}) and the characters following point also
29008 make up such a number, then Calc will replace that number with the new
29009 number, lengthening or shortening as necessary.  The concept of
29010 ``overwrite mode'' has thus been generalized from overwriting characters
29011 to overwriting one complete number with another.
29013 @kindex M-# y
29014 The @kbd{M-# y} key sequence is equivalent to @kbd{y} except that
29015 it can be typed anywhere, not just in Calc.  This provides an easy
29016 way to guarantee that Calc knows which editing buffer you want to use!
29018 @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
29019 @section X Cut and Paste
29021 @noindent
29022 If you are using Emacs with the X window system, there is an easier
29023 way to move small amounts of data into and out of the calculator:
29024 Use the mouse-oriented cut and paste facilities of X.
29026 The default bindings for a three-button mouse cause the left button
29027 to move the Emacs cursor to the given place, the right button to
29028 select the text between the cursor and the clicked location, and
29029 the middle button to yank the selection into the buffer at the
29030 clicked location.  So, if you have a Calc window and an editing
29031 window on your Emacs screen, you can use left-click/right-click
29032 to select a number, vector, or formula from one window, then
29033 middle-click to paste that value into the other window.  When you
29034 paste text into the Calc window, Calc interprets it as an algebraic
29035 entry.  It doesn't matter where you click in the Calc window; the
29036 new value is always pushed onto the top of the stack.
29038 The @code{xterm} program that is typically used for general-purpose
29039 shell windows in X interprets the mouse buttons in the same way.
29040 So you can use the mouse to move data between Calc and any other
29041 Unix program.  One nice feature of @code{xterm} is that a double
29042 left-click selects one word, and a triple left-click selects a
29043 whole line.  So you can usually transfer a single number into Calc
29044 just by double-clicking on it in the shell, then middle-clicking
29045 in the Calc window.
29047 @node Keypad Mode, Embedded Mode, Kill and Yank, Introduction
29048 @chapter ``Keypad'' Mode
29050 @noindent
29051 @kindex M-# k
29052 @pindex calc-keypad
29053 The @kbd{M-# k} (@code{calc-keypad}) command starts the Calculator
29054 and displays a picture of a calculator-style keypad.  If you are using
29055 the X window system, you can click on any of the ``keys'' in the
29056 keypad using the left mouse button to operate the calculator.
29057 The original window remains the selected window; in keypad mode
29058 you can type in your file while simultaneously performing
29059 calculations with the mouse.
29061 @pindex full-calc-keypad
29062 If you have used @kbd{M-# b} first, @kbd{M-# k} instead invokes
29063 the @code{full-calc-keypad} command, which takes over the whole
29064 Emacs screen and displays the keypad, the Calc stack, and the Calc
29065 trail all at once.  This mode would normally be used when running
29066 Calc standalone (@pxref{Standalone Operation}).
29068 If you aren't using the X window system, you must switch into
29069 the @samp{*Calc Keypad*} window, place the cursor on the desired
29070 ``key,'' and type @key{SPC} or @key{RET}.  If you think this
29071 is easier than using Calc normally, go right ahead.
29073 Calc commands are more or less the same in keypad mode.  Certain
29074 keypad keys differ slightly from the corresponding normal Calc
29075 keystrokes; all such deviations are described below.
29077 Keypad Mode includes many more commands than will fit on the keypad
29078 at once.  Click the right mouse button [@code{calc-keypad-menu}]
29079 to switch to the next menu.  The bottom five rows of the keypad
29080 stay the same; the top three rows change to a new set of commands.
29081 To return to earlier menus, click the middle mouse button
29082 [@code{calc-keypad-menu-back}] or simply advance through the menus
29083 until you wrap around.  Typing @key{TAB} inside the keypad window
29084 is equivalent to clicking the right mouse button there.
29086 You can always click the @key{EXEC} button and type any normal
29087 Calc key sequence.  This is equivalent to switching into the
29088 Calc buffer, typing the keys, then switching back to your
29089 original buffer.
29091 @menu
29092 * Keypad Main Menu::
29093 * Keypad Functions Menu::
29094 * Keypad Binary Menu::
29095 * Keypad Vectors Menu::
29096 * Keypad Modes Menu::
29097 @end menu
29099 @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
29100 @section Main Menu
29102 @smallexample
29103 @group
29104 |----+-----Calc 2.00-----+----1
29105 |FLR |CEIL|RND |TRNC|CLN2|FLT |
29106 |----+----+----+----+----+----|
29107 | LN |EXP |    |ABS |IDIV|MOD |
29108 |----+----+----+----+----+----|
29109 |SIN |COS |TAN |SQRT|y^x |1/x |
29110 |----+----+----+----+----+----|
29111 |  ENTER  |+/- |EEX |UNDO| <- |
29112 |-----+---+-+--+--+-+---++----|
29113 | INV |  7  |  8  |  9  |  /  |
29114 |-----+-----+-----+-----+-----|
29115 | HYP |  4  |  5  |  6  |  *  |
29116 |-----+-----+-----+-----+-----|
29117 |EXEC |  1  |  2  |  3  |  -  |
29118 |-----+-----+-----+-----+-----|
29119 | OFF |  0  |  .  | PI  |  +  |
29120 |-----+-----+-----+-----+-----+
29121 @end group
29122 @end smallexample
29124 @noindent
29125 This is the menu that appears the first time you start Keypad Mode.
29126 It will show up in a vertical window on the right side of your screen.
29127 Above this menu is the traditional Calc stack display.  On a 24-line
29128 screen you will be able to see the top three stack entries.
29130 The ten digit keys, decimal point, and @key{EEX} key are used for
29131 entering numbers in the obvious way.  @key{EEX} begins entry of an
29132 exponent in scientific notation.  Just as with regular Calc, the
29133 number is pushed onto the stack as soon as you press @key{ENTER}
29134 or any other function key.
29136 The @key{+/-} key corresponds to normal Calc's @kbd{n} key.  During
29137 numeric entry it changes the sign of the number or of the exponent.
29138 At other times it changes the sign of the number on the top of the
29139 stack.
29141 The @key{INV} and @key{HYP} keys modify other keys.  As well as
29142 having the effects described elsewhere in this manual, Keypad Mode
29143 defines several other ``inverse'' operations.  These are described
29144 below and in the following sections.
29146 The @key{ENTER} key finishes the current numeric entry, or otherwise
29147 duplicates the top entry on the stack.
29149 The @key{UNDO} key undoes the most recent Calc operation.
29150 @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
29151 ``last arguments'' (@kbd{M-@key{RET}}).
29153 The @key{<-} key acts as a ``backspace'' during numeric entry.
29154 At other times it removes the top stack entry.  @kbd{INV <-}
29155 clears the entire stack.  @kbd{HYP <-} takes an integer from
29156 the stack, then removes that many additional stack elements.
29158 The @key{EXEC} key prompts you to enter any keystroke sequence
29159 that would normally work in Calc mode.  This can include a
29160 numeric prefix if you wish.  It is also possible simply to
29161 switch into the Calc window and type commands in it; there is
29162 nothing ``magic'' about this window when Keypad Mode is active.
29164 The other keys in this display perform their obvious calculator
29165 functions.  @key{CLN2} rounds the top-of-stack by temporarily
29166 reducing the precision by 2 digits.  @key{FLT} converts an
29167 integer or fraction on the top of the stack to floating-point.
29169 The @key{INV} and @key{HYP} keys combined with several of these keys
29170 give you access to some common functions even if the appropriate menu
29171 is not displayed.  Obviously you don't need to learn these keys
29172 unless you find yourself wasting time switching among the menus.
29174 @table @kbd
29175 @item INV +/-
29176 is the same as @key{1/x}.
29177 @item INV +
29178 is the same as @key{SQRT}.
29179 @item INV -
29180 is the same as @key{CONJ}.
29181 @item INV *
29182 is the same as @key{y^x}.
29183 @item INV /
29184 is the same as @key{INV y^x} (the @cite{x}th root of @cite{y}).
29185 @item HYP/INV 1
29186 are the same as @key{SIN} / @kbd{INV SIN}.
29187 @item HYP/INV 2
29188 are the same as @key{COS} / @kbd{INV COS}.
29189 @item HYP/INV 3
29190 are the same as @key{TAN} / @kbd{INV TAN}.
29191 @item INV/HYP 4
29192 are the same as @key{LN} / @kbd{HYP LN}.
29193 @item INV/HYP 5
29194 are the same as @key{EXP} / @kbd{HYP EXP}.
29195 @item INV 6
29196 is the same as @key{ABS}.
29197 @item INV 7
29198 is the same as @key{RND} (@code{calc-round}).
29199 @item INV 8
29200 is the same as @key{CLN2}.
29201 @item INV 9
29202 is the same as @key{FLT} (@code{calc-float}).
29203 @item INV 0
29204 is the same as @key{IMAG}.
29205 @item INV .
29206 is the same as @key{PREC}.
29207 @item INV ENTER
29208 is the same as @key{SWAP}.
29209 @item HYP ENTER
29210 is the same as @key{RLL3}.
29211 @item INV HYP ENTER
29212 is the same as @key{OVER}.
29213 @item HYP +/-
29214 packs the top two stack entries as an error form.
29215 @item HYP EEX
29216 packs the top two stack entries as a modulo form.
29217 @item INV EEX
29218 creates an interval form; this removes an integer which is one
29219 of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
29220 by the two limits of the interval.
29221 @end table
29223 The @kbd{OFF} key turns Calc off; typing @kbd{M-# k} or @kbd{M-# M-#}
29224 again has the same effect.  This is analogous to typing @kbd{q} or
29225 hitting @kbd{M-# c} again in the normal calculator.  If Calc is
29226 running standalone (the @code{full-calc-keypad} command appeared in the
29227 command line that started Emacs), then @kbd{OFF} is replaced with
29228 @kbd{EXIT}; clicking on this actually exits Emacs itself.
29230 @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
29231 @section Functions Menu
29233 @smallexample
29234 @group
29235 |----+----+----+----+----+----2
29236 |IGAM|BETA|IBET|ERF |BESJ|BESY|
29237 |----+----+----+----+----+----|
29238 |IMAG|CONJ| RE |ATN2|RAND|RAGN|
29239 |----+----+----+----+----+----|
29240 |GCD |FACT|DFCT|BNOM|PERM|NXTP|
29241 |----+----+----+----+----+----|
29242 @end group
29243 @end smallexample
29245 @noindent
29246 This menu provides various operations from the @kbd{f} and @kbd{k}
29247 prefix keys.
29249 @key{IMAG} multiplies the number on the stack by the imaginary
29250 number @cite{i = (0, 1)}.
29252 @key{RE} extracts the real part a complex number.  @kbd{INV RE}
29253 extracts the imaginary part.
29255 @key{RAND} takes a number from the top of the stack and computes
29256 a random number greater than or equal to zero but less than that
29257 number.  (@xref{Random Numbers}.)  @key{RAGN} is the ``random
29258 again'' command; it computes another random number using the
29259 same limit as last time.
29261 @key{INV GCD} computes the LCM (least common multiple) function.
29263 @key{INV FACT} is the gamma function.  @c{$\Gamma(x) = (x-1)!$}
29264 @cite{gamma(x) = (x-1)!}.
29266 @key{PERM} is the number-of-permutations function, which is on the
29267 @kbd{H k c} key in normal Calc.
29269 @key{NXTP} finds the next prime after a number.  @kbd{INV NXTP}
29270 finds the previous prime.
29272 @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
29273 @section Binary Menu
29275 @smallexample
29276 @group
29277 |----+----+----+----+----+----3
29278 |AND | OR |XOR |NOT |LSH |RSH |
29279 |----+----+----+----+----+----|
29280 |DEC |HEX |OCT |BIN |WSIZ|ARSH|
29281 |----+----+----+----+----+----|
29282 | A  | B  | C  | D  | E  | F  |
29283 |----+----+----+----+----+----|
29284 @end group
29285 @end smallexample
29287 @noindent
29288 The keys in this menu perform operations on binary integers.
29289 Note that both logical and arithmetic right-shifts are provided.
29290 @key{INV LSH} rotates one bit to the left.
29292 The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
29293 The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
29295 The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
29296 current radix for display and entry of numbers:  Decimal, hexadecimal,
29297 octal, or binary.  The six letter keys @key{A} through @key{F} are used
29298 for entering hexadecimal numbers.
29300 The @key{WSIZ} key displays the current word size for binary operations
29301 and allows you to enter a new word size.  You can respond to the prompt
29302 using either the keyboard or the digits and @key{ENTER} from the keypad.
29303 The initial word size is 32 bits.
29305 @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
29306 @section Vectors Menu
29308 @smallexample
29309 @group
29310 |----+----+----+----+----+----4
29311 |SUM |PROD|MAX |MAP*|MAP^|MAP$|
29312 |----+----+----+----+----+----|
29313 |MINV|MDET|MTRN|IDNT|CRSS|"x" |
29314 |----+----+----+----+----+----|
29315 |PACK|UNPK|INDX|BLD |LEN |... |
29316 |----+----+----+----+----+----|
29317 @end group
29318 @end smallexample
29320 @noindent
29321 The keys in this menu operate on vectors and matrices.
29323 @key{PACK} removes an integer @var{n} from the top of the stack;
29324 the next @var{n} stack elements are removed and packed into a vector,
29325 which is replaced onto the stack.  Thus the sequence
29326 @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
29327 @samp{[1, 3, 5]} onto the stack.  To enter a matrix, build each row
29328 on the stack as a vector, then use a final @key{PACK} to collect the
29329 rows into a matrix.
29331 @key{UNPK} unpacks the vector on the stack, pushing each of its
29332 components separately.
29334 @key{INDX} removes an integer @var{n}, then builds a vector of
29335 integers from 1 to @var{n}.  @kbd{INV INDX} takes three numbers
29336 from the stack:  The vector size @var{n}, the starting number,
29337 and the increment.  @kbd{BLD} takes an integer @var{n} and any
29338 value @var{x} and builds a vector of @var{n} copies of @var{x}.
29340 @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
29341 identity matrix.
29343 @key{LEN} replaces a vector by its length, an integer.
29345 @key{...} turns on or off ``abbreviated'' display mode for large vectors.
29347 @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
29348 inverse, determinant, and transpose, and vector cross product.
29350 @key{SUM} replaces a vector by the sum of its elements.  It is
29351 equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
29352 @key{PROD} computes the product of the elements of a vector, and
29353 @key{MAX} computes the maximum of all the elements of a vector.
29355 @key{INV SUM} computes the alternating sum of the first element
29356 minus the second, plus the third, minus the fourth, and so on.
29357 @key{INV MAX} computes the minimum of the vector elements.
29359 @key{HYP SUM} computes the mean of the vector elements.
29360 @key{HYP PROD} computes the sample standard deviation.
29361 @key{HYP MAX} computes the median.
29363 @key{MAP*} multiplies two vectors elementwise.  It is equivalent
29364 to the @kbd{V M *} command.  @key{MAP^} computes powers elementwise.
29365 The arguments must be vectors of equal length, or one must be a vector
29366 and the other must be a plain number.  For example, @kbd{2 MAP^} squares
29367 all the elements of a vector.
29369 @key{MAP$} maps the formula on the top of the stack across the
29370 vector in the second-to-top position.  If the formula contains
29371 several variables, Calc takes that many vectors starting at the
29372 second-to-top position and matches them to the variables in
29373 alphabetical order.  The result is a vector of the same size as
29374 the input vectors, whose elements are the formula evaluated with
29375 the variables set to the various sets of numbers in those vectors.
29376 For example, you could simulate @key{MAP^} using @key{MAP$} with
29377 the formula @samp{x^y}.
29379 The @kbd{"x"} key pushes the variable name @cite{x} onto the
29380 stack.  To build the formula @cite{x^2 + 6}, you would use the
29381 key sequence @kbd{"x" 2 y^x 6 +}.  This formula would then be
29382 suitable for use with the @key{MAP$} key described above.
29383 With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
29384 @kbd{"x"} key pushes the variable names @cite{y}, @cite{z}, and
29385 @cite{t}, respectively.
29387 @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
29388 @section Modes Menu
29390 @smallexample
29391 @group
29392 |----+----+----+----+----+----5
29393 |FLT |FIX |SCI |ENG |GRP |    |
29394 |----+----+----+----+----+----|
29395 |RAD |DEG |FRAC|POLR|SYMB|PREC|
29396 |----+----+----+----+----+----|
29397 |SWAP|RLL3|RLL4|OVER|STO |RCL |
29398 |----+----+----+----+----+----|
29399 @end group
29400 @end smallexample
29402 @noindent
29403 The keys in this menu manipulate modes, variables, and the stack.
29405 The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
29406 floating-point, fixed-point, scientific, or engineering notation.
29407 @key{FIX} displays two digits after the decimal by default; the
29408 others display full precision.  With the @key{INV} prefix, these
29409 keys pop a number-of-digits argument from the stack.
29411 The @key{GRP} key turns grouping of digits with commas on or off.
29412 @kbd{INV GRP} enables grouping to the right of the decimal point as
29413 well as to the left.
29415 The @key{RAD} and @key{DEG} keys switch between radians and degrees
29416 for trigonometric functions.
29418 The @key{FRAC} key turns Fraction mode on or off.  This affects
29419 whether commands like @kbd{/} with integer arguments produce
29420 fractional or floating-point results.
29422 The @key{POLR} key turns Polar mode on or off, determining whether
29423 polar or rectangular complex numbers are used by default.
29425 The @key{SYMB} key turns Symbolic mode on or off, in which
29426 operations that would produce inexact floating-point results
29427 are left unevaluated as algebraic formulas.
29429 The @key{PREC} key selects the current precision.  Answer with
29430 the keyboard or with the keypad digit and @key{ENTER} keys.
29432 The @key{SWAP} key exchanges the top two stack elements.
29433 The @key{RLL3} key rotates the top three stack elements upwards.
29434 The @key{RLL4} key rotates the top four stack elements upwards.
29435 The @key{OVER} key duplicates the second-to-top stack element.
29437 The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
29438 @kbd{s r} in regular Calc.  @xref{Store and Recall}.  Click the
29439 @key{STO} or @key{RCL} key, then one of the ten digits.  (Named
29440 variables are not available in Keypad Mode.)  You can also use,
29441 for example, @kbd{STO + 3} to add to register 3.
29443 @node Embedded Mode, Programming, Keypad Mode, Top
29444 @chapter Embedded Mode
29446 @noindent
29447 Embedded Mode in Calc provides an alternative to copying numbers
29448 and formulas back and forth between editing buffers and the Calc
29449 stack.  In Embedded Mode, your editing buffer becomes temporarily
29450 linked to the stack and this copying is taken care of automatically.
29452 @menu
29453 * Basic Embedded Mode::
29454 * More About Embedded Mode::
29455 * Assignments in Embedded Mode::
29456 * Mode Settings in Embedded Mode::
29457 * Customizing Embedded Mode::
29458 @end menu
29460 @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
29461 @section Basic Embedded Mode
29463 @noindent
29464 @kindex M-# e
29465 @pindex calc-embedded
29466 To enter Embedded mode, position the Emacs point (cursor) on a
29467 formula in any buffer and press @kbd{M-# e} (@code{calc-embedded}).
29468 Note that @kbd{M-# e} is not to be used in the Calc stack buffer
29469 like most Calc commands, but rather in regular editing buffers that
29470 are visiting your own files.
29472 Calc normally scans backward and forward in the buffer for the
29473 nearest opening and closing @dfn{formula delimiters}.  The simplest
29474 delimiters are blank lines.  Other delimiters that Embedded Mode
29475 understands are:
29477 @enumerate
29478 @item
29479 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
29480 @samp{\[ \]}, and @samp{\( \)};
29481 @item
29482 Lines beginning with @samp{\begin} and @samp{\end};
29483 @item
29484 Lines beginning with @samp{@@} (Texinfo delimiters).
29485 @item
29486 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
29487 @item
29488 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
29489 @end enumerate
29491 @xref{Customizing Embedded Mode}, to see how to make Calc recognize
29492 your own favorite delimiters.  Delimiters like @samp{$ $} can appear
29493 on their own separate lines or in-line with the formula.
29495 If you give a positive or negative numeric prefix argument, Calc
29496 instead uses the current point as one end of the formula, and moves
29497 forward or backward (respectively) by that many lines to find the
29498 other end.  Explicit delimiters are not necessary in this case.
29500 With a prefix argument of zero, Calc uses the current region
29501 (delimited by point and mark) instead of formula delimiters.
29503 @kindex M-# w
29504 @pindex calc-embedded-word
29505 With a prefix argument of @kbd{C-u} only, Calc scans for the first
29506 non-numeric character (i.e., the first character that is not a
29507 digit, sign, decimal point, or upper- or lower-case @samp{e})
29508 forward and backward to delimit the formula.  @kbd{M-# w}
29509 (@code{calc-embedded-word}) is equivalent to @kbd{C-u M-# e}.
29511 When you enable Embedded mode for a formula, Calc reads the text
29512 between the delimiters and tries to interpret it as a Calc formula.
29513 It's best if the current Calc language mode is correct for the
29514 formula, but Calc can generally identify @TeX{} formulas and
29515 Big-style formulas even if the language mode is wrong.  If Calc
29516 can't make sense of the formula, it beeps and refuses to enter
29517 Embedded mode.  But if the current language is wrong, Calc can
29518 sometimes parse the formula successfully (but incorrectly);
29519 for example, the C expression @samp{atan(a[1])} can be parsed
29520 in Normal language mode, but the @code{atan} won't correspond to
29521 the built-in @code{arctan} function, and the @samp{a[1]} will be
29522 interpreted as @samp{a} times the vector @samp{[1]}!
29524 If you press @kbd{M-# e} or @kbd{M-# w} to activate an embedded
29525 formula which is blank, say with the cursor on the space between
29526 the two delimiters @samp{$ $}, Calc will immediately prompt for
29527 an algebraic entry.
29529 Only one formula in one buffer can be enabled at a time.  If you
29530 move to another area of the current buffer and give Calc commands,
29531 Calc turns Embedded mode off for the old formula and then tries
29532 to restart Embedded mode at the new position.  Other buffers are
29533 not affected by Embedded mode.
29535 When Embedded mode begins, Calc pushes the current formula onto
29536 the stack.  No Calc stack window is created; however, Calc copies
29537 the top-of-stack position into the original buffer at all times.
29538 You can create a Calc window by hand with @kbd{M-# o} if you
29539 find you need to see the entire stack.
29541 For example, typing @kbd{M-# e} while somewhere in the formula
29542 @samp{n>2} in the following line enables Embedded mode on that
29543 inequality:
29545 @example
29546 We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
29547 @end example
29549 @noindent
29550 The formula @cite{n>2} will be pushed onto the Calc stack, and
29551 the top of stack will be copied back into the editing buffer.
29552 This means that spaces will appear around the @samp{>} symbol
29553 to match Calc's usual display style:
29555 @example
29556 We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
29557 @end example
29559 @noindent
29560 No spaces have appeared around the @samp{+} sign because it's
29561 in a different formula, one which we have not yet touched with
29562 Embedded mode.
29564 Now that Embedded mode is enabled, keys you type in this buffer
29565 are interpreted as Calc commands.  At this point we might use
29566 the ``commute'' command @kbd{j C} to reverse the inequality.
29567 This is a selection-based command for which we first need to
29568 move the cursor onto the operator (@samp{>} in this case) that
29569 needs to be commuted.
29571 @example
29572 We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
29573 @end example
29575 The @kbd{M-# o} command is a useful way to open a Calc window
29576 without actually selecting that window.  Giving this command
29577 verifies that @samp{2 < n} is also on the Calc stack.  Typing
29578 @kbd{17 @key{RET}} would produce:
29580 @example
29581 We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
29582 @end example
29584 @noindent
29585 with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
29586 at this point will exchange the two stack values and restore
29587 @samp{2 < n} to the embedded formula.  Even though you can't
29588 normally see the stack in Embedded mode, it is still there and
29589 it still operates in the same way.  But, as with old-fashioned
29590 RPN calculators, you can only see the value at the top of the
29591 stack at any given time (unless you use @kbd{M-# o}).
29593 Typing @kbd{M-# e} again turns Embedded mode off.  The Calc
29594 window reveals that the formula @w{@samp{2 < n}} is automatically
29595 removed from the stack, but the @samp{17} is not.  Entering
29596 Embedded mode always pushes one thing onto the stack, and
29597 leaving Embedded mode always removes one thing.  Anything else
29598 that happens on the stack is entirely your business as far as
29599 Embedded mode is concerned.
29601 If you press @kbd{M-# e} in the wrong place by accident, it is
29602 possible that Calc will be able to parse the nearby text as a
29603 formula and will mangle that text in an attempt to redisplay it
29604 ``properly'' in the current language mode.  If this happens,
29605 press @kbd{M-# e} again to exit Embedded mode, then give the
29606 regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
29607 the text back the way it was before Calc edited it.  Note that Calc's
29608 own Undo command (typed before you turn Embedded mode back off)
29609 will not do you any good, because as far as Calc is concerned
29610 you haven't done anything with this formula yet.
29612 @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
29613 @section More About Embedded Mode
29615 @noindent
29616 When Embedded mode ``activates'' a formula, i.e., when it examines
29617 the formula for the first time since the buffer was created or
29618 loaded, Calc tries to sense the language in which the formula was
29619 written.  If the formula contains any @TeX{}-like @samp{\} sequences,
29620 it is parsed (i.e., read) in @TeX{} mode.  If the formula appears to
29621 be written in multi-line Big mode, it is parsed in Big mode.  Otherwise,
29622 it is parsed according to the current language mode.
29624 Note that Calc does not change the current language mode according
29625 to what it finds.  Even though it can read a @TeX{} formula when
29626 not in @TeX{} mode, it will immediately rewrite this formula using
29627 whatever language mode is in effect.  You must then type @kbd{d T}
29628 to switch Calc permanently into @TeX{} mode if that is what you
29629 desire.
29631 @tex
29632 \bigskip
29633 @end tex
29635 @kindex d p
29636 @pindex calc-show-plain
29637 Calc's parser is unable to read certain kinds of formulas.  For
29638 example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
29639 specify matrix display styles which the parser is unable to
29640 recognize as matrices.  The @kbd{d p} (@code{calc-show-plain})
29641 command turns on a mode in which a ``plain'' version of a
29642 formula is placed in front of the fully-formatted version.
29643 When Calc reads a formula that has such a plain version in
29644 front, it reads the plain version and ignores the formatted
29645 version.
29647 Plain formulas are preceded and followed by @samp{%%%} signs
29648 by default.  This notation has the advantage that the @samp{%}
29649 character begins a comment in @TeX{}, so if your formula is
29650 embedded in a @TeX{} document its plain version will be
29651 invisible in the final printed copy.  @xref{Customizing
29652 Embedded Mode}, to see how to change the ``plain'' formula
29653 delimiters, say to something that @dfn{eqn} or some other
29654 formatter will treat as a comment.
29656 There are several notations which Calc's parser for ``big''
29657 formatted formulas can't yet recognize.  In particular, it can't
29658 read the large symbols for @code{sum}, @code{prod}, and @code{integ},
29659 and it can't handle @samp{=>} with the righthand argument omitted.
29660 Also, Calc won't recognize special formats you have defined with
29661 the @kbd{Z C} command (@pxref{User-Defined Compositions}).  In
29662 these cases it is important to use ``plain'' mode to make sure
29663 Calc will be able to read your formula later.
29665 Another example where ``plain'' mode is important is if you have
29666 specified a float mode with few digits of precision.  Normally
29667 any digits that are computed but not displayed will simply be
29668 lost when you save and re-load your embedded buffer, but ``plain''
29669 mode allows you to make sure that the complete number is present
29670 in the file as well as the rounded-down number.
29672 @tex
29673 \bigskip
29674 @end tex
29676 Embedded buffers remember active formulas for as long as they
29677 exist in Emacs memory.  Suppose you have an embedded formula
29678 which is @c{$\pi$}
29679 @cite{pi} to the normal 12 decimal places, and then
29680 type @w{@kbd{C-u 5 d n}} to display only five decimal places.
29681 If you then type @kbd{d n}, all 12 places reappear because the
29682 full number is still there on the Calc stack.  More surprisingly,
29683 even if you exit Embedded mode and later re-enter it for that
29684 formula, typing @kbd{d n} will restore all 12 places because
29685 each buffer remembers all its active formulas.  However, if you
29686 save the buffer in a file and reload it in a new Emacs session,
29687 all non-displayed digits will have been lost unless you used
29688 ``plain'' mode.
29690 @tex
29691 \bigskip
29692 @end tex
29694 In some applications of Embedded mode, you will want to have a
29695 sequence of copies of a formula that show its evolution as you
29696 work on it.  For example, you might want to have a sequence
29697 like this in your file (elaborating here on the example from
29698 the ``Getting Started'' chapter):
29700 @smallexample
29701 The derivative of
29703                               ln(ln(x))
29707                   @r{(the derivative of }ln(ln(x))@r{)}
29709 whose value at x = 2 is
29711                             @r{(the value)}
29713 and at x = 3 is
29715                             @r{(the value)}
29716 @end smallexample
29718 @kindex M-# d
29719 @pindex calc-embedded-duplicate
29720 The @kbd{M-# d} (@code{calc-embedded-duplicate}) command is a
29721 handy way to make sequences like this.  If you type @kbd{M-# d},
29722 the formula under the cursor (which may or may not have Embedded
29723 mode enabled for it at the time) is copied immediately below and
29724 Embedded mode is then enabled for that copy.
29726 For this example, you would start with just
29728 @smallexample
29729 The derivative of
29731                               ln(ln(x))
29732 @end smallexample
29734 @noindent
29735 and press @kbd{M-# d} with the cursor on this formula.  The result
29738 @smallexample
29739 The derivative of
29741                               ln(ln(x))
29744                               ln(ln(x))
29745 @end smallexample
29747 @noindent
29748 with the second copy of the formula enabled in Embedded mode.
29749 You can now press @kbd{a d x @key{RET}} to take the derivative, and
29750 @kbd{M-# d M-# d} to make two more copies of the derivative.
29751 To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
29752 the last formula, then move up to the second-to-last formula
29753 and type @kbd{2 s l x @key{RET}}.
29755 Finally, you would want to press @kbd{M-# e} to exit Embedded
29756 mode, then go up and insert the necessary text in between the
29757 various formulas and numbers.
29759 @tex
29760 \bigskip
29761 @end tex
29763 @kindex M-# f
29764 @kindex M-# '
29765 @pindex calc-embedded-new-formula
29766 The @kbd{M-# f} (@code{calc-embedded-new-formula}) command
29767 creates a new embedded formula at the current point.  It inserts
29768 some default delimiters, which are usually just blank lines,
29769 and then does an algebraic entry to get the formula (which is
29770 then enabled for Embedded mode).  This is just shorthand for
29771 typing the delimiters yourself, positioning the cursor between
29772 the new delimiters, and pressing @kbd{M-# e}.  The key sequence
29773 @kbd{M-# '} is equivalent to @kbd{M-# f}.
29775 @kindex M-# n
29776 @kindex M-# p
29777 @pindex calc-embedded-next
29778 @pindex calc-embedded-previous
29779 The @kbd{M-# n} (@code{calc-embedded-next}) and @kbd{M-# p}
29780 (@code{calc-embedded-previous}) commands move the cursor to the
29781 next or previous active embedded formula in the buffer.  They
29782 can take positive or negative prefix arguments to move by several
29783 formulas.  Note that these commands do not actually examine the
29784 text of the buffer looking for formulas; they only see formulas
29785 which have previously been activated in Embedded mode.  In fact,
29786 @kbd{M-# n} and @kbd{M-# p} are a useful way to tell which
29787 embedded formulas are currently active.  Also, note that these
29788 commands do not enable Embedded mode on the next or previous
29789 formula, they just move the cursor.  (By the way, @kbd{M-# n} is
29790 not as awkward to type as it may seem, because @kbd{M-#} ignores
29791 Shift and Meta on the second keystroke:  @kbd{M-# M-N} can be typed
29792 by holding down Shift and Meta and alternately typing two keys.)
29794 @kindex M-# `
29795 @pindex calc-embedded-edit
29796 The @kbd{M-# `} (@code{calc-embedded-edit}) command edits the
29797 embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
29798 Embedded mode does not have to be enabled for this to work.  Press
29799 @kbd{M-# M-#} to finish the edit, or @kbd{M-# x} to cancel.
29801 @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
29802 @section Assignments in Embedded Mode
29804 @noindent
29805 The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
29806 are especially useful in Embedded mode.  They allow you to make
29807 a definition in one formula, then refer to that definition in
29808 other formulas embedded in the same buffer.
29810 An embedded formula which is an assignment to a variable, as in
29812 @example
29813 foo := 5
29814 @end example
29816 @noindent
29817 records @cite{5} as the stored value of @code{foo} for the
29818 purposes of Embedded mode operations in the current buffer.  It
29819 does @emph{not} actually store @cite{5} as the ``global'' value
29820 of @code{foo}, however.  Regular Calc operations, and Embedded
29821 formulas in other buffers, will not see this assignment.
29823 One way to use this assigned value is simply to create an
29824 Embedded formula elsewhere that refers to @code{foo}, and to press
29825 @kbd{=} in that formula.  However, this permanently replaces the
29826 @code{foo} in the formula with its current value.  More interesting
29827 is to use @samp{=>} elsewhere:
29829 @example
29830 foo + 7 => 12
29831 @end example
29833 @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
29835 If you move back and change the assignment to @code{foo}, any
29836 @samp{=>} formulas which refer to it are automatically updated.
29838 @example
29839 foo := 17
29841 foo + 7 => 24
29842 @end example
29844 The obvious question then is, @emph{how} can one easily change the
29845 assignment to @code{foo}?  If you simply select the formula in
29846 Embedded mode and type 17, the assignment itself will be replaced
29847 by the 17.  The effect on the other formula will be that the
29848 variable @code{foo} becomes unassigned:
29850 @example
29853 foo + 7 => foo + 7
29854 @end example
29856 The right thing to do is first to use a selection command (@kbd{j 2}
29857 will do the trick) to select the righthand side of the assignment.
29858 Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
29859 Subformulas}, to see how this works).
29861 @kindex M-# j
29862 @pindex calc-embedded-select
29863 The @kbd{M-# j} (@code{calc-embedded-select}) command provides an
29864 easy way to operate on assignments.  It is just like @kbd{M-# e},
29865 except that if the enabled formula is an assignment, it uses
29866 @kbd{j 2} to select the righthand side.  If the enabled formula
29867 is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
29868 A formula can also be a combination of both:
29870 @example
29871 bar := foo + 3 => 20
29872 @end example
29874 @noindent
29875 in which case @kbd{M-# j} will select the middle part (@samp{foo + 3}).
29877 The formula is automatically deselected when you leave Embedded
29878 mode.
29880 @kindex M-# u
29881 @kindex M-# =
29882 @pindex calc-embedded-update
29883 Another way to change the assignment to @code{foo} would simply be
29884 to edit the number using regular Emacs editing rather than Embedded
29885 mode.  Then, we have to find a way to get Embedded mode to notice
29886 the change.  The @kbd{M-# u} or @kbd{M-# =}
29887 (@code{calc-embedded-update-formula}) command is a convenient way
29888 to do this.@refill
29890 @example
29891 foo := 6
29893 foo + 7 => 13
29894 @end example
29896 Pressing @kbd{M-# u} is much like pressing @kbd{M-# e = M-# e}, that
29897 is, temporarily enabling Embedded mode for the formula under the
29898 cursor and then evaluating it with @kbd{=}.  But @kbd{M-# u} does
29899 not actually use @kbd{M-# e}, and in fact another formula somewhere
29900 else can be enabled in Embedded mode while you use @kbd{M-# u} and
29901 that formula will not be disturbed.
29903 With a numeric prefix argument, @kbd{M-# u} updates all active
29904 @samp{=>} formulas in the buffer.  Formulas which have not yet
29905 been activated in Embedded mode, and formulas which do not have
29906 @samp{=>} as their top-level operator, are not affected by this.
29907 (This is useful only if you have used @kbd{m C}; see below.)
29909 With a plain @kbd{C-u} prefix, @kbd{C-u M-# u} updates only in the
29910 region between mark and point rather than in the whole buffer.
29912 @kbd{M-# u} is also a handy way to activate a formula, such as an
29913 @samp{=>} formula that has freshly been typed in or loaded from a
29914 file.
29916 @kindex M-# a
29917 @pindex calc-embedded-activate
29918 The @kbd{M-# a} (@code{calc-embedded-activate}) command scans
29919 through the current buffer and activates all embedded formulas
29920 that contain @samp{:=} or @samp{=>} symbols.  This does not mean
29921 that Embedded mode is actually turned on, but only that the
29922 formulas' positions are registered with Embedded mode so that
29923 the @samp{=>} values can be properly updated as assignments are
29924 changed.
29926 It is a good idea to type @kbd{M-# a} right after loading a file
29927 that uses embedded @samp{=>} operators.  Emacs includes a nifty
29928 ``buffer-local variables'' feature that you can use to do this
29929 automatically.  The idea is to place near the end of your file
29930 a few lines that look like this:
29932 @example
29933 --- Local Variables: ---
29934 --- eval:(calc-embedded-activate) ---
29935 --- End: ---
29936 @end example
29938 @noindent
29939 where the leading and trailing @samp{---} can be replaced by
29940 any suitable strings (which must be the same on all three lines)
29941 or omitted altogether; in a @TeX{} file, @samp{%} would be a good
29942 leading string and no trailing string would be necessary.  In a
29943 C program, @samp{/*} and @samp{*/} would be good leading and
29944 trailing strings.
29946 When Emacs loads a file into memory, it checks for a Local Variables
29947 section like this one at the end of the file.  If it finds this
29948 section, it does the specified things (in this case, running
29949 @kbd{M-# a} automatically) before editing of the file begins.
29950 The Local Variables section must be within 3000 characters of the
29951 end of the file for Emacs to find it, and it must be in the last
29952 page of the file if the file has any page separators.
29953 @xref{File Variables, , Local Variables in Files, emacs, the
29954 Emacs manual}.
29956 Note that @kbd{M-# a} does not update the formulas it finds.
29957 To do this, type, say, @kbd{M-1 M-# u} after @w{@kbd{M-# a}}.
29958 Generally this should not be a problem, though, because the
29959 formulas will have been up-to-date already when the file was
29960 saved.
29962 Normally, @kbd{M-# a} activates all the formulas it finds, but
29963 any previous active formulas remain active as well.  With a
29964 positive numeric prefix argument, @kbd{M-# a} first deactivates
29965 all current active formulas, then actives the ones it finds in
29966 its scan of the buffer.  With a negative prefix argument,
29967 @kbd{M-# a} simply deactivates all formulas.
29969 Embedded mode has two symbols, @samp{Active} and @samp{~Active},
29970 which it puts next to the major mode name in a buffer's mode line.
29971 It puts @samp{Active} if it has reason to believe that all
29972 formulas in the buffer are active, because you have typed @kbd{M-# a}
29973 and Calc has not since had to deactivate any formulas (which can
29974 happen if Calc goes to update an @samp{=>} formula somewhere because
29975 a variable changed, and finds that the formula is no longer there
29976 due to some kind of editing outside of Embedded mode).  Calc puts
29977 @samp{~Active} in the mode line if some, but probably not all,
29978 formulas in the buffer are active.  This happens if you activate
29979 a few formulas one at a time but never use @kbd{M-# a}, or if you
29980 used @kbd{M-# a} but then Calc had to deactivate a formula
29981 because it lost track of it.  If neither of these symbols appears
29982 in the mode line, no embedded formulas are active in the buffer
29983 (e.g., before Embedded mode has been used, or after a @kbd{M-- M-# a}).
29985 Embedded formulas can refer to assignments both before and after them
29986 in the buffer.  If there are several assignments to a variable, the
29987 nearest preceding assignment is used if there is one, otherwise the
29988 following assignment is used.
29990 @example
29991 x => 1
29993 x := 1
29995 x => 1
29997 x := 2
29999 x => 2
30000 @end example
30002 As well as simple variables, you can also assign to subscript
30003 expressions of the form @samp{@var{var}_@var{number}} (as in
30004 @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
30005 Assignments to other kinds of objects can be represented by Calc,
30006 but the automatic linkage between assignments and references works
30007 only for plain variables and these two kinds of subscript expressions.
30009 If there are no assignments to a given variable, the global
30010 stored value for the variable is used (@pxref{Storing Variables}),
30011 or, if no value is stored, the variable is left in symbolic form.
30012 Note that global stored values will be lost when the file is saved
30013 and loaded in a later Emacs session, unless you have used the
30014 @kbd{s p} (@code{calc-permanent-variable}) command to save them;
30015 @pxref{Operations on Variables}.
30017 The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
30018 recomputation of @samp{=>} forms on and off.  If you turn automatic
30019 recomputation off, you will have to use @kbd{M-# u} to update these
30020 formulas manually after an assignment has been changed.  If you
30021 plan to change several assignments at once, it may be more efficient
30022 to type @kbd{m C}, change all the assignments, then use @kbd{M-1 M-# u}
30023 to update the entire buffer afterwards.  The @kbd{m C} command also
30024 controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
30025 Operator}.  When you turn automatic recomputation back on, the
30026 stack will be updated but the Embedded buffer will not; you must
30027 use @kbd{M-# u} to update the buffer by hand.
30029 @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
30030 @section Mode Settings in Embedded Mode
30032 @noindent
30033 Embedded Mode has a rather complicated mechanism for handling mode
30034 settings in Embedded formulas.  It is possible to put annotations
30035 in the file that specify mode settings either global to the entire
30036 file or local to a particular formula or formulas.  In the latter
30037 case, different modes can be specified for use when a formula
30038 is the enabled Embedded Mode formula.
30040 When you give any mode-setting command, like @kbd{m f} (for fraction
30041 mode) or @kbd{d s} (for scientific notation), Embedded Mode adds
30042 a line like the following one to the file just before the opening
30043 delimiter of the formula.
30045 @example
30046 % [calc-mode: fractions: t]
30047 % [calc-mode: float-format: (sci 0)]
30048 @end example
30050 When Calc interprets an embedded formula, it scans the text before
30051 the formula for mode-setting annotations like these and sets the
30052 Calc buffer to match these modes.  Modes not explicitly described
30053 in the file are not changed.  Calc scans all the way to the top of
30054 the file, or up to a line of the form
30056 @example
30057 % [calc-defaults]
30058 @end example
30060 @noindent
30061 which you can insert at strategic places in the file if this backward
30062 scan is getting too slow, or just to provide a barrier between one
30063 ``zone'' of mode settings and another.
30065 If the file contains several annotations for the same mode, the
30066 closest one before the formula is used.  Annotations after the
30067 formula are never used (except for global annotations, described
30068 below).
30070 The scan does not look for the leading @samp{% }, only for the
30071 square brackets and the text they enclose.  You can edit the mode
30072 annotations to a style that works better in context if you wish.
30073 @xref{Customizing Embedded Mode}, to see how to change the style
30074 that Calc uses when it generates the annotations.  You can write
30075 mode annotations into the file yourself if you know the syntax;
30076 the easiest way to find the syntax for a given mode is to let
30077 Calc write the annotation for it once and see what it does.
30079 If you give a mode-changing command for a mode that already has
30080 a suitable annotation just above the current formula, Calc will
30081 modify that annotation rather than generating a new, conflicting
30082 one.
30084 Mode annotations have three parts, separated by colons.  (Spaces
30085 after the colons are optional.)  The first identifies the kind
30086 of mode setting, the second is a name for the mode itself, and
30087 the third is the value in the form of a Lisp symbol, number,
30088 or list.  Annotations with unrecognizable text in the first or
30089 second parts are ignored.  The third part is not checked to make
30090 sure the value is of a legal type or range; if you write an
30091 annotation by hand, be sure to give a proper value or results
30092 will be unpredictable.  Mode-setting annotations are case-sensitive.
30094 While Embedded Mode is enabled, the word @code{Local} appears in
30095 the mode line.  This is to show that mode setting commands generate
30096 annotations that are ``local'' to the current formula or set of
30097 formulas.  The @kbd{m R} (@code{calc-mode-record-mode}) command
30098 causes Calc to generate different kinds of annotations.  Pressing
30099 @kbd{m R} repeatedly cycles through the possible modes.
30101 @code{LocEdit} and @code{LocPerm} modes generate annotations
30102 that look like this, respectively:
30104 @example
30105 % [calc-edit-mode: float-format: (sci 0)]
30106 % [calc-perm-mode: float-format: (sci 5)]
30107 @end example
30109 The first kind of annotation will be used only while a formula
30110 is enabled in Embedded Mode.  The second kind will be used only
30111 when the formula is @emph{not} enabled.  (Whether the formula
30112 is ``active'' or not, i.e., whether Calc has seen this formula
30113 yet, is not relevant here.)
30115 @code{Global} mode generates an annotation like this at the end
30116 of the file:
30118 @example
30119 % [calc-global-mode: fractions t]
30120 @end example
30122 Global mode annotations affect all formulas throughout the file,
30123 and may appear anywhere in the file.  This allows you to tuck your
30124 mode annotations somewhere out of the way, say, on a new page of
30125 the file, as long as those mode settings are suitable for all
30126 formulas in the file.
30128 Enabling a formula with @kbd{M-# e} causes a fresh scan for local
30129 mode annotations; you will have to use this after adding annotations
30130 above a formula by hand to get the formula to notice them.  Updating
30131 a formula with @kbd{M-# u} will also re-scan the local modes, but
30132 global modes are only re-scanned by @kbd{M-# a}.
30134 Another way that modes can get out of date is if you add a local
30135 mode annotation to a formula that has another formula after it.
30136 In this example, we have used the @kbd{d s} command while the
30137 first of the two embedded formulas is active.  But the second
30138 formula has not changed its style to match, even though by the
30139 rules of reading annotations the @samp{(sci 0)} applies to it, too.
30141 @example
30142 % [calc-mode: float-format: (sci 0)]
30143 1.23e2
30145 456.
30146 @end example
30148 We would have to go down to the other formula and press @kbd{M-# u}
30149 on it in order to get it to notice the new annotation.
30151 Two more mode-recording modes selectable by @kbd{m R} are @code{Save}
30152 (which works even outside of Embedded Mode), in which mode settings
30153 are recorded permanently in your Emacs startup file @file{~/.emacs}
30154 rather than by annotating the current document, and no-recording
30155 mode (where there is no symbol like @code{Save} or @code{Local} in
30156 the mode line), in which mode-changing commands do not leave any
30157 annotations at all.
30159 When Embedded Mode is not enabled, mode-recording modes except
30160 for @code{Save} have no effect.
30162 @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
30163 @section Customizing Embedded Mode
30165 @noindent
30166 You can modify Embedded Mode's behavior by setting various Lisp
30167 variables described here.  Use @kbd{M-x set-variable} or
30168 @kbd{M-x edit-options} to adjust a variable on the fly, or
30169 put a suitable @code{setq} statement in your @file{~/.emacs}
30170 file to set a variable permanently.  (Another possibility would
30171 be to use a file-local variable annotation at the end of the
30172 file; @pxref{File Variables, , Local Variables in Files, emacs, the
30173 Emacs manual}.)
30175 While none of these variables will be buffer-local by default, you
30176 can make any of them local to any embedded-mode buffer.  (Their
30177 values in the @samp{*Calculator*} buffer are never used.)
30179 @vindex calc-embedded-open-formula
30180 The @code{calc-embedded-open-formula} variable holds a regular
30181 expression for the opening delimiter of a formula.  @xref{Regexp Search,
30182 , Regular Expression Search, emacs, the Emacs manual}, to see
30183 how regular expressions work.  Basically, a regular expression is a
30184 pattern that Calc can search for.  A regular expression that considers
30185 blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
30186 @code{"\\`\\|^\n\\|\\$\\$?"}.  Just in case the meaning of this
30187 regular expression is not completely plain, let's go through it
30188 in detail.
30190 The surrounding @samp{" "} marks quote the text between them as a
30191 Lisp string.  If you left them off, @code{set-variable} or
30192 @code{edit-options} would try to read the regular expression as a
30193 Lisp program.
30195 The most obvious property of this regular expression is that it
30196 contains indecently many backslashes.  There are actually two levels
30197 of backslash usage going on here.  First, when Lisp reads a quoted
30198 string, all pairs of characters beginning with a backslash are
30199 interpreted as special characters.  Here, @code{\n} changes to a
30200 new-line character, and @code{\\} changes to a single backslash.
30201 So the actual regular expression seen by Calc is
30202 @samp{\`\|^ @r{(newline)} \|\$\$?}.
30204 Regular expressions also consider pairs beginning with backslash
30205 to have special meanings.  Sometimes the backslash is used to quote
30206 a character that otherwise would have a special meaning in a regular
30207 expression, like @samp{$}, which normally means ``end-of-line,''
30208 or @samp{?}, which means that the preceding item is optional.  So
30209 @samp{\$\$?} matches either one or two dollar signs.
30211 The other codes in this regular expression are @samp{^}, which matches
30212 ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
30213 which matches ``beginning-of-buffer.''  So the whole pattern means
30214 that a formula begins at the beginning of the buffer, or on a newline
30215 that occurs at the beginning of a line (i.e., a blank line), or at
30216 one or two dollar signs.
30218 The default value of @code{calc-embedded-open-formula} looks just
30219 like this example, with several more alternatives added on to
30220 recognize various other common kinds of delimiters.
30222 By the way, the reason to use @samp{^\n} rather than @samp{^$}
30223 or @samp{\n\n}, which also would appear to match blank lines,
30224 is that the former expression actually ``consumes'' only one
30225 newline character as @emph{part of} the delimiter, whereas the
30226 latter expressions consume zero or two newlines, respectively.
30227 The former choice gives the most natural behavior when Calc
30228 must operate on a whole formula including its delimiters.
30230 See the Emacs manual for complete details on regular expressions.
30231 But just for your convenience, here is a list of all characters
30232 which must be quoted with backslash (like @samp{\$}) to avoid
30233 some special interpretation:  @samp{. * + ? [ ] ^ $ \}.  (Note
30234 the backslash in this list; for example, to match @samp{\[} you
30235 must use @code{"\\\\\\["}.  An exercise for the reader is to
30236 account for each of these six backslashes!)
30238 @vindex calc-embedded-close-formula
30239 The @code{calc-embedded-close-formula} variable holds a regular
30240 expression for the closing delimiter of a formula.  A closing
30241 regular expression to match the above example would be
30242 @code{"\\'\\|\n$\\|\\$\\$?"}.  This is almost the same as the
30243 other one, except it now uses @samp{\'} (``end-of-buffer'') and
30244 @samp{\n$} (newline occurring at end of line, yet another way
30245 of describing a blank line that is more appropriate for this
30246 case).
30248 @vindex calc-embedded-open-word
30249 @vindex calc-embedded-close-word
30250 The @code{calc-embedded-open-word} and @code{calc-embedded-close-word}
30251 variables are similar expressions used when you type @kbd{M-# w}
30252 instead of @kbd{M-# e} to enable Embedded mode.
30254 @vindex calc-embedded-open-plain
30255 The @code{calc-embedded-open-plain} variable is a string which
30256 begins a ``plain'' formula written in front of the formatted
30257 formula when @kbd{d p} mode is turned on.  Note that this is an
30258 actual string, not a regular expression, because Calc must be able
30259 to write this string into a buffer as well as to recognize it.
30260 The default string is @code{"%%% "} (note the trailing space).
30262 @vindex calc-embedded-close-plain
30263 The @code{calc-embedded-close-plain} variable is a string which
30264 ends a ``plain'' formula.  The default is @code{" %%%\n"}.  Without
30265 the trailing newline here, the first line of a ``big'' mode formula
30266 that followed might be shifted over with respect to the other lines.
30268 @vindex calc-embedded-open-new-formula
30269 The @code{calc-embedded-open-new-formula} variable is a string
30270 which is inserted at the front of a new formula when you type
30271 @kbd{M-# f}.  Its default value is @code{"\n\n"}.  If this
30272 string begins with a newline character and the @kbd{M-# f} is
30273 typed at the beginning of a line, @kbd{M-# f} will skip this
30274 first newline to avoid introducing unnecessary blank lines in
30275 the file.
30277 @vindex calc-embedded-close-new-formula
30278 The @code{calc-embedded-close-new-formula} variable is the corresponding
30279 string which is inserted at the end of a new formula.  Its default
30280 value is also @code{"\n\n"}.  The final newline is omitted by
30281 @w{@kbd{M-# f}} if typed at the end of a line.  (It follows that if
30282 @kbd{M-# f} is typed on a blank line, both a leading opening
30283 newline and a trailing closing newline are omitted.)
30285 @vindex calc-embedded-announce-formula
30286 The @code{calc-embedded-announce-formula} variable is a regular
30287 expression which is sure to be followed by an embedded formula.
30288 The @kbd{M-# a} command searches for this pattern as well as for
30289 @samp{=>} and @samp{:=} operators.  Note that @kbd{M-# a} will
30290 not activate just anything surrounded by formula delimiters; after
30291 all, blank lines are considered formula delimiters by default!
30292 But if your language includes a delimiter which can only occur
30293 actually in front of a formula, you can take advantage of it here.
30294 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which
30295 checks for @samp{%Embed} followed by any number of lines beginning
30296 with @samp{%} and a space.  This last is important to make Calc
30297 consider mode annotations part of the pattern, so that the formula's
30298 opening delimiter really is sure to follow the pattern.
30300 @vindex calc-embedded-open-mode
30301 The @code{calc-embedded-open-mode} variable is a string (not a
30302 regular expression) which should precede a mode annotation.
30303 Calc never scans for this string; Calc always looks for the
30304 annotation itself.  But this is the string that is inserted before
30305 the opening bracket when Calc adds an annotation on its own.
30306 The default is @code{"% "}.
30308 @vindex calc-embedded-close-mode
30309 The @code{calc-embedded-close-mode} variable is a string which
30310 follows a mode annotation written by Calc.  Its default value
30311 is simply a newline, @code{"\n"}.  If you change this, it is a
30312 good idea still to end with a newline so that mode annotations
30313 will appear on lines by themselves.
30315 @node Programming, Installation, Embedded Mode, Top
30316 @chapter Programming
30318 @noindent
30319 There are several ways to ``program'' the Emacs Calculator, depending
30320 on the nature of the problem you need to solve.
30322 @enumerate
30323 @item
30324 @dfn{Keyboard macros} allow you to record a sequence of keystrokes
30325 and play them back at a later time.  This is just the standard Emacs
30326 keyboard macro mechanism, dressed up with a few more features such
30327 as loops and conditionals.
30329 @item
30330 @dfn{Algebraic definitions} allow you to use any formula to define a
30331 new function.  This function can then be used in algebraic formulas or
30332 as an interactive command.
30334 @item
30335 @dfn{Rewrite rules} are discussed in the section on algebra commands.
30336 @xref{Rewrite Rules}.  If you put your rewrite rules in the variable
30337 @code{EvalRules}, they will be applied automatically to all Calc
30338 results in just the same way as an internal ``rule'' is applied to
30339 evaluate @samp{sqrt(9)} to 3 and so on.  @xref{Automatic Rewrites}.
30341 @item
30342 @dfn{Lisp} is the programming language that Calc (and most of Emacs)
30343 is written in.  If the above techniques aren't powerful enough, you
30344 can write Lisp functions to do anything that built-in Calc commands
30345 can do.  Lisp code is also somewhat faster than keyboard macros or
30346 rewrite rules.
30347 @end enumerate
30349 @kindex z
30350 Programming features are available through the @kbd{z} and @kbd{Z}
30351 prefix keys.  New commands that you define are two-key sequences
30352 beginning with @kbd{z}.  Commands for managing these definitions
30353 use the shift-@kbd{Z} prefix.  (The @kbd{Z T} (@code{calc-timing})
30354 command is described elsewhere; @pxref{Troubleshooting Commands}.
30355 The @kbd{Z C} (@code{calc-user-define-composition}) command is also
30356 described elsewhere; @pxref{User-Defined Compositions}.)
30358 @menu
30359 * Creating User Keys::
30360 * Keyboard Macros::
30361 * Invocation Macros::
30362 * Algebraic Definitions::
30363 * Lisp Definitions::
30364 @end menu
30366 @node Creating User Keys, Keyboard Macros, Programming, Programming
30367 @section Creating User Keys
30369 @noindent
30370 @kindex Z D
30371 @pindex calc-user-define
30372 Any Calculator command may be bound to a key using the @kbd{Z D}
30373 (@code{calc-user-define}) command.  Actually, it is bound to a two-key
30374 sequence beginning with the lower-case @kbd{z} prefix.
30376 The @kbd{Z D} command first prompts for the key to define.  For example,
30377 press @kbd{Z D a} to define the new key sequence @kbd{z a}.  You are then
30378 prompted for the name of the Calculator command that this key should
30379 run.  For example, the @code{calc-sincos} command is not normally
30380 available on a key.  Typing @kbd{Z D s sincos @key{RET}} programs the
30381 @kbd{z s} key sequence to run @code{calc-sincos}.  This definition will remain
30382 in effect for the rest of this Emacs session, or until you redefine
30383 @kbd{z s} to be something else.
30385 You can actually bind any Emacs command to a @kbd{z} key sequence by
30386 backspacing over the @samp{calc-} when you are prompted for the command name.
30388 As with any other prefix key, you can type @kbd{z ?} to see a list of
30389 all the two-key sequences you have defined that start with @kbd{z}.
30390 Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
30392 User keys are typically letters, but may in fact be any key.
30393 (@key{META}-keys are not permitted, nor are a terminal's special
30394 function keys which generate multi-character sequences when pressed.)
30395 You can define different commands on the shifted and unshifted versions
30396 of a letter if you wish.
30398 @kindex Z U
30399 @pindex calc-user-undefine
30400 The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
30401 For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
30402 key we defined above.
30404 @kindex Z P
30405 @pindex calc-user-define-permanent
30406 @cindex Storing user definitions
30407 @cindex Permanent user definitions
30408 @cindex @file{.emacs} file, user-defined commands
30409 The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
30410 binding permanent so that it will remain in effect even in future Emacs
30411 sessions.  (It does this by adding a suitable bit of Lisp code into
30412 your @file{.emacs} file.)  For example, @kbd{Z P s} would register
30413 our @code{sincos} command permanently.  If you later wish to unregister
30414 this command you must edit your @file{.emacs} file by hand.
30415 (@xref{General Mode Commands}, for a way to tell Calc to use a
30416 different file instead of @file{.emacs}.)
30418 The @kbd{Z P} command also saves the user definition, if any, for the
30419 command bound to the key.  After @kbd{Z F} and @kbd{Z C}, a given user
30420 key could invoke a command, which in turn calls an algebraic function,
30421 which might have one or more special display formats.  A single @kbd{Z P}
30422 command will save all of these definitions.
30424 To save a command or function without its key binding (or if there is
30425 no key binding for the command or function), type @kbd{'} (the apostrophe)
30426 when prompted for a key.  Then, type the function name, or backspace
30427 to change the @samp{calcFunc-} prefix to @samp{calc-} and enter a
30428 command name.  (If the command you give implies a function, the function
30429 will be saved, and if the function has any display formats, those will
30430 be saved, but not the other way around:  Saving a function will not save
30431 any commands or key bindings associated with the function.)
30433 @kindex Z E
30434 @pindex calc-user-define-edit
30435 @cindex Editing user definitions
30436 The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
30437 of a user key.  This works for keys that have been defined by either
30438 keyboard macros or formulas; further details are contained in the relevant
30439 following sections.
30441 @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
30442 @section Programming with Keyboard Macros
30444 @noindent
30445 @kindex X
30446 @cindex Programming with keyboard macros
30447 @cindex Keyboard macros
30448 The easiest way to ``program'' the Emacs Calculator is to use standard
30449 keyboard macros.  Press @w{@kbd{C-x (}} to begin recording a macro.  From
30450 this point on, keystrokes you type will be saved away as well as
30451 performing their usual functions.  Press @kbd{C-x )} to end recording.
30452 Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
30453 execute your keyboard macro by replaying the recorded keystrokes.
30454 @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
30455 information.@refill
30457 When you use @kbd{X} to invoke a keyboard macro, the entire macro is
30458 treated as a single command by the undo and trail features.  The stack
30459 display buffer is not updated during macro execution, but is instead
30460 fixed up once the macro completes.  Thus, commands defined with keyboard
30461 macros are convenient and efficient.  The @kbd{C-x e} command, on the
30462 other hand, invokes the keyboard macro with no special treatment: Each
30463 command in the macro will record its own undo information and trail entry,
30464 and update the stack buffer accordingly.  If your macro uses features
30465 outside of Calc's control to operate on the contents of the Calc stack
30466 buffer, or if it includes Undo, Redo, or last-arguments commands, you
30467 must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
30468 at all times.  You could also consider using @kbd{K} (@code{calc-keep-args})
30469 instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
30471 Calc extends the standard Emacs keyboard macros in several ways.
30472 Keyboard macros can be used to create user-defined commands.  Keyboard
30473 macros can include conditional and iteration structures, somewhat
30474 analogous to those provided by a traditional programmable calculator.
30476 @menu
30477 * Naming Keyboard Macros::
30478 * Conditionals in Macros::
30479 * Loops in Macros::
30480 * Local Values in Macros::
30481 * Queries in Macros::
30482 @end menu
30484 @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
30485 @subsection Naming Keyboard Macros
30487 @noindent
30488 @kindex Z K
30489 @pindex calc-user-define-kbd-macro
30490 Once you have defined a keyboard macro, you can bind it to a @kbd{z}
30491 key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
30492 This command prompts first for a key, then for a command name.  For
30493 example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
30494 define a keyboard macro which negates the top two numbers on the stack
30495 (@key{TAB} swaps the top two stack elements).  Now you can type
30496 @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
30497 sequence.  The default command name (if you answer the second prompt with
30498 just the @key{RET} key as in this example) will be something like
30499 @samp{calc-User-n}.  The keyboard macro will now be available as both
30500 @kbd{z n} and @kbd{M-x calc-User-n}.  You can backspace and enter a more
30501 descriptive command name if you wish.@refill
30503 Macros defined by @kbd{Z K} act like single commands; they are executed
30504 in the same way as by the @kbd{X} key.  If you wish to define the macro
30505 as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
30506 give a negative prefix argument to @kbd{Z K}.
30508 Once you have bound your keyboard macro to a key, you can use
30509 @kbd{Z P} to register it permanently with Emacs.  @xref{Creating User Keys}.
30511 @cindex Keyboard macros, editing
30512 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
30513 been defined by a keyboard macro tries to use the @code{edit-kbd-macro}
30514 command to edit the macro.  This command may be found in the
30515 @file{macedit} package, a copy of which comes with Calc.  It decomposes
30516 the macro definition into full Emacs command names, like @code{calc-pop}
30517 and @code{calc-add}.  Type @kbd{M-# M-#} to finish editing and update
30518 the definition stored on the key, or, to cancel the edit, type
30519 @kbd{M-# x}.@refill
30521 If you give a negative numeric prefix argument to @kbd{Z E}, the keyboard
30522 macro is edited in spelled-out keystroke form.  For example, the editing
30523 buffer might contain the nine characters @w{@samp{1 @key{RET} 2 +}}.  When you press
30524 @kbd{M-# M-#}, the @code{read-kbd-macro} feature of the @file{macedit}
30525 package is used to reinterpret these key names.  The
30526 notations @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL}, and
30527 @code{NUL} must be written in all uppercase, as must the prefixes @code{C-}
30528 and @code{M-}.  Spaces and line breaks are ignored.  Other characters are
30529 copied verbatim into the keyboard macro.  Basically, the notation is the
30530 same as is used in all of this manual's examples, except that the manual
30531 takes some liberties with spaces:  When we say @kbd{' [1 2 3] @key{RET}}, we take
30532 it for granted that it is clear we really mean @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}},
30533 which is what @code{read-kbd-macro} wants to see.@refill
30535 If @file{macedit} is not available, @kbd{Z E} edits the keyboard macro
30536 in ``raw'' form; the editing buffer simply contains characters like
30537 @samp{1^M2+} (here @samp{^M} represents the carriage-return character).
30538 Editing in this mode, you will have to use @kbd{C-q} to enter new
30539 control characters into the buffer.@refill
30541 @kindex M-# m
30542 @pindex read-kbd-macro
30543 The @kbd{M-# m} (@code{read-kbd-macro}) command reads an Emacs ``region''
30544 of spelled-out keystrokes and defines it as the current keyboard macro.
30545 It is a convenient way to define a keyboard macro that has been stored
30546 in a file, or to define a macro without executing it at the same time.
30547 The @kbd{M-# m} command works only if @file{macedit} is present.
30549 @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
30550 @subsection Conditionals in Keyboard Macros
30552 @noindent
30553 @kindex Z [
30554 @kindex Z ]
30555 @pindex calc-kbd-if
30556 @pindex calc-kbd-else
30557 @pindex calc-kbd-else-if
30558 @pindex calc-kbd-end-if
30559 @cindex Conditional structures
30560 The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
30561 commands allow you to put simple tests in a keyboard macro.  When Calc
30562 sees the @kbd{Z [}, it pops an object from the stack and, if the object is
30563 a non-zero value, continues executing keystrokes.  But if the object is
30564 zero, or if it is not provably nonzero, Calc skips ahead to the matching
30565 @kbd{Z ]} keystroke.  @xref{Logical Operations}, for a set of commands for
30566 performing tests which conveniently produce 1 for true and 0 for false.
30568 For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
30569 function in the form of a keyboard macro.  This macro duplicates the
30570 number on the top of the stack, pushes zero and compares using @kbd{a <}
30571 (@code{calc-less-than}), then, if the number was less than zero,
30572 executes @kbd{n} (@code{calc-change-sign}).  Otherwise, the change-sign
30573 command is skipped.
30575 To program this macro, type @kbd{C-x (}, type the above sequence of
30576 keystrokes, then type @kbd{C-x )}.  Note that the keystrokes will be
30577 executed while you are making the definition as well as when you later
30578 re-execute the macro by typing @kbd{X}.  Thus you should make sure a
30579 suitable number is on the stack before defining the macro so that you
30580 don't get a stack-underflow error during the definition process.
30582 Conditionals can be nested arbitrarily.  However, there should be exactly
30583 one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
30585 @kindex Z :
30586 The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
30587 two keystroke sequences.  The general format is @kbd{@var{cond} Z [
30588 @var{then-part} Z : @var{else-part} Z ]}.  If @var{cond} is true
30589 (i.e., if the top of stack contains a non-zero number after @var{cond}
30590 has been executed), the @var{then-part} will be executed and the
30591 @var{else-part} will be skipped.  Otherwise, the @var{then-part} will
30592 be skipped and the @var{else-part} will be executed.
30594 @kindex Z |
30595 The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
30596 between any number of alternatives.  For example,
30597 @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
30598 @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
30599 otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
30600 it will execute @var{part3}.
30602 More precisely, @kbd{Z [} pops a number and conditionally skips to the
30603 next matching @kbd{Z :} or @kbd{Z ]} key.  @w{@kbd{Z ]}} has no effect when
30604 actually executed.  @kbd{Z :} skips to the next matching @kbd{Z ]}.
30605 @kbd{Z |} pops a number and conditionally skips to the next matching
30606 @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
30607 equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
30608 does not.
30610 Calc's conditional and looping constructs work by scanning the
30611 keyboard macro for occurrences of character sequences like @samp{Z:}
30612 and @samp{Z]}.  One side-effect of this is that if you use these
30613 constructs you must be careful that these character pairs do not
30614 occur by accident in other parts of the macros.  Since Calc rarely
30615 uses shift-@kbd{Z} for any purpose except as a prefix character, this
30616 is not likely to be a problem.  Another side-effect is that it will
30617 not work to define your own custom key bindings for these commands.
30618 Only the standard shift-@kbd{Z} bindings will work correctly.
30620 @kindex Z C-g
30621 If Calc gets stuck while skipping characters during the definition of a
30622 macro, type @kbd{Z C-g} to cancel the definition.  (Typing plain @kbd{C-g}
30623 actually adds a @kbd{C-g} keystroke to the macro.)
30625 @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
30626 @subsection Loops in Keyboard Macros
30628 @noindent
30629 @kindex Z <
30630 @kindex Z >
30631 @pindex calc-kbd-repeat
30632 @pindex calc-kbd-end-repeat
30633 @cindex Looping structures
30634 @cindex Iterative structures
30635 The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
30636 (@code{calc-kbd-end-repeat}) commands pop a number from the stack,
30637 which must be an integer, then repeat the keystrokes between the brackets
30638 the specified number of times.  If the integer is zero or negative, the
30639 body is skipped altogether.  For example, @kbd{1 @key{TAB} Z < 2 * Z >}
30640 computes two to a nonnegative integer power.  First, we push 1 on the
30641 stack and then swap the integer argument back to the top.  The @kbd{Z <}
30642 pops that argument leaving the 1 back on top of the stack.  Then, we
30643 repeat a multiply-by-two step however many times.@refill
30645 Once again, the keyboard macro is executed as it is being entered.
30646 In this case it is especially important to set up reasonable initial
30647 conditions before making the definition:  Suppose the integer 1000 just
30648 happened to be sitting on the stack before we typed the above definition!
30649 Another approach is to enter a harmless dummy definition for the macro,
30650 then go back and edit in the real one with a @kbd{Z E} command.  Yet
30651 another approach is to type the macro as written-out keystroke names
30652 in a buffer, then use @kbd{M-# m} (@code{read-kbd-macro}) to read the
30653 macro.
30655 @kindex Z /
30656 @pindex calc-break
30657 The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
30658 of a keyboard macro loop prematurely.  It pops an object from the stack;
30659 if that object is true (a non-zero number), control jumps out of the
30660 innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
30661 after the @kbd{Z >}.  If the object is false, the @kbd{Z /} has no
30662 effect.  Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
30663 in the C language.@refill
30665 @kindex Z (
30666 @kindex Z )
30667 @pindex calc-kbd-for
30668 @pindex calc-kbd-end-for
30669 The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
30670 commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
30671 value of the counter available inside the loop.  The general layout is
30672 @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}.  The @kbd{Z (}
30673 command pops initial and final values from the stack.  It then creates
30674 a temporary internal counter and initializes it with the value @var{init}.
30675 The @kbd{Z (} command then repeatedly pushes the counter value onto the
30676 stack and executes @var{body} and @var{step}, adding @var{step} to the
30677 counter each time until the loop finishes.@refill
30679 @cindex Summations (by keyboard macros)
30680 By default, the loop finishes when the counter becomes greater than (or
30681 less than) @var{final}, assuming @var{initial} is less than (greater
30682 than) @var{final}.  If @var{initial} is equal to @var{final}, the body
30683 executes exactly once.  The body of the loop always executes at least
30684 once.  For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
30685 squares of the integers from 1 to 10, in steps of 1.
30687 If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
30688 forced to use upward-counting conventions.  In this case, if @var{initial}
30689 is greater than @var{final} the body will not be executed at all.
30690 Note that @var{step} may still be negative in this loop; the prefix
30691 argument merely constrains the loop-finished test.  Likewise, a prefix
30692 argument of @i{-1} forces downward-counting conventions.
30694 @kindex Z @{
30695 @kindex Z @}
30696 @pindex calc-kbd-loop
30697 @pindex calc-kbd-end-loop
30698 The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
30699 (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
30700 @kbd{Z >}, except that they do not pop a count from the stack---they
30701 effectively create an infinite loop.  Every @kbd{Z @{} @dots{} @kbd{Z @}}
30702 loop ought to include at least one @kbd{Z /} to make sure the loop
30703 doesn't run forever.  (If any error message occurs which causes Emacs
30704 to beep, the keyboard macro will also be halted; this is a standard
30705 feature of Emacs.  You can also generally press @kbd{C-g} to halt a
30706 running keyboard macro, although not all versions of Unix support
30707 this feature.)
30709 The conditional and looping constructs are not actually tied to
30710 keyboard macros, but they are most often used in that context.
30711 For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
30712 ten copies of 23 onto the stack.  This can be typed ``live'' just
30713 as easily as in a macro definition.
30715 @xref{Conditionals in Macros}, for some additional notes about
30716 conditional and looping commands.
30718 @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
30719 @subsection Local Values in Macros
30721 @noindent
30722 @cindex Local variables
30723 @cindex Restoring saved modes
30724 Keyboard macros sometimes want to operate under known conditions
30725 without affecting surrounding conditions.  For example, a keyboard
30726 macro may wish to turn on Fraction Mode, or set a particular
30727 precision, independent of the user's normal setting for those
30728 modes.
30730 @kindex Z `
30731 @kindex Z '
30732 @pindex calc-kbd-push
30733 @pindex calc-kbd-pop
30734 Macros also sometimes need to use local variables.  Assignments to
30735 local variables inside the macro should not affect any variables
30736 outside the macro.  The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
30737 (@code{calc-kbd-pop}) commands give you both of these capabilities.
30739 When you type @kbd{Z `} (with a backquote or accent grave character),
30740 the values of various mode settings are saved away.  The ten ``quick''
30741 variables @code{q0} through @code{q9} are also saved.  When
30742 you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
30743 Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
30745 If a keyboard macro halts due to an error in between a @kbd{Z `} and
30746 a @kbd{Z '}, the saved values will be restored correctly even though
30747 the macro never reaches the @kbd{Z '} command.  Thus you can use
30748 @kbd{Z `} and @kbd{Z '} without having to worry about what happens
30749 in exceptional conditions.
30751 If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
30752 you into a ``recursive edit.''  You can tell you are in a recursive
30753 edit because there will be extra square brackets in the mode line,
30754 as in @samp{[(Calculator)]}.  These brackets will go away when you
30755 type the matching @kbd{Z '} command.  The modes and quick variables
30756 will be saved and restored in just the same way as if actual keyboard
30757 macros were involved.
30759 The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
30760 and binary word size, the angular mode (Deg, Rad, or HMS), the
30761 simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
30762 Matrix or Scalar mode, Fraction mode, and the current complex mode
30763 (Polar or Rectangular).  The ten ``quick'' variables' values (or lack
30764 thereof) are also saved.
30766 Most mode-setting commands act as toggles, but with a numeric prefix
30767 they force the mode either on (positive prefix) or off (negative
30768 or zero prefix).  Since you don't know what the environment might
30769 be when you invoke your macro, it's best to use prefix arguments
30770 for all mode-setting commands inside the macro.
30772 In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
30773 listed above to their default values.  As usual, the matching @kbd{Z '}
30774 will restore the modes to their settings from before the @kbd{C-u Z `}.
30775 Also, @w{@kbd{Z `}} with a negative prefix argument resets algebraic mode
30776 to its default (off) but leaves the other modes the same as they were
30777 outside the construct.
30779 The contents of the stack and trail, values of non-quick variables, and
30780 other settings such as the language mode and the various display modes,
30781 are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
30783 @node Queries in Macros, , Local Values in Macros, Keyboard Macros
30784 @subsection Queries in Keyboard Macros
30786 @noindent
30787 @kindex Z =
30788 @pindex calc-kbd-report
30789 The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
30790 message including the value on the top of the stack.  You are prompted
30791 to enter a string.  That string, along with the top-of-stack value,
30792 is displayed unless @kbd{m w} (@code{calc-working}) has been used
30793 to turn such messages off.
30795 @kindex Z #
30796 @pindex calc-kbd-query
30797 The @kbd{Z #} (@code{calc-kbd-query}) command displays a prompt message
30798 (which you enter during macro definition), then does an algebraic entry
30799 which takes its input from the keyboard, even during macro execution.
30800 This command allows your keyboard macros to accept numbers or formulas
30801 as interactive input.  All the normal conventions of algebraic input,
30802 including the use of @kbd{$} characters, are supported.
30804 @xref{Kbd Macro Query, , , emacs, the Emacs Manual}, for a description of
30805 @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
30806 keyboard input during a keyboard macro.  In particular, you can use
30807 @kbd{C-x q} to enter a recursive edit, which allows the user to perform
30808 any Calculator operations interactively before pressing @kbd{C-M-c} to
30809 return control to the keyboard macro.
30811 @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
30812 @section Invocation Macros
30814 @kindex M-# z
30815 @kindex Z I
30816 @pindex calc-user-invocation
30817 @pindex calc-user-define-invocation
30818 Calc provides one special keyboard macro, called up by @kbd{M-# z}
30819 (@code{calc-user-invocation}), that is intended to allow you to define
30820 your own special way of starting Calc.  To define this ``invocation
30821 macro,'' create the macro in the usual way with @kbd{C-x (} and
30822 @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
30823 There is only one invocation macro, so you don't need to type any
30824 additional letters after @kbd{Z I}.  From now on, you can type
30825 @kbd{M-# z} at any time to execute your invocation macro.
30827 For example, suppose you find yourself often grabbing rectangles of
30828 numbers into Calc and multiplying their columns.  You can do this
30829 by typing @kbd{M-# r} to grab, and @kbd{V R : *} to multiply columns.
30830 To make this into an invocation macro, just type @kbd{C-x ( M-# r
30831 V R : * C-x )}, then @kbd{Z I}.  Then, to multiply a rectangle of data,
30832 just mark the data in its buffer in the usual way and type @kbd{M-# z}.
30834 Invocation macros are treated like regular Emacs keyboard macros;
30835 all the special features described above for @kbd{Z K}-style macros
30836 do not apply.  @kbd{M-# z} is just like @kbd{C-x e}, except that it
30837 uses the macro that was last stored by @kbd{Z I}.  (In fact, the
30838 macro does not even have to have anything to do with Calc!)
30840 The @kbd{m m} command saves the last invocation macro defined by
30841 @kbd{Z I} along with all the other Calc mode settings.
30842 @xref{General Mode Commands}.
30844 @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
30845 @section Programming with Formulas
30847 @noindent
30848 @kindex Z F
30849 @pindex calc-user-define-formula
30850 @cindex Programming with algebraic formulas
30851 Another way to create a new Calculator command uses algebraic formulas.
30852 The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
30853 formula at the top of the stack as the definition for a key.  This
30854 command prompts for five things: The key, the command name, the function
30855 name, the argument list, and the behavior of the command when given
30856 non-numeric arguments.
30858 For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
30859 @samp{a + 2*b} onto the stack.  We now type @kbd{Z F m} to define this
30860 formula on the @kbd{z m} key sequence.  The next prompt is for a command
30861 name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
30862 for the new command.  If you simply press @key{RET}, a default name like
30863 @code{calc-User-m} will be constructed.  In our example, suppose we enter
30864 @kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
30866 If you want to give the formula a long-style name only, you can press
30867 @key{SPC} or @key{RET} when asked which single key to use.  For example
30868 @kbd{Z F @key{RET} spam @key{RET}} defines the new command as
30869 @kbd{M-x calc-spam}, with no keyboard equivalent.
30871 The third prompt is for a function name.  The default is to use the same
30872 name as the command name but with @samp{calcFunc-} in place of
30873 @samp{calc-}.  This is the name you will use if you want to enter your
30874 new function in an algebraic formula.  Suppose we enter @kbd{yow @key{RET}}.
30875 Then the new function can be invoked by pushing two numbers on the
30876 stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
30877 formula @samp{yow(x,y)}.@refill
30879 The fourth prompt is for the function's argument list.  This is used to
30880 associate values on the stack with the variables that appear in the formula.
30881 The default is a list of all variables which appear in the formula, sorted
30882 into alphabetical order.  In our case, the default would be @samp{(a b)}.
30883 This means that, when the user types @kbd{z m}, the Calculator will remove
30884 two numbers from the stack, substitute these numbers for @samp{a} and
30885 @samp{b} (respectively) in the formula, then simplify the formula and
30886 push the result on the stack.  In other words, @kbd{10 @key{RET} 100 z m}
30887 would replace the 10 and 100 on the stack with the number 210, which is
30888 @cite{a + 2 b} with @cite{a=10} and @cite{b=100}.  Likewise, the formula
30889 @samp{yow(10, 100)} will be evaluated by substituting @cite{a=10} and
30890 @cite{b=100} in the definition.
30892 You can rearrange the order of the names before pressing @key{RET} to
30893 control which stack positions go to which variables in the formula.  If
30894 you remove a variable from the argument list, that variable will be left
30895 in symbolic form by the command.  Thus using an argument list of @samp{(b)}
30896 for our function would cause @kbd{10 z m} to replace the 10 on the stack
30897 with the formula @samp{a + 20}.  If we had used an argument list of
30898 @samp{(b a)}, the result with inputs 10 and 100 would have been 120.
30900 You can also put a nameless function on the stack instead of just a
30901 formula, as in @samp{<a, b : a + 2 b>}.  @xref{Specifying Operators}.
30902 In this example, the command will be defined by the formula @samp{a + 2 b}
30903 using the argument list @samp{(a b)}.
30905 The final prompt is a y-or-n question concerning what to do if symbolic
30906 arguments are given to your function.  If you answer @kbd{y}, then
30907 executing @kbd{z m} (using the original argument list @samp{(a b)}) with
30908 arguments @cite{10} and @cite{x} will leave the function in symbolic
30909 form, i.e., @samp{yow(10,x)}.  On the other hand, if you answer @kbd{n},
30910 then the formula will always be expanded, even for non-constant
30911 arguments: @samp{10 + 2 x}.  If you never plan to feed algebraic
30912 formulas to your new function, it doesn't matter how you answer this
30913 question.@refill
30915 If you answered @kbd{y} to this question you can still cause a function
30916 call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
30917 Also, Calc will expand the function if necessary when you take a
30918 derivative or integral or solve an equation involving the function.
30920 @kindex Z G
30921 @pindex calc-get-user-defn
30922 Once you have defined a formula on a key, you can retrieve this formula
30923 with the @kbd{Z G} (@code{calc-user-define-get-defn}) command.  Press a
30924 key, and this command pushes the formula that was used to define that
30925 key onto the stack.  Actually, it pushes a nameless function that
30926 specifies both the argument list and the defining formula.  You will get
30927 an error message if the key is undefined, or if the key was not defined
30928 by a @kbd{Z F} command.@refill
30930 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
30931 been defined by a formula uses a variant of the @code{calc-edit} command
30932 to edit the defining formula.  Press @kbd{M-# M-#} to finish editing and
30933 store the new formula back in the definition, or @kbd{M-# x} to
30934 cancel the edit.  (The argument list and other properties of the
30935 definition are unchanged; to adjust the argument list, you can use
30936 @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
30937 then re-execute the @kbd{Z F} command.)
30939 As usual, the @kbd{Z P} command records your definition permanently.
30940 In this case it will permanently record all three of the relevant
30941 definitions: the key, the command, and the function.
30943 You may find it useful to turn off the default simplifications with
30944 @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
30945 used as a function definition.  For example, the formula @samp{deriv(a^2,v)}
30946 which might be used to define a new function @samp{dsqr(a,v)} will be
30947 ``simplified'' to 0 immediately upon entry since @code{deriv} considers
30948 @cite{a} to be constant with respect to @cite{v}.  Turning off
30949 default simplifications cures this problem:  The definition will be stored
30950 in symbolic form without ever activating the @code{deriv} function.  Press
30951 @kbd{m D} to turn the default simplifications back on afterwards.
30953 @node Lisp Definitions, , Algebraic Definitions, Programming
30954 @section Programming with Lisp
30956 @noindent
30957 The Calculator can be programmed quite extensively in Lisp.  All you
30958 do is write a normal Lisp function definition, but with @code{defmath}
30959 in place of @code{defun}.  This has the same form as @code{defun}, but it
30960 automagically replaces calls to standard Lisp functions like @code{+} and
30961 @code{zerop} with calls to the corresponding functions in Calc's own library.
30962 Thus you can write natural-looking Lisp code which operates on all of the
30963 standard Calculator data types.  You can then use @kbd{Z D} if you wish to
30964 bind your new command to a @kbd{z}-prefix key sequence.  The @kbd{Z E} command
30965 will not edit a Lisp-based definition.
30967 Emacs Lisp is described in the GNU Emacs Lisp Reference Manual.  This section
30968 assumes a familiarity with Lisp programming concepts; if you do not know
30969 Lisp, you may find keyboard macros or rewrite rules to be an easier way
30970 to program the Calculator.
30972 This section first discusses ways to write commands, functions, or
30973 small programs to be executed inside of Calc.  Then it discusses how
30974 your own separate programs are able to call Calc from the outside.
30975 Finally, there is a list of internal Calc functions and data structures
30976 for the true Lisp enthusiast.
30978 @menu
30979 * Defining Functions::
30980 * Defining Simple Commands::
30981 * Defining Stack Commands::
30982 * Argument Qualifiers::
30983 * Example Definitions::
30985 * Calling Calc from Your Programs::
30986 * Internals::
30987 @end menu
30989 @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
30990 @subsection Defining New Functions
30992 @noindent
30993 @findex defmath
30994 The @code{defmath} function (actually a Lisp macro) is like @code{defun}
30995 except that code in the body of the definition can make use of the full
30996 range of Calculator data types.  The prefix @samp{calcFunc-} is added
30997 to the specified name to get the actual Lisp function name.  As a simple
30998 example,
31000 @example
31001 (defmath myfact (n)
31002   (if (> n 0)
31003       (* n (myfact (1- n)))
31004     1))
31005 @end example
31007 @noindent
31008 This actually expands to the code,
31010 @example
31011 (defun calcFunc-myfact (n)
31012   (if (math-posp n)
31013       (math-mul n (calcFunc-myfact (math-add n -1)))
31014     1))
31015 @end example
31017 @noindent
31018 This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
31020 The @samp{myfact} function as it is defined above has the bug that an
31021 expression @samp{myfact(a+b)} will be simplified to 1 because the
31022 formula @samp{a+b} is not considered to be @code{posp}.  A robust
31023 factorial function would be written along the following lines:
31025 @smallexample
31026 (defmath myfact (n)
31027   (if (> n 0)
31028       (* n (myfact (1- n)))
31029     (if (= n 0)
31030         1
31031       nil)))    ; this could be simplified as: (and (= n 0) 1)
31032 @end smallexample
31034 If a function returns @code{nil}, it is left unsimplified by the Calculator
31035 (except that its arguments will be simplified).  Thus, @samp{myfact(a+1+2)}
31036 will be simplified to @samp{myfact(a+3)} but no further.  Beware that every
31037 time the Calculator reexamines this formula it will attempt to resimplify
31038 it, so your function ought to detect the returning-@code{nil} case as
31039 efficiently as possible.
31041 The following standard Lisp functions are treated by @code{defmath}:
31042 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
31043 @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
31044 @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
31045 @code{logandc2}, @code{lognot}.  Also, @code{~=} is an abbreviation for
31046 @code{math-nearly-equal}, which is useful in implementing Taylor series.@refill
31048 For other functions @var{func}, if a function by the name
31049 @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
31050 name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
31051 is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
31052 used on the assumption that this is a to-be-defined math function.  Also, if
31053 the function name is quoted as in @samp{('integerp a)} the function name is
31054 always used exactly as written (but not quoted).@refill
31056 Variable names have @samp{var-} prepended to them unless they appear in
31057 the function's argument list or in an enclosing @code{let}, @code{let*},
31058 @code{for}, or @code{foreach} form,
31059 or their names already contain a @samp{-} character.  Thus a reference to
31060 @samp{foo} is the same as a reference to @samp{var-foo}.@refill
31062 A few other Lisp extensions are available in @code{defmath} definitions:
31064 @itemize @bullet
31065 @item
31066 The @code{elt} function accepts any number of index variables.
31067 Note that Calc vectors are stored as Lisp lists whose first
31068 element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
31069 the second element of vector @code{v}, and @samp{(elt m i j)}
31070 yields one element of a Calc matrix.
31072 @item
31073 The @code{setq} function has been extended to act like the Common
31074 Lisp @code{setf} function.  (The name @code{setf} is recognized as
31075 a synonym of @code{setq}.)  Specifically, the first argument of
31076 @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
31077 in which case the effect is to store into the specified
31078 element of a list.  Thus, @samp{(setq (elt m i j) x)} stores @cite{x}
31079 into one element of a matrix.
31081 @item
31082 A @code{for} looping construct is available.  For example,
31083 @samp{(for ((i 0 10)) body)} executes @code{body} once for each
31084 binding of @cite{i} from zero to 10.  This is like a @code{let}
31085 form in that @cite{i} is temporarily bound to the loop count
31086 without disturbing its value outside the @code{for} construct.
31087 Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
31088 are also available.  For each value of @cite{i} from zero to 10,
31089 @cite{j} counts from 0 to @cite{i-1} in steps of two.  Note that
31090 @code{for} has the same general outline as @code{let*}, except
31091 that each element of the header is a list of three or four
31092 things, not just two.
31094 @item
31095 The @code{foreach} construct loops over elements of a list.
31096 For example, @samp{(foreach ((x (cdr v))) body)} executes
31097 @code{body} with @cite{x} bound to each element of Calc vector
31098 @cite{v} in turn.  The purpose of @code{cdr} here is to skip over
31099 the initial @code{vec} symbol in the vector.
31101 @item
31102 The @code{break} function breaks out of the innermost enclosing
31103 @code{while}, @code{for}, or @code{foreach} loop.  If given a
31104 value, as in @samp{(break x)}, this value is returned by the
31105 loop.  (Lisp loops otherwise always return @code{nil}.)
31107 @item
31108 The @code{return} function prematurely returns from the enclosing
31109 function.  For example, @samp{(return (+ x y))} returns @cite{x+y}
31110 as the value of a function.  You can use @code{return} anywhere
31111 inside the body of the function.
31112 @end itemize
31114 Non-integer numbers (and extremely large integers) cannot be included
31115 directly into a @code{defmath} definition.  This is because the Lisp
31116 reader will fail to parse them long before @code{defmath} ever gets control.
31117 Instead, use the notation, @samp{:"3.1415"}.  In fact, any algebraic
31118 formula can go between the quotes.  For example,
31120 @smallexample
31121 (defmath sqexp (x)     ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
31122   (and (numberp x)
31123        (exp :"x * 0.5")))
31124 @end smallexample
31126 expands to
31128 @smallexample
31129 (defun calcFunc-sqexp (x)
31130   (and (math-numberp x)
31131        (calcFunc-exp (math-mul x '(float 5 -1)))))
31132 @end smallexample
31134 Note the use of @code{numberp} as a guard to ensure that the argument is
31135 a number first, returning @code{nil} if not.  The exponential function
31136 could itself have been included in the expression, if we had preferred:
31137 @samp{:"exp(x * 0.5)"}.  As another example, the multiplication-and-recursion
31138 step of @code{myfact} could have been written
31140 @example
31141 :"n * myfact(n-1)"
31142 @end example
31144 If a file named @file{.emacs} exists in your home directory, Emacs reads
31145 and executes the Lisp forms in this file as it starts up.  While it may
31146 seem like a good idea to put your favorite @code{defmath} commands here,
31147 this has the unfortunate side-effect that parts of the Calculator must be
31148 loaded in to process the @code{defmath} commands whether or not you will
31149 actually use the Calculator!  A better effect can be had by writing
31151 @example
31152 (put 'calc-define 'thing '(progn
31153  (defmath ... )
31154  (defmath ... )
31156 @end example
31158 @noindent
31159 @vindex calc-define
31160 The @code{put} function adds a @dfn{property} to a symbol.  Each Lisp
31161 symbol has a list of properties associated with it.  Here we add a
31162 property with a name of @code{thing} and a @samp{(progn ...)} form as
31163 its value.  When Calc starts up, and at the start of every Calc command,
31164 the property list for the symbol @code{calc-define} is checked and the
31165 values of any properties found are evaluated as Lisp forms.  The
31166 properties are removed as they are evaluated.  The property names
31167 (like @code{thing}) are not used; you should choose something like the
31168 name of your project so as not to conflict with other properties.
31170 The net effect is that you can put the above code in your @file{.emacs}
31171 file and it will not be executed until Calc is loaded.  Or, you can put
31172 that same code in another file which you load by hand either before or
31173 after Calc itself is loaded.
31175 The properties of @code{calc-define} are evaluated in the same order
31176 that they were added.  They can assume that the Calc modules @file{calc.el},
31177 @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
31178 that the @samp{*Calculator*} buffer will be the current buffer.
31180 If your @code{calc-define} property only defines algebraic functions,
31181 you can be sure that it will have been evaluated before Calc tries to
31182 call your function, even if the file defining the property is loaded
31183 after Calc is loaded.  But if the property defines commands or key
31184 sequences, it may not be evaluated soon enough.  (Suppose it defines the
31185 new command @code{tweak-calc}; the user can load your file, then type
31186 @kbd{M-x tweak-calc} before Calc has had chance to do anything.)  To
31187 protect against this situation, you can put
31189 @example
31190 (run-hooks 'calc-check-defines)
31191 @end example
31193 @findex calc-check-defines
31194 @noindent
31195 at the end of your file.  The @code{calc-check-defines} function is what
31196 looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
31197 has the advantage that it is quietly ignored if @code{calc-check-defines}
31198 is not yet defined because Calc has not yet been loaded.
31200 Examples of things that ought to be enclosed in a @code{calc-define}
31201 property are @code{defmath} calls, @code{define-key} calls that modify
31202 the Calc key map, and any calls that redefine things defined inside Calc.
31203 Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
31205 @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
31206 @subsection Defining New Simple Commands
31208 @noindent
31209 @findex interactive
31210 If a @code{defmath} form contains an @code{interactive} clause, it defines
31211 a Calculator command.  Actually such a @code{defmath} results in @emph{two}
31212 function definitions:  One, a @samp{calcFunc-} function as was just described,
31213 with the @code{interactive} clause removed.  Two, a @samp{calc-} function
31214 with a suitable @code{interactive} clause and some sort of wrapper to make
31215 the command work in the Calc environment.
31217 In the simple case, the @code{interactive} clause has the same form as
31218 for normal Emacs Lisp commands:
31220 @smallexample
31221 (defmath increase-precision (delta)
31222   "Increase precision by DELTA."     ; This is the "documentation string"
31223   (interactive "p")                  ; Register this as a M-x-able command
31224   (setq calc-internal-prec (+ calc-internal-prec delta)))
31225 @end smallexample
31227 This expands to the pair of definitions,
31229 @smallexample
31230 (defun calc-increase-precision (delta)
31231   "Increase precision by DELTA."
31232   (interactive "p")
31233   (calc-wrapper
31234    (setq calc-internal-prec (math-add calc-internal-prec delta))))
31236 (defun calcFunc-increase-precision (delta)
31237   "Increase precision by DELTA."
31238   (setq calc-internal-prec (math-add calc-internal-prec delta)))
31239 @end smallexample
31241 @noindent
31242 where in this case the latter function would never really be used!  Note
31243 that since the Calculator stores small integers as plain Lisp integers,
31244 the @code{math-add} function will work just as well as the native
31245 @code{+} even when the intent is to operate on native Lisp integers.
31247 @findex calc-wrapper
31248 The @samp{calc-wrapper} call invokes a macro which surrounds the body of
31249 the function with code that looks roughly like this:
31251 @smallexample
31252 (let ((calc-command-flags nil))
31253   (unwind-protect
31254       (save-excursion
31255         (calc-select-buffer)
31256         @emph{body of function}
31257         @emph{renumber stack}
31258         @emph{clear} Working @emph{message})
31259     @emph{realign cursor and window}
31260     @emph{clear Inverse, Hyperbolic, and Keep Args flags}
31261     @emph{update Emacs mode line}))
31262 @end smallexample
31264 @findex calc-select-buffer
31265 The @code{calc-select-buffer} function selects the @samp{*Calculator*}
31266 buffer if necessary, say, because the command was invoked from inside
31267 the @samp{*Calc Trail*} window.
31269 @findex calc-set-command-flag
31270 You can call, for example, @code{(calc-set-command-flag 'no-align)} to
31271 set the above-mentioned command flags.  Calc routines recognize the
31272 following command flags:
31274 @table @code
31275 @item renum-stack
31276 Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
31277 after this command completes.  This is set by routines like
31278 @code{calc-push}.
31280 @item clear-message
31281 Calc should call @samp{(message "")} if this command completes normally
31282 (to clear a ``Working@dots{}'' message out of the echo area).
31284 @item no-align
31285 Do not move the cursor back to the @samp{.} top-of-stack marker.
31287 @item position-point
31288 Use the variables @code{calc-position-point-line} and
31289 @code{calc-position-point-column} to position the cursor after
31290 this command finishes.
31292 @item keep-flags
31293 Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
31294 and @code{calc-keep-args-flag} at the end of this command.
31296 @item do-edit
31297 Switch to buffer @samp{*Calc Edit*} after this command.
31299 @item hold-trail
31300 Do not move trail pointer to end of trail when something is recorded
31301 there.
31302 @end table
31304 @kindex Y
31305 @kindex Y ?
31306 @vindex calc-Y-help-msgs
31307 Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
31308 extensions to Calc.  There are no built-in commands that work with
31309 this prefix key; you must call @code{define-key} from Lisp (probably
31310 from inside a @code{calc-define} property) to add to it.  Initially only
31311 @kbd{Y ?} is defined; it takes help messages from a list of strings
31312 (initially @code{nil}) in the variable @code{calc-Y-help-msgs}.  All
31313 other undefined keys except for @kbd{Y} are reserved for use by
31314 future versions of Calc.
31316 If you are writing a Calc enhancement which you expect to give to
31317 others, it is best to minimize the number of @kbd{Y}-key sequences
31318 you use.  In fact, if you have more than one key sequence you should
31319 consider defining three-key sequences with a @kbd{Y}, then a key that
31320 stands for your package, then a third key for the particular command
31321 within your package.
31323 Users may wish to install several Calc enhancements, and it is possible
31324 that several enhancements will choose to use the same key.  In the
31325 example below, a variable @code{inc-prec-base-key} has been defined
31326 to contain the key that identifies the @code{inc-prec} package.  Its
31327 value is initially @code{"P"}, but a user can change this variable
31328 if necessary without having to modify the file.
31330 Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
31331 command that increases the precision, and a @kbd{Y P D} command that
31332 decreases the precision.
31334 @smallexample
31335 ;;; Increase and decrease Calc precision.  Dave Gillespie, 5/31/91.
31336 ;;; (Include copyright or copyleft stuff here.)
31338 (defvar inc-prec-base-key "P"
31339   "Base key for inc-prec.el commands.")
31341 (put 'calc-define 'inc-prec '(progn
31343 (define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
31344             'increase-precision)
31345 (define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
31346             'decrease-precision)
31348 (setq calc-Y-help-msgs
31349       (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
31350             calc-Y-help-msgs))
31352 (defmath increase-precision (delta)
31353   "Increase precision by DELTA."
31354   (interactive "p")
31355   (setq calc-internal-prec (+ calc-internal-prec delta)))
31357 (defmath decrease-precision (delta)
31358   "Decrease precision by DELTA."
31359   (interactive "p")
31360   (setq calc-internal-prec (- calc-internal-prec delta)))
31362 ))  ; end of calc-define property
31364 (run-hooks 'calc-check-defines)
31365 @end smallexample
31367 @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
31368 @subsection Defining New Stack-Based Commands
31370 @noindent
31371 To define a new computational command which takes and/or leaves arguments
31372 on the stack, a special form of @code{interactive} clause is used.
31374 @example
31375 (interactive @var{num} @var{tag})
31376 @end example
31378 @noindent
31379 where @var{num} is an integer, and @var{tag} is a string.  The effect is
31380 to pop @var{num} values off the stack, resimplify them by calling
31381 @code{calc-normalize}, and hand them to your function according to the
31382 function's argument list.  Your function may include @code{&optional} and
31383 @code{&rest} parameters, so long as calling the function with @var{num}
31384 parameters is legal.
31386 Your function must return either a number or a formula in a form
31387 acceptable to Calc, or a list of such numbers or formulas.  These value(s)
31388 are pushed onto the stack when the function completes.  They are also
31389 recorded in the Calc Trail buffer on a line beginning with @var{tag},
31390 a string of (normally) four characters or less.  If you omit @var{tag}
31391 or use @code{nil} as a tag, the result is not recorded in the trail.
31393 As an example, the definition
31395 @smallexample
31396 (defmath myfact (n)
31397   "Compute the factorial of the integer at the top of the stack."
31398   (interactive 1 "fact")
31399   (if (> n 0)
31400       (* n (myfact (1- n)))
31401     (and (= n 0) 1)))
31402 @end smallexample
31404 @noindent
31405 is a version of the factorial function shown previously which can be used
31406 as a command as well as an algebraic function.  It expands to
31408 @smallexample
31409 (defun calc-myfact ()
31410   "Compute the factorial of the integer at the top of the stack."
31411   (interactive)
31412   (calc-slow-wrapper
31413    (calc-enter-result 1 "fact"
31414      (cons 'calcFunc-myfact (calc-top-list-n 1)))))
31416 (defun calcFunc-myfact (n)
31417   "Compute the factorial of the integer at the top of the stack."
31418   (if (math-posp n)
31419       (math-mul n (calcFunc-myfact (math-add n -1)))
31420     (and (math-zerop n) 1)))
31421 @end smallexample
31423 @findex calc-slow-wrapper
31424 The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
31425 that automatically puts up a @samp{Working...} message before the
31426 computation begins.  (This message can be turned off by the user
31427 with an @kbd{m w} (@code{calc-working}) command.)
31429 @findex calc-top-list-n
31430 The @code{calc-top-list-n} function returns a list of the specified number
31431 of values from the top of the stack.  It resimplifies each value by
31432 calling @code{calc-normalize}.  If its argument is zero it returns an
31433 empty list.  It does not actually remove these values from the stack.
31435 @findex calc-enter-result
31436 The @code{calc-enter-result} function takes an integer @var{num} and string
31437 @var{tag} as described above, plus a third argument which is either a
31438 Calculator data object or a list of such objects.  These objects are
31439 resimplified and pushed onto the stack after popping the specified number
31440 of values from the stack.  If @var{tag} is non-@code{nil}, the values
31441 being pushed are also recorded in the trail.
31443 Note that if @code{calcFunc-myfact} returns @code{nil} this represents
31444 ``leave the function in symbolic form.''  To return an actual empty list,
31445 in the sense that @code{calc-enter-result} will push zero elements back
31446 onto the stack, you should return the special value @samp{'(nil)}, a list
31447 containing the single symbol @code{nil}.
31449 The @code{interactive} declaration can actually contain a limited
31450 Emacs-style code string as well which comes just before @var{num} and
31451 @var{tag}.  Currently the only Emacs code supported is @samp{"p"}, as in
31453 @example
31454 (defmath foo (a b &optional c)
31455   (interactive "p" 2 "foo")
31456   @var{body})
31457 @end example
31459 In this example, the command @code{calc-foo} will evaluate the expression
31460 @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
31461 executed with a numeric prefix argument of @cite{n}.
31463 The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
31464 code as used with @code{defun}).  It uses the numeric prefix argument as the
31465 number of objects to remove from the stack and pass to the function.
31466 In this case, the integer @var{num} serves as a default number of
31467 arguments to be used when no prefix is supplied.
31469 @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
31470 @subsection Argument Qualifiers
31472 @noindent
31473 Anywhere a parameter name can appear in the parameter list you can also use
31474 an @dfn{argument qualifier}.  Thus the general form of a definition is:
31476 @example
31477 (defmath @var{name} (@var{param} @var{param...}
31478                &optional @var{param} @var{param...}
31479                &rest @var{param})
31480   @var{body})
31481 @end example
31483 @noindent
31484 where each @var{param} is either a symbol or a list of the form
31486 @example
31487 (@var{qual} @var{param})
31488 @end example
31490 The following qualifiers are recognized:
31492 @table @samp
31493 @item complete
31494 @findex complete
31495 The argument must not be an incomplete vector, interval, or complex number.
31496 (This is rarely needed since the Calculator itself will never call your
31497 function with an incomplete argument.  But there is nothing stopping your
31498 own Lisp code from calling your function with an incomplete argument.)@refill
31500 @item integer
31501 @findex integer
31502 The argument must be an integer.  If it is an integer-valued float
31503 it will be accepted but converted to integer form.  Non-integers and
31504 formulas are rejected.
31506 @item natnum
31507 @findex natnum
31508 Like @samp{integer}, but the argument must be non-negative.
31510 @item fixnum
31511 @findex fixnum
31512 Like @samp{integer}, but the argument must fit into a native Lisp integer,
31513 which on most systems means less than 2^23 in absolute value.  The
31514 argument is converted into Lisp-integer form if necessary.
31516 @item float
31517 @findex float
31518 The argument is converted to floating-point format if it is a number or
31519 vector.  If it is a formula it is left alone.  (The argument is never
31520 actually rejected by this qualifier.)
31522 @item @var{pred}
31523 The argument must satisfy predicate @var{pred}, which is one of the
31524 standard Calculator predicates.  @xref{Predicates}.
31526 @item not-@var{pred}
31527 The argument must @emph{not} satisfy predicate @var{pred}.
31528 @end table
31530 For example,
31532 @example
31533 (defmath foo (a (constp (not-matrixp b)) &optional (float c)
31534               &rest (integer d))
31535   @var{body})
31536 @end example
31538 @noindent
31539 expands to
31541 @example
31542 (defun calcFunc-foo (a b &optional c &rest d)
31543   (and (math-matrixp b)
31544        (math-reject-arg b 'not-matrixp))
31545   (or (math-constp b)
31546       (math-reject-arg b 'constp))
31547   (and c (setq c (math-check-float c)))
31548   (setq d (mapcar 'math-check-integer d))
31549   @var{body})
31550 @end example
31552 @noindent
31553 which performs the necessary checks and conversions before executing the
31554 body of the function.
31556 @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
31557 @subsection Example Definitions
31559 @noindent
31560 This section includes some Lisp programming examples on a larger scale.
31561 These programs make use of some of the Calculator's internal functions;
31562 @pxref{Internals}.
31564 @menu
31565 * Bit Counting Example::
31566 * Sine Example::
31567 @end menu
31569 @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
31570 @subsubsection Bit-Counting
31572 @noindent
31573 @ignore
31574 @starindex
31575 @end ignore
31576 @tindex bcount
31577 Calc does not include a built-in function for counting the number of
31578 ``one'' bits in a binary integer.  It's easy to invent one using @kbd{b u}
31579 to convert the integer to a set, and @kbd{V #} to count the elements of
31580 that set; let's write a function that counts the bits without having to
31581 create an intermediate set.
31583 @smallexample
31584 (defmath bcount ((natnum n))
31585   (interactive 1 "bcnt")
31586   (let ((count 0))
31587     (while (> n 0)
31588       (if (oddp n)
31589           (setq count (1+ count)))
31590       (setq n (lsh n -1)))
31591     count))
31592 @end smallexample
31594 @noindent
31595 When this is expanded by @code{defmath}, it will become the following
31596 Emacs Lisp function:
31598 @smallexample
31599 (defun calcFunc-bcount (n)
31600   (setq n (math-check-natnum n))
31601   (let ((count 0))
31602     (while (math-posp n)
31603       (if (math-oddp n)
31604           (setq count (math-add count 1)))
31605       (setq n (calcFunc-lsh n -1)))
31606     count))
31607 @end smallexample
31609 If the input numbers are large, this function involves a fair amount
31610 of arithmetic.  A binary right shift is essentially a division by two;
31611 recall that Calc stores integers in decimal form so bit shifts must
31612 involve actual division.
31614 To gain a bit more efficiency, we could divide the integer into
31615 @var{n}-bit chunks, each of which can be handled quickly because
31616 they fit into Lisp integers.  It turns out that Calc's arithmetic
31617 routines are especially fast when dividing by an integer less than
31618 1000, so we can set @var{n = 9} bits and use repeated division by 512:
31620 @smallexample
31621 (defmath bcount ((natnum n))
31622   (interactive 1 "bcnt")
31623   (let ((count 0))
31624     (while (not (fixnump n))
31625       (let ((qr (idivmod n 512)))
31626         (setq count (+ count (bcount-fixnum (cdr qr)))
31627               n (car qr))))
31628     (+ count (bcount-fixnum n))))
31630 (defun bcount-fixnum (n)
31631   (let ((count 0))
31632     (while (> n 0)
31633       (setq count (+ count (logand n 1))
31634             n (lsh n -1)))
31635     count))
31636 @end smallexample
31638 @noindent
31639 Note that the second function uses @code{defun}, not @code{defmath}.
31640 Because this function deals only with native Lisp integers (``fixnums''),
31641 it can use the actual Emacs @code{+} and related functions rather
31642 than the slower but more general Calc equivalents which @code{defmath}
31643 uses.
31645 The @code{idivmod} function does an integer division, returning both
31646 the quotient and the remainder at once.  Again, note that while it
31647 might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
31648 more efficient ways to split off the bottom nine bits of @code{n},
31649 actually they are less efficient because each operation is really
31650 a division by 512 in disguise; @code{idivmod} allows us to do the
31651 same thing with a single division by 512.
31653 @node Sine Example, , Bit Counting Example, Example Definitions
31654 @subsubsection The Sine Function
31656 @noindent
31657 @ignore
31658 @starindex
31659 @end ignore
31660 @tindex mysin
31661 A somewhat limited sine function could be defined as follows, using the
31662 well-known Taylor series expansion for @c{$\sin x$}
31663 @samp{sin(x)}:
31665 @smallexample
31666 (defmath mysin ((float (anglep x)))
31667   (interactive 1 "mysn")
31668   (setq x (to-radians x))    ; Convert from current angular mode.
31669   (let ((sum x)              ; Initial term of Taylor expansion of sin.
31670         newsum
31671         (nfact 1)            ; "nfact" equals "n" factorial at all times.
31672         (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
31673     (for ((n 3 100 2))       ; Upper limit of 100 is a good precaution.
31674       (working "mysin" sum)  ; Display "Working" message, if enabled.
31675       (setq nfact (* nfact (1- n) n)
31676             x (* x xnegsqr)
31677             newsum (+ sum (/ x nfact)))
31678       (if (~= newsum sum)    ; If newsum is "nearly equal to" sum,
31679           (break))           ;  then we are done.
31680       (setq sum newsum))
31681     sum))
31682 @end smallexample
31684 The actual @code{sin} function in Calc works by first reducing the problem
31685 to a sine or cosine of a nonnegative number less than @c{$\pi \over 4$}
31686 @cite{pi/4}.  This
31687 ensures that the Taylor series will converge quickly.  Also, the calculation
31688 is carried out with two extra digits of precision to guard against cumulative
31689 round-off in @samp{sum}.  Finally, complex arguments are allowed and handled
31690 by a separate algorithm.
31692 @smallexample
31693 (defmath mysin ((float (scalarp x)))
31694   (interactive 1 "mysn")
31695   (setq x (to-radians x))    ; Convert from current angular mode.
31696   (with-extra-prec 2         ; Evaluate with extra precision.
31697     (cond ((complexp x)
31698            (mysin-complex x))
31699           ((< x 0)
31700            (- (mysin-raw (- x)))    ; Always call mysin-raw with x >= 0.
31701           (t (mysin-raw x))))))
31703 (defmath mysin-raw (x)
31704   (cond ((>= x 7)
31705          (mysin-raw (% x (two-pi))))     ; Now x < 7.
31706         ((> x (pi-over-2))
31707          (- (mysin-raw (- x (pi)))))     ; Now -pi/2 <= x <= pi/2.
31708         ((> x (pi-over-4))
31709          (mycos-raw (- x (pi-over-2))))  ; Now -pi/2 <= x <= pi/4.
31710         ((< x (- (pi-over-4)))
31711          (- (mycos-raw (+ x (pi-over-2)))))  ; Now -pi/4 <= x <= pi/4,
31712         (t (mysin-series x))))           ; so the series will be efficient.
31713 @end smallexample
31715 @noindent
31716 where @code{mysin-complex} is an appropriate function to handle complex
31717 numbers, @code{mysin-series} is the routine to compute the sine Taylor
31718 series as before, and @code{mycos-raw} is a function analogous to
31719 @code{mysin-raw} for cosines.
31721 The strategy is to ensure that @cite{x} is nonnegative before calling
31722 @code{mysin-raw}.  This function then recursively reduces its argument
31723 to a suitable range, namely, plus-or-minus @c{$\pi \over 4$}
31724 @cite{pi/4}.  Note that each
31725 test, and particularly the first comparison against 7, is designed so
31726 that small roundoff errors cannot produce an infinite loop.  (Suppose
31727 we compared with @samp{(two-pi)} instead; if due to roundoff problems
31728 the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
31729 recursion could result!)  We use modulo only for arguments that will
31730 clearly get reduced, knowing that the next rule will catch any reductions
31731 that this rule misses.
31733 If a program is being written for general use, it is important to code
31734 it carefully as shown in this second example.  For quick-and-dirty programs,
31735 when you know that your own use of the sine function will never encounter
31736 a large argument, a simpler program like the first one shown is fine.
31738 @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
31739 @subsection Calling Calc from Your Lisp Programs
31741 @noindent
31742 A later section (@pxref{Internals}) gives a full description of
31743 Calc's internal Lisp functions.  It's not hard to call Calc from
31744 inside your programs, but the number of these functions can be daunting.
31745 So Calc provides one special ``programmer-friendly'' function called
31746 @code{calc-eval} that can be made to do just about everything you
31747 need.  It's not as fast as the low-level Calc functions, but it's
31748 much simpler to use!
31750 It may seem that @code{calc-eval} itself has a daunting number of
31751 options, but they all stem from one simple operation.
31753 In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
31754 string @code{"1+2"} as if it were a Calc algebraic entry and returns
31755 the result formatted as a string: @code{"3"}.
31757 Since @code{calc-eval} is on the list of recommended @code{autoload}
31758 functions, you don't need to make any special preparations to load
31759 Calc before calling @code{calc-eval} the first time.  Calc will be
31760 loaded and initialized for you.
31762 All the Calc modes that are currently in effect will be used when
31763 evaluating the expression and formatting the result.
31765 @ifinfo
31766 @example
31768 @end example
31769 @end ifinfo
31770 @subsubsection Additional Arguments to @code{calc-eval}
31772 @noindent
31773 If the input string parses to a list of expressions, Calc returns
31774 the results separated by @code{", "}.  You can specify a different
31775 separator by giving a second string argument to @code{calc-eval}:
31776 @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
31778 The ``separator'' can also be any of several Lisp symbols which
31779 request other behaviors from @code{calc-eval}.  These are discussed
31780 one by one below.
31782 You can give additional arguments to be substituted for
31783 @samp{$}, @samp{$$}, and so on in the main expression.  For
31784 example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
31785 expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
31786 (assuming Fraction mode is not in effect).  Note the @code{nil}
31787 used as a placeholder for the item-separator argument.
31789 @ifinfo
31790 @example
31792 @end example
31793 @end ifinfo
31794 @subsubsection Error Handling
31796 @noindent
31797 If @code{calc-eval} encounters an error, it returns a list containing
31798 the character position of the error, plus a suitable message as a
31799 string.  Note that @samp{1 / 0} is @emph{not} an error by Calc's
31800 standards; it simply returns the string @code{"1 / 0"} which is the
31801 division left in symbolic form.  But @samp{(calc-eval "1/")} will
31802 return the list @samp{(2 "Expected a number")}.
31804 If you bind the variable @code{calc-eval-error} to @code{t}
31805 using a @code{let} form surrounding the call to @code{calc-eval},
31806 errors instead call the Emacs @code{error} function which aborts
31807 to the Emacs command loop with a beep and an error message.
31809 If you bind this variable to the symbol @code{string}, error messages
31810 are returned as strings instead of lists.  The character position is
31811 ignored.
31813 As a courtesy to other Lisp code which may be using Calc, be sure
31814 to bind @code{calc-eval-error} using @code{let} rather than changing
31815 it permanently with @code{setq}.
31817 @ifinfo
31818 @example
31820 @end example
31821 @end ifinfo
31822 @subsubsection Numbers Only
31824 @noindent
31825 Sometimes it is preferable to treat @samp{1 / 0} as an error
31826 rather than returning a symbolic result.  If you pass the symbol
31827 @code{num} as the second argument to @code{calc-eval}, results
31828 that are not constants are treated as errors.  The error message
31829 reported is the first @code{calc-why} message if there is one,
31830 or otherwise ``Number expected.''
31832 A result is ``constant'' if it is a number, vector, or other
31833 object that does not include variables or function calls.  If it
31834 is a vector, the components must themselves be constants.
31836 @ifinfo
31837 @example
31839 @end example
31840 @end ifinfo
31841 @subsubsection Default Modes
31843 @noindent
31844 If the first argument to @code{calc-eval} is a list whose first
31845 element is a formula string, then @code{calc-eval} sets all the
31846 various Calc modes to their default values while the formula is
31847 evaluated and formatted.  For example, the precision is set to 12
31848 digits, digit grouping is turned off, and the normal language
31849 mode is used.
31851 This same principle applies to the other options discussed below.
31852 If the first argument would normally be @var{x}, then it can also
31853 be the list @samp{(@var{x})} to use the default mode settings.
31855 If there are other elements in the list, they are taken as
31856 variable-name/value pairs which override the default mode
31857 settings.  Look at the documentation at the front of the
31858 @file{calc.el} file to find the names of the Lisp variables for
31859 the various modes.  The mode settings are restored to their
31860 original values when @code{calc-eval} is done.
31862 For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
31863 computes the sum of two numbers, requiring a numeric result, and
31864 using default mode settings except that the precision is 8 instead
31865 of the default of 12.
31867 It's usually best to use this form of @code{calc-eval} unless your
31868 program actually considers the interaction with Calc's mode settings
31869 to be a feature.  This will avoid all sorts of potential ``gotchas'';
31870 consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
31871 when the user has left Calc in symbolic mode or no-simplify mode.
31873 As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
31874 checks if the number in string @cite{a} is less than the one in
31875 string @cite{b}.  Without using a list, the integer 1 might
31876 come out in a variety of formats which would be hard to test for
31877 conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}.  (But
31878 see ``Predicates'' mode, below.)
31880 @ifinfo
31881 @example
31883 @end example
31884 @end ifinfo
31885 @subsubsection Raw Numbers
31887 @noindent
31888 Normally all input and output for @code{calc-eval} is done with strings.
31889 You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
31890 in place of @samp{(+ a b)}, but this is very inefficient since the
31891 numbers must be converted to and from string format as they are passed
31892 from one @code{calc-eval} to the next.
31894 If the separator is the symbol @code{raw}, the result will be returned
31895 as a raw Calc data structure rather than a string.  You can read about
31896 how these objects look in the following sections, but usually you can
31897 treat them as ``black box'' objects with no important internal
31898 structure.
31900 There is also a @code{rawnum} symbol, which is a combination of
31901 @code{raw} (returning a raw Calc object) and @code{num} (signaling
31902 an error if that object is not a constant).
31904 You can pass a raw Calc object to @code{calc-eval} in place of a
31905 string, either as the formula itself or as one of the @samp{$}
31906 arguments.  Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
31907 addition function that operates on raw Calc objects.  Of course
31908 in this case it would be easier to call the low-level @code{math-add}
31909 function in Calc, if you can remember its name.
31911 In particular, note that a plain Lisp integer is acceptable to Calc
31912 as a raw object.  (All Lisp integers are accepted on input, but
31913 integers of more than six decimal digits are converted to ``big-integer''
31914 form for output.  @xref{Data Type Formats}.)
31916 When it comes time to display the object, just use @samp{(calc-eval a)}
31917 to format it as a string.
31919 It is an error if the input expression evaluates to a list of
31920 values.  The separator symbol @code{list} is like @code{raw}
31921 except that it returns a list of one or more raw Calc objects.
31923 Note that a Lisp string is not a valid Calc object, nor is a list
31924 containing a string.  Thus you can still safely distinguish all the
31925 various kinds of error returns discussed above.
31927 @ifinfo
31928 @example
31930 @end example
31931 @end ifinfo
31932 @subsubsection Predicates
31934 @noindent
31935 If the separator symbol is @code{pred}, the result of the formula is
31936 treated as a true/false value; @code{calc-eval} returns @code{t} or
31937 @code{nil}, respectively.  A value is considered ``true'' if it is a
31938 non-zero number, or false if it is zero or if it is not a number.
31940 For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
31941 one value is less than another.
31943 As usual, it is also possible for @code{calc-eval} to return one of
31944 the error indicators described above.  Lisp will interpret such an
31945 indicator as ``true'' if you don't check for it explicitly.  If you
31946 wish to have an error register as ``false'', use something like
31947 @samp{(eq (calc-eval ...) t)}.
31949 @ifinfo
31950 @example
31952 @end example
31953 @end ifinfo
31954 @subsubsection Variable Values
31956 @noindent
31957 Variables in the formula passed to @code{calc-eval} are not normally
31958 replaced by their values.  If you wish this, you can use the
31959 @code{evalv} function (@pxref{Algebraic Manipulation}).  For example,
31960 if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
31961 @code{var-a}), then @samp{(calc-eval "a+pi")} will return the
31962 formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
31963 will return @code{"7.14159265359"}.
31965 To store in a Calc variable, just use @code{setq} to store in the
31966 corresponding Lisp variable.  (This is obtained by prepending
31967 @samp{var-} to the Calc variable name.)  Calc routines will
31968 understand either string or raw form values stored in variables,
31969 although raw data objects are much more efficient.  For example,
31970 to increment the Calc variable @code{a}:
31972 @example
31973 (setq var-a (calc-eval "evalv(a+1)" 'raw))
31974 @end example
31976 @ifinfo
31977 @example
31979 @end example
31980 @end ifinfo
31981 @subsubsection Stack Access
31983 @noindent
31984 If the separator symbol is @code{push}, the formula argument is
31985 evaluated (with possible @samp{$} expansions, as usual).  The
31986 result is pushed onto the Calc stack.  The return value is @code{nil}
31987 (unless there is an error from evaluating the formula, in which
31988 case the return value depends on @code{calc-eval-error} in the
31989 usual way).
31991 If the separator symbol is @code{pop}, the first argument to
31992 @code{calc-eval} must be an integer instead of a string.  That
31993 many values are popped from the stack and thrown away.  A negative
31994 argument deletes the entry at that stack level.  The return value
31995 is the number of elements remaining in the stack after popping;
31996 @samp{(calc-eval 0 'pop)} is a good way to measure the size of
31997 the stack.
31999 If the separator symbol is @code{top}, the first argument to
32000 @code{calc-eval} must again be an integer.  The value at that
32001 stack level is formatted as a string and returned.  Thus
32002 @samp{(calc-eval 1 'top)} returns the top-of-stack value.  If the
32003 integer is out of range, @code{nil} is returned.
32005 The separator symbol @code{rawtop} is just like @code{top} except
32006 that the stack entry is returned as a raw Calc object instead of
32007 as a string.
32009 In all of these cases the first argument can be made a list in
32010 order to force the default mode settings, as described above.
32011 Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
32012 second-to-top stack entry, formatted as a string using the default
32013 instead of current display modes, except that the radix is
32014 hexadecimal instead of decimal.
32016 It is, of course, polite to put the Calc stack back the way you
32017 found it when you are done, unless the user of your program is
32018 actually expecting it to affect the stack.
32020 Note that you do not actually have to switch into the @samp{*Calculator*}
32021 buffer in order to use @code{calc-eval}; it temporarily switches into
32022 the stack buffer if necessary.
32024 @ifinfo
32025 @example
32027 @end example
32028 @end ifinfo
32029 @subsubsection Keyboard Macros
32031 @noindent
32032 If the separator symbol is @code{macro}, the first argument must be a
32033 string of characters which Calc can execute as a sequence of keystrokes.
32034 This switches into the Calc buffer for the duration of the macro.
32035 For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
32036 vector @samp{[1,2,3,4,5]} on the stack and then replaces it
32037 with the sum of those numbers.  Note that @samp{\r} is the Lisp
32038 notation for the carriage-return, @key{RET}, character.
32040 If your keyboard macro wishes to pop the stack, @samp{\C-d} is
32041 safer than @samp{\177} (the @key{DEL} character) because some
32042 installations may have switched the meanings of @key{DEL} and
32043 @kbd{C-h}.  Calc always interprets @kbd{C-d} as a synonym for
32044 ``pop-stack'' regardless of key mapping.
32046 If you provide a third argument to @code{calc-eval}, evaluation
32047 of the keyboard macro will leave a record in the Trail using
32048 that argument as a tag string.  Normally the Trail is unaffected.
32050 The return value in this case is always @code{nil}.
32052 @ifinfo
32053 @example
32055 @end example
32056 @end ifinfo
32057 @subsubsection Lisp Evaluation
32059 @noindent
32060 Finally, if the separator symbol is @code{eval}, then the Lisp
32061 @code{eval} function is called on the first argument, which must
32062 be a Lisp expression rather than a Calc formula.  Remember to
32063 quote the expression so that it is not evaluated until inside
32064 @code{calc-eval}.
32066 The difference from plain @code{eval} is that @code{calc-eval}
32067 switches to the Calc buffer before evaluating the expression.
32068 For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
32069 will correctly affect the buffer-local Calc precision variable.
32071 An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
32072 This is evaluating a call to the function that is normally invoked
32073 by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
32074 Note that this function will leave a message in the echo area as
32075 a side effect.  Also, all Calc functions switch to the Calc buffer
32076 automatically if not invoked from there, so the above call is
32077 also equivalent to @samp{(calc-precision 17)} by itself.
32078 In all cases, Calc uses @code{save-excursion} to switch back to
32079 your original buffer when it is done.
32081 As usual the first argument can be a list that begins with a Lisp
32082 expression to use default instead of current mode settings.
32084 The result of @code{calc-eval} in this usage is just the result
32085 returned by the evaluated Lisp expression.
32087 @ifinfo
32088 @example
32090 @end example
32091 @end ifinfo
32092 @subsubsection Example
32094 @noindent
32095 @findex convert-temp
32096 Here is a sample Emacs command that uses @code{calc-eval}.  Suppose
32097 you have a document with lots of references to temperatures on the
32098 Fahrenheit scale, say ``98.6 F'', and you wish to convert these
32099 references to Centigrade.  The following command does this conversion.
32100 Place the Emacs cursor right after the letter ``F'' and invoke the
32101 command to change ``98.6 F'' to ``37 C''.  Or, if the temperature is
32102 already in Centigrade form, the command changes it back to Fahrenheit.
32104 @example
32105 (defun convert-temp ()
32106   (interactive)
32107   (save-excursion
32108     (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
32109     (let* ((top1 (match-beginning 1))
32110            (bot1 (match-end 1))
32111            (number (buffer-substring top1 bot1))
32112            (top2 (match-beginning 2))
32113            (bot2 (match-end 2))
32114            (type (buffer-substring top2 bot2)))
32115       (if (equal type "F")
32116           (setq type "C"
32117                 number (calc-eval "($ - 32)*5/9" nil number))
32118         (setq type "F"
32119               number (calc-eval "$*9/5 + 32" nil number)))
32120       (goto-char top2)
32121       (delete-region top2 bot2)
32122       (insert-before-markers type)
32123       (goto-char top1)
32124       (delete-region top1 bot1)
32125       (if (string-match "\\.$" number)   ; change "37." to "37"
32126           (setq number (substring number 0 -1)))
32127       (insert number))))
32128 @end example
32130 Note the use of @code{insert-before-markers} when changing between
32131 ``F'' and ``C'', so that the character winds up before the cursor
32132 instead of after it.
32134 @node Internals, , Calling Calc from Your Programs, Lisp Definitions
32135 @subsection Calculator Internals
32137 @noindent
32138 This section describes the Lisp functions defined by the Calculator that
32139 may be of use to user-written Calculator programs (as described in the
32140 rest of this chapter).  These functions are shown by their names as they
32141 conventionally appear in @code{defmath}.  Their full Lisp names are
32142 generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
32143 apparent names.  (Names that begin with @samp{calc-} are already in
32144 their full Lisp form.)  You can use the actual full names instead if you
32145 prefer them, or if you are calling these functions from regular Lisp.
32147 The functions described here are scattered throughout the various
32148 Calc component files.  Note that @file{calc.el} includes @code{autoload}s
32149 for only a few component files; when Calc wants to call an advanced
32150 function it calls @samp{(calc-extensions)} first; this function
32151 autoloads @file{calc-ext.el}, which in turn autoloads all the functions
32152 in the remaining component files.
32154 Because @code{defmath} itself uses the extensions, user-written code
32155 generally always executes with the extensions already loaded, so
32156 normally you can use any Calc function and be confident that it will
32157 be autoloaded for you when necessary.  If you are doing something
32158 special, check carefully to make sure each function you are using is
32159 from @file{calc.el} or its components, and call @samp{(calc-extensions)}
32160 before using any function based in @file{calc-ext.el} if you can't
32161 prove this file will already be loaded.
32163 @menu
32164 * Data Type Formats::
32165 * Interactive Lisp Functions::
32166 * Stack Lisp Functions::
32167 * Predicates::
32168 * Computational Lisp Functions::
32169 * Vector Lisp Functions::
32170 * Symbolic Lisp Functions::
32171 * Formatting Lisp Functions::
32172 * Hooks::
32173 @end menu
32175 @node Data Type Formats, Interactive Lisp Functions, Internals, Internals
32176 @subsubsection Data Type Formats
32178 @noindent
32179 Integers are stored in either of two ways, depending on their magnitude.
32180 Integers less than one million in absolute value are stored as standard
32181 Lisp integers.  This is the only storage format for Calc data objects
32182 which is not a Lisp list.
32184 Large integers are stored as lists of the form @samp{(bigpos @var{d0}
32185 @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or
32186 @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers
32187 @i{-1000000} or less.  Each @var{d} is a base-1000 ``digit,'' a Lisp integer
32188 from 0 to 999.  The least significant digit is @var{d0}; the last digit,
32189 @var{dn}, which is always nonzero, is the most significant digit.  For
32190 example, the integer @i{-12345678} is stored as @samp{(bigneg 678 345 12)}.
32192 The distinction between small and large integers is entirely hidden from
32193 the user.  In @code{defmath} definitions, the Lisp predicate @code{integerp}
32194 returns true for either kind of integer, and in general both big and small
32195 integers are accepted anywhere the word ``integer'' is used in this manual.
32196 If the distinction must be made, native Lisp integers are called @dfn{fixnums}
32197 and large integers are called @dfn{bignums}.
32199 Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
32200 where @var{n} is an integer (big or small) numerator, @var{d} is an
32201 integer denominator greater than one, and @var{n} and @var{d} are relatively
32202 prime.  Note that fractions where @var{d} is one are automatically converted
32203 to plain integers by all math routines; fractions where @var{d} is negative
32204 are normalized by negating the numerator and denominator.
32206 Floating-point numbers are stored in the form, @samp{(float @var{mant}
32207 @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
32208 @samp{10^@var{p}} in absolute value (@var{p} represents the current
32209 precision), and @var{exp} (the ``exponent'') is a fixnum.  The value of
32210 the float is @samp{@var{mant} * 10^@var{exp}}.  For example, the number
32211 @i{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}.  Other constraints
32212 are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
32213 except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
32214 always nonzero.  (If the rightmost digit is zero, the number is
32215 rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)@refill
32217 Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
32218 @var{im})}, where @var{re} and @var{im} are each real numbers, either
32219 integers, fractions, or floats.  The value is @samp{@var{re} + @var{im}i}.
32220 The @var{im} part is nonzero; complex numbers with zero imaginary
32221 components are converted to real numbers automatically.@refill
32223 Polar complex numbers are stored in the form @samp{(polar @var{r}
32224 @var{theta})}, where @var{r} is a positive real value and @var{theta}
32225 is a real value or HMS form representing an angle.  This angle is
32226 usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
32227 or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
32228 If the angle is 0 the value is converted to a real number automatically.
32229 (If the angle is 180 degrees, the value is usually also converted to a
32230 negative real number.)@refill
32232 Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
32233 @var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
32234 a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
32235 float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
32236 in the range @samp{[0 ..@: 60)}.@refill
32238 Date forms are stored as @samp{(date @var{n})}, where @var{n} is
32239 a real number that counts days since midnight on the morning of
32240 January 1, 1 AD.  If @var{n} is an integer, this is a pure date
32241 form.  If @var{n} is a fraction or float, this is a date/time form.
32243 Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
32244 positive real number or HMS form, and @var{n} is a real number or HMS
32245 form in the range @samp{[0 ..@: @var{m})}.
32247 Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
32248 is the mean value and @var{sigma} is the standard deviation.  Each
32249 component is either a number, an HMS form, or a symbolic object
32250 (a variable or function call).  If @var{sigma} is zero, the value is
32251 converted to a plain real number.  If @var{sigma} is negative or
32252 complex, it is automatically normalized to be a positive real.
32254 Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
32255 where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
32256 @var{hi} are real numbers, HMS forms, or symbolic objects.  The @var{mask}
32257 is a binary integer where 1 represents the fact that the interval is
32258 closed on the high end, and 2 represents the fact that it is closed on
32259 the low end.  (Thus 3 represents a fully closed interval.)  The interval
32260 @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
32261 intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
32262 represent empty intervals.  If @var{hi} is less than @var{lo}, the interval
32263 is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
32265 Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
32266 is the first element of the vector, @var{v2} is the second, and so on.
32267 An empty vector is stored as @samp{(vec)}.  A matrix is simply a vector
32268 where all @var{v}'s are themselves vectors of equal lengths.  Note that
32269 Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
32270 generally unused by Calc data structures.
32272 Variables are stored as @samp{(var @var{name} @var{sym})}, where
32273 @var{name} is a Lisp symbol whose print name is used as the visible name
32274 of the variable, and @var{sym} is a Lisp symbol in which the variable's
32275 value is actually stored.  Thus, @samp{(var pi var-pi)} represents the
32276 special constant @samp{pi}.  Almost always, the form is @samp{(var
32277 @var{v} var-@var{v})}.  If the variable name was entered with @code{#}
32278 signs (which are converted to hyphens internally), the form is
32279 @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
32280 contains @code{#} characters, and @var{v} is a symbol that contains
32281 @code{-} characters instead.  The value of a variable is the Calc
32282 object stored in its @var{sym} symbol's value cell.  If the symbol's
32283 value cell is void or if it contains @code{nil}, the variable has no
32284 value.  Special constants have the form @samp{(special-const
32285 @var{value})} stored in their value cell, where @var{value} is a formula
32286 which is evaluated when the constant's value is requested.  Variables
32287 which represent units are not stored in any special way; they are units
32288 only because their names appear in the units table.  If the value
32289 cell contains a string, it is parsed to get the variable's value when
32290 the variable is used.@refill
32292 A Lisp list with any other symbol as the first element is a function call.
32293 The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
32294 and @code{|} represent special binary operators; these lists are always
32295 of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
32296 sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
32297 right.  The symbol @code{neg} represents unary negation; this list is always
32298 of the form @samp{(neg @var{arg})}.  Any other symbol @var{func} represents a
32299 function that would be displayed in function-call notation; the symbol
32300 @var{func} is in general always of the form @samp{calcFunc-@var{name}}.
32301 The function cell of the symbol @var{func} should contain a Lisp function
32302 for evaluating a call to @var{func}.  This function is passed the remaining
32303 elements of the list (themselves already evaluated) as arguments; such
32304 functions should return @code{nil} or call @code{reject-arg} to signify
32305 that they should be left in symbolic form, or they should return a Calc
32306 object which represents their value, or a list of such objects if they
32307 wish to return multiple values.  (The latter case is allowed only for
32308 functions which are the outer-level call in an expression whose value is
32309 about to be pushed on the stack; this feature is considered obsolete
32310 and is not used by any built-in Calc functions.)@refill
32312 @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
32313 @subsubsection Interactive Functions
32315 @noindent
32316 The functions described here are used in implementing interactive Calc
32317 commands.  Note that this list is not exhaustive!  If there is an
32318 existing command that behaves similarly to the one you want to define,
32319 you may find helpful tricks by checking the source code for that command.
32321 @defun calc-set-command-flag flag
32322 Set the command flag @var{flag}.  This is generally a Lisp symbol, but
32323 may in fact be anything.  The effect is to add @var{flag} to the list
32324 stored in the variable @code{calc-command-flags}, unless it is already
32325 there.  @xref{Defining Simple Commands}.
32326 @end defun
32328 @defun calc-clear-command-flag flag
32329 If @var{flag} appears among the list of currently-set command flags,
32330 remove it from that list.
32331 @end defun
32333 @defun calc-record-undo rec
32334 Add the ``undo record'' @var{rec} to the list of steps to take if the
32335 current operation should need to be undone.  Stack push and pop functions
32336 automatically call @code{calc-record-undo}, so the kinds of undo records
32337 you might need to create take the form @samp{(set @var{sym} @var{value})},
32338 which says that the Lisp variable @var{sym} was changed and had previously
32339 contained @var{value}; @samp{(store @var{var} @var{value})} which says that
32340 the Calc variable @var{var} (a string which is the name of the symbol that
32341 contains the variable's value) was stored and its previous value was
32342 @var{value} (either a Calc data object, or @code{nil} if the variable was
32343 previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
32344 which means that to undo requires calling the function @samp{(@var{undo}
32345 @var{args} @dots{})} and, if the undo is later redone, calling
32346 @samp{(@var{redo} @var{args} @dots{})}.@refill
32347 @end defun
32349 @defun calc-record-why msg args
32350 Record the error or warning message @var{msg}, which is normally a string.
32351 This message will be replayed if the user types @kbd{w} (@code{calc-why});
32352 if the message string begins with a @samp{*}, it is considered important
32353 enough to display even if the user doesn't type @kbd{w}.  If one or more
32354 @var{args} are present, the displayed message will be of the form,
32355 @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
32356 formatted on the assumption that they are either strings or Calc objects of
32357 some sort.  If @var{msg} is a symbol, it is the name of a Calc predicate
32358 (such as @code{integerp} or @code{numvecp}) which the arguments did not
32359 satisfy; it is expanded to a suitable string such as ``Expected an
32360 integer.''  The @code{reject-arg} function calls @code{calc-record-why}
32361 automatically; @pxref{Predicates}.@refill
32362 @end defun
32364 @defun calc-is-inverse
32365 This predicate returns true if the current command is inverse,
32366 i.e., if the Inverse (@kbd{I} key) flag was set.
32367 @end defun
32369 @defun calc-is-hyperbolic
32370 This predicate is the analogous function for the @kbd{H} key.
32371 @end defun
32373 @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
32374 @subsubsection Stack-Oriented Functions
32376 @noindent
32377 The functions described here perform various operations on the Calc
32378 stack and trail.  They are to be used in interactive Calc commands.
32380 @defun calc-push-list vals n
32381 Push the Calc objects in list @var{vals} onto the stack at stack level
32382 @var{n}.  If @var{n} is omitted it defaults to 1, so that the elements
32383 are pushed at the top of the stack.  If @var{n} is greater than 1, the
32384 elements will be inserted into the stack so that the last element will
32385 end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
32386 The elements of @var{vals} are assumed to be valid Calc objects, and
32387 are not evaluated, rounded, or renormalized in any way.  If @var{vals}
32388 is an empty list, nothing happens.@refill
32390 The stack elements are pushed without any sub-formula selections.
32391 You can give an optional third argument to this function, which must
32392 be a list the same size as @var{vals} of selections.  Each selection
32393 must be @code{eq} to some sub-formula of the corresponding formula
32394 in @var{vals}, or @code{nil} if that formula should have no selection.
32395 @end defun
32397 @defun calc-top-list n m
32398 Return a list of the @var{n} objects starting at level @var{m} of the
32399 stack.  If @var{m} is omitted it defaults to 1, so that the elements are
32400 taken from the top of the stack.  If @var{n} is omitted, it also
32401 defaults to 1, so that the top stack element (in the form of a
32402 one-element list) is returned.  If @var{m} is greater than 1, the
32403 @var{m}th stack element will be at the end of the list, the @var{m}+1st
32404 element will be next-to-last, etc.  If @var{n} or @var{m} are out of
32405 range, the command is aborted with a suitable error message.  If @var{n}
32406 is zero, the function returns an empty list.  The stack elements are not
32407 evaluated, rounded, or renormalized.@refill
32409 If any stack elements contain selections, and selections have not
32410 been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
32411 this function returns the selected portions rather than the entire
32412 stack elements.  It can be given a third ``selection-mode'' argument
32413 which selects other behaviors.  If it is the symbol @code{t}, then
32414 a selection in any of the requested stack elements produces an
32415 ``illegal operation on selections'' error.  If it is the symbol @code{full},
32416 the whole stack entry is always returned regardless of selections.
32417 If it is the symbol @code{sel}, the selected portion is always returned,
32418 or @code{nil} if there is no selection.  (This mode ignores the @kbd{j e}
32419 command.)  If the symbol is @code{entry}, the complete stack entry in
32420 list form is returned; the first element of this list will be the whole
32421 formula, and the third element will be the selection (or @code{nil}).
32422 @end defun
32424 @defun calc-pop-stack n m
32425 Remove the specified elements from the stack.  The parameters @var{n}
32426 and @var{m} are defined the same as for @code{calc-top-list}.  The return
32427 value of @code{calc-pop-stack} is uninteresting.
32429 If there are any selected sub-formulas among the popped elements, and
32430 @kbd{j e} has not been used to disable selections, this produces an
32431 error without changing the stack.  If you supply an optional third
32432 argument of @code{t}, the stack elements are popped even if they
32433 contain selections.
32434 @end defun
32436 @defun calc-record-list vals tag
32437 This function records one or more results in the trail.  The @var{vals}
32438 are a list of strings or Calc objects.  The @var{tag} is the four-character
32439 tag string to identify the values.  If @var{tag} is omitted, a blank tag
32440 will be used.
32441 @end defun
32443 @defun calc-normalize n
32444 This function takes a Calc object and ``normalizes'' it.  At the very
32445 least this involves re-rounding floating-point values according to the
32446 current precision and other similar jobs.  Also, unless the user has
32447 selected no-simplify mode (@pxref{Simplification Modes}), this involves
32448 actually evaluating a formula object by executing the function calls
32449 it contains, and possibly also doing algebraic simplification, etc.
32450 @end defun
32452 @defun calc-top-list-n n m
32453 This function is identical to @code{calc-top-list}, except that it calls
32454 @code{calc-normalize} on the values that it takes from the stack.  They
32455 are also passed through @code{check-complete}, so that incomplete
32456 objects will be rejected with an error message.  All computational
32457 commands should use this in preference to @code{calc-top-list}; the only
32458 standard Calc commands that operate on the stack without normalizing
32459 are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
32460 This function accepts the same optional selection-mode argument as
32461 @code{calc-top-list}.
32462 @end defun
32464 @defun calc-top-n m
32465 This function is a convenient form of @code{calc-top-list-n} in which only
32466 a single element of the stack is taken and returned, rather than a list
32467 of elements.  This also accepts an optional selection-mode argument.
32468 @end defun
32470 @defun calc-enter-result n tag vals
32471 This function is a convenient interface to most of the above functions.
32472 The @var{vals} argument should be either a single Calc object, or a list
32473 of Calc objects; the object or objects are normalized, and the top @var{n}
32474 stack entries are replaced by the normalized objects.  If @var{tag} is
32475 non-@code{nil}, the normalized objects are also recorded in the trail.
32476 A typical stack-based computational command would take the form,
32478 @smallexample
32479 (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
32480                                (calc-top-list-n @var{n})))
32481 @end smallexample
32483 If any of the @var{n} stack elements replaced contain sub-formula
32484 selections, and selections have not been disabled by @kbd{j e},
32485 this function takes one of two courses of action.  If @var{n} is
32486 equal to the number of elements in @var{vals}, then each element of
32487 @var{vals} is spliced into the corresponding selection; this is what
32488 happens when you use the @key{TAB} key, or when you use a unary
32489 arithmetic operation like @code{sqrt}.  If @var{vals} has only one
32490 element but @var{n} is greater than one, there must be only one
32491 selection among the top @var{n} stack elements; the element from
32492 @var{vals} is spliced into that selection.  This is what happens when
32493 you use a binary arithmetic operation like @kbd{+}.  Any other
32494 combination of @var{n} and @var{vals} is an error when selections
32495 are present.
32496 @end defun
32498 @defun calc-unary-op tag func arg
32499 This function implements a unary operator that allows a numeric prefix
32500 argument to apply the operator over many stack entries.  If the prefix
32501 argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
32502 as outlined above.  Otherwise, it maps the function over several stack
32503 elements; @pxref{Prefix Arguments}.  For example,@refill
32505 @smallexample
32506 (defun calc-zeta (arg)
32507   (interactive "P")
32508   (calc-unary-op "zeta" 'calcFunc-zeta arg))
32509 @end smallexample
32510 @end defun
32512 @defun calc-binary-op tag func arg ident unary
32513 This function implements a binary operator, analogously to
32514 @code{calc-unary-op}.  The optional @var{ident} and @var{unary}
32515 arguments specify the behavior when the prefix argument is zero or
32516 one, respectively.  If the prefix is zero, the value @var{ident}
32517 is pushed onto the stack, if specified, otherwise an error message
32518 is displayed.  If the prefix is one, the unary function @var{unary}
32519 is applied to the top stack element, or, if @var{unary} is not
32520 specified, nothing happens.  When the argument is two or more,
32521 the binary function @var{func} is reduced across the top @var{arg}
32522 stack elements; when the argument is negative, the function is
32523 mapped between the next-to-top @i{-@var{arg}} stack elements and the
32524 top element.@refill
32525 @end defun
32527 @defun calc-stack-size
32528 Return the number of elements on the stack as an integer.  This count
32529 does not include elements that have been temporarily hidden by stack
32530 truncation; @pxref{Truncating the Stack}.
32531 @end defun
32533 @defun calc-cursor-stack-index n
32534 Move the point to the @var{n}th stack entry.  If @var{n} is zero, this
32535 will be the @samp{.} line.  If @var{n} is from 1 to the current stack size,
32536 this will be the beginning of the first line of that stack entry's display.
32537 If line numbers are enabled, this will move to the first character of the
32538 line number, not the stack entry itself.@refill
32539 @end defun
32541 @defun calc-substack-height n
32542 Return the number of lines between the beginning of the @var{n}th stack
32543 entry and the bottom of the buffer.  If @var{n} is zero, this
32544 will be one (assuming no stack truncation).  If all stack entries are
32545 one line long (i.e., no matrices are displayed), the return value will
32546 be equal @var{n}+1 as long as @var{n} is in range.  (Note that in Big
32547 mode, the return value includes the blank lines that separate stack
32548 entries.)@refill
32549 @end defun
32551 @defun calc-refresh
32552 Erase the @code{*Calculator*} buffer and reformat its contents from memory.
32553 This must be called after changing any parameter, such as the current
32554 display radix, which might change the appearance of existing stack
32555 entries.  (During a keyboard macro invoked by the @kbd{X} key, refreshing
32556 is suppressed, but a flag is set so that the entire stack will be refreshed
32557 rather than just the top few elements when the macro finishes.)@refill
32558 @end defun
32560 @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
32561 @subsubsection Predicates
32563 @noindent
32564 The functions described here are predicates, that is, they return a
32565 true/false value where @code{nil} means false and anything else means
32566 true.  These predicates are expanded by @code{defmath}, for example,
32567 from @code{zerop} to @code{math-zerop}.  In many cases they correspond
32568 to native Lisp functions by the same name, but are extended to cover
32569 the full range of Calc data types.
32571 @defun zerop x
32572 Returns true if @var{x} is numerically zero, in any of the Calc data
32573 types.  (Note that for some types, such as error forms and intervals,
32574 it never makes sense to return true.)  In @code{defmath}, the expression
32575 @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
32576 and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
32577 @end defun
32579 @defun negp x
32580 Returns true if @var{x} is negative.  This accepts negative real numbers
32581 of various types, negative HMS and date forms, and intervals in which
32582 all included values are negative.  In @code{defmath}, the expression
32583 @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
32584 and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
32585 @end defun
32587 @defun posp x
32588 Returns true if @var{x} is positive (and non-zero).  For complex
32589 numbers, none of these three predicates will return true.
32590 @end defun
32592 @defun looks-negp x
32593 Returns true if @var{x} is ``negative-looking.''  This returns true if
32594 @var{x} is a negative number, or a formula with a leading minus sign
32595 such as @samp{-a/b}.  In other words, this is an object which can be
32596 made simpler by calling @code{(- @var{x})}.
32597 @end defun
32599 @defun integerp x
32600 Returns true if @var{x} is an integer of any size.
32601 @end defun
32603 @defun fixnump x
32604 Returns true if @var{x} is a native Lisp integer.
32605 @end defun
32607 @defun natnump x
32608 Returns true if @var{x} is a nonnegative integer of any size.
32609 @end defun
32611 @defun fixnatnump x
32612 Returns true if @var{x} is a nonnegative Lisp integer.
32613 @end defun
32615 @defun num-integerp x
32616 Returns true if @var{x} is numerically an integer, i.e., either a
32617 true integer or a float with no significant digits to the right of
32618 the decimal point.
32619 @end defun
32621 @defun messy-integerp x
32622 Returns true if @var{x} is numerically, but not literally, an integer.
32623 A value is @code{num-integerp} if it is @code{integerp} or
32624 @code{messy-integerp} (but it is never both at once).
32625 @end defun
32627 @defun num-natnump x
32628 Returns true if @var{x} is numerically a nonnegative integer.
32629 @end defun
32631 @defun evenp x
32632 Returns true if @var{x} is an even integer.
32633 @end defun
32635 @defun looks-evenp x
32636 Returns true if @var{x} is an even integer, or a formula with a leading
32637 multiplicative coefficient which is an even integer.
32638 @end defun
32640 @defun oddp x
32641 Returns true if @var{x} is an odd integer.
32642 @end defun
32644 @defun ratp x
32645 Returns true if @var{x} is a rational number, i.e., an integer or a
32646 fraction.
32647 @end defun
32649 @defun realp x
32650 Returns true if @var{x} is a real number, i.e., an integer, fraction,
32651 or floating-point number.
32652 @end defun
32654 @defun anglep x
32655 Returns true if @var{x} is a real number or HMS form.
32656 @end defun
32658 @defun floatp x
32659 Returns true if @var{x} is a float, or a complex number, error form,
32660 interval, date form, or modulo form in which at least one component
32661 is a float.
32662 @end defun
32664 @defun complexp x
32665 Returns true if @var{x} is a rectangular or polar complex number
32666 (but not a real number).
32667 @end defun
32669 @defun rect-complexp x
32670 Returns true if @var{x} is a rectangular complex number.
32671 @end defun
32673 @defun polar-complexp x
32674 Returns true if @var{x} is a polar complex number.
32675 @end defun
32677 @defun numberp x
32678 Returns true if @var{x} is a real number or a complex number.
32679 @end defun
32681 @defun scalarp x
32682 Returns true if @var{x} is a real or complex number or an HMS form.
32683 @end defun
32685 @defun vectorp x
32686 Returns true if @var{x} is a vector (this simply checks if its argument
32687 is a list whose first element is the symbol @code{vec}).
32688 @end defun
32690 @defun numvecp x
32691 Returns true if @var{x} is a number or vector.
32692 @end defun
32694 @defun matrixp x
32695 Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
32696 all of the same size.
32697 @end defun
32699 @defun square-matrixp x
32700 Returns true if @var{x} is a square matrix.
32701 @end defun
32703 @defun objectp x
32704 Returns true if @var{x} is any numeric Calc object, including real and
32705 complex numbers, HMS forms, date forms, error forms, intervals, and
32706 modulo forms.  (Note that error forms and intervals may include formulas
32707 as their components; see @code{constp} below.)
32708 @end defun
32710 @defun objvecp x
32711 Returns true if @var{x} is an object or a vector.  This also accepts
32712 incomplete objects, but it rejects variables and formulas (except as
32713 mentioned above for @code{objectp}).
32714 @end defun
32716 @defun primp x
32717 Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
32718 i.e., one whose components cannot be regarded as sub-formulas.  This
32719 includes variables, and all @code{objectp} types except error forms
32720 and intervals.
32721 @end defun
32723 @defun constp x
32724 Returns true if @var{x} is constant, i.e., a real or complex number,
32725 HMS form, date form, or error form, interval, or vector all of whose
32726 components are @code{constp}.
32727 @end defun
32729 @defun lessp x y
32730 Returns true if @var{x} is numerically less than @var{y}.  Returns false
32731 if @var{x} is greater than or equal to @var{y}, or if the order is
32732 undefined or cannot be determined.  Generally speaking, this works
32733 by checking whether @samp{@var{x} - @var{y}} is @code{negp}.  In
32734 @code{defmath}, the expression @samp{(< x y)} will automatically be
32735 converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
32736 and @code{>=} are similarly converted in terms of @code{lessp}.@refill
32737 @end defun
32739 @defun beforep x y
32740 Returns true if @var{x} comes before @var{y} in a canonical ordering
32741 of Calc objects.  If @var{x} and @var{y} are both real numbers, this
32742 will be the same as @code{lessp}.  But whereas @code{lessp} considers
32743 other types of objects to be unordered, @code{beforep} puts any two
32744 objects into a definite, consistent order.  The @code{beforep}
32745 function is used by the @kbd{V S} vector-sorting command, and also
32746 by @kbd{a s} to put the terms of a product into canonical order:
32747 This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}.
32748 @end defun
32750 @defun equal x y
32751 This is the standard Lisp @code{equal} predicate; it returns true if
32752 @var{x} and @var{y} are structurally identical.  This is the usual way
32753 to compare numbers for equality, but note that @code{equal} will treat
32754 0 and 0.0 as different.
32755 @end defun
32757 @defun math-equal x y
32758 Returns true if @var{x} and @var{y} are numerically equal, either because
32759 they are @code{equal}, or because their difference is @code{zerop}.  In
32760 @code{defmath}, the expression @samp{(= x y)} will automatically be
32761 converted to @samp{(math-equal x y)}.
32762 @end defun
32764 @defun equal-int x n
32765 Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
32766 is a fixnum which is not a multiple of 10.  This will automatically be
32767 used by @code{defmath} in place of the more general @code{math-equal}
32768 whenever possible.@refill
32769 @end defun
32771 @defun nearly-equal x y
32772 Returns true if @var{x} and @var{y}, as floating-point numbers, are
32773 equal except possibly in the last decimal place.  For example,
32774 314.159 and 314.166 are considered nearly equal if the current
32775 precision is 6 (since they differ by 7 units), but not if the current
32776 precision is 7 (since they differ by 70 units).  Most functions which
32777 use series expansions use @code{with-extra-prec} to evaluate the
32778 series with 2 extra digits of precision, then use @code{nearly-equal}
32779 to decide when the series has converged; this guards against cumulative
32780 error in the series evaluation without doing extra work which would be
32781 lost when the result is rounded back down to the current precision.
32782 In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
32783 The @var{x} and @var{y} can be numbers of any kind, including complex.
32784 @end defun
32786 @defun nearly-zerop x y
32787 Returns true if @var{x} is nearly zero, compared to @var{y}.  This
32788 checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
32789 to @var{y} itself, to within the current precision, in other words,
32790 if adding @var{x} to @var{y} would have a negligible effect on @var{y}
32791 due to roundoff error.  @var{X} may be a real or complex number, but
32792 @var{y} must be real.
32793 @end defun
32795 @defun is-true x
32796 Return true if the formula @var{x} represents a true value in
32797 Calc, not Lisp, terms.  It tests if @var{x} is a non-zero number
32798 or a provably non-zero formula.
32799 @end defun
32801 @defun reject-arg val pred
32802 Abort the current function evaluation due to unacceptable argument values.
32803 This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
32804 Lisp error which @code{normalize} will trap.  The net effect is that the
32805 function call which led here will be left in symbolic form.@refill
32806 @end defun
32808 @defun inexact-value
32809 If Symbolic Mode is enabled, this will signal an error that causes
32810 @code{normalize} to leave the formula in symbolic form, with the message
32811 ``Inexact result.''  (This function has no effect when not in Symbolic Mode.)
32812 Note that if your function calls @samp{(sin 5)} in Symbolic Mode, the
32813 @code{sin} function will call @code{inexact-value}, which will cause your
32814 function to be left unsimplified.  You may instead wish to call
32815 @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic Mode will
32816 return the formula @samp{sin(5)} to your function.@refill
32817 @end defun
32819 @defun overflow
32820 This signals an error that will be reported as a floating-point overflow.
32821 @end defun
32823 @defun underflow
32824 This signals a floating-point underflow.
32825 @end defun
32827 @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
32828 @subsubsection Computational Functions
32830 @noindent
32831 The functions described here do the actual computational work of the
32832 Calculator.  In addition to these, note that any function described in
32833 the main body of this manual may be called from Lisp; for example, if
32834 the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
32835 this means @code{calc-sqrt} is an interactive stack-based square-root
32836 command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
32837 is the actual Lisp function for taking square roots.@refill
32839 The functions @code{math-add}, @code{math-sub}, @code{math-mul},
32840 @code{math-div}, @code{math-mod}, and @code{math-neg} are not included
32841 in this list, since @code{defmath} allows you to write native Lisp
32842 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
32843 respectively, instead.@refill
32845 @defun normalize val
32846 (Full form: @code{math-normalize}.)
32847 Reduce the value @var{val} to standard form.  For example, if @var{val}
32848 is a fixnum, it will be converted to a bignum if it is too large, and
32849 if @var{val} is a bignum it will be normalized by clipping off trailing
32850 (i.e., most-significant) zero digits and converting to a fixnum if it is
32851 small.  All the various data types are similarly converted to their standard
32852 forms.  Variables are left alone, but function calls are actually evaluated
32853 in formulas.  For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
32854 return 6.@refill
32856 If a function call fails, because the function is void or has the wrong
32857 number of parameters, or because it returns @code{nil} or calls
32858 @code{reject-arg} or @code{inexact-result}, @code{normalize} returns
32859 the formula still in symbolic form.@refill
32861 If the current Simplification Mode is ``none'' or ``numeric arguments
32862 only,'' @code{normalize} will act appropriately.  However, the more
32863 powerful simplification modes (like algebraic simplification) are
32864 not handled by @code{normalize}.  They are handled by @code{calc-normalize},
32865 which calls @code{normalize} and possibly some other routines, such
32866 as @code{simplify} or @code{simplify-units}.  Programs generally will
32867 never call @code{calc-normalize} except when popping or pushing values
32868 on the stack.@refill
32869 @end defun
32871 @defun evaluate-expr expr
32872 Replace all variables in @var{expr} that have values with their values,
32873 then use @code{normalize} to simplify the result.  This is what happens
32874 when you press the @kbd{=} key interactively.@refill
32875 @end defun
32877 @defmac with-extra-prec n body
32878 Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
32879 digits.  This is a macro which expands to
32881 @smallexample
32882 (math-normalize
32883   (let ((calc-internal-prec (+ calc-internal-prec @var{n})))
32884     @var{body}))
32885 @end smallexample
32887 The surrounding call to @code{math-normalize} causes a floating-point
32888 result to be rounded down to the original precision afterwards.  This
32889 is important because some arithmetic operations assume a number's
32890 mantissa contains no more digits than the current precision allows.
32891 @end defmac
32893 @defun make-frac n d
32894 Build a fraction @samp{@var{n}:@var{d}}.  This is equivalent to calling
32895 @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
32896 @end defun
32898 @defun make-float mant exp
32899 Build a floating-point value out of @var{mant} and @var{exp}, both
32900 of which are arbitrary integers.  This function will return a
32901 properly normalized float value, or signal an overflow or underflow
32902 if @var{exp} is out of range.
32903 @end defun
32905 @defun make-sdev x sigma
32906 Build an error form out of @var{x} and the absolute value of @var{sigma}.
32907 If @var{sigma} is zero, the result is the number @var{x} directly.
32908 If @var{sigma} is negative or complex, its absolute value is used.
32909 If @var{x} or @var{sigma} is not a valid type of object for use in
32910 error forms, this calls @code{reject-arg}.
32911 @end defun
32913 @defun make-intv mask lo hi
32914 Build an interval form out of @var{mask} (which is assumed to be an
32915 integer from 0 to 3), and the limits @var{lo} and @var{hi}.  If
32916 @var{lo} is greater than @var{hi}, an empty interval form is returned.
32917 This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
32918 @end defun
32920 @defun sort-intv mask lo hi
32921 Build an interval form, similar to @code{make-intv}, except that if
32922 @var{lo} is less than @var{hi} they are simply exchanged, and the
32923 bits of @var{mask} are swapped accordingly.
32924 @end defun
32926 @defun make-mod n m
32927 Build a modulo form out of @var{n} and the modulus @var{m}.  Since modulo
32928 forms do not allow formulas as their components, if @var{n} or @var{m}
32929 is not a real number or HMS form the result will be a formula which
32930 is a call to @code{makemod}, the algebraic version of this function.
32931 @end defun
32933 @defun float x
32934 Convert @var{x} to floating-point form.  Integers and fractions are
32935 converted to numerically equivalent floats; components of complex
32936 numbers, vectors, HMS forms, date forms, error forms, intervals, and
32937 modulo forms are recursively floated.  If the argument is a variable
32938 or formula, this calls @code{reject-arg}.
32939 @end defun
32941 @defun compare x y
32942 Compare the numbers @var{x} and @var{y}, and return @i{-1} if
32943 @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
32944 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
32945 undefined or cannot be determined.@refill
32946 @end defun
32948 @defun numdigs n
32949 Return the number of digits of integer @var{n}, effectively
32950 @samp{ceil(log10(@var{n}))}, but much more efficient.  Zero is
32951 considered to have zero digits.
32952 @end defun
32954 @defun scale-int x n
32955 Shift integer @var{x} left @var{n} decimal digits, or right @i{-@var{n}}
32956 digits with truncation toward zero.
32957 @end defun
32959 @defun scale-rounding x n
32960 Like @code{scale-int}, except that a right shift rounds to the nearest
32961 integer rather than truncating.
32962 @end defun
32964 @defun fixnum n
32965 Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
32966 If @var{n} is outside the permissible range for Lisp integers (usually
32967 24 binary bits) the result is undefined.
32968 @end defun
32970 @defun sqr x
32971 Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
32972 @end defun
32974 @defun quotient x y
32975 Divide integer @var{x} by integer @var{y}; return an integer quotient
32976 and discard the remainder.  If @var{x} or @var{y} is negative, the
32977 direction of rounding is undefined.
32978 @end defun
32980 @defun idiv x y
32981 Perform an integer division; if @var{x} and @var{y} are both nonnegative
32982 integers, this uses the @code{quotient} function, otherwise it computes
32983 @samp{floor(@var{x}/@var{y})}.  Thus the result is well-defined but
32984 slower than for @code{quotient}.
32985 @end defun
32987 @defun imod x y
32988 Divide integer @var{x} by integer @var{y}; return the integer remainder
32989 and discard the quotient.  Like @code{quotient}, this works only for
32990 integer arguments and is not well-defined for negative arguments.
32991 For a more well-defined result, use @samp{(% @var{x} @var{y})}.
32992 @end defun
32994 @defun idivmod x y
32995 Divide integer @var{x} by integer @var{y}; return a cons cell whose
32996 @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
32997 is @samp{(imod @var{x} @var{y})}.@refill
32998 @end defun
33000 @defun pow x y
33001 Compute @var{x} to the power @var{y}.  In @code{defmath} code, this can
33002 also be written @samp{(^ @var{x} @var{y})} or
33003 @w{@samp{(expt @var{x} @var{y})}}.@refill
33004 @end defun
33006 @defun abs-approx x
33007 Compute a fast approximation to the absolute value of @var{x}.  For
33008 example, for a rectangular complex number the result is the sum of
33009 the absolute values of the components.
33010 @end defun
33012 @findex two-pi
33013 @findex pi-over-2
33014 @findex pi-over-4
33015 @findex pi-over-180
33016 @findex sqrt-two-pi
33017 @findex sqrt-e
33018 @findex e
33019 @findex ln-2
33020 @findex ln-10
33021 @defun pi
33022 The function @samp{(pi)} computes @samp{pi} to the current precision.
33023 Other related constant-generating functions are @code{two-pi},
33024 @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
33025 @code{e}, @code{sqrt-e}, @code{ln-2}, and @code{ln-10}.  Each function
33026 returns a floating-point value in the current precision, and each uses
33027 caching so that all calls after the first are essentially free.@refill
33028 @end defun
33030 @defmac math-defcache @var{func} @var{initial} @var{form}
33031 This macro, usually used as a top-level call like @code{defun} or
33032 @code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
33033 It defines a function @code{func} which returns the requested value;
33034 if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
33035 form which serves as an initial value for the cache.  If @var{func}
33036 is called when the cache is empty or does not have enough digits to
33037 satisfy the current precision, the Lisp expression @var{form} is evaluated
33038 with the current precision increased by four, and the result minus its
33039 two least significant digits is stored in the cache.  For example,
33040 calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
33041 digits, rounds it down to 32 digits for future use, then rounds it
33042 again to 30 digits for use in the present request.@refill
33043 @end defmac
33045 @findex half-circle
33046 @findex quarter-circle
33047 @defun full-circle symb
33048 If the current angular mode is Degrees or HMS, this function returns the
33049 integer 360.  In Radians mode, this function returns either the
33050 corresponding value in radians to the current precision, or the formula
33051 @samp{2*pi}, depending on the Symbolic Mode.  There are also similar
33052 function @code{half-circle} and @code{quarter-circle}.
33053 @end defun
33055 @defun power-of-2 n
33056 Compute two to the integer power @var{n}, as a (potentially very large)
33057 integer.  Powers of two are cached, so only the first call for a
33058 particular @var{n} is expensive.
33059 @end defun
33061 @defun integer-log2 n
33062 Compute the base-2 logarithm of @var{n}, which must be an integer which
33063 is a power of two.  If @var{n} is not a power of two, this function will
33064 return @code{nil}.
33065 @end defun
33067 @defun div-mod a b m
33068 Divide @var{a} by @var{b}, modulo @var{m}.  This returns @code{nil} if
33069 there is no solution, or if any of the arguments are not integers.@refill
33070 @end defun
33072 @defun pow-mod a b m
33073 Compute @var{a} to the power @var{b}, modulo @var{m}.  If @var{a},
33074 @var{b}, and @var{m} are integers, this uses an especially efficient
33075 algorithm.  Otherwise, it simply computes @samp{(% (^ a b) m)}.
33076 @end defun
33078 @defun isqrt n
33079 Compute the integer square root of @var{n}.  This is the square root
33080 of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
33081 If @var{n} is itself an integer, the computation is especially efficient.
33082 @end defun
33084 @defun to-hms a ang
33085 Convert the argument @var{a} into an HMS form.  If @var{ang} is specified,
33086 it is the angular mode in which to interpret @var{a}, either @code{deg}
33087 or @code{rad}.  Otherwise, the current angular mode is used.  If @var{a}
33088 is already an HMS form it is returned as-is.
33089 @end defun
33091 @defun from-hms a ang
33092 Convert the HMS form @var{a} into a real number.  If @var{ang} is specified,
33093 it is the angular mode in which to express the result, otherwise the
33094 current angular mode is used.  If @var{a} is already a real number, it
33095 is returned as-is.
33096 @end defun
33098 @defun to-radians a
33099 Convert the number or HMS form @var{a} to radians from the current
33100 angular mode.
33101 @end defun
33103 @defun from-radians a
33104 Convert the number @var{a} from radians to the current angular mode.
33105 If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
33106 @end defun
33108 @defun to-radians-2 a
33109 Like @code{to-radians}, except that in Symbolic Mode a degrees to
33110 radians conversion yields a formula like @samp{@var{a}*pi/180}.
33111 @end defun
33113 @defun from-radians-2 a
33114 Like @code{from-radians}, except that in Symbolic Mode a radians to
33115 degrees conversion yields a formula like @samp{@var{a}*180/pi}.
33116 @end defun
33118 @defun random-digit
33119 Produce a random base-1000 digit in the range 0 to 999.
33120 @end defun
33122 @defun random-digits n
33123 Produce a random @var{n}-digit integer; this will be an integer
33124 in the interval @samp{[0, 10^@var{n})}.
33125 @end defun
33127 @defun random-float
33128 Produce a random float in the interval @samp{[0, 1)}.
33129 @end defun
33131 @defun prime-test n iters
33132 Determine whether the integer @var{n} is prime.  Return a list which has
33133 one of these forms: @samp{(nil @var{f})} means the number is non-prime
33134 because it was found to be divisible by @var{f}; @samp{(nil)} means it
33135 was found to be non-prime by table look-up (so no factors are known);
33136 @samp{(nil unknown)} means it is definitely non-prime but no factors
33137 are known because @var{n} was large enough that Fermat's probabilistic
33138 test had to be used; @samp{(t)} means the number is definitely prime;
33139 and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
33140 iterations, is @var{p} percent sure that the number is prime.  The
33141 @var{iters} parameter is the number of Fermat iterations to use, in the
33142 case that this is necessary.  If @code{prime-test} returns ``maybe,''
33143 you can call it again with the same @var{n} to get a greater certainty;
33144 @code{prime-test} remembers where it left off.@refill
33145 @end defun
33147 @defun to-simple-fraction f
33148 If @var{f} is a floating-point number which can be represented exactly
33149 as a small rational number. return that number, else return @var{f}.
33150 For example, 0.75 would be converted to 3:4.  This function is very
33151 fast.
33152 @end defun
33154 @defun to-fraction f tol
33155 Find a rational approximation to floating-point number @var{f} to within
33156 a specified tolerance @var{tol}; this corresponds to the algebraic
33157 function @code{frac}, and can be rather slow.
33158 @end defun
33160 @defun quarter-integer n
33161 If @var{n} is an integer or integer-valued float, this function
33162 returns zero.  If @var{n} is a half-integer (i.e., an integer plus
33163 @i{1:2} or 0.5), it returns 2.  If @var{n} is a quarter-integer,
33164 it returns 1 or 3.  If @var{n} is anything else, this function
33165 returns @code{nil}.
33166 @end defun
33168 @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
33169 @subsubsection Vector Functions
33171 @noindent
33172 The functions described here perform various operations on vectors and
33173 matrices.
33175 @defun math-concat x y
33176 Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
33177 in a symbolic formula.  @xref{Building Vectors}.
33178 @end defun
33180 @defun vec-length v
33181 Return the length of vector @var{v}.  If @var{v} is not a vector, the
33182 result is zero.  If @var{v} is a matrix, this returns the number of
33183 rows in the matrix.
33184 @end defun
33186 @defun mat-dimens m
33187 Determine the dimensions of vector or matrix @var{m}.  If @var{m} is not
33188 a vector, the result is an empty list.  If @var{m} is a plain vector
33189 but not a matrix, the result is a one-element list containing the length
33190 of the vector.  If @var{m} is a matrix with @var{r} rows and @var{c} columns,
33191 the result is the list @samp{(@var{r} @var{c})}.  Higher-order tensors
33192 produce lists of more than two dimensions.  Note that the object
33193 @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
33194 and is treated by this and other Calc routines as a plain vector of two
33195 elements.@refill
33196 @end defun
33198 @defun dimension-error
33199 Abort the current function with a message of ``Dimension error.''
33200 The Calculator will leave the function being evaluated in symbolic
33201 form; this is really just a special case of @code{reject-arg}.
33202 @end defun
33204 @defun build-vector args
33205 Return a Calc vector with @var{args} as elements.
33206 For example, @samp{(build-vector 1 2 3)} returns the Calc vector
33207 @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
33208 @end defun
33210 @defun make-vec obj dims
33211 Return a Calc vector or matrix all of whose elements are equal to
33212 @var{obj}.  For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
33213 filled with 27's.
33214 @end defun
33216 @defun row-matrix v
33217 If @var{v} is a plain vector, convert it into a row matrix, i.e.,
33218 a matrix whose single row is @var{v}.  If @var{v} is already a matrix,
33219 leave it alone.
33220 @end defun
33222 @defun col-matrix v
33223 If @var{v} is a plain vector, convert it into a column matrix, i.e., a
33224 matrix with each element of @var{v} as a separate row.  If @var{v} is
33225 already a matrix, leave it alone.
33226 @end defun
33228 @defun map-vec f v
33229 Map the Lisp function @var{f} over the Calc vector @var{v}.  For example,
33230 @samp{(map-vec 'math-floor v)} returns a vector of the floored components
33231 of vector @var{v}.
33232 @end defun
33234 @defun map-vec-2 f a b
33235 Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
33236 If @var{a} and @var{b} are vectors of equal length, the result is a
33237 vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
33238 for each pair of elements @var{ai} and @var{bi}.  If either @var{a} or
33239 @var{b} is a scalar, it is matched with each value of the other vector.
33240 For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
33241 with each element increased by one.  Note that using @samp{'+} would not
33242 work here, since @code{defmath} does not expand function names everywhere,
33243 just where they are in the function position of a Lisp expression.@refill
33244 @end defun
33246 @defun reduce-vec f v
33247 Reduce the function @var{f} over the vector @var{v}.  For example, if
33248 @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
33249 If @var{v} is a matrix, this reduces over the rows of @var{v}.
33250 @end defun
33252 @defun reduce-cols f m
33253 Reduce the function @var{f} over the columns of matrix @var{m}.  For
33254 example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
33255 is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
33256 @end defun
33258 @defun mat-row m n
33259 Return the @var{n}th row of matrix @var{m}.  This is equivalent to
33260 @samp{(elt m n)}.  For a slower but safer version, use @code{mrow}.
33261 (@xref{Extracting Elements}.)
33262 @end defun
33264 @defun mat-col m n
33265 Return the @var{n}th column of matrix @var{m}, in the form of a vector.
33266 The arguments are not checked for correctness.
33267 @end defun
33269 @defun mat-less-row m n
33270 Return a copy of matrix @var{m} with its @var{n}th row deleted.  The
33271 number @var{n} must be in range from 1 to the number of rows in @var{m}.
33272 @end defun
33274 @defun mat-less-col m n
33275 Return a copy of matrix @var{m} with its @var{n}th column deleted.
33276 @end defun
33278 @defun transpose m
33279 Return the transpose of matrix @var{m}.
33280 @end defun
33282 @defun flatten-vector v
33283 Flatten nested vector @var{v} into a vector of scalars.  For example,
33284 if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
33285 @end defun
33287 @defun copy-matrix m
33288 If @var{m} is a matrix, return a copy of @var{m}.  This maps
33289 @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
33290 element of the result matrix will be @code{eq} to the corresponding
33291 element of @var{m}, but none of the @code{cons} cells that make up
33292 the structure of the matrix will be @code{eq}.  If @var{m} is a plain
33293 vector, this is the same as @code{copy-sequence}.@refill
33294 @end defun
33296 @defun swap-rows m r1 r2
33297 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place.  In
33298 other words, unlike most of the other functions described here, this
33299 function changes @var{m} itself rather than building up a new result
33300 matrix.  The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
33301 is true, with the side effect of exchanging the first two rows of
33302 @var{m}.@refill
33303 @end defun
33305 @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
33306 @subsubsection Symbolic Functions
33308 @noindent
33309 The functions described here operate on symbolic formulas in the
33310 Calculator.
33312 @defun calc-prepare-selection num
33313 Prepare a stack entry for selection operations.  If @var{num} is
33314 omitted, the stack entry containing the cursor is used; otherwise,
33315 it is the number of the stack entry to use.  This function stores
33316 useful information about the current stack entry into a set of
33317 variables.  @code{calc-selection-cache-num} contains the number of
33318 the stack entry involved (equal to @var{num} if you specified it);
33319 @code{calc-selection-cache-entry} contains the stack entry as a
33320 list (such as @code{calc-top-list} would return with @code{entry}
33321 as the selection mode); and @code{calc-selection-cache-comp} contains
33322 a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
33323 which allows Calc to relate cursor positions in the buffer with
33324 their corresponding sub-formulas.
33326 A slight complication arises in the selection mechanism because
33327 formulas may contain small integers.  For example, in the vector
33328 @samp{[1, 2, 1]} the first and last elements are @code{eq} to each
33329 other; selections are recorded as the actual Lisp object that
33330 appears somewhere in the tree of the whole formula, but storing
33331 @code{1} would falsely select both @code{1}'s in the vector.  So
33332 @code{calc-prepare-selection} also checks the stack entry and
33333 replaces any plain integers with ``complex number'' lists of the form
33334 @samp{(cplx @var{n} 0)}.  This list will be displayed the same as a
33335 plain @var{n} and the change will be completely invisible to the
33336 user, but it will guarantee that no two sub-formulas of the stack
33337 entry will be @code{eq} to each other.  Next time the stack entry
33338 is involved in a computation, @code{calc-normalize} will replace
33339 these lists with plain numbers again, again invisibly to the user.
33340 @end defun
33342 @defun calc-encase-atoms x
33343 This modifies the formula @var{x} to ensure that each part of the
33344 formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
33345 described above.  This function may use @code{setcar} to modify
33346 the formula in-place.
33347 @end defun
33349 @defun calc-find-selected-part
33350 Find the smallest sub-formula of the current formula that contains
33351 the cursor.  This assumes @code{calc-prepare-selection} has been
33352 called already.  If the cursor is not actually on any part of the
33353 formula, this returns @code{nil}.
33354 @end defun
33356 @defun calc-change-current-selection selection
33357 Change the currently prepared stack element's selection to
33358 @var{selection}, which should be @code{eq} to some sub-formula
33359 of the stack element, or @code{nil} to unselect the formula.
33360 The stack element's appearance in the Calc buffer is adjusted
33361 to reflect the new selection.
33362 @end defun
33364 @defun calc-find-nth-part expr n
33365 Return the @var{n}th sub-formula of @var{expr}.  This function is used
33366 by the selection commands, and (unless @kbd{j b} has been used) treats
33367 sums and products as flat many-element formulas.  Thus if @var{expr}
33368 is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
33369 @var{n} equal to four will return @samp{d}.
33370 @end defun
33372 @defun calc-find-parent-formula expr part
33373 Return the sub-formula of @var{expr} which immediately contains
33374 @var{part}.  If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
33375 is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
33376 will return @samp{(c+1)*d}.  If @var{part} turns out not to be a
33377 sub-formula of @var{expr}, the function returns @code{nil}.  If
33378 @var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
33379 This function does not take associativity into account.
33380 @end defun
33382 @defun calc-find-assoc-parent-formula expr part
33383 This is the same as @code{calc-find-parent-formula}, except that
33384 (unless @kbd{j b} has been used) it continues widening the selection
33385 to contain a complete level of the formula.  Given @samp{a} from
33386 @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
33387 return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
33388 return the whole expression.
33389 @end defun
33391 @defun calc-grow-assoc-formula expr part
33392 This expands sub-formula @var{part} of @var{expr} to encompass a
33393 complete level of the formula.  If @var{part} and its immediate
33394 parent are not compatible associative operators, or if @kbd{j b}
33395 has been used, this simply returns @var{part}.
33396 @end defun
33398 @defun calc-find-sub-formula expr part
33399 This finds the immediate sub-formula of @var{expr} which contains
33400 @var{part}.  It returns an index @var{n} such that
33401 @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
33402 If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
33403 If @var{part} is @code{eq} to @var{expr}, it returns @code{t}.  This
33404 function does not take associativity into account.
33405 @end defun
33407 @defun calc-replace-sub-formula expr old new
33408 This function returns a copy of formula @var{expr}, with the
33409 sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
33410 @end defun
33412 @defun simplify expr
33413 Simplify the expression @var{expr} by applying various algebraic rules.
33414 This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses.  This
33415 always returns a copy of the expression; the structure @var{expr} points
33416 to remains unchanged in memory.
33418 More precisely, here is what @code{simplify} does:  The expression is
33419 first normalized and evaluated by calling @code{normalize}.  If any
33420 @code{AlgSimpRules} have been defined, they are then applied.  Then
33421 the expression is traversed in a depth-first, bottom-up fashion; at
33422 each level, any simplifications that can be made are made until no
33423 further changes are possible.  Once the entire formula has been
33424 traversed in this way, it is compared with the original formula (from
33425 before the call to @code{normalize}) and, if it has changed,
33426 the entire procedure is repeated (starting with @code{normalize})
33427 until no further changes occur.  Usually only two iterations are
33428 needed:@: one to simplify the formula, and another to verify that no
33429 further simplifications were possible.
33430 @end defun
33432 @defun simplify-extended expr
33433 Simplify the expression @var{expr}, with additional rules enabled that
33434 help do a more thorough job, while not being entirely ``safe'' in all
33435 circumstances.  (For example, this mode will simplify @samp{sqrt(x^2)}
33436 to @samp{x}, which is only valid when @var{x} is positive.)  This is
33437 implemented by temporarily binding the variable @code{math-living-dangerously}
33438 to @code{t} (using a @code{let} form) and calling @code{simplify}.
33439 Dangerous simplification rules are written to check this variable
33440 before taking any action.@refill
33441 @end defun
33443 @defun simplify-units expr
33444 Simplify the expression @var{expr}, treating variable names as units
33445 whenever possible.  This works by binding the variable
33446 @code{math-simplifying-units} to @code{t} while calling @code{simplify}.
33447 @end defun
33449 @defmac math-defsimplify funcs body
33450 Register a new simplification rule; this is normally called as a top-level
33451 form, like @code{defun} or @code{defmath}.  If @var{funcs} is a symbol
33452 (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
33453 applied to the formulas which are calls to the specified function.  Or,
33454 @var{funcs} can be a list of such symbols; the rule applies to all
33455 functions on the list.  The @var{body} is written like the body of a
33456 function with a single argument called @code{expr}.  The body will be
33457 executed with @code{expr} bound to a formula which is a call to one of
33458 the functions @var{funcs}.  If the function body returns @code{nil}, or
33459 if it returns a result @code{equal} to the original @code{expr}, it is
33460 ignored and Calc goes on to try the next simplification rule that applies.
33461 If the function body returns something different, that new formula is
33462 substituted for @var{expr} in the original formula.@refill
33464 At each point in the formula, rules are tried in the order of the
33465 original calls to @code{math-defsimplify}; the search stops after the
33466 first rule that makes a change.  Thus later rules for that same
33467 function will not have a chance to trigger until the next iteration
33468 of the main @code{simplify} loop.
33470 Note that, since @code{defmath} is not being used here, @var{body} must
33471 be written in true Lisp code without the conveniences that @code{defmath}
33472 provides.  If you prefer, you can have @var{body} simply call another
33473 function (defined with @code{defmath}) which does the real work.
33475 The arguments of a function call will already have been simplified
33476 before any rules for the call itself are invoked.  Since a new argument
33477 list is consed up when this happens, this means that the rule's body is
33478 allowed to rearrange the function's arguments destructively if that is
33479 convenient.  Here is a typical example of a simplification rule:
33481 @smallexample
33482 (math-defsimplify calcFunc-arcsinh
33483   (or (and (math-looks-negp (nth 1 expr))
33484            (math-neg (list 'calcFunc-arcsinh
33485                            (math-neg (nth 1 expr)))))
33486       (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
33487            (or math-living-dangerously
33488                (math-known-realp (nth 1 (nth 1 expr))))
33489            (nth 1 (nth 1 expr)))))
33490 @end smallexample
33492 This is really a pair of rules written with one @code{math-defsimplify}
33493 for convenience; the first replaces @samp{arcsinh(-x)} with
33494 @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
33495 replaces @samp{arcsinh(sinh(x))} with @samp{x}.@refill
33496 @end defmac
33498 @defun common-constant-factor expr
33499 Check @var{expr} to see if it is a sum of terms all multiplied by the
33500 same rational value.  If so, return this value.  If not, return @code{nil}.
33501 For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
33502 3 is a common factor of all the terms.
33503 @end defun
33505 @defun cancel-common-factor expr factor
33506 Assuming @var{expr} is a sum with @var{factor} as a common factor,
33507 divide each term of the sum by @var{factor}.  This is done by
33508 destructively modifying parts of @var{expr}, on the assumption that
33509 it is being used by a simplification rule (where such things are
33510 allowed; see above).  For example, consider this built-in rule for
33511 square roots:
33513 @smallexample
33514 (math-defsimplify calcFunc-sqrt
33515   (let ((fac (math-common-constant-factor (nth 1 expr))))
33516     (and fac (not (eq fac 1))
33517          (math-mul (math-normalize (list 'calcFunc-sqrt fac))
33518                    (math-normalize
33519                     (list 'calcFunc-sqrt
33520                           (math-cancel-common-factor
33521                            (nth 1 expr) fac)))))))
33522 @end smallexample
33523 @end defun
33525 @defun frac-gcd a b
33526 Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
33527 rational numbers.  This is the fraction composed of the GCD of the
33528 numerators of @var{a} and @var{b}, over the GCD of the denominators.
33529 It is used by @code{common-constant-factor}.  Note that the standard
33530 @code{gcd} function uses the LCM to combine the denominators.@refill
33531 @end defun
33533 @defun map-tree func expr many
33534 Try applying Lisp function @var{func} to various sub-expressions of
33535 @var{expr}.  Initially, call @var{func} with @var{expr} itself as an
33536 argument.  If this returns an expression which is not @code{equal} to
33537 @var{expr}, apply @var{func} again until eventually it does return
33538 @var{expr} with no changes.  Then, if @var{expr} is a function call,
33539 recursively apply @var{func} to each of the arguments.  This keeps going
33540 until no changes occur anywhere in the expression; this final expression
33541 is returned by @code{map-tree}.  Note that, unlike simplification rules,
33542 @var{func} functions may @emph{not} make destructive changes to
33543 @var{expr}.  If a third argument @var{many} is provided, it is an
33544 integer which says how many times @var{func} may be applied; the
33545 default, as described above, is infinitely many times.@refill
33546 @end defun
33548 @defun compile-rewrites rules
33549 Compile the rewrite rule set specified by @var{rules}, which should
33550 be a formula that is either a vector or a variable name.  If the latter,
33551 the compiled rules are saved so that later @code{compile-rules} calls
33552 for that same variable can return immediately.  If there are problems
33553 with the rules, this function calls @code{error} with a suitable
33554 message.
33555 @end defun
33557 @defun apply-rewrites expr crules heads
33558 Apply the compiled rewrite rule set @var{crules} to the expression
33559 @var{expr}.  This will make only one rewrite and only checks at the
33560 top level of the expression.  The result @code{nil} if no rules
33561 matched, or if the only rules that matched did not actually change
33562 the expression.  The @var{heads} argument is optional; if is given,
33563 it should be a list of all function names that (may) appear in
33564 @var{expr}.  The rewrite compiler tags each rule with the
33565 rarest-looking function name in the rule; if you specify @var{heads},
33566 @code{apply-rewrites} can use this information to narrow its search
33567 down to just a few rules in the rule set.
33568 @end defun
33570 @defun rewrite-heads expr
33571 Compute a @var{heads} list for @var{expr} suitable for use with
33572 @code{apply-rewrites}, as discussed above.
33573 @end defun
33575 @defun rewrite expr rules many
33576 This is an all-in-one rewrite function.  It compiles the rule set
33577 specified by @var{rules}, then uses @code{map-tree} to apply the
33578 rules throughout @var{expr} up to @var{many} (default infinity)
33579 times.
33580 @end defun
33582 @defun match-patterns pat vec not-flag
33583 Given a Calc vector @var{vec} and an uncompiled pattern set or
33584 pattern set variable @var{pat}, this function returns a new vector
33585 of all elements of @var{vec} which do (or don't, if @var{not-flag} is
33586 non-@code{nil}) match any of the patterns in @var{pat}.
33587 @end defun
33589 @defun deriv expr var value symb
33590 Compute the derivative of @var{expr} with respect to variable @var{var}
33591 (which may actually be any sub-expression).  If @var{value} is specified,
33592 the derivative is evaluated at the value of @var{var}; otherwise, the
33593 derivative is left in terms of @var{var}.  If the expression contains
33594 functions for which no derivative formula is known, new derivative
33595 functions are invented by adding primes to the names; @pxref{Calculus}.
33596 However, if @var{symb} is non-@code{nil}, the presence of undifferentiable
33597 functions in @var{expr} instead cancels the whole differentiation, and
33598 @code{deriv} returns @code{nil} instead.
33600 Derivatives of an @var{n}-argument function can be defined by
33601 adding a @code{math-derivative-@var{n}} property to the property list
33602 of the symbol for the function's derivative, which will be the
33603 function name followed by an apostrophe.  The value of the property
33604 should be a Lisp function; it is called with the same arguments as the
33605 original function call that is being differentiated.  It should return
33606 a formula for the derivative.  For example, the derivative of @code{ln}
33607 is defined by
33609 @smallexample
33610 (put 'calcFunc-ln\' 'math-derivative-1
33611      (function (lambda (u) (math-div 1 u))))
33612 @end smallexample
33614 The two-argument @code{log} function has two derivatives,
33615 @smallexample
33616 (put 'calcFunc-log\' 'math-derivative-2     ; d(log(x,b)) / dx
33617      (function (lambda (x b) ... )))
33618 (put 'calcFunc-log\'2 'math-derivative-2    ; d(log(x,b)) / db
33619      (function (lambda (x b) ... )))
33620 @end smallexample
33621 @end defun
33623 @defun tderiv expr var value symb
33624 Compute the total derivative of @var{expr}.  This is the same as
33625 @code{deriv}, except that variables other than @var{var} are not
33626 assumed to be constant with respect to @var{var}.
33627 @end defun
33629 @defun integ expr var low high
33630 Compute the integral of @var{expr} with respect to @var{var}.
33631 @xref{Calculus}, for further details.
33632 @end defun
33634 @defmac math-defintegral funcs body
33635 Define a rule for integrating a function or functions of one argument;
33636 this macro is very similar in format to @code{math-defsimplify}.
33637 The main difference is that here @var{body} is the body of a function
33638 with a single argument @code{u} which is bound to the argument to the
33639 function being integrated, not the function call itself.  Also, the
33640 variable of integration is available as @code{math-integ-var}.  If
33641 evaluation of the integral requires doing further integrals, the body
33642 should call @samp{(math-integral @var{x})} to find the integral of
33643 @var{x} with respect to @code{math-integ-var}; this function returns
33644 @code{nil} if the integral could not be done.  Some examples:
33646 @smallexample
33647 (math-defintegral calcFunc-conj
33648   (let ((int (math-integral u)))
33649     (and int
33650          (list 'calcFunc-conj int))))
33652 (math-defintegral calcFunc-cos
33653   (and (equal u math-integ-var)
33654        (math-from-radians-2 (list 'calcFunc-sin u))))
33655 @end smallexample
33657 In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
33658 relying on the general integration-by-substitution facility to handle
33659 cosines of more complicated arguments.  An integration rule should return
33660 @code{nil} if it can't do the integral; if several rules are defined for
33661 the same function, they are tried in order until one returns a non-@code{nil}
33662 result.@refill
33663 @end defmac
33665 @defmac math-defintegral-2 funcs body
33666 Define a rule for integrating a function or functions of two arguments.
33667 This is exactly analogous to @code{math-defintegral}, except that @var{body}
33668 is written as the body of a function with two arguments, @var{u} and
33669 @var{v}.@refill
33670 @end defmac
33672 @defun solve-for lhs rhs var full
33673 Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
33674 the variable @var{var} on the lefthand side; return the resulting righthand
33675 side, or @code{nil} if the equation cannot be solved.  The variable
33676 @var{var} must appear at least once in @var{lhs} or @var{rhs}.  Note that
33677 the return value is a formula which does not contain @var{var}; this is
33678 different from the user-level @code{solve} and @code{finv} functions,
33679 which return a rearranged equation or a functional inverse, respectively.
33680 If @var{full} is non-@code{nil}, a full solution including dummy signs
33681 and dummy integers will be produced.  User-defined inverses are provided
33682 as properties in a manner similar to derivatives:@refill
33684 @smallexample
33685 (put 'calcFunc-ln 'math-inverse
33686      (function (lambda (x) (list 'calcFunc-exp x))))
33687 @end smallexample
33689 This function can call @samp{(math-solve-get-sign @var{x})} to create
33690 a new arbitrary sign variable, returning @var{x} times that sign, and
33691 @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
33692 variable multiplied by @var{x}.  These functions simply return @var{x}
33693 if the caller requested a non-``full'' solution.
33694 @end defun
33696 @defun solve-eqn expr var full
33697 This version of @code{solve-for} takes an expression which will
33698 typically be an equation or inequality.  (If it is not, it will be
33699 interpreted as the equation @samp{@var{expr} = 0}.)  It returns an
33700 equation or inequality, or @code{nil} if no solution could be found.
33701 @end defun
33703 @defun solve-system exprs vars full
33704 This function solves a system of equations.  Generally, @var{exprs}
33705 and @var{vars} will be vectors of equal length.
33706 @xref{Solving Systems of Equations}, for other options.
33707 @end defun
33709 @defun expr-contains expr var
33710 Returns a non-@code{nil} value if @var{var} occurs as a subexpression
33711 of @var{expr}.
33713 This function might seem at first to be identical to
33714 @code{calc-find-sub-formula}.  The key difference is that
33715 @code{expr-contains} uses @code{equal} to test for matches, whereas
33716 @code{calc-find-sub-formula} uses @code{eq}.  In the formula
33717 @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
33718 @code{eq} to each other.@refill
33719 @end defun
33721 @defun expr-contains-count expr var
33722 Returns the number of occurrences of @var{var} as a subexpression
33723 of @var{expr}, or @code{nil} if there are no occurrences.@refill
33724 @end defun
33726 @defun expr-depends expr var
33727 Returns true if @var{expr} refers to any variable the occurs in @var{var}.
33728 In other words, it checks if @var{expr} and @var{var} have any variables
33729 in common.
33730 @end defun
33732 @defun expr-contains-vars expr
33733 Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
33734 contains only constants and functions with constant arguments.
33735 @end defun
33737 @defun expr-subst expr old new
33738 Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
33739 by @var{new}.  This treats @code{lambda} forms specially with respect
33740 to the dummy argument variables, so that the effect is always to return
33741 @var{expr} evaluated at @var{old} = @var{new}.@refill
33742 @end defun
33744 @defun multi-subst expr old new
33745 This is like @code{expr-subst}, except that @var{old} and @var{new}
33746 are lists of expressions to be substituted simultaneously.  If one
33747 list is shorter than the other, trailing elements of the longer list
33748 are ignored.
33749 @end defun
33751 @defun expr-weight expr
33752 Returns the ``weight'' of @var{expr}, basically a count of the total
33753 number of objects and function calls that appear in @var{expr}.  For
33754 ``primitive'' objects, this will be one.
33755 @end defun
33757 @defun expr-height expr
33758 Returns the ``height'' of @var{expr}, which is the deepest level to
33759 which function calls are nested.  (Note that @samp{@var{a} + @var{b}}
33760 counts as a function call.)  For primitive objects, this returns zero.@refill
33761 @end defun
33763 @defun polynomial-p expr var
33764 Check if @var{expr} is a polynomial in variable (or sub-expression)
33765 @var{var}.  If so, return the degree of the polynomial, that is, the
33766 highest power of @var{var} that appears in @var{expr}.  For example,
33767 for @samp{(x^2 + 3)^3 + 4} this would return 6.  This function returns
33768 @code{nil} unless @var{expr}, when expanded out by @kbd{a x}
33769 (@code{calc-expand}), would consist of a sum of terms in which @var{var}
33770 appears only raised to nonnegative integer powers.  Note that if
33771 @var{var} does not occur in @var{expr}, then @var{expr} is considered
33772 a polynomial of degree 0.@refill
33773 @end defun
33775 @defun is-polynomial expr var degree loose
33776 Check if @var{expr} is a polynomial in variable or sub-expression
33777 @var{var}, and, if so, return a list representation of the polynomial
33778 where the elements of the list are coefficients of successive powers of
33779 @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
33780 list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
33781 produce the list @samp{(1 2 1)}.  The highest element of the list will
33782 be non-zero, with the special exception that if @var{expr} is the
33783 constant zero, the returned value will be @samp{(0)}.  Return @code{nil}
33784 if @var{expr} is not a polynomial in @var{var}.  If @var{degree} is
33785 specified, this will not consider polynomials of degree higher than that
33786 value.  This is a good precaution because otherwise an input of
33787 @samp{(x+1)^1000} will cause a huge coefficient list to be built.  If
33788 @var{loose} is non-@code{nil}, then a looser definition of a polynomial
33789 is used in which coefficients are no longer required not to depend on
33790 @var{var}, but are only required not to take the form of polynomials
33791 themselves.  For example, @samp{sin(x) x^2 + cos(x)} is a loose
33792 polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
33793 x))}.  The result will never be @code{nil} in loose mode, since any
33794 expression can be interpreted as a ``constant'' loose polynomial.@refill
33795 @end defun
33797 @defun polynomial-base expr pred
33798 Check if @var{expr} is a polynomial in any variable that occurs in it;
33799 if so, return that variable.  (If @var{expr} is a multivariate polynomial,
33800 this chooses one variable arbitrarily.)  If @var{pred} is specified, it should
33801 be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
33802 and which should return true if @code{mpb-top-expr} (a global name for
33803 the original @var{expr}) is a suitable polynomial in @var{subexpr}.
33804 The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
33805 you can use @var{pred} to specify additional conditions.  Or, you could
33806 have @var{pred} build up a list of every suitable @var{subexpr} that
33807 is found.@refill
33808 @end defun
33810 @defun poly-simplify poly
33811 Simplify polynomial coefficient list @var{poly} by (destructively)
33812 clipping off trailing zeros.
33813 @end defun
33815 @defun poly-mix a ac b bc
33816 Mix two polynomial lists @var{a} and @var{b} (in the form returned by
33817 @code{is-polynomial}) in a linear combination with coefficient expressions
33818 @var{ac} and @var{bc}.  The result is a (not necessarily simplified)
33819 polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.@refill
33820 @end defun
33822 @defun poly-mul a b
33823 Multiply two polynomial coefficient lists @var{a} and @var{b}.  The
33824 result will be in simplified form if the inputs were simplified.
33825 @end defun
33827 @defun build-polynomial-expr poly var
33828 Construct a Calc formula which represents the polynomial coefficient
33829 list @var{poly} applied to variable @var{var}.  The @kbd{a c}
33830 (@code{calc-collect}) command uses @code{is-polynomial} to turn an
33831 expression into a coefficient list, then @code{build-polynomial-expr}
33832 to turn the list back into an expression in regular form.@refill
33833 @end defun
33835 @defun check-unit-name var
33836 Check if @var{var} is a variable which can be interpreted as a unit
33837 name.  If so, return the units table entry for that unit.  This
33838 will be a list whose first element is the unit name (not counting
33839 prefix characters) as a symbol and whose second element is the
33840 Calc expression which defines the unit.  (Refer to the Calc sources
33841 for details on the remaining elements of this list.)  If @var{var}
33842 is not a variable or is not a unit name, return @code{nil}.
33843 @end defun
33845 @defun units-in-expr-p expr sub-exprs
33846 Return true if @var{expr} contains any variables which can be
33847 interpreted as units.  If @var{sub-exprs} is @code{t}, the entire
33848 expression is searched.  If @var{sub-exprs} is @code{nil}, this
33849 checks whether @var{expr} is directly a units expression.@refill
33850 @end defun
33852 @defun single-units-in-expr-p expr
33853 Check whether @var{expr} contains exactly one units variable.  If so,
33854 return the units table entry for the variable.  If @var{expr} does
33855 not contain any units, return @code{nil}.  If @var{expr} contains
33856 two or more units, return the symbol @code{wrong}.
33857 @end defun
33859 @defun to-standard-units expr which
33860 Convert units expression @var{expr} to base units.  If @var{which}
33861 is @code{nil}, use Calc's native base units.  Otherwise, @var{which}
33862 can specify a units system, which is a list of two-element lists,
33863 where the first element is a Calc base symbol name and the second
33864 is an expression to substitute for it.@refill
33865 @end defun
33867 @defun remove-units expr
33868 Return a copy of @var{expr} with all units variables replaced by ones.
33869 This expression is generally normalized before use.
33870 @end defun
33872 @defun extract-units expr
33873 Return a copy of @var{expr} with everything but units variables replaced
33874 by ones.
33875 @end defun
33877 @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
33878 @subsubsection I/O and Formatting Functions
33880 @noindent
33881 The functions described here are responsible for parsing and formatting
33882 Calc numbers and formulas.
33884 @defun calc-eval str sep arg1 arg2 @dots{}
33885 This is the simplest interface to the Calculator from another Lisp program.
33886 @xref{Calling Calc from Your Programs}.
33887 @end defun
33889 @defun read-number str
33890 If string @var{str} contains a valid Calc number, either integer,
33891 fraction, float, or HMS form, this function parses and returns that
33892 number.  Otherwise, it returns @code{nil}.
33893 @end defun
33895 @defun read-expr str
33896 Read an algebraic expression from string @var{str}.  If @var{str} does
33897 not have the form of a valid expression, return a list of the form
33898 @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
33899 into @var{str} of the general location of the error, and @var{msg} is
33900 a string describing the problem.@refill
33901 @end defun
33903 @defun read-exprs str
33904 Read a list of expressions separated by commas, and return it as a
33905 Lisp list.  If an error occurs in any expressions, an error list as
33906 shown above is returned instead.
33907 @end defun
33909 @defun calc-do-alg-entry initial prompt no-norm
33910 Read an algebraic formula or formulas using the minibuffer.  All
33911 conventions of regular algebraic entry are observed.  The return value
33912 is a list of Calc formulas; there will be more than one if the user
33913 entered a list of values separated by commas.  The result is @code{nil}
33914 if the user presses Return with a blank line.  If @var{initial} is
33915 given, it is a string which the minibuffer will initially contain.
33916 If @var{prompt} is given, it is the prompt string to use; the default
33917 is ``Algebraic:''.  If @var{no-norm} is @code{t}, the formulas will
33918 be returned exactly as parsed; otherwise, they will be passed through
33919 @code{calc-normalize} first.@refill
33921 To support the use of @kbd{$} characters in the algebraic entry, use
33922 @code{let} to bind @code{calc-dollar-values} to a list of the values
33923 to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
33924 @code{calc-dollar-used} to 0.  Upon return, @code{calc-dollar-used}
33925 will have been changed to the highest number of consecutive @kbd{$}s
33926 that actually appeared in the input.@refill
33927 @end defun
33929 @defun format-number a
33930 Convert the real or complex number or HMS form @var{a} to string form.
33931 @end defun
33933 @defun format-flat-expr a prec
33934 Convert the arbitrary Calc number or formula @var{a} to string form,
33935 in the style used by the trail buffer and the @code{calc-edit} command.
33936 This is a simple format designed
33937 mostly to guarantee the string is of a form that can be re-parsed by
33938 @code{read-expr}.  Most formatting modes, such as digit grouping,
33939 complex number format, and point character, are ignored to ensure the
33940 result will be re-readable.  The @var{prec} parameter is normally 0; if
33941 you pass a large integer like 1000 instead, the expression will be
33942 surrounded by parentheses unless it is a plain number or variable name.@refill
33943 @end defun
33945 @defun format-nice-expr a width
33946 This is like @code{format-flat-expr} (with @var{prec} equal to 0),
33947 except that newlines will be inserted to keep lines down to the
33948 specified @var{width}, and vectors that look like matrices or rewrite
33949 rules are written in a pseudo-matrix format.  The @code{calc-edit}
33950 command uses this when only one stack entry is being edited.
33951 @end defun
33953 @defun format-value a width
33954 Convert the Calc number or formula @var{a} to string form, using the
33955 format seen in the stack buffer.  Beware the string returned may
33956 not be re-readable by @code{read-expr}, for example, because of digit
33957 grouping.  Multi-line objects like matrices produce strings that
33958 contain newline characters to separate the lines.  The @var{w}
33959 parameter, if given, is the target window size for which to format
33960 the expressions.  If @var{w} is omitted, the width of the Calculator
33961 window is used.@refill
33962 @end defun
33964 @defun compose-expr a prec
33965 Format the Calc number or formula @var{a} according to the current
33966 language mode, returning a ``composition.''  To learn about the
33967 structure of compositions, see the comments in the Calc source code.
33968 You can specify the format of a given type of function call by putting
33969 a @code{math-compose-@var{lang}} property on the function's symbol,
33970 whose value is a Lisp function that takes @var{a} and @var{prec} as
33971 arguments and returns a composition.  Here @var{lang} is a language
33972 mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
33973 @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
33974 In Big mode, Calc actually tries @code{math-compose-big} first, then
33975 tries @code{math-compose-normal}.  If this property does not exist,
33976 or if the function returns @code{nil}, the function is written in the
33977 normal function-call notation for that language.
33978 @end defun
33980 @defun composition-to-string c w
33981 Convert a composition structure returned by @code{compose-expr} into
33982 a string.  Multi-line compositions convert to strings containing
33983 newline characters.  The target window size is given by @var{w}.
33984 The @code{format-value} function basically calls @code{compose-expr}
33985 followed by @code{composition-to-string}.
33986 @end defun
33988 @defun comp-width c
33989 Compute the width in characters of composition @var{c}.
33990 @end defun
33992 @defun comp-height c
33993 Compute the height in lines of composition @var{c}.
33994 @end defun
33996 @defun comp-ascent c
33997 Compute the portion of the height of composition @var{c} which is on or
33998 above the baseline.  For a one-line composition, this will be one.
33999 @end defun
34001 @defun comp-descent c
34002 Compute the portion of the height of composition @var{c} which is below
34003 the baseline.  For a one-line composition, this will be zero.
34004 @end defun
34006 @defun comp-first-char c
34007 If composition @var{c} is a ``flat'' composition, return the first
34008 (leftmost) character of the composition as an integer.  Otherwise,
34009 return @code{nil}.@refill
34010 @end defun
34012 @defun comp-last-char c
34013 If composition @var{c} is a ``flat'' composition, return the last
34014 (rightmost) character, otherwise return @code{nil}.
34015 @end defun
34017 @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
34018 @comment @subsubsection Lisp Variables
34019 @comment
34020 @comment @noindent
34021 @comment (This section is currently unfinished.)
34023 @node Hooks, , Formatting Lisp Functions, Internals
34024 @subsubsection Hooks
34026 @noindent
34027 Hooks are variables which contain Lisp functions (or lists of functions)
34028 which are called at various times.  Calc defines a number of hooks
34029 that help you to customize it in various ways.  Calc uses the Lisp
34030 function @code{run-hooks} to invoke the hooks shown below.  Several
34031 other customization-related variables are also described here.
34033 @defvar calc-load-hook
34034 This hook is called at the end of @file{calc.el}, after the file has
34035 been loaded, before any functions in it have been called, but after
34036 @code{calc-mode-map} and similar variables have been set up.
34037 @end defvar
34039 @defvar calc-ext-load-hook
34040 This hook is called at the end of @file{calc-ext.el}.
34041 @end defvar
34043 @defvar calc-start-hook
34044 This hook is called as the last step in a @kbd{M-x calc} command.
34045 At this point, the Calc buffer has been created and initialized if
34046 necessary, the Calc window and trail window have been created,
34047 and the ``Welcome to Calc'' message has been displayed.
34048 @end defvar
34050 @defvar calc-mode-hook
34051 This hook is called when the Calc buffer is being created.  Usually
34052 this will only happen once per Emacs session.  The hook is called
34053 after Emacs has switched to the new buffer, the mode-settings file
34054 has been read if necessary, and all other buffer-local variables
34055 have been set up.  After this hook returns, Calc will perform a
34056 @code{calc-refresh} operation, set up the mode line display, then
34057 evaluate any deferred @code{calc-define} properties that have not
34058 been evaluated yet.
34059 @end defvar
34061 @defvar calc-trail-mode-hook
34062 This hook is called when the Calc Trail buffer is being created.
34063 It is called as the very last step of setting up the Trail buffer.
34064 Like @code{calc-mode-hook}, this will normally happen only once
34065 per Emacs session.
34066 @end defvar
34068 @defvar calc-end-hook
34069 This hook is called by @code{calc-quit}, generally because the user
34070 presses @kbd{q} or @kbd{M-# c} while in Calc.  The Calc buffer will
34071 be the current buffer.  The hook is called as the very first
34072 step, before the Calc window is destroyed.
34073 @end defvar
34075 @defvar calc-window-hook
34076 If this hook exists, it is called to create the Calc window.
34077 Upon return, this new Calc window should be the current window.
34078 (The Calc buffer will already be the current buffer when the
34079 hook is called.)  If the hook is not defined, Calc will
34080 generally use @code{split-window}, @code{set-window-buffer},
34081 and @code{select-window} to create the Calc window.
34082 @end defvar
34084 @defvar calc-trail-window-hook
34085 If this hook exists, it is called to create the Calc Trail window.
34086 The variable @code{calc-trail-buffer} will contain the buffer
34087 which the window should use.  Unlike @code{calc-window-hook},
34088 this hook must @emph{not} switch into the new window.
34089 @end defvar
34091 @defvar calc-edit-mode-hook
34092 This hook is called by @code{calc-edit} (and the other ``edit''
34093 commands) when the temporary editing buffer is being created.
34094 The buffer will have been selected and set up to be in
34095 @code{calc-edit-mode}, but will not yet have been filled with
34096 text.  (In fact it may still have leftover text from a previous
34097 @code{calc-edit} command.)
34098 @end defvar
34100 @defvar calc-mode-save-hook
34101 This hook is called by the @code{calc-save-modes} command,
34102 after Calc's own mode features have been inserted into the
34103 @file{.emacs} buffer and just before the ``End of mode settings''
34104 message is inserted.
34105 @end defvar
34107 @defvar calc-reset-hook
34108 This hook is called after @kbd{M-# 0} (@code{calc-reset}) has
34109 reset all modes.  The Calc buffer will be the current buffer.
34110 @end defvar
34112 @defvar calc-other-modes
34113 This variable contains a list of strings.  The strings are
34114 concatenated at the end of the modes portion of the Calc
34115 mode line (after standard modes such as ``Deg'', ``Inv'' and
34116 ``Hyp'').  Each string should be a short, single word followed
34117 by a space.  The variable is @code{nil} by default.
34118 @end defvar
34120 @defvar calc-mode-map
34121 This is the keymap that is used by Calc mode.  The best time
34122 to adjust it is probably in a @code{calc-mode-hook}.  If the
34123 Calc extensions package (@file{calc-ext.el}) has not yet been
34124 loaded, many of these keys will be bound to @code{calc-missing-key},
34125 which is a command that loads the extensions package and
34126 ``retypes'' the key.  If your @code{calc-mode-hook} rebinds
34127 one of these keys, it will probably be overridden when the
34128 extensions are loaded.
34129 @end defvar
34131 @defvar calc-digit-map
34132 This is the keymap that is used during numeric entry.  Numeric
34133 entry uses the minibuffer, but this map binds every non-numeric
34134 key to @code{calcDigit-nondigit} which generally calls
34135 @code{exit-minibuffer} and ``retypes'' the key.
34136 @end defvar
34138 @defvar calc-alg-ent-map
34139 This is the keymap that is used during algebraic entry.  This is
34140 mostly a copy of @code{minibuffer-local-map}.
34141 @end defvar
34143 @defvar calc-store-var-map
34144 This is the keymap that is used during entry of variable names for
34145 commands like @code{calc-store} and @code{calc-recall}.  This is
34146 mostly a copy of @code{minibuffer-local-completion-map}.
34147 @end defvar
34149 @defvar calc-edit-mode-map
34150 This is the (sparse) keymap used by @code{calc-edit} and other
34151 temporary editing commands.  It binds @key{RET}, @key{LFD},
34152 and @kbd{C-c C-c} to @code{calc-edit-finish}.
34153 @end defvar
34155 @defvar calc-mode-var-list
34156 This is a list of variables which are saved by @code{calc-save-modes}.
34157 Each entry is a list of two items, the variable (as a Lisp symbol)
34158 and its default value.  When modes are being saved, each variable
34159 is compared with its default value (using @code{equal}) and any
34160 non-default variables are written out.
34161 @end defvar
34163 @defvar calc-local-var-list
34164 This is a list of variables which should be buffer-local to the
34165 Calc buffer.  Each entry is a variable name (as a Lisp symbol).
34166 These variables also have their default values manipulated by
34167 the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
34168 Since @code{calc-mode-hook} is called after this list has been
34169 used the first time, your hook should add a variable to the
34170 list and also call @code{make-local-variable} itself.
34171 @end defvar
34173 @node Installation, Reporting Bugs, Programming, Top
34174 @appendix Installation
34176 @noindent
34177 As of Calc 2.02g, Calc is integrated with GNU Emacs, and thus requires
34178 no separate installation of its Lisp files and this manual.
34180 @appendixsec The GNUPLOT Program
34182 @noindent
34183 Calc's graphing commands use the GNUPLOT program.  If you have GNUPLOT
34184 but you must type some command other than @file{gnuplot} to get it,
34185 you should add a command to set the Lisp variable @code{calc-gnuplot-name}
34186 to the appropriate file name.  You may also need to change the variables
34187 @code{calc-gnuplot-plot-command} and @code{calc-gnuplot-print-command} in
34188 order to get correct displays and hardcopies, respectively, of your
34189 plots.@refill
34191 @ifinfo
34192 @example
34194 @end example
34195 @end ifinfo
34196 @appendixsec Printed Documentation
34198 @noindent
34199 Because the Calc manual is so large, you should only make a printed
34200 copy if you really need it.  To print the manual, you will need the
34201 @TeX{} typesetting program (this is a free program by Donald Knuth
34202 at Stanford University) as well as the @file{texindex} program and
34203 @file{texinfo.tex} file, both of which can be obtained from the FSF
34204 as part of the @code{texinfo} package.@refill
34206 To print the Calc manual in one huge 470 page tome, you will need the
34207 source code to this manual, @file{calc.texi}, available as part of the
34208 Emacs source.  Once you have this file, type @kbd{texi2dvi calc.texi}.
34209 Alternatively, change to the @file{man} subdirectory of the Emacs
34210 source distribution, and type @kbd{make calc.dvi}. (Don't worry if you
34211 get some ``overfull box'' warnings while @TeX{} runs.)
34213 The result will be a device-independent output file called
34214 @file{calc.dvi}, which you must print in whatever way is right
34215 for your system.  On many systems, the command is
34217 @example
34218 lpr -d calc.dvi
34219 @end example
34221 @noindent
34224 @example
34225 dvips calc.dvi
34226 @end example
34228 @c the bumpoddpages macro was deleted
34229 @ignore
34230 @cindex Marginal notes, adjusting
34231 Marginal notes for each function and key sequence normally alternate
34232 between the left and right sides of the page, which is correct if the
34233 manual is going to be bound as double-sided pages.  Near the top of
34234 the file @file{calc.texi} you will find alternate definitions of
34235 the @code{\bumpoddpages} macro that put the marginal notes always on
34236 the same side, best if you plan to be binding single-sided pages.
34237 @end ignore
34239 @appendixsec Settings File
34241 @noindent
34242 @vindex calc-settings-file
34243 Another variable you might want to set is @code{calc-settings-file},
34244 which holds the file name in which commands like @kbd{m m} and @kbd{Z P}
34245 store ``permanent'' definitions.  The default value for this variable
34246 is @code{"~/.emacs"}.  If @code{calc-settings-file} does not contain
34247 @code{".emacs"} as a substring, and if the variable
34248 @code{calc-loaded-settings-file} is @code{nil}, then Calc will
34249 automatically load your settings file (if it exists) the first time
34250 Calc is invoked.@refill
34252 @ifinfo
34253 @example
34255 @end example
34256 @end ifinfo
34257 @appendixsec Testing the Installation
34259 @noindent
34260 To test your installation of Calc, start a new Emacs and type @kbd{M-# c}
34261 to make sure the autoloads and key bindings work.  Type @kbd{M-# i}
34262 to make sure Calc can find its Info documentation.  Press @kbd{q} to
34263 exit the Info system and @kbd{M-# c} to re-enter the Calculator.
34264 Type @kbd{20 S} to compute the sine of 20 degrees; this will test the
34265 autoloading of the extensions modules.  The result should be
34266 0.342020143326.  Finally, press @kbd{M-# c} again to make sure the
34267 Calculator can exit.
34269 You may also wish to test the GNUPLOT interface; to plot a sine wave,
34270 type @kbd{' [0 ..@: 360], sin(x) @key{RET} g f}.  Type @kbd{g q} when you
34271 are done viewing the plot.
34273 Calc is now ready to use.  If you wish to go through the Calc Tutorial,
34274 press @kbd{M-# t} to begin.
34275 @example
34277 @end example
34278 @node Reporting Bugs, Summary, Installation, Top
34279 @appendix Reporting Bugs
34281 @noindent
34282 If you find a bug in Calc, send e-mail to Colin Walters,
34284 @example
34285 walters@@debian.org           @r{or}
34286 walters@@verbum.org
34287 @end example
34289 @noindent
34290 (In the following text, ``I'' refers to the original Calc author, Dave
34291 Gillespie).
34293 While I cannot guarantee that I will have time to work on your bug,
34294 I do try to fix bugs quickly whenever I can.
34296 The latest version of Calc is available from Savannah, in the Emacs
34297 CVS tree.  See @uref{http://savannah.gnu.org/projects/emacs}.
34299 There is an automatic command @kbd{M-x report-calc-bug} which helps
34300 you to report bugs.  This command prompts you for a brief subject
34301 line, then leaves you in a mail editing buffer.  Type @kbd{C-c C-c} to
34302 send your mail.  Make sure your subject line indicates that you are
34303 reporting a Calc bug; this command sends mail to the maintainer's
34304 regular mailbox.
34306 If you have suggestions for additional features for Calc, I would
34307 love to hear them.  Some have dared to suggest that Calc is already
34308 top-heavy with features; I really don't see what they're talking
34309 about, so, if you have ideas, send them right in.  (I may even have
34310 time to implement them!)
34312 At the front of the source file, @file{calc.el}, is a list of ideas for
34313 future work which I have not had time to do.  If any enthusiastic souls
34314 wish to take it upon themselves to work on these, I would be delighted.
34315 Please let me know if you plan to contribute to Calc so I can coordinate
34316 your efforts with mine and those of others.  I will do my best to help
34317 you in whatever way I can.
34319 @c [summary]
34320 @node Summary, Key Index, Reporting Bugs, Top
34321 @appendix Calc Summary
34323 @noindent
34324 This section includes a complete list of Calc 2.02 keystroke commands.
34325 Each line lists the stack entries used by the command (top-of-stack
34326 last), the keystrokes themselves, the prompts asked by the command,
34327 and the result of the command (also with top-of-stack last).
34328 The result is expressed using the equivalent algebraic function.
34329 Commands which put no results on the stack show the full @kbd{M-x}
34330 command name in that position.  Numbers preceding the result or
34331 command name refer to notes at the end.
34333 Algebraic functions and @kbd{M-x} commands that don't have corresponding
34334 keystrokes are not listed in this summary.
34335 @xref{Command Index}.  @xref{Function Index}.
34337 @iftex
34338 @begingroup
34339 @tex
34340 \vskip-2\baselineskip \null
34341 \gdef\sumrow#1{\sumrowx#1\relax}%
34342 \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
34343 \leavevmode%
34344 {\smallfonts
34345 \hbox to5em{\sl\hss#1}%
34346 \hbox to5em{\tt#2\hss}%
34347 \hbox to4em{\sl#3\hss}%
34348 \hbox to5em{\rm\hss#4}%
34349 \thinspace%
34350 {\tt#5}%
34351 {\sl#6}%
34353 \gdef\sumlpar{{\rm(}}%
34354 \gdef\sumrpar{{\rm)}}%
34355 \gdef\sumcomma{{\rm,\thinspace}}%
34356 \gdef\sumexcl{{\rm!}}%
34357 \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
34358 \gdef\minus#1{{\tt-}}%
34359 @end tex
34360 @let@:=@sumsep
34361 @let@r=@sumrow
34362 @catcode`@(=@active @let(=@sumlpar
34363 @catcode`@)=@active @let)=@sumrpar
34364 @catcode`@,=@active @let,=@sumcomma
34365 @catcode`@!=@active @let!=@sumexcl
34366 @end iftex
34367 @format
34368 @iftex
34369 @advance@baselineskip-2.5pt
34370 @let@c@sumbreak
34371 @end iftex
34372 @r{       @:     M-# a  @:             @:    33  @:calc-embedded-activate@:}
34373 @r{       @:     M-# b  @:             @:        @:calc-big-or-small@:}
34374 @r{       @:     M-# c  @:             @:        @:calc@:}
34375 @r{       @:     M-# d  @:             @:        @:calc-embedded-duplicate@:}
34376 @r{       @:     M-# e  @:             @:    34  @:calc-embedded@:}
34377 @r{       @:     M-# f  @:formula      @:        @:calc-embedded-new-formula@:}
34378 @r{       @:     M-# g  @:             @:    35  @:calc-grab-region@:}
34379 @r{       @:     M-# i  @:             @:        @:calc-info@:}
34380 @r{       @:     M-# j  @:             @:        @:calc-embedded-select@:}
34381 @r{       @:     M-# k  @:             @:        @:calc-keypad@:}
34382 @r{       @:     M-# l  @:             @:        @:calc-load-everything@:}
34383 @r{       @:     M-# m  @:             @:        @:read-kbd-macro@:}
34384 @r{       @:     M-# n  @:             @:     4  @:calc-embedded-next@:}
34385 @r{       @:     M-# o  @:             @:        @:calc-other-window@:}
34386 @r{       @:     M-# p  @:             @:     4  @:calc-embedded-previous@:}
34387 @r{       @:     M-# q  @:formula      @:        @:quick-calc@:}
34388 @r{       @:     M-# r  @:             @:    36  @:calc-grab-rectangle@:}
34389 @r{       @:     M-# s  @:             @:        @:calc-info-summary@:}
34390 @r{       @:     M-# t  @:             @:        @:calc-tutorial@:}
34391 @r{       @:     M-# u  @:             @:        @:calc-embedded-update@:}
34392 @r{       @:     M-# w  @:             @:        @:calc-embedded-word@:}
34393 @r{       @:     M-# x  @:             @:        @:calc-quit@:}
34394 @r{       @:     M-# y  @:            @:1,28,49  @:calc-copy-to-buffer@:}
34395 @r{       @:     M-# z  @:             @:        @:calc-user-invocation@:}
34396 @r{       @:     M-# :  @:             @:    36  @:calc-grab-sum-down@:}
34397 @r{       @:     M-# _  @:             @:    36  @:calc-grab-sum-across@:}
34398 @r{       @:     M-# `  @:editing      @:    30  @:calc-embedded-edit@:}
34399 @r{       @:     M-# 0  @:(zero)       @:        @:calc-reset@:}
34402 @r{       @:      0-9   @:number       @:        @:@:number}
34403 @r{       @:      .     @:number       @:        @:@:0.number}
34404 @r{       @:      _     @:number       @:        @:-@:number}
34405 @r{       @:      e     @:number       @:        @:@:1e number}
34406 @r{       @:      #     @:number       @:        @:@:current-radix@t{#}number}
34407 @r{       @:      P     @:(in number)  @:        @:+/-@:}
34408 @r{       @:      M     @:(in number)  @:        @:mod@:}
34409 @r{       @:      @@ ' " @:  (in number)@:        @:@:HMS form}
34410 @r{       @:      h m s @:  (in number)@:        @:@:HMS form}
34413 @r{       @:      '     @:formula      @: 37,46  @:@:formula}
34414 @r{       @:      $     @:formula      @: 37,46  @:$@:formula}
34415 @r{       @:      "     @:string       @: 37,46  @:@:string}
34418 @r{    a b@:      +     @:             @:     2  @:add@:(a,b)  a+b}
34419 @r{    a b@:      -     @:             @:     2  @:sub@:(a,b)  a@minus{}b}
34420 @r{    a b@:      *     @:             @:     2  @:mul@:(a,b)  a b, a*b}
34421 @r{    a b@:      /     @:             @:     2  @:div@:(a,b)  a/b}
34422 @r{    a b@:      ^     @:             @:     2  @:pow@:(a,b)  a^b}
34423 @r{    a b@:    I ^     @:             @:     2  @:nroot@:(a,b)  a^(1/b)}
34424 @r{    a b@:      %     @:             @:     2  @:mod@:(a,b)  a%b}
34425 @r{    a b@:      \     @:             @:     2  @:idiv@:(a,b)  a\b}
34426 @r{    a b@:      :     @:             @:     2  @:fdiv@:(a,b)}
34427 @r{    a b@:      |     @:             @:     2  @:vconcat@:(a,b)  a|b}
34428 @r{    a b@:    I |     @:             @:        @:vconcat@:(b,a)  b|a}
34429 @r{    a b@:    H |     @:             @:     2  @:append@:(a,b)}
34430 @r{    a b@:  I H |     @:             @:        @:append@:(b,a)}
34431 @r{      a@:      &     @:             @:     1  @:inv@:(a)  1/a}
34432 @r{      a@:      !     @:             @:     1  @:fact@:(a)  a!}
34433 @r{      a@:      =     @:             @:     1  @:evalv@:(a)}
34434 @r{      a@:      M-%   @:             @:        @:percent@:(a)  a%}
34437 @r{  ... a@:      @key{RET}   @:             @:     1  @:@:... a a}
34438 @r{  ... a@:      @key{SPC}   @:             @:     1  @:@:... a a}
34439 @r{... a b@:      @key{TAB}   @:             @:     3  @:@:... b a}
34440 @r{. a b c@:      M-@key{TAB} @:             @:     3  @:@:... b c a}
34441 @r{... a b@:      @key{LFD}   @:             @:     1  @:@:... a b a}
34442 @r{  ... a@:      @key{DEL}   @:             @:     1  @:@:...}
34443 @r{... a b@:      M-@key{DEL} @:             @:     1  @:@:... b}
34444 @r{       @:      M-@key{RET} @:             @:     4  @:calc-last-args@:}
34445 @r{      a@:      `     @:editing      @:  1,30  @:calc-edit@:}
34448 @r{  ... a@:      C-d   @:             @:     1  @:@:...}
34449 @r{       @:      C-k   @:             @:    27  @:calc-kill@:}
34450 @r{       @:      C-w   @:             @:    27  @:calc-kill-region@:}
34451 @r{       @:      C-y   @:             @:        @:calc-yank@:}
34452 @r{       @:      C-_   @:             @:     4  @:calc-undo@:}
34453 @r{       @:      M-k   @:             @:    27  @:calc-copy-as-kill@:}
34454 @r{       @:      M-w   @:             @:    27  @:calc-copy-region-as-kill@:}
34457 @r{       @:      [     @:             @:        @:@:[...}
34458 @r{[.. a b@:      ]     @:             @:        @:@:[a,b]}
34459 @r{       @:      (     @:             @:        @:@:(...}
34460 @r{(.. a b@:      )     @:             @:        @:@:(a,b)}
34461 @r{       @:      ,     @:             @:        @:@:vector or rect complex}
34462 @r{       @:      ;     @:             @:        @:@:matrix or polar complex}
34463 @r{       @:      ..    @:             @:        @:@:interval}
34466 @r{       @:      ~     @:             @:        @:calc-num-prefix@:}
34467 @r{       @:      <     @:             @:     4  @:calc-scroll-left@:}
34468 @r{       @:      >     @:             @:     4  @:calc-scroll-right@:}
34469 @r{       @:      @{     @:             @:     4  @:calc-scroll-down@:}
34470 @r{       @:      @}     @:             @:     4  @:calc-scroll-up@:}
34471 @r{       @:      ?     @:             @:        @:calc-help@:}
34474 @r{      a@:      n     @:             @:     1  @:neg@:(a)  @minus{}a}
34475 @r{       @:      o     @:             @:     4  @:calc-realign@:}
34476 @r{       @:      p     @:precision    @:    31  @:calc-precision@:}
34477 @r{       @:      q     @:             @:        @:calc-quit@:}
34478 @r{       @:      w     @:             @:        @:calc-why@:}
34479 @r{       @:      x     @:command      @:        @:M-x calc-@:command}
34480 @r{      a@:      y     @:            @:1,28,49  @:calc-copy-to-buffer@:}
34483 @r{      a@:      A     @:             @:     1  @:abs@:(a)}
34484 @r{    a b@:      B     @:             @:     2  @:log@:(a,b)}
34485 @r{    a b@:    I B     @:             @:     2  @:alog@:(a,b)  b^a}
34486 @r{      a@:      C     @:             @:     1  @:cos@:(a)}
34487 @r{      a@:    I C     @:             @:     1  @:arccos@:(a)}
34488 @r{      a@:    H C     @:             @:     1  @:cosh@:(a)}
34489 @r{      a@:  I H C     @:             @:     1  @:arccosh@:(a)}
34490 @r{       @:      D     @:             @:     4  @:calc-redo@:}
34491 @r{      a@:      E     @:             @:     1  @:exp@:(a)}
34492 @r{      a@:    H E     @:             @:     1  @:exp10@:(a)  10.^a}
34493 @r{      a@:      F     @:             @:  1,11  @:floor@:(a,d)}
34494 @r{      a@:    I F     @:             @:  1,11  @:ceil@:(a,d)}
34495 @r{      a@:    H F     @:             @:  1,11  @:ffloor@:(a,d)}
34496 @r{      a@:  I H F     @:             @:  1,11  @:fceil@:(a,d)}
34497 @r{      a@:      G     @:             @:     1  @:arg@:(a)}
34498 @r{       @:      H     @:command      @:    32  @:@:Hyperbolic}
34499 @r{       @:      I     @:command      @:    32  @:@:Inverse}
34500 @r{      a@:      J     @:             @:     1  @:conj@:(a)}
34501 @r{       @:      K     @:command      @:    32  @:@:Keep-args}
34502 @r{      a@:      L     @:             @:     1  @:ln@:(a)}
34503 @r{      a@:    H L     @:             @:     1  @:log10@:(a)}
34504 @r{       @:      M     @:             @:        @:calc-more-recursion-depth@:}
34505 @r{       @:    I M     @:             @:        @:calc-less-recursion-depth@:}
34506 @r{      a@:      N     @:             @:     5  @:evalvn@:(a)}
34507 @r{       @:      P     @:             @:        @:@:pi}
34508 @r{       @:    I P     @:             @:        @:@:gamma}
34509 @r{       @:    H P     @:             @:        @:@:e}
34510 @r{       @:  I H P     @:             @:        @:@:phi}
34511 @r{      a@:      Q     @:             @:     1  @:sqrt@:(a)}
34512 @r{      a@:    I Q     @:             @:     1  @:sqr@:(a)  a^2}
34513 @r{      a@:      R     @:             @:  1,11  @:round@:(a,d)}
34514 @r{      a@:    I R     @:             @:  1,11  @:trunc@:(a,d)}
34515 @r{      a@:    H R     @:             @:  1,11  @:fround@:(a,d)}
34516 @r{      a@:  I H R     @:             @:  1,11  @:ftrunc@:(a,d)}
34517 @r{      a@:      S     @:             @:     1  @:sin@:(a)}
34518 @r{      a@:    I S     @:             @:     1  @:arcsin@:(a)}
34519 @r{      a@:    H S     @:             @:     1  @:sinh@:(a)}
34520 @r{      a@:  I H S     @:             @:     1  @:arcsinh@:(a)}
34521 @r{      a@:      T     @:             @:     1  @:tan@:(a)}
34522 @r{      a@:    I T     @:             @:     1  @:arctan@:(a)}
34523 @r{      a@:    H T     @:             @:     1  @:tanh@:(a)}
34524 @r{      a@:  I H T     @:             @:     1  @:arctanh@:(a)}
34525 @r{       @:      U     @:             @:     4  @:calc-undo@:}
34526 @r{       @:      X     @:             @:     4  @:calc-call-last-kbd-macro@:}
34529 @r{    a b@:      a =   @:             @:     2  @:eq@:(a,b)  a=b}
34530 @r{    a b@:      a #   @:             @:     2  @:neq@:(a,b)  a!=b}
34531 @r{    a b@:      a <   @:             @:     2  @:lt@:(a,b)  a<b}
34532 @r{    a b@:      a >   @:             @:     2  @:gt@:(a,b)  a>b}
34533 @r{    a b@:      a [   @:             @:     2  @:leq@:(a,b)  a<=b}
34534 @r{    a b@:      a ]   @:             @:     2  @:geq@:(a,b)  a>=b}
34535 @r{    a b@:      a @{   @:             @:     2  @:in@:(a,b)}
34536 @r{    a b@:      a &   @:             @:  2,45  @:land@:(a,b)  a&&b}
34537 @r{    a b@:      a |   @:             @:  2,45  @:lor@:(a,b)  a||b}
34538 @r{      a@:      a !   @:             @:  1,45  @:lnot@:(a)  !a}
34539 @r{  a b c@:      a :   @:             @:    45  @:if@:(a,b,c)  a?b:c}
34540 @r{      a@:      a .   @:             @:     1  @:rmeq@:(a)}
34541 @r{      a@:      a "   @:             @:   7,8  @:calc-expand-formula@:}
34544 @r{      a@:      a +   @:i, l, h      @:  6,38  @:sum@:(a,i,l,h)}
34545 @r{      a@:      a -   @:i, l, h      @:  6,38  @:asum@:(a,i,l,h)}
34546 @r{      a@:      a *   @:i, l, h      @:  6,38  @:prod@:(a,i,l,h)}
34547 @r{    a b@:      a _   @:             @:     2  @:subscr@:(a,b)  a_b}
34550 @r{    a b@:      a \   @:             @:     2  @:pdiv@:(a,b)}
34551 @r{    a b@:      a %   @:             @:     2  @:prem@:(a,b)}
34552 @r{    a b@:      a /   @:             @:     2  @:pdivrem@:(a,b)  [q,r]}
34553 @r{    a b@:    H a /   @:             @:     2  @:pdivide@:(a,b)  q+r/b}
34556 @r{      a@:      a a   @:             @:     1  @:apart@:(a)}
34557 @r{      a@:      a b   @:old, new     @:    38  @:subst@:(a,old,new)}
34558 @r{      a@:      a c   @:v            @:    38  @:collect@:(a,v)}
34559 @r{      a@:      a d   @:v            @:  4,38  @:deriv@:(a,v)}
34560 @r{      a@:    H a d   @:v            @:  4,38  @:tderiv@:(a,v)}
34561 @r{      a@:      a e   @:             @:        @:esimplify@:(a)}
34562 @r{      a@:      a f   @:             @:     1  @:factor@:(a)}
34563 @r{      a@:    H a f   @:             @:     1  @:factors@:(a)}
34564 @r{    a b@:      a g   @:             @:     2  @:pgcd@:(a,b)}
34565 @r{      a@:      a i   @:v            @:    38  @:integ@:(a,v)}
34566 @r{      a@:      a m   @:pats         @:    38  @:match@:(a,pats)}
34567 @r{      a@:    I a m   @:pats         @:    38  @:matchnot@:(a,pats)}
34568 @r{ data x@:      a p   @:             @:    28  @:polint@:(data,x)}
34569 @r{ data x@:    H a p   @:             @:    28  @:ratint@:(data,x)}
34570 @r{      a@:      a n   @:             @:     1  @:nrat@:(a)}
34571 @r{      a@:      a r   @:rules        @:4,8,38  @:rewrite@:(a,rules,n)}
34572 @r{      a@:      a s   @:             @:        @:simplify@:(a)}
34573 @r{      a@:      a t   @:v, n         @: 31,39  @:taylor@:(a,v,n)}
34574 @r{      a@:      a v   @:             @:   7,8  @:calc-alg-evaluate@:}
34575 @r{      a@:      a x   @:             @:   4,8  @:expand@:(a)}
34578 @r{   data@:      a F   @:model, vars  @:    48  @:fit@:(m,iv,pv,data)}
34579 @r{   data@:    I a F   @:model, vars  @:    48  @:xfit@:(m,iv,pv,data)}
34580 @r{   data@:    H a F   @:model, vars  @:    48  @:efit@:(m,iv,pv,data)}
34581 @r{      a@:      a I   @:v, l, h      @:    38  @:ninteg@:(a,v,l,h)}
34582 @r{    a b@:      a M   @:op           @:    22  @:mapeq@:(op,a,b)}
34583 @r{    a b@:    I a M   @:op           @:    22  @:mapeqr@:(op,a,b)}
34584 @r{    a b@:    H a M   @:op           @:    22  @:mapeqp@:(op,a,b)}
34585 @r{    a g@:      a N   @:v            @:    38  @:minimize@:(a,v,g)}
34586 @r{    a g@:    H a N   @:v            @:    38  @:wminimize@:(a,v,g)}
34587 @r{      a@:      a P   @:v            @:    38  @:roots@:(a,v)}
34588 @r{    a g@:      a R   @:v            @:    38  @:root@:(a,v,g)}
34589 @r{    a g@:    H a R   @:v            @:    38  @:wroot@:(a,v,g)}
34590 @r{      a@:      a S   @:v            @:    38  @:solve@:(a,v)}
34591 @r{      a@:    I a S   @:v            @:    38  @:finv@:(a,v)}
34592 @r{      a@:    H a S   @:v            @:    38  @:fsolve@:(a,v)}
34593 @r{      a@:  I H a S   @:v            @:    38  @:ffinv@:(a,v)}
34594 @r{      a@:      a T   @:i, l, h      @:  6,38  @:table@:(a,i,l,h)}
34595 @r{    a g@:      a X   @:v            @:    38  @:maximize@:(a,v,g)}
34596 @r{    a g@:    H a X   @:v            @:    38  @:wmaximize@:(a,v,g)}
34599 @r{    a b@:      b a   @:             @:     9  @:and@:(a,b,w)}
34600 @r{      a@:      b c   @:             @:     9  @:clip@:(a,w)}
34601 @r{    a b@:      b d   @:             @:     9  @:diff@:(a,b,w)}
34602 @r{      a@:      b l   @:             @:    10  @:lsh@:(a,n,w)}
34603 @r{    a n@:    H b l   @:             @:     9  @:lsh@:(a,n,w)}
34604 @r{      a@:      b n   @:             @:     9  @:not@:(a,w)}
34605 @r{    a b@:      b o   @:             @:     9  @:or@:(a,b,w)}
34606 @r{      v@:      b p   @:             @:     1  @:vpack@:(v)}
34607 @r{      a@:      b r   @:             @:    10  @:rsh@:(a,n,w)}
34608 @r{    a n@:    H b r   @:             @:     9  @:rsh@:(a,n,w)}
34609 @r{      a@:      b t   @:             @:    10  @:rot@:(a,n,w)}
34610 @r{    a n@:    H b t   @:             @:     9  @:rot@:(a,n,w)}
34611 @r{      a@:      b u   @:             @:     1  @:vunpack@:(a)}
34612 @r{       @:      b w   @:w            @:  9,50  @:calc-word-size@:}
34613 @r{    a b@:      b x   @:             @:     9  @:xor@:(a,b,w)}
34616 @r{c s l p@:      b D   @:             @:        @:ddb@:(c,s,l,p)}
34617 @r{  r n p@:      b F   @:             @:        @:fv@:(r,n,p)}
34618 @r{  r n p@:    I b F   @:             @:        @:fvb@:(r,n,p)}
34619 @r{  r n p@:    H b F   @:             @:        @:fvl@:(r,n,p)}
34620 @r{      v@:      b I   @:             @:    19  @:irr@:(v)}
34621 @r{      v@:    I b I   @:             @:    19  @:irrb@:(v)}
34622 @r{      a@:      b L   @:             @:    10  @:ash@:(a,n,w)}
34623 @r{    a n@:    H b L   @:             @:     9  @:ash@:(a,n,w)}
34624 @r{  r n a@:      b M   @:             @:        @:pmt@:(r,n,a)}
34625 @r{  r n a@:    I b M   @:             @:        @:pmtb@:(r,n,a)}
34626 @r{  r n a@:    H b M   @:             @:        @:pmtl@:(r,n,a)}
34627 @r{    r v@:      b N   @:             @:    19  @:npv@:(r,v)}
34628 @r{    r v@:    I b N   @:             @:    19  @:npvb@:(r,v)}
34629 @r{  r n p@:      b P   @:             @:        @:pv@:(r,n,p)}
34630 @r{  r n p@:    I b P   @:             @:        @:pvb@:(r,n,p)}
34631 @r{  r n p@:    H b P   @:             @:        @:pvl@:(r,n,p)}
34632 @r{      a@:      b R   @:             @:    10  @:rash@:(a,n,w)}
34633 @r{    a n@:    H b R   @:             @:     9  @:rash@:(a,n,w)}
34634 @r{  c s l@:      b S   @:             @:        @:sln@:(c,s,l)}
34635 @r{  n p a@:      b T   @:             @:        @:rate@:(n,p,a)}
34636 @r{  n p a@:    I b T   @:             @:        @:rateb@:(n,p,a)}
34637 @r{  n p a@:    H b T   @:             @:        @:ratel@:(n,p,a)}
34638 @r{c s l p@:      b Y   @:             @:        @:syd@:(c,s,l,p)}
34640 @r{  r p a@:      b #   @:             @:        @:nper@:(r,p,a)}
34641 @r{  r p a@:    I b #   @:             @:        @:nperb@:(r,p,a)}
34642 @r{  r p a@:    H b #   @:             @:        @:nperl@:(r,p,a)}
34643 @r{    a b@:      b %   @:             @:        @:relch@:(a,b)}
34646 @r{      a@:      c c   @:             @:     5  @:pclean@:(a,p)}
34647 @r{      a@:      c 0-9 @:             @:        @:pclean@:(a,p)}
34648 @r{      a@:    H c c   @:             @:     5  @:clean@:(a,p)}
34649 @r{      a@:    H c 0-9 @:             @:        @:clean@:(a,p)}
34650 @r{      a@:      c d   @:             @:     1  @:deg@:(a)}
34651 @r{      a@:      c f   @:             @:     1  @:pfloat@:(a)}
34652 @r{      a@:    H c f   @:             @:     1  @:float@:(a)}
34653 @r{      a@:      c h   @:             @:     1  @:hms@:(a)}
34654 @r{      a@:      c p   @:             @:        @:polar@:(a)}
34655 @r{      a@:    I c p   @:             @:        @:rect@:(a)}
34656 @r{      a@:      c r   @:             @:     1  @:rad@:(a)}
34659 @r{      a@:      c F   @:             @:     5  @:pfrac@:(a,p)}
34660 @r{      a@:    H c F   @:             @:     5  @:frac@:(a,p)}
34663 @r{      a@:      c %   @:             @:        @:percent@:(a*100)}
34666 @r{       @:      d .   @:char         @:    50  @:calc-point-char@:}
34667 @r{       @:      d ,   @:char         @:    50  @:calc-group-char@:}
34668 @r{       @:      d <   @:             @: 13,50  @:calc-left-justify@:}
34669 @r{       @:      d =   @:             @: 13,50  @:calc-center-justify@:}
34670 @r{       @:      d >   @:             @: 13,50  @:calc-right-justify@:}
34671 @r{       @:      d @{   @:label        @:    50  @:calc-left-label@:}
34672 @r{       @:      d @}   @:label        @:    50  @:calc-right-label@:}
34673 @r{       @:      d [   @:             @:     4  @:calc-truncate-up@:}
34674 @r{       @:      d ]   @:             @:     4  @:calc-truncate-down@:}
34675 @r{       @:      d "   @:             @: 12,50  @:calc-display-strings@:}
34676 @r{       @:      d @key{SPC} @:             @:        @:calc-refresh@:}
34677 @r{       @:      d @key{RET} @:             @:     1  @:calc-refresh-top@:}
34680 @r{       @:      d 0   @:             @:    50  @:calc-decimal-radix@:}
34681 @r{       @:      d 2   @:             @:    50  @:calc-binary-radix@:}
34682 @r{       @:      d 6   @:             @:    50  @:calc-hex-radix@:}
34683 @r{       @:      d 8   @:             @:    50  @:calc-octal-radix@:}
34686 @r{       @:      d b   @:           @:12,13,50  @:calc-line-breaking@:}
34687 @r{       @:      d c   @:             @:    50  @:calc-complex-notation@:}
34688 @r{       @:      d d   @:format       @:    50  @:calc-date-notation@:}
34689 @r{       @:      d e   @:             @:  5,50  @:calc-eng-notation@:}
34690 @r{       @:      d f   @:num          @: 31,50  @:calc-fix-notation@:}
34691 @r{       @:      d g   @:           @:12,13,50  @:calc-group-digits@:}
34692 @r{       @:      d h   @:format       @:    50  @:calc-hms-notation@:}
34693 @r{       @:      d i   @:             @:    50  @:calc-i-notation@:}
34694 @r{       @:      d j   @:             @:    50  @:calc-j-notation@:}
34695 @r{       @:      d l   @:             @: 12,50  @:calc-line-numbering@:}
34696 @r{       @:      d n   @:             @:  5,50  @:calc-normal-notation@:}
34697 @r{       @:      d o   @:format       @:    50  @:calc-over-notation@:}
34698 @r{       @:      d p   @:             @: 12,50  @:calc-show-plain@:}
34699 @r{       @:      d r   @:radix        @: 31,50  @:calc-radix@:}
34700 @r{       @:      d s   @:             @:  5,50  @:calc-sci-notation@:}
34701 @r{       @:      d t   @:             @:    27  @:calc-truncate-stack@:}
34702 @r{       @:      d w   @:             @: 12,13  @:calc-auto-why@:}
34703 @r{       @:      d z   @:             @: 12,50  @:calc-leading-zeros@:}
34706 @r{       @:      d B   @:             @:    50  @:calc-big-language@:}
34707 @r{       @:      d C   @:             @:    50  @:calc-c-language@:}
34708 @r{       @:      d E   @:             @:    50  @:calc-eqn-language@:}
34709 @r{       @:      d F   @:             @:    50  @:calc-fortran-language@:}
34710 @r{       @:      d M   @:             @:    50  @:calc-mathematica-language@:}
34711 @r{       @:      d N   @:             @:    50  @:calc-normal-language@:}
34712 @r{       @:      d O   @:             @:    50  @:calc-flat-language@:}
34713 @r{       @:      d P   @:             @:    50  @:calc-pascal-language@:}
34714 @r{       @:      d T   @:             @:    50  @:calc-tex-language@:}
34715 @r{       @:      d U   @:             @:    50  @:calc-unformatted-language@:}
34716 @r{       @:      d W   @:             @:    50  @:calc-maple-language@:}
34719 @r{      a@:      f [   @:             @:     4  @:decr@:(a,n)}
34720 @r{      a@:      f ]   @:             @:     4  @:incr@:(a,n)}
34723 @r{    a b@:      f b   @:             @:     2  @:beta@:(a,b)}
34724 @r{      a@:      f e   @:             @:     1  @:erf@:(a)}
34725 @r{      a@:    I f e   @:             @:     1  @:erfc@:(a)}
34726 @r{      a@:      f g   @:             @:     1  @:gamma@:(a)}
34727 @r{    a b@:      f h   @:             @:     2  @:hypot@:(a,b)}
34728 @r{      a@:      f i   @:             @:     1  @:im@:(a)}
34729 @r{    n a@:      f j   @:             @:     2  @:besJ@:(n,a)}
34730 @r{    a b@:      f n   @:             @:     2  @:min@:(a,b)}
34731 @r{      a@:      f r   @:             @:     1  @:re@:(a)}
34732 @r{      a@:      f s   @:             @:     1  @:sign@:(a)}
34733 @r{    a b@:      f x   @:             @:     2  @:max@:(a,b)}
34734 @r{    n a@:      f y   @:             @:     2  @:besY@:(n,a)}
34737 @r{      a@:      f A   @:             @:     1  @:abssqr@:(a)}
34738 @r{  x a b@:      f B   @:             @:        @:betaI@:(x,a,b)}
34739 @r{  x a b@:    H f B   @:             @:        @:betaB@:(x,a,b)}
34740 @r{      a@:      f E   @:             @:     1  @:expm1@:(a)}
34741 @r{    a x@:      f G   @:             @:     2  @:gammaP@:(a,x)}
34742 @r{    a x@:    I f G   @:             @:     2  @:gammaQ@:(a,x)}
34743 @r{    a x@:    H f G   @:             @:     2  @:gammag@:(a,x)}
34744 @r{    a x@:  I H f G   @:             @:     2  @:gammaG@:(a,x)}
34745 @r{    a b@:      f I   @:             @:     2  @:ilog@:(a,b)}
34746 @r{    a b@:    I f I   @:             @:     2  @:alog@:(a,b)  b^a}
34747 @r{      a@:      f L   @:             @:     1  @:lnp1@:(a)}
34748 @r{      a@:      f M   @:             @:     1  @:mant@:(a)}
34749 @r{      a@:      f Q   @:             @:     1  @:isqrt@:(a)}
34750 @r{      a@:    I f Q   @:             @:     1  @:sqr@:(a)  a^2}
34751 @r{    a n@:      f S   @:             @:     2  @:scf@:(a,n)}
34752 @r{    y x@:      f T   @:             @:        @:arctan2@:(y,x)}
34753 @r{      a@:      f X   @:             @:     1  @:xpon@:(a)}
34756 @r{    x y@:      g a   @:             @: 28,40  @:calc-graph-add@:}
34757 @r{       @:      g b   @:             @:    12  @:calc-graph-border@:}
34758 @r{       @:      g c   @:             @:        @:calc-graph-clear@:}
34759 @r{       @:      g d   @:             @:    41  @:calc-graph-delete@:}
34760 @r{    x y@:      g f   @:             @: 28,40  @:calc-graph-fast@:}
34761 @r{       @:      g g   @:             @:    12  @:calc-graph-grid@:}
34762 @r{       @:      g h   @:title        @:        @:calc-graph-header@:}
34763 @r{       @:      g j   @:             @:     4  @:calc-graph-juggle@:}
34764 @r{       @:      g k   @:             @:    12  @:calc-graph-key@:}
34765 @r{       @:      g l   @:             @:    12  @:calc-graph-log-x@:}
34766 @r{       @:      g n   @:name         @:        @:calc-graph-name@:}
34767 @r{       @:      g p   @:             @:    42  @:calc-graph-plot@:}
34768 @r{       @:      g q   @:             @:        @:calc-graph-quit@:}
34769 @r{       @:      g r   @:range        @:        @:calc-graph-range-x@:}
34770 @r{       @:      g s   @:             @: 12,13  @:calc-graph-line-style@:}
34771 @r{       @:      g t   @:title        @:        @:calc-graph-title-x@:}
34772 @r{       @:      g v   @:             @:        @:calc-graph-view-commands@:}
34773 @r{       @:      g x   @:display      @:        @:calc-graph-display@:}
34774 @r{       @:      g z   @:             @:    12  @:calc-graph-zero-x@:}
34777 @r{  x y z@:      g A   @:             @: 28,40  @:calc-graph-add-3d@:}
34778 @r{       @:      g C   @:command      @:        @:calc-graph-command@:}
34779 @r{       @:      g D   @:device       @: 43,44  @:calc-graph-device@:}
34780 @r{  x y z@:      g F   @:             @: 28,40  @:calc-graph-fast-3d@:}
34781 @r{       @:      g H   @:             @:    12  @:calc-graph-hide@:}
34782 @r{       @:      g K   @:             @:        @:calc-graph-kill@:}
34783 @r{       @:      g L   @:             @:    12  @:calc-graph-log-y@:}
34784 @r{       @:      g N   @:number       @: 43,51  @:calc-graph-num-points@:}
34785 @r{       @:      g O   @:filename     @: 43,44  @:calc-graph-output@:}
34786 @r{       @:      g P   @:             @:    42  @:calc-graph-print@:}
34787 @r{       @:      g R   @:range        @:        @:calc-graph-range-y@:}
34788 @r{       @:      g S   @:             @: 12,13  @:calc-graph-point-style@:}
34789 @r{       @:      g T   @:title        @:        @:calc-graph-title-y@:}
34790 @r{       @:      g V   @:             @:        @:calc-graph-view-trail@:}
34791 @r{       @:      g X   @:format       @:        @:calc-graph-geometry@:}
34792 @r{       @:      g Z   @:             @:    12  @:calc-graph-zero-y@:}
34795 @r{       @:      g C-l @:             @:    12  @:calc-graph-log-z@:}
34796 @r{       @:      g C-r @:range        @:        @:calc-graph-range-z@:}
34797 @r{       @:      g C-t @:title        @:        @:calc-graph-title-z@:}
34800 @r{       @:      h b   @:             @:        @:calc-describe-bindings@:}
34801 @r{       @:      h c   @:key          @:        @:calc-describe-key-briefly@:}
34802 @r{       @:      h f   @:function     @:        @:calc-describe-function@:}
34803 @r{       @:      h h   @:             @:        @:calc-full-help@:}
34804 @r{       @:      h i   @:             @:        @:calc-info@:}
34805 @r{       @:      h k   @:key          @:        @:calc-describe-key@:}
34806 @r{       @:      h n   @:             @:        @:calc-view-news@:}
34807 @r{       @:      h s   @:             @:        @:calc-info-summary@:}
34808 @r{       @:      h t   @:             @:        @:calc-tutorial@:}
34809 @r{       @:      h v   @:var          @:        @:calc-describe-variable@:}
34812 @r{       @:      j 1-9 @:             @:        @:calc-select-part@:}
34813 @r{       @:      j @key{RET} @:             @:    27  @:calc-copy-selection@:}
34814 @r{       @:      j @key{DEL} @:             @:    27  @:calc-del-selection@:}
34815 @r{       @:      j '   @:formula      @:    27  @:calc-enter-selection@:}
34816 @r{       @:      j `   @:editing      @: 27,30  @:calc-edit-selection@:}
34817 @r{       @:      j "   @:             @:  7,27  @:calc-sel-expand-formula@:}
34820 @r{       @:      j +   @:formula      @:    27  @:calc-sel-add-both-sides@:}
34821 @r{       @:      j -   @:formula      @:    27  @:calc-sel-sub-both-sides@:}
34822 @r{       @:      j *   @:formula      @:    27  @:calc-sel-mul-both-sides@:}
34823 @r{       @:      j /   @:formula      @:    27  @:calc-sel-div-both-sides@:}
34824 @r{       @:      j &   @:             @:    27  @:calc-sel-invert@:}
34827 @r{       @:      j a   @:             @:    27  @:calc-select-additional@:}
34828 @r{       @:      j b   @:             @:    12  @:calc-break-selections@:}
34829 @r{       @:      j c   @:             @:        @:calc-clear-selections@:}
34830 @r{       @:      j d   @:             @: 12,50  @:calc-show-selections@:}
34831 @r{       @:      j e   @:             @:    12  @:calc-enable-selections@:}
34832 @r{       @:      j l   @:             @:  4,27  @:calc-select-less@:}
34833 @r{       @:      j m   @:             @:  4,27  @:calc-select-more@:}
34834 @r{       @:      j n   @:             @:     4  @:calc-select-next@:}
34835 @r{       @:      j o   @:             @:  4,27  @:calc-select-once@:}
34836 @r{       @:      j p   @:             @:     4  @:calc-select-previous@:}
34837 @r{       @:      j r   @:rules        @:4,8,27  @:calc-rewrite-selection@:}
34838 @r{       @:      j s   @:             @:  4,27  @:calc-select-here@:}
34839 @r{       @:      j u   @:             @:    27  @:calc-unselect@:}
34840 @r{       @:      j v   @:             @:  7,27  @:calc-sel-evaluate@:}
34843 @r{       @:      j C   @:             @:    27  @:calc-sel-commute@:}
34844 @r{       @:      j D   @:             @:  4,27  @:calc-sel-distribute@:}
34845 @r{       @:      j E   @:             @:    27  @:calc-sel-jump-equals@:}
34846 @r{       @:      j I   @:             @:    27  @:calc-sel-isolate@:}
34847 @r{       @:    H j I   @:             @:    27  @:calc-sel-isolate@: (full)}
34848 @r{       @:      j L   @:             @:  4,27  @:calc-commute-left@:}
34849 @r{       @:      j M   @:             @:    27  @:calc-sel-merge@:}
34850 @r{       @:      j N   @:             @:    27  @:calc-sel-negate@:}
34851 @r{       @:      j O   @:             @:  4,27  @:calc-select-once-maybe@:}
34852 @r{       @:      j R   @:             @:  4,27  @:calc-commute-right@:}
34853 @r{       @:      j S   @:             @:  4,27  @:calc-select-here-maybe@:}
34854 @r{       @:      j U   @:             @:    27  @:calc-sel-unpack@:}
34857 @r{       @:      k a   @:             @:        @:calc-random-again@:}
34858 @r{      n@:      k b   @:             @:     1  @:bern@:(n)}
34859 @r{    n x@:    H k b   @:             @:     2  @:bern@:(n,x)}
34860 @r{    n m@:      k c   @:             @:     2  @:choose@:(n,m)}
34861 @r{    n m@:    H k c   @:             @:     2  @:perm@:(n,m)}
34862 @r{      n@:      k d   @:             @:     1  @:dfact@:(n)  n!!}
34863 @r{      n@:      k e   @:             @:     1  @:euler@:(n)}
34864 @r{    n x@:    H k e   @:             @:     2  @:euler@:(n,x)}
34865 @r{      n@:      k f   @:             @:     4  @:prfac@:(n)}
34866 @r{    n m@:      k g   @:             @:     2  @:gcd@:(n,m)}
34867 @r{    m n@:      k h   @:             @:    14  @:shuffle@:(n,m)}
34868 @r{    n m@:      k l   @:             @:     2  @:lcm@:(n,m)}
34869 @r{      n@:      k m   @:             @:     1  @:moebius@:(n)}
34870 @r{      n@:      k n   @:             @:     4  @:nextprime@:(n)}
34871 @r{      n@:    I k n   @:             @:     4  @:prevprime@:(n)}
34872 @r{      n@:      k p   @:             @:  4,28  @:calc-prime-test@:}
34873 @r{      m@:      k r   @:             @:    14  @:random@:(m)}
34874 @r{    n m@:      k s   @:             @:     2  @:stir1@:(n,m)}
34875 @r{    n m@:    H k s   @:             @:     2  @:stir2@:(n,m)}
34876 @r{      n@:      k t   @:             @:     1  @:totient@:(n)}
34879 @r{  n p x@:      k B   @:             @:        @:utpb@:(x,n,p)}
34880 @r{  n p x@:    I k B   @:             @:        @:ltpb@:(x,n,p)}
34881 @r{    v x@:      k C   @:             @:        @:utpc@:(x,v)}
34882 @r{    v x@:    I k C   @:             @:        @:ltpc@:(x,v)}
34883 @r{    n m@:      k E   @:             @:        @:egcd@:(n,m)}
34884 @r{v1 v2 x@:      k F   @:             @:        @:utpf@:(x,v1,v2)}
34885 @r{v1 v2 x@:    I k F   @:             @:        @:ltpf@:(x,v1,v2)}
34886 @r{  m s x@:      k N   @:             @:        @:utpn@:(x,m,s)}
34887 @r{  m s x@:    I k N   @:             @:        @:ltpn@:(x,m,s)}
34888 @r{    m x@:      k P   @:             @:        @:utpp@:(x,m)}
34889 @r{    m x@:    I k P   @:             @:        @:ltpp@:(x,m)}
34890 @r{    v x@:      k T   @:             @:        @:utpt@:(x,v)}
34891 @r{    v x@:    I k T   @:             @:        @:ltpt@:(x,v)}
34894 @r{       @:      m a   @:             @: 12,13  @:calc-algebraic-mode@:}
34895 @r{       @:      m d   @:             @:        @:calc-degrees-mode@:}
34896 @r{       @:      m f   @:             @:    12  @:calc-frac-mode@:}
34897 @r{       @:      m g   @:             @:    52  @:calc-get-modes@:}
34898 @r{       @:      m h   @:             @:        @:calc-hms-mode@:}
34899 @r{       @:      m i   @:             @: 12,13  @:calc-infinite-mode@:}
34900 @r{       @:      m m   @:             @:        @:calc-save-modes@:}
34901 @r{       @:      m p   @:             @:    12  @:calc-polar-mode@:}
34902 @r{       @:      m r   @:             @:        @:calc-radians-mode@:}
34903 @r{       @:      m s   @:             @:    12  @:calc-symbolic-mode@:}
34904 @r{       @:      m t   @:             @:    12  @:calc-total-algebraic-mode@:}
34905 @r{       @:      m v   @:             @: 12,13  @:calc-matrix-mode@:}
34906 @r{       @:      m w   @:             @:    13  @:calc-working@:}
34907 @r{       @:      m x   @:             @:        @:calc-always-load-extensions@:}
34910 @r{       @:      m A   @:             @:    12  @:calc-alg-simplify-mode@:}
34911 @r{       @:      m B   @:             @:    12  @:calc-bin-simplify-mode@:}
34912 @r{       @:      m C   @:             @:    12  @:calc-auto-recompute@:}
34913 @r{       @:      m D   @:             @:        @:calc-default-simplify-mode@:}
34914 @r{       @:      m E   @:             @:    12  @:calc-ext-simplify-mode@:}
34915 @r{       @:      m F   @:filename     @:    13  @:calc-settings-file-name@:}
34916 @r{       @:      m N   @:             @:    12  @:calc-num-simplify-mode@:}
34917 @r{       @:      m O   @:             @:    12  @:calc-no-simplify-mode@:}
34918 @r{       @:      m R   @:             @: 12,13  @:calc-mode-record-mode@:}
34919 @r{       @:      m S   @:             @:    12  @:calc-shift-prefix@:}
34920 @r{       @:      m U   @:             @:    12  @:calc-units-simplify-mode@:}
34923 @r{       @:      s c   @:var1, var2   @:    29  @:calc-copy-variable@:}
34924 @r{       @:      s d   @:var, decl    @:        @:calc-declare-variable@:}
34925 @r{       @:      s e   @:var, editing @: 29,30  @:calc-edit-variable@:}
34926 @r{       @:      s i   @:buffer       @:        @:calc-insert-variables@:}
34927 @r{    a b@:      s l   @:var          @:    29  @:@:a  (letting var=b)}
34928 @r{  a ...@:      s m   @:op, var      @: 22,29  @:calc-store-map@:}
34929 @r{       @:      s n   @:var          @: 29,47  @:calc-store-neg@:  (v/-1)}
34930 @r{       @:      s p   @:var          @:    29  @:calc-permanent-variable@:}
34931 @r{       @:      s r   @:var          @:    29  @:@:v  (recalled value)}
34932 @r{       @:      r 0-9 @:             @:        @:calc-recall-quick@:}
34933 @r{      a@:      s s   @:var          @: 28,29  @:calc-store@:}
34934 @r{      a@:      s 0-9 @:             @:        @:calc-store-quick@:}
34935 @r{      a@:      s t   @:var          @:    29  @:calc-store-into@:}
34936 @r{      a@:      t 0-9 @:             @:        @:calc-store-into-quick@:}
34937 @r{       @:      s u   @:var          @:    29  @:calc-unstore@:}
34938 @r{      a@:      s x   @:var          @:    29  @:calc-store-exchange@:}
34941 @r{       @:      s A   @:editing      @:    30  @:calc-edit-AlgSimpRules@:}
34942 @r{       @:      s D   @:editing      @:    30  @:calc-edit-Decls@:}
34943 @r{       @:      s E   @:editing      @:    30  @:calc-edit-EvalRules@:}
34944 @r{       @:      s F   @:editing      @:    30  @:calc-edit-FitRules@:}
34945 @r{       @:      s G   @:editing      @:    30  @:calc-edit-GenCount@:}
34946 @r{       @:      s H   @:editing      @:    30  @:calc-edit-Holidays@:}
34947 @r{       @:      s I   @:editing      @:    30  @:calc-edit-IntegLimit@:}
34948 @r{       @:      s L   @:editing      @:    30  @:calc-edit-LineStyles@:}
34949 @r{       @:      s P   @:editing      @:    30  @:calc-edit-PointStyles@:}
34950 @r{       @:      s R   @:editing      @:    30  @:calc-edit-PlotRejects@:}
34951 @r{       @:      s T   @:editing      @:    30  @:calc-edit-TimeZone@:}
34952 @r{       @:      s U   @:editing      @:    30  @:calc-edit-Units@:}
34953 @r{       @:      s X   @:editing      @:    30  @:calc-edit-ExtSimpRules@:}
34956 @r{      a@:      s +   @:var          @: 29,47  @:calc-store-plus@:  (v+a)}
34957 @r{      a@:      s -   @:var          @: 29,47  @:calc-store-minus@:  (v-a)}
34958 @r{      a@:      s *   @:var          @: 29,47  @:calc-store-times@:  (v*a)}
34959 @r{      a@:      s /   @:var          @: 29,47  @:calc-store-div@:  (v/a)}
34960 @r{      a@:      s ^   @:var          @: 29,47  @:calc-store-power@:  (v^a)}
34961 @r{      a@:      s |   @:var          @: 29,47  @:calc-store-concat@:  (v|a)}
34962 @r{       @:      s &   @:var          @: 29,47  @:calc-store-inv@:  (v^-1)}
34963 @r{       @:      s [   @:var          @: 29,47  @:calc-store-decr@:  (v-1)}
34964 @r{       @:      s ]   @:var          @: 29,47  @:calc-store-incr@:  (v-(-1))}
34965 @r{    a b@:      s :   @:             @:     2  @:assign@:(a,b)  a @t{:=} b}
34966 @r{      a@:      s =   @:             @:     1  @:evalto@:(a,b)  a @t{=>}}
34969 @r{       @:      t [   @:             @:     4  @:calc-trail-first@:}
34970 @r{       @:      t ]   @:             @:     4  @:calc-trail-last@:}
34971 @r{       @:      t <   @:             @:     4  @:calc-trail-scroll-left@:}
34972 @r{       @:      t >   @:             @:     4  @:calc-trail-scroll-right@:}
34973 @r{       @:      t .   @:             @:    12  @:calc-full-trail-vectors@:}
34976 @r{       @:      t b   @:             @:     4  @:calc-trail-backward@:}
34977 @r{       @:      t d   @:             @: 12,50  @:calc-trail-display@:}
34978 @r{       @:      t f   @:             @:     4  @:calc-trail-forward@:}
34979 @r{       @:      t h   @:             @:        @:calc-trail-here@:}
34980 @r{       @:      t i   @:             @:        @:calc-trail-in@:}
34981 @r{       @:      t k   @:             @:     4  @:calc-trail-kill@:}
34982 @r{       @:      t m   @:string       @:        @:calc-trail-marker@:}
34983 @r{       @:      t n   @:             @:     4  @:calc-trail-next@:}
34984 @r{       @:      t o   @:             @:        @:calc-trail-out@:}
34985 @r{       @:      t p   @:             @:     4  @:calc-trail-previous@:}
34986 @r{       @:      t r   @:string       @:        @:calc-trail-isearch-backward@:}
34987 @r{       @:      t s   @:string       @:        @:calc-trail-isearch-forward@:}
34988 @r{       @:      t y   @:             @:     4  @:calc-trail-yank@:}
34991 @r{      d@:      t C   @:oz, nz       @:        @:tzconv@:(d,oz,nz)}
34992 @r{d oz nz@:      t C   @:$            @:        @:tzconv@:(d,oz,nz)}
34993 @r{      d@:      t D   @:             @:    15  @:date@:(d)}
34994 @r{      d@:      t I   @:             @:     4  @:incmonth@:(d,n)}
34995 @r{      d@:      t J   @:             @:    16  @:julian@:(d,z)}
34996 @r{      d@:      t M   @:             @:    17  @:newmonth@:(d,n)}
34997 @r{       @:      t N   @:             @:    16  @:now@:(z)}
34998 @r{      d@:      t P   @:1            @:    31  @:year@:(d)}
34999 @r{      d@:      t P   @:2            @:    31  @:month@:(d)}
35000 @r{      d@:      t P   @:3            @:    31  @:day@:(d)}
35001 @r{      d@:      t P   @:4            @:    31  @:hour@:(d)}
35002 @r{      d@:      t P   @:5            @:    31  @:minute@:(d)}
35003 @r{      d@:      t P   @:6            @:    31  @:second@:(d)}
35004 @r{      d@:      t P   @:7            @:    31  @:weekday@:(d)}
35005 @r{      d@:      t P   @:8            @:    31  @:yearday@:(d)}
35006 @r{      d@:      t P   @:9            @:    31  @:time@:(d)}
35007 @r{      d@:      t U   @:             @:    16  @:unixtime@:(d,z)}
35008 @r{      d@:      t W   @:             @:    17  @:newweek@:(d,w)}
35009 @r{      d@:      t Y   @:             @:    17  @:newyear@:(d,n)}
35012 @r{    a b@:      t +   @:             @:     2  @:badd@:(a,b)}
35013 @r{    a b@:      t -   @:             @:     2  @:bsub@:(a,b)}
35016 @r{       @:      u a   @:             @:    12  @:calc-autorange-units@:}
35017 @r{      a@:      u b   @:             @:        @:calc-base-units@:}
35018 @r{      a@:      u c   @:units        @:    18  @:calc-convert-units@:}
35019 @r{   defn@:      u d   @:unit, descr  @:        @:calc-define-unit@:}
35020 @r{       @:      u e   @:             @:        @:calc-explain-units@:}
35021 @r{       @:      u g   @:unit         @:        @:calc-get-unit-definition@:}
35022 @r{       @:      u p   @:             @:        @:calc-permanent-units@:}
35023 @r{      a@:      u r   @:             @:        @:calc-remove-units@:}
35024 @r{      a@:      u s   @:             @:        @:usimplify@:(a)}
35025 @r{      a@:      u t   @:units        @:    18  @:calc-convert-temperature@:}
35026 @r{       @:      u u   @:unit         @:        @:calc-undefine-unit@:}
35027 @r{       @:      u v   @:             @:        @:calc-enter-units-table@:}
35028 @r{      a@:      u x   @:             @:        @:calc-extract-units@:}
35029 @r{      a@:      u 0-9 @:             @:        @:calc-quick-units@:}
35032 @r{  v1 v2@:      u C   @:             @:    20  @:vcov@:(v1,v2)}
35033 @r{  v1 v2@:    I u C   @:             @:    20  @:vpcov@:(v1,v2)}
35034 @r{  v1 v2@:    H u C   @:             @:    20  @:vcorr@:(v1,v2)}
35035 @r{      v@:      u G   @:             @:    19  @:vgmean@:(v)}
35036 @r{    a b@:    H u G   @:             @:     2  @:agmean@:(a,b)}
35037 @r{      v@:      u M   @:             @:    19  @:vmean@:(v)}
35038 @r{      v@:    I u M   @:             @:    19  @:vmeane@:(v)}
35039 @r{      v@:    H u M   @:             @:    19  @:vmedian@:(v)}
35040 @r{      v@:  I H u M   @:             @:    19  @:vhmean@:(v)}
35041 @r{      v@:      u N   @:             @:    19  @:vmin@:(v)}
35042 @r{      v@:      u S   @:             @:    19  @:vsdev@:(v)}
35043 @r{      v@:    I u S   @:             @:    19  @:vpsdev@:(v)}
35044 @r{      v@:    H u S   @:             @:    19  @:vvar@:(v)}
35045 @r{      v@:  I H u S   @:             @:    19  @:vpvar@:(v)}
35046 @r{       @:      u V   @:             @:        @:calc-view-units-table@:}
35047 @r{      v@:      u X   @:             @:    19  @:vmax@:(v)}
35050 @r{      v@:      u +   @:             @:    19  @:vsum@:(v)}
35051 @r{      v@:      u *   @:             @:    19  @:vprod@:(v)}
35052 @r{      v@:      u #   @:             @:    19  @:vcount@:(v)}
35055 @r{       @:      V (   @:             @:    50  @:calc-vector-parens@:}
35056 @r{       @:      V @{   @:             @:    50  @:calc-vector-braces@:}
35057 @r{       @:      V [   @:             @:    50  @:calc-vector-brackets@:}
35058 @r{       @:      V ]   @:ROCP         @:    50  @:calc-matrix-brackets@:}
35059 @r{       @:      V ,   @:             @:    50  @:calc-vector-commas@:}
35060 @r{       @:      V <   @:             @:    50  @:calc-matrix-left-justify@:}
35061 @r{       @:      V =   @:             @:    50  @:calc-matrix-center-justify@:}
35062 @r{       @:      V >   @:             @:    50  @:calc-matrix-right-justify@:}
35063 @r{       @:      V /   @:             @: 12,50  @:calc-break-vectors@:}
35064 @r{       @:      V .   @:             @: 12,50  @:calc-full-vectors@:}
35067 @r{    s t@:      V ^   @:             @:     2  @:vint@:(s,t)}
35068 @r{    s t@:      V -   @:             @:     2  @:vdiff@:(s,t)}
35069 @r{      s@:      V ~   @:             @:     1  @:vcompl@:(s)}
35070 @r{      s@:      V #   @:             @:     1  @:vcard@:(s)}
35071 @r{      s@:      V :   @:             @:     1  @:vspan@:(s)}
35072 @r{      s@:      V +   @:             @:     1  @:rdup@:(s)}
35075 @r{      m@:      V &   @:             @:     1  @:inv@:(m)  1/m}
35078 @r{      v@:      v a   @:n            @:        @:arrange@:(v,n)}
35079 @r{      a@:      v b   @:n            @:        @:cvec@:(a,n)}
35080 @r{      v@:      v c   @:n >0         @: 21,31  @:mcol@:(v,n)}
35081 @r{      v@:      v c   @:n <0         @:    31  @:mrcol@:(v,-n)}
35082 @r{      m@:      v c   @:0            @:    31  @:getdiag@:(m)}
35083 @r{      v@:      v d   @:             @:    25  @:diag@:(v,n)}
35084 @r{    v m@:      v e   @:             @:     2  @:vexp@:(v,m)}
35085 @r{  v m f@:    H v e   @:             @:     2  @:vexp@:(v,m,f)}
35086 @r{    v a@:      v f   @:             @:    26  @:find@:(v,a,n)}
35087 @r{      v@:      v h   @:             @:     1  @:head@:(v)}
35088 @r{      v@:    I v h   @:             @:     1  @:tail@:(v)}
35089 @r{      v@:    H v h   @:             @:     1  @:rhead@:(v)}
35090 @r{      v@:  I H v h   @:             @:     1  @:rtail@:(v)}
35091 @r{       @:      v i   @:n            @:    31  @:idn@:(1,n)}
35092 @r{       @:      v i   @:0            @:    31  @:idn@:(1)}
35093 @r{    h t@:      v k   @:             @:     2  @:cons@:(h,t)}
35094 @r{    h t@:    H v k   @:             @:     2  @:rcons@:(h,t)}
35095 @r{      v@:      v l   @:             @:     1  @:vlen@:(v)}
35096 @r{      v@:    H v l   @:             @:     1  @:mdims@:(v)}
35097 @r{    v m@:      v m   @:             @:     2  @:vmask@:(v,m)}
35098 @r{      v@:      v n   @:             @:     1  @:rnorm@:(v)}
35099 @r{  a b c@:      v p   @:             @:    24  @:calc-pack@:}
35100 @r{      v@:      v r   @:n >0         @: 21,31  @:mrow@:(v,n)}
35101 @r{      v@:      v r   @:n <0         @:    31  @:mrrow@:(v,-n)}
35102 @r{      m@:      v r   @:0            @:    31  @:getdiag@:(m)}
35103 @r{  v i j@:      v s   @:             @:        @:subvec@:(v,i,j)}
35104 @r{  v i j@:    I v s   @:             @:        @:rsubvec@:(v,i,j)}
35105 @r{      m@:      v t   @:             @:     1  @:trn@:(m)}
35106 @r{      v@:      v u   @:             @:    24  @:calc-unpack@:}
35107 @r{      v@:      v v   @:             @:     1  @:rev@:(v)}
35108 @r{       @:      v x   @:n            @:    31  @:index@:(n)}
35109 @r{  n s i@:  C-u v x   @:             @:        @:index@:(n,s,i)}
35112 @r{      v@:      V A   @:op           @:    22  @:apply@:(op,v)}
35113 @r{  v1 v2@:      V C   @:             @:     2  @:cross@:(v1,v2)}
35114 @r{      m@:      V D   @:             @:     1  @:det@:(m)}
35115 @r{      s@:      V E   @:             @:     1  @:venum@:(s)}
35116 @r{      s@:      V F   @:             @:     1  @:vfloor@:(s)}
35117 @r{      v@:      V G   @:             @:        @:grade@:(v)}
35118 @r{      v@:    I V G   @:             @:        @:rgrade@:(v)}
35119 @r{      v@:      V H   @:n            @:    31  @:histogram@:(v,n)}
35120 @r{    v w@:    H V H   @:n            @:    31  @:histogram@:(v,w,n)}
35121 @r{  v1 v2@:      V I   @:mop aop      @:    22  @:inner@:(mop,aop,v1,v2)}
35122 @r{      m@:      V J   @:             @:     1  @:ctrn@:(m)}
35123 @r{      m@:      V L   @:             @:     1  @:lud@:(m)}
35124 @r{      v@:      V M   @:op           @: 22,23  @:map@:(op,v)}
35125 @r{      v@:      V N   @:             @:     1  @:cnorm@:(v)}
35126 @r{  v1 v2@:      V O   @:op           @:    22  @:outer@:(op,v1,v2)}
35127 @r{      v@:      V R   @:op           @: 22,23  @:reduce@:(op,v)}
35128 @r{      v@:    I V R   @:op           @: 22,23  @:rreduce@:(op,v)}
35129 @r{    a n@:    H V R   @:op           @:    22  @:nest@:(op,a,n)}
35130 @r{      a@:  I H V R   @:op           @:    22  @:fixp@:(op,a)}
35131 @r{      v@:      V S   @:             @:        @:sort@:(v)}
35132 @r{      v@:    I V S   @:             @:        @:rsort@:(v)}
35133 @r{      m@:      V T   @:             @:     1  @:tr@:(m)}
35134 @r{      v@:      V U   @:op           @:    22  @:accum@:(op,v)}
35135 @r{      v@:    I V U   @:op           @:    22  @:raccum@:(op,v)}
35136 @r{    a n@:    H V U   @:op           @:    22  @:anest@:(op,a,n)}
35137 @r{      a@:  I H V U   @:op           @:    22  @:afixp@:(op,a)}
35138 @r{    s t@:      V V   @:             @:     2  @:vunion@:(s,t)}
35139 @r{    s t@:      V X   @:             @:     2  @:vxor@:(s,t)}
35142 @r{       @:      Y     @:             @:        @:@:user commands}
35145 @r{       @:      z     @:             @:        @:@:user commands}
35148 @r{      c@:      Z [   @:             @:    45  @:calc-kbd-if@:}
35149 @r{      c@:      Z |   @:             @:    45  @:calc-kbd-else-if@:}
35150 @r{       @:      Z :   @:             @:        @:calc-kbd-else@:}
35151 @r{       @:      Z ]   @:             @:        @:calc-kbd-end-if@:}
35154 @r{       @:      Z @{   @:             @:     4  @:calc-kbd-loop@:}
35155 @r{      c@:      Z /   @:             @:    45  @:calc-kbd-break@:}
35156 @r{       @:      Z @}   @:             @:        @:calc-kbd-end-loop@:}
35157 @r{      n@:      Z <   @:             @:        @:calc-kbd-repeat@:}
35158 @r{       @:      Z >   @:             @:        @:calc-kbd-end-repeat@:}
35159 @r{    n m@:      Z (   @:             @:        @:calc-kbd-for@:}
35160 @r{      s@:      Z )   @:             @:        @:calc-kbd-end-for@:}
35163 @r{       @:      Z C-g @:             @:        @:@:cancel if/loop command}
35166 @r{       @:      Z `   @:             @:        @:calc-kbd-push@:}
35167 @r{       @:      Z '   @:             @:        @:calc-kbd-pop@:}
35168 @r{      a@:      Z =   @:message      @:    28  @:calc-kbd-report@:}
35169 @r{       @:      Z #   @:prompt       @:        @:calc-kbd-query@:}
35172 @r{   comp@:      Z C   @:func, args   @:    50  @:calc-user-define-composition@:}
35173 @r{       @:      Z D   @:key, command @:        @:calc-user-define@:}
35174 @r{       @:      Z E   @:key, editing @:    30  @:calc-user-define-edit@:}
35175 @r{   defn@:      Z F   @:k, c, f, a, n@:    28  @:calc-user-define-formula@:}
35176 @r{       @:      Z G   @:key          @:        @:calc-get-user-defn@:}
35177 @r{       @:      Z I   @:             @:        @:calc-user-define-invocation@:}
35178 @r{       @:      Z K   @:key, command @:        @:calc-user-define-kbd-macro@:}
35179 @r{       @:      Z P   @:key          @:        @:calc-user-define-permanent@:}
35180 @r{       @:      Z S   @:             @:    30  @:calc-edit-user-syntax@:}
35181 @r{       @:      Z T   @:             @:    12  @:calc-timing@:}
35182 @r{       @:      Z U   @:key          @:        @:calc-user-undefine@:}
35184 @end format
35186 @noindent
35187 NOTES
35189 @enumerate
35190 @c 1
35191 @item
35192 Positive prefix arguments apply to @cite{n} stack entries.
35193 Negative prefix arguments apply to the @cite{-n}th stack entry.
35194 A prefix of zero applies to the entire stack.  (For @key{LFD} and
35195 @kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
35197 @c 2
35198 @item
35199 Positive prefix arguments apply to @cite{n} stack entries.
35200 Negative prefix arguments apply to the top stack entry
35201 and the next @cite{-n} stack entries.
35203 @c 3
35204 @item
35205 Positive prefix arguments rotate top @cite{n} stack entries by one.
35206 Negative prefix arguments rotate the entire stack by @cite{-n}.
35207 A prefix of zero reverses the entire stack.
35209 @c 4
35210 @item
35211 Prefix argument specifies a repeat count or distance.
35213 @c 5
35214 @item
35215 Positive prefix arguments specify a precision @cite{p}.
35216 Negative prefix arguments reduce the current precision by @cite{-p}.
35218 @c 6
35219 @item
35220 A prefix argument is interpreted as an additional step-size parameter.
35221 A plain @kbd{C-u} prefix means to prompt for the step size.
35223 @c 7
35224 @item
35225 A prefix argument specifies simplification level and depth.
35226 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}.
35228 @c 8
35229 @item
35230 A negative prefix operates only on the top level of the input formula.
35232 @c 9
35233 @item
35234 Positive prefix arguments specify a word size of @cite{w} bits, unsigned.
35235 Negative prefix arguments specify a word size of @cite{w} bits, signed.
35237 @c 10
35238 @item
35239 Prefix arguments specify the shift amount @cite{n}.  The @cite{w} argument
35240 cannot be specified in the keyboard version of this command.
35242 @c 11
35243 @item
35244 From the keyboard, @cite{d} is omitted and defaults to zero.
35246 @c 12
35247 @item
35248 Mode is toggled; a positive prefix always sets the mode, and a negative
35249 prefix always clears the mode.
35251 @c 13
35252 @item
35253 Some prefix argument values provide special variations of the mode.
35255 @c 14
35256 @item
35257 A prefix argument, if any, is used for @cite{m} instead of taking
35258 @cite{m} from the stack.  @cite{M} may take any of these values:
35259 @iftex
35260 {@advance@tableindent10pt
35261 @end iftex
35262 @table @asis
35263 @item Integer
35264 Random integer in the interval @cite{[0 .. m)}.
35265 @item Float
35266 Random floating-point number in the interval @cite{[0 .. m)}.
35267 @item 0.0
35268 Gaussian with mean 1 and standard deviation 0.
35269 @item Error form
35270 Gaussian with specified mean and standard deviation.
35271 @item Interval
35272 Random integer or floating-point number in that interval.
35273 @item Vector
35274 Random element from the vector.
35275 @end table
35276 @iftex
35278 @end iftex
35280 @c 15
35281 @item
35282 A prefix argument from 1 to 6 specifies number of date components
35283 to remove from the stack.  @xref{Date Conversions}.
35285 @c 16
35286 @item
35287 A prefix argument specifies a time zone; @kbd{C-u} says to take the
35288 time zone number or name from the top of the stack.  @xref{Time Zones}.
35290 @c 17
35291 @item
35292 A prefix argument specifies a day number (0-6, 0-31, or 0-366).
35294 @c 18
35295 @item
35296 If the input has no units, you will be prompted for both the old and
35297 the new units.
35299 @c 19
35300 @item
35301 With a prefix argument, collect that many stack entries to form the
35302 input data set.  Each entry may be a single value or a vector of values.
35304 @c 20
35305 @item
35306 With a prefix argument of 1, take a single @c{$@var{n}\times2$}
35307 @i{@var{N}x2} matrix from the
35308 stack instead of two separate data vectors.
35310 @c 21
35311 @item
35312 The row or column number @cite{n} may be given as a numeric prefix
35313 argument instead.  A plain @kbd{C-u} prefix says to take @cite{n}
35314 from the top of the stack.  If @cite{n} is a vector or interval,
35315 a subvector/submatrix of the input is created.
35317 @c 22
35318 @item
35319 The @cite{op} prompt can be answered with the key sequence for the
35320 desired function, or with @kbd{x} or @kbd{z} followed by a function name,
35321 or with @kbd{$} to take a formula from the top of the stack, or with
35322 @kbd{'} and a typed formula.  In the last two cases, the formula may
35323 be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
35324 may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
35325 last argument of the created function), or otherwise you will be
35326 prompted for an argument list.  The number of vectors popped from the
35327 stack by @kbd{V M} depends on the number of arguments of the function.
35329 @c 23
35330 @item
35331 One of the mapping direction keys @kbd{_} (horizontal, i.e., map
35332 by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
35333 reduce down), or @kbd{=} (map or reduce by rows) may be used before
35334 entering @cite{op}; these modify the function name by adding the letter
35335 @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
35336 or @code{d} for ``down.''
35338 @c 24
35339 @item
35340 The prefix argument specifies a packing mode.  A nonnegative mode
35341 is the number of items (for @kbd{v p}) or the number of levels
35342 (for @kbd{v u}).  A negative mode is as described below.  With no
35343 prefix argument, the mode is taken from the top of the stack and
35344 may be an integer or a vector of integers.
35345 @iftex
35346 {@advance@tableindent-20pt
35347 @end iftex
35348 @table @cite
35349 @item -1
35350 (@var{2})  Rectangular complex number.
35351 @item -2
35352 (@var{2})  Polar complex number.
35353 @item -3
35354 (@var{3})  HMS form.
35355 @item -4
35356 (@var{2})  Error form.
35357 @item -5
35358 (@var{2})  Modulo form.
35359 @item -6
35360 (@var{2})  Closed interval.
35361 @item -7
35362 (@var{2})  Closed .. open interval.
35363 @item -8
35364 (@var{2})  Open .. closed interval.
35365 @item -9
35366 (@var{2})  Open interval.
35367 @item -10
35368 (@var{2})  Fraction.
35369 @item -11
35370 (@var{2})  Float with integer mantissa.
35371 @item -12
35372 (@var{2})  Float with mantissa in @cite{[1 .. 10)}.
35373 @item -13
35374 (@var{1})  Date form (using date numbers).
35375 @item -14
35376 (@var{3})  Date form (using year, month, day).
35377 @item -15
35378 (@var{6})  Date form (using year, month, day, hour, minute, second).
35379 @end table
35380 @iftex
35382 @end iftex
35384 @c 25
35385 @item
35386 A prefix argument specifies the size @cite{n} of the matrix.  With no
35387 prefix argument, @cite{n} is omitted and the size is inferred from
35388 the input vector.
35390 @c 26
35391 @item
35392 The prefix argument specifies the starting position @cite{n} (default 1).
35394 @c 27
35395 @item
35396 Cursor position within stack buffer affects this command.
35398 @c 28
35399 @item
35400 Arguments are not actually removed from the stack by this command.
35402 @c 29
35403 @item
35404 Variable name may be a single digit or a full name.
35406 @c 30
35407 @item
35408 Editing occurs in a separate buffer.  Press @kbd{M-# M-#} (or @kbd{C-c C-c},
35409 @key{LFD}, or in some cases @key{RET}) to finish the edit, or press
35410 @kbd{M-# x} to cancel the edit.  The @key{LFD} key prevents evaluation
35411 of the result of the edit.
35413 @c 31
35414 @item
35415 The number prompted for can also be provided as a prefix argument.
35417 @c 32
35418 @item
35419 Press this key a second time to cancel the prefix.
35421 @c 33
35422 @item
35423 With a negative prefix, deactivate all formulas.  With a positive
35424 prefix, deactivate and then reactivate from scratch.
35426 @c 34
35427 @item
35428 Default is to scan for nearest formula delimiter symbols.  With a
35429 prefix of zero, formula is delimited by mark and point.  With a
35430 non-zero prefix, formula is delimited by scanning forward or
35431 backward by that many lines.
35433 @c 35
35434 @item
35435 Parse the region between point and mark as a vector.  A nonzero prefix
35436 parses @var{n} lines before or after point as a vector.  A zero prefix
35437 parses the current line as a vector.  A @kbd{C-u} prefix parses the
35438 region between point and mark as a single formula.
35440 @c 36
35441 @item
35442 Parse the rectangle defined by point and mark as a matrix.  A positive
35443 prefix @var{n} divides the rectangle into columns of width @var{n}.
35444 A zero or @kbd{C-u} prefix parses each line as one formula.  A negative
35445 prefix suppresses special treatment of bracketed portions of a line.
35447 @c 37
35448 @item
35449 A numeric prefix causes the current language mode to be ignored.
35451 @c 38
35452 @item
35453 Responding to a prompt with a blank line answers that and all
35454 later prompts by popping additional stack entries.
35456 @c 39
35457 @item
35458 Answer for @cite{v} may also be of the form @cite{v = v_0} or
35459 @cite{v - v_0}.
35461 @c 40
35462 @item
35463 With a positive prefix argument, stack contains many @cite{y}'s and one
35464 common @cite{x}.  With a zero prefix, stack contains a vector of
35465 @cite{y}s and a common @cite{x}.  With a negative prefix, stack
35466 contains many @cite{[x,y]} vectors.  (For 3D plots, substitute
35467 @cite{z} for @cite{y} and @cite{x,y} for @cite{x}.)
35469 @c 41
35470 @item
35471 With any prefix argument, all curves in the graph are deleted.
35473 @c 42
35474 @item
35475 With a positive prefix, refines an existing plot with more data points.
35476 With a negative prefix, forces recomputation of the plot data.
35478 @c 43
35479 @item
35480 With any prefix argument, set the default value instead of the
35481 value for this graph.
35483 @c 44
35484 @item
35485 With a negative prefix argument, set the value for the printer.
35487 @c 45
35488 @item
35489 Condition is considered ``true'' if it is a nonzero real or complex
35490 number, or a formula whose value is known to be nonzero; it is ``false''
35491 otherwise.
35493 @c 46
35494 @item
35495 Several formulas separated by commas are pushed as multiple stack
35496 entries.  Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
35497 delimiters may be omitted.  The notation @kbd{$$$} refers to the value
35498 in stack level three, and causes the formula to replace the top three
35499 stack levels.  The notation @kbd{$3} refers to stack level three without
35500 causing that value to be removed from the stack.  Use @key{LFD} in place
35501 of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
35502 to evaluate variables.@refill
35504 @c 47
35505 @item
35506 The variable is replaced by the formula shown on the right.  The
35507 Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
35508 assigns @c{$x \coloneq a-x$}
35509 @cite{x := a-x}.
35511 @c 48
35512 @item
35513 Press @kbd{?} repeatedly to see how to choose a model.  Answer the
35514 variables prompt with @cite{iv} or @cite{iv;pv} to specify
35515 independent and parameter variables.  A positive prefix argument
35516 takes @i{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
35517 and a vector from the stack.
35519 @c 49
35520 @item
35521 With a plain @kbd{C-u} prefix, replace the current region of the
35522 destination buffer with the yanked text instead of inserting.
35524 @c 50
35525 @item
35526 All stack entries are reformatted; the @kbd{H} prefix inhibits this.
35527 The @kbd{I} prefix sets the mode temporarily, redraws the top stack
35528 entry, then restores the original setting of the mode.
35530 @c 51
35531 @item
35532 A negative prefix sets the default 3D resolution instead of the
35533 default 2D resolution.
35535 @c 52
35536 @item
35537 This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
35538 @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
35539 @var{matrix}, @var{simp}, @var{inf}].  A prefix argument from 1 to 12
35540 grabs the @var{n}th mode value only.
35541 @end enumerate
35543 @iftex
35544 (Space is provided below for you to keep your own written notes.)
35545 @page
35546 @endgroup
35547 @end iftex
35550 @c [end-summary]
35552 @node Key Index, Command Index, Summary, Top
35553 @unnumbered Index of Key Sequences
35555 @printindex ky
35557 @node Command Index, Function Index, Key Index, Top
35558 @unnumbered Index of Calculator Commands
35560 Since all Calculator commands begin with the prefix @samp{calc-}, the
35561 @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
35562 types @samp{calc-} for you.  Thus, @kbd{x last-args} is short for
35563 @kbd{M-x calc-last-args}.
35565 @printindex pg
35567 @node Function Index, Concept Index, Command Index, Top
35568 @unnumbered Index of Algebraic Functions
35570 This is a list of built-in functions and operators usable in algebraic
35571 expressions.  Their full Lisp names are derived by adding the prefix
35572 @samp{calcFunc-}, as in @code{calcFunc-sqrt}.
35573 @iftex
35574 All functions except those noted with ``*'' have corresponding
35575 Calc keystrokes and can also be found in the Calc Summary.
35576 @end iftex
35578 @printindex tp
35580 @node Concept Index, Variable Index, Function Index, Top
35581 @unnumbered Concept Index
35583 @printindex cp
35585 @node Variable Index, Lisp Function Index, Concept Index, Top
35586 @unnumbered Index of Variables
35588 The variables in this list that do not contain dashes are accessible
35589 as Calc variables.  Add a @samp{var-} prefix to get the name of the
35590 corresponding Lisp variable.
35592 The remaining variables are Lisp variables suitable for @code{setq}ing
35593 in your @file{.emacs} file.
35595 @printindex vr
35597 @node Lisp Function Index, , Variable Index, Top
35598 @unnumbered Index of Lisp Math Functions
35600 The following functions are meant to be used with @code{defmath}, not
35601 @code{defun} definitions.  For names that do not start with @samp{calc-},
35602 the corresponding full Lisp name is derived by adding a prefix of
35603 @samp{math-}.
35605 @printindex fn
35607 @summarycontents
35609 @c [end]
35611 @contents
35612 @bye