1 \input texinfo @c -*-texinfo-*-
2 @comment %**start of header (This is for running Texinfo on a region.)
4 @setfilename ../info/calc
6 @settitle GNU Emacs Calc 2.02g Manual
8 @comment %**end of header (This is for running Texinfo on a region.)
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}
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
35 \gdef\mycxxy#1#2{#1\Etex\mycxxz}
39 @c Fix some other things specifically for this manual.
42 @mathcode`@:=`@: @c Make Calc fractions come out right in math mode
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}
51 @newdimen@kyvpos @kyvpos=0pt
52 @newdimen@kyhpos @kyhpos=0pt
53 @newcount@calcclubpenalty @calcclubpenalty=1000
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
62 \catcode`\@=0 @catcode`@\=@active
67 This file documents Calc, the GNU Emacs calculator.
69 Copyright (C) 1990, 1991, 2001, 2002 Free Software Foundation, Inc.
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.''
87 * Calc: (calc). Advanced desk calculator and mathematical tool.
92 @center @titlefont{Calc Manual}
94 @center GNU Emacs Calc Version 2.02g
99 @center Dave Gillespie
100 @center daveg@@synaptics.com
103 @vskip 0pt plus 1filll
104 Copyright @copyright{} 1990, 1991, 2001, 2002 Free Software Foundation, Inc.
110 @node Top, , (dir), (dir)
111 @chapter The GNU Emacs Calculator
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.)
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.
163 @node Copying, Getting Started, Top, Top
164 @unnumbered GNU GENERAL PUBLIC LICENSE
165 @center Version 1, February 1989
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.
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
217 @unnumberedsec TERMS AND CONDITIONS
220 @center TERMS AND CONDITIONS
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''.
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
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:
250 cause the modified files to carry prominent notices stating that
251 you changed the files and the date of any change; and
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).
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
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
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.
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:
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,
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,
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.)
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.
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.
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.
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.
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
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.
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.
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.
389 @node Getting Started, Tutorial, Copying, Top
390 @chapter Getting Started
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.
398 * About This Manual::
399 * Notations Used in This Manual::
401 * Demonstration of Calc::
402 * History and Acknowledgements::
405 @node What is Calc, About This Manual, Getting Started, Getting Started
406 @section What is Calc?
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:
415 Choice of algebraic or RPN (stack-based) entry of calculations.
418 Arbitrary precision integers and floating-point numbers.
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.
427 Mathematical operations such as logarithms and trigonometric functions.
430 Programmer's features (bitwise operations, non-decimal numbers).
433 Financial functions such as future value and internal rate of return.
436 Number theoretical features such as prime factorization and arithmetic
437 modulo @var{m} for any @var{m}.
440 Algebraic manipulation features, including symbolic calculus.
443 Moving data to and from regular editing buffers.
446 ``Embedded mode'' for manipulating Calc formulas and data directly
447 inside any editing buffer.
450 Graphics using GNUPLOT, a versatile (and free) plotting program.
453 Easy programming using keyboard macros, algebraic formulas,
454 algebraic rewrite rules, or extended Emacs Lisp.
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
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
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).
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).
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''
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
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
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
534 @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
535 @section Notations Used in This Manual
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.
547 The @key{DEL} key is called Backspace on some keyboards, it is
548 whatever key you would use to correct a simple typing error when
549 regularly using Emacs.
551 (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
552 the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
553 If you don't have a Meta key, look for Alt or Extend Char. You can
554 also press @key{ESC} or @key{C-[} first to get the same effect, so
555 that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
557 Sometimes the @key{RET} key is not shown when it is ``obvious''
558 that you must press @key{RET} to proceed. For example, the @key{RET}
559 is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
561 Commands are generally shown like this: @kbd{p} (@code{calc-precision})
562 or @kbd{M-# k} (@code{calc-keypad}). This means that the command is
563 normally used by pressing the @kbd{p} key or @kbd{M-# k} key sequence,
564 but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
566 Commands that correspond to functions in algebraic notation
567 are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means
568 the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
569 the corresponding function in an algebraic-style formula would
570 be @samp{cos(@var{x})}.
572 A few commands don't have key equivalents: @code{calc-sincos}
573 [@code{sincos}].@refill
575 @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
576 @section A Demonstration of Calc
579 @cindex Demonstration of Calc
580 This section will show some typical small problems being solved with
581 Calc. The focus is more on demonstration than explanation, but
582 everything you see here will be covered more thoroughly in the
585 To begin, start Emacs if necessary (usually the command @code{emacs}
586 does this), and type @kbd{M-# c} (or @kbd{@key{ESC} # c}) to start the
587 Calculator. (@xref{Starting Calc}, if this doesn't work for you.)
589 Be sure to type all the sample input exactly, especially noting the
590 difference between lower-case and upper-case letters. Remember,
591 @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
592 Delete, and Space keys.
594 @strong{RPN calculation.} In RPN, you type the input number(s) first,
595 then the command to operate on the numbers.
598 Type @kbd{2 @key{RET} 3 + Q} to compute @c{$\sqrt{2+3} = 2.2360679775$}
599 @asis{the square root of 2+3, which is 2.2360679775}.
602 Type @kbd{P 2 ^} to compute @c{$\pi^2 = 9.86960440109$}
603 @asis{the value of `pi' squared, 9.86960440109}.
606 Type @key{TAB} to exchange the order of these two results.
609 Type @kbd{- I H S} to subtract these results and compute the Inverse
610 Hyperbolic sine of the difference, 2.72996136574.
613 Type @key{DEL} to erase this result.
615 @strong{Algebraic calculation.} You can also enter calculations using
616 conventional ``algebraic'' notation. To enter an algebraic formula,
617 use the apostrophe key.
620 Type @kbd{' sqrt(2+3) @key{RET}} to compute @c{$\sqrt{2+3}$}
621 @asis{the square root of 2+3}.
624 Type @kbd{' pi^2 @key{RET}} to enter @c{$\pi^2$}
625 @asis{`pi' squared}. To evaluate this symbolic
626 formula as a number, type @kbd{=}.
629 Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
630 result from the most-recent and compute the Inverse Hyperbolic sine.
632 @strong{Keypad mode.} If you are using the X window system, press
633 @w{@kbd{M-# k}} to get Keypad mode. (If you don't use X, skip to
637 Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
638 ``buttons'' using your left mouse button.
641 Click on @key{PI}, @key{2}, and @t{y^x}.
644 Click on @key{INV}, then @key{ENTER} to swap the two results.
647 Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
650 Click on @key{<-} to erase the result, then click @key{OFF} to turn
651 the Keypad Calculator off.
653 @strong{Grabbing data.} Type @kbd{M-# x} if necessary to exit Calc.
654 Now select the following numbers as an Emacs region: ``Mark'' the
655 front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
656 then move to the other end of the list. (Either get this list from
657 the on-line copy of this manual, accessed by @w{@kbd{M-# i}}, or just
658 type these numbers into a scratch file.) Now type @kbd{M-# g} to
659 ``grab'' these numbers into Calc.
670 The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
671 Type @w{@kbd{V R +}} to compute the sum of these numbers.
674 Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
675 the product of the numbers.
678 You can also grab data as a rectangular matrix. Place the cursor on
679 the upper-leftmost @samp{1} and set the mark, then move to just after
680 the lower-right @samp{8} and press @kbd{M-# r}.
683 Type @kbd{v t} to transpose this @c{$3\times2$}
684 @asis{3x2} matrix into a @c{$2\times3$}
685 @asis{2x3} matrix. Type
686 @w{@kbd{v u}} to unpack the rows into two separate vectors. Now type
687 @w{@kbd{V R + @key{TAB} V R +}} to compute the sums of the two original columns.
688 (There is also a special grab-and-sum-columns command, @kbd{M-# :}.)
690 @strong{Units conversion.} Units are entered algebraically.
691 Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
692 Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}.
694 @strong{Date arithmetic.} Type @kbd{t N} to get the current date and
695 time. Type @kbd{90 +} to find the date 90 days from now. Type
696 @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
697 many weeks have passed since then.
699 @strong{Algebra.} Algebraic entries can also include formulas
700 or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
701 to enter a pair of equations involving three variables.
702 (Note the leading apostrophe in this example; also, note that the space
703 between @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve
704 these equations for the variables @cite{x} and @cite{y}.@refill
707 Type @kbd{d B} to view the solutions in more readable notation.
708 Type @w{@kbd{d C}} to view them in C language notation, and @kbd{d T}
709 to view them in the notation for the @TeX{} typesetting system.
710 Type @kbd{d N} to return to normal notation.
713 Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @cite{a = 7.5} in these formulas.
714 (That's a letter @kbd{l}, not a numeral @kbd{1}.)
717 @strong{Help functions.} You can read about any command in the on-line
718 manual. Type @kbd{M-# c} to return to Calc after each of these
719 commands: @kbd{h k t N} to read about the @kbd{t N} command,
720 @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
721 @kbd{h s} to read the Calc summary.
724 @strong{Help functions.} You can read about any command in the on-line
725 manual. Remember to type the letter @kbd{l}, then @kbd{M-# c}, to
726 return here after each of these commands: @w{@kbd{h k t N}} to read
727 about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
728 @code{sqrt} function, and @kbd{h s} to read the Calc summary.
731 Press @key{DEL} repeatedly to remove any leftover results from the stack.
732 To exit from Calc, press @kbd{q} or @kbd{M-# c} again.
734 @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
738 Calc has several user interfaces that are specialized for
739 different kinds of tasks. As well as Calc's standard interface,
740 there are Quick Mode, Keypad Mode, and Embedded Mode.
742 @c [fix-ref Installation]
743 Calc must be @dfn{installed} before it can be used. @xref{Installation},
744 for instructions on setting up and installing Calc. We will assume
745 you or someone on your system has already installed Calc as described
750 * The Standard Interface::
751 * Quick Mode Overview::
752 * Keypad Mode Overview::
753 * Standalone Operation::
754 * Embedded Mode Overview::
755 * Other M-# Commands::
758 @node Starting Calc, The Standard Interface, Using Calc, Using Calc
759 @subsection Starting Calc
762 On most systems, you can type @kbd{M-#} to start the Calculator.
763 The notation @kbd{M-#} is short for Meta-@kbd{#}. On most
764 keyboards this means holding down the Meta (or Alt) and
765 Shift keys while typing @kbd{3}.
768 Once again, if you don't have a Meta key on your keyboard you can type
769 @key{ESC} first, then @kbd{#}, to accomplish the same thing. If you
770 don't even have an @key{ESC} key, you can fake it by holding down
771 Control or @key{CTRL} while typing a left square bracket
772 (that's @kbd{C-[} in Emacs notation).@refill
774 @kbd{M-#} is a @dfn{prefix key}; when you press it, Emacs waits for
775 you to press a second key to complete the command. In this case,
776 you will follow @kbd{M-#} with a letter (upper- or lower-case, it
777 doesn't matter for @kbd{M-#}) that says which Calc interface you
780 To get Calc's standard interface, type @kbd{M-# c}. To get
781 Keypad Mode, type @kbd{M-# k}. Type @kbd{M-# ?} to get a brief
782 list of the available options, and type a second @kbd{?} to get
785 To ease typing, @kbd{M-# M-#} (or @kbd{M-# #} if that's easier)
786 also works to start Calc. It starts the same interface (either
787 @kbd{M-# c} or @w{@kbd{M-# k}}) that you last used, selecting the
788 @kbd{M-# c} interface by default. (If your installation has
789 a special function key set up to act like @kbd{M-#}, hitting that
790 function key twice is just like hitting @kbd{M-# M-#}.)
792 If @kbd{M-#} doesn't work for you, you can always type explicit
793 commands like @kbd{M-x calc} (for the standard user interface) or
794 @w{@kbd{M-x calc-keypad}} (for Keypad Mode). First type @kbd{M-x}
795 (that's Meta with the letter @kbd{x}), then, at the prompt,
796 type the full command (like @kbd{calc-keypad}) and press Return.
798 If you type @kbd{M-x calc} and Emacs still doesn't recognize the
799 command (it will say @samp{[No match]} when you try to press
800 @key{RET}), then Calc has not been properly installed.
802 The same commands (like @kbd{M-# c} or @kbd{M-# M-#}) that start
803 the Calculator also turn it off if it is already on.
805 @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
806 @subsection The Standard Calc Interface
809 @cindex Standard user interface
810 Calc's standard interface acts like a traditional RPN calculator,
811 operated by the normal Emacs keyboard. When you type @kbd{M-# c}
812 to start the Calculator, the Emacs screen splits into two windows
813 with the file you were editing on top and Calc on the bottom.
819 --**-Emacs: myfile (Fundamental)----All----------------------
820 --- Emacs Calculator Mode --- |Emacs Calc Mode v2.00...
828 --%%-Calc: 12 Deg (Calculator)----All----- --%%-Emacs: *Calc Trail*
832 In this figure, the mode-line for @file{myfile} has moved up and the
833 ``Calculator'' window has appeared below it. As you can see, Calc
834 actually makes two windows side-by-side. The lefthand one is
835 called the @dfn{stack window} and the righthand one is called the
836 @dfn{trail window.} The stack holds the numbers involved in the
837 calculation you are currently performing. The trail holds a complete
838 record of all calculations you have done. In a desk calculator with
839 a printer, the trail corresponds to the paper tape that records what
842 In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
843 were first entered into the Calculator, then the 2 and 4 were
844 multiplied to get 8, then the 3 and 8 were subtracted to get @i{-5}.
845 (The @samp{>} symbol shows that this was the most recent calculation.)
846 The net result is the two numbers 17.3 and @i{-5} sitting on the stack.
848 Most Calculator commands deal explicitly with the stack only, but
849 there is a set of commands that allow you to search back through
850 the trail and retrieve any previous result.
852 Calc commands use the digits, letters, and punctuation keys.
853 Shifted (i.e., upper-case) letters are different from lowercase
854 letters. Some letters are @dfn{prefix} keys that begin two-letter
855 commands. For example, @kbd{e} means ``enter exponent'' and shifted
856 @kbd{E} means @cite{e^x}. With the @kbd{d} (``display modes'') prefix
857 the letter ``e'' takes on very different meanings: @kbd{d e} means
858 ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
860 There is nothing stopping you from switching out of the Calc
861 window and back into your editing window, say by using the Emacs
862 @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is
863 inside a regular window, Emacs acts just like normal. When the
864 cursor is in the Calc stack or trail windows, keys are interpreted
867 When you quit by pressing @kbd{M-# c} a second time, the Calculator
868 windows go away but the actual Stack and Trail are not gone, just
869 hidden. When you press @kbd{M-# c} once again you will get the
870 same stack and trail contents you had when you last used the
873 The Calculator does not remember its state between Emacs sessions.
874 Thus if you quit Emacs and start it again, @kbd{M-# c} will give you
875 a fresh stack and trail. There is a command (@kbd{m m}) that lets
876 you save your favorite mode settings between sessions, though.
877 One of the things it saves is which user interface (standard or
878 Keypad) you last used; otherwise, a freshly started Emacs will
879 always treat @kbd{M-# M-#} the same as @kbd{M-# c}.
881 The @kbd{q} key is another equivalent way to turn the Calculator off.
883 If you type @kbd{M-# b} first and then @kbd{M-# c}, you get a
884 full-screen version of Calc (@code{full-calc}) in which the stack and
885 trail windows are still side-by-side but are now as tall as the whole
886 Emacs screen. When you press @kbd{q} or @kbd{M-# c} again to quit,
887 the file you were editing before reappears. The @kbd{M-# b} key
888 switches back and forth between ``big'' full-screen mode and the
889 normal partial-screen mode.
891 Finally, @kbd{M-# o} (@code{calc-other-window}) is like @kbd{M-# c}
892 except that the Calc window is not selected. The buffer you were
893 editing before remains selected instead. @kbd{M-# o} is a handy
894 way to switch out of Calc momentarily to edit your file; type
895 @kbd{M-# c} to switch back into Calc when you are done.
897 @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
898 @subsection Quick Mode (Overview)
901 @dfn{Quick Mode} is a quick way to use Calc when you don't need the
902 full complexity of the stack and trail. To use it, type @kbd{M-# q}
903 (@code{quick-calc}) in any regular editing buffer.
905 Quick Mode is very simple: It prompts you to type any formula in
906 standard algebraic notation (like @samp{4 - 2/3}) and then displays
907 the result at the bottom of the Emacs screen (@i{3.33333333333}
908 in this case). You are then back in the same editing buffer you
909 were in before, ready to continue editing or to type @kbd{M-# q}
910 again to do another quick calculation. The result of the calculation
911 will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
912 at this point will yank the result into your editing buffer.
914 Calc mode settings affect Quick Mode, too, though you will have to
915 go into regular Calc (with @kbd{M-# c}) to change the mode settings.
917 @c [fix-ref Quick Calculator mode]
918 @xref{Quick Calculator}, for further information.
920 @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
921 @subsection Keypad Mode (Overview)
924 @dfn{Keypad Mode} is a mouse-based interface to the Calculator.
925 It is designed for use with terminals that support a mouse. If you
926 don't have a mouse, you will have to operate keypad mode with your
927 arrow keys (which is probably more trouble than it's worth). Keypad
928 mode is currently not supported under Emacs 19.
930 Type @kbd{M-# k} to turn Keypad Mode on or off. Once again you
931 get two new windows, this time on the righthand side of the screen
932 instead of at the bottom. The upper window is the familiar Calc
933 Stack; the lower window is a picture of a typical calculator keypad.
937 \advance \dimen0 by 24\baselineskip%
938 \ifdim \dimen0>\pagegoal \vfill\eject \fi%
942 |--- Emacs Calculator Mode ---
946 |--%%-Calc: 12 Deg (Calcul
947 |----+-----Calc 2.00-----+----1
948 |FLR |CEIL|RND |TRNC|CLN2|FLT |
949 |----+----+----+----+----+----|
950 | LN |EXP | |ABS |IDIV|MOD |
951 |----+----+----+----+----+----|
952 |SIN |COS |TAN |SQRT|y^x |1/x |
953 |----+----+----+----+----+----|
954 | ENTER |+/- |EEX |UNDO| <- |
955 |-----+---+-+--+--+-+---++----|
956 | INV | 7 | 8 | 9 | / |
957 |-----+-----+-----+-----+-----|
958 | HYP | 4 | 5 | 6 | * |
959 |-----+-----+-----+-----+-----|
960 |EXEC | 1 | 2 | 3 | - |
961 |-----+-----+-----+-----+-----|
962 | OFF | 0 | . | PI | + |
963 |-----+-----+-----+-----+-----+
966 Keypad Mode is much easier for beginners to learn, because there
967 is no need to memorize lots of obscure key sequences. But not all
968 commands in regular Calc are available on the Keypad. You can
969 always switch the cursor into the Calc stack window to use
970 standard Calc commands if you need. Serious Calc users, though,
971 often find they prefer the standard interface over Keypad Mode.
973 To operate the Calculator, just click on the ``buttons'' of the
974 keypad using your left mouse button. To enter the two numbers
975 shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
976 add them together you would then click @kbd{+} (to get 12.3 on
979 If you click the right mouse button, the top three rows of the
980 keypad change to show other sets of commands, such as advanced
981 math functions, vector operations, and operations on binary
984 Because Keypad Mode doesn't use the regular keyboard, Calc leaves
985 the cursor in your original editing buffer. You can type in
986 this buffer in the usual way while also clicking on the Calculator
987 keypad. One advantage of Keypad Mode is that you don't need an
988 explicit command to switch between editing and calculating.
990 If you press @kbd{M-# b} first, you get a full-screen Keypad Mode
991 (@code{full-calc-keypad}) with three windows: The keypad in the lower
992 left, the stack in the lower right, and the trail on top.
994 @c [fix-ref Keypad Mode]
995 @xref{Keypad Mode}, for further information.
997 @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
998 @subsection Standalone Operation
1001 @cindex Standalone Operation
1002 If you are not in Emacs at the moment but you wish to use Calc,
1003 you must start Emacs first. If all you want is to run Calc, you
1004 can give the commands:
1014 emacs -f full-calc-keypad
1018 which run a full-screen Calculator (as if by @kbd{M-# b M-# c}) or
1019 a full-screen X-based Calculator (as if by @kbd{M-# b M-# k}).
1020 In standalone operation, quitting the Calculator (by pressing
1021 @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
1024 @node Embedded Mode Overview, Other M-# Commands, Standalone Operation, Using Calc
1025 @subsection Embedded Mode (Overview)
1028 @dfn{Embedded Mode} is a way to use Calc directly from inside an
1029 editing buffer. Suppose you have a formula written as part of a
1043 and you wish to have Calc compute and format the derivative for
1044 you and store this derivative in the buffer automatically. To
1045 do this with Embedded Mode, first copy the formula down to where
1046 you want the result to be:
1060 Now, move the cursor onto this new formula and press @kbd{M-# e}.
1061 Calc will read the formula (using the surrounding blank lines to
1062 tell how much text to read), then push this formula (invisibly)
1063 onto the Calc stack. The cursor will stay on the formula in the
1064 editing buffer, but the buffer's mode line will change to look
1065 like the Calc mode line (with mode indicators like @samp{12 Deg}
1066 and so on). Even though you are still in your editing buffer,
1067 the keyboard now acts like the Calc keyboard, and any new result
1068 you get is copied from the stack back into the buffer. To take
1069 the derivative, you would type @kbd{a d x @key{RET}}.
1083 To make this look nicer, you might want to press @kbd{d =} to center
1084 the formula, and even @kbd{d B} to use ``big'' display mode.
1093 % [calc-mode: justify: center]
1094 % [calc-mode: language: big]
1102 Calc has added annotations to the file to help it remember the modes
1103 that were used for this formula. They are formatted like comments
1104 in the @TeX{} typesetting language, just in case you are using @TeX{}.
1105 (In this example @TeX{} is not being used, so you might want to move
1106 these comments up to the top of the file or otherwise put them out
1109 As an extra flourish, we can add an equation number using a
1110 righthand label: Type @kbd{d @} (1) @key{RET}}.
1114 % [calc-mode: justify: center]
1115 % [calc-mode: language: big]
1116 % [calc-mode: right-label: " (1)"]
1124 To leave Embedded Mode, type @kbd{M-# e} again. The mode line
1125 and keyboard will revert to the way they were before. (If you have
1126 actually been trying this as you read along, you'll want to press
1127 @kbd{M-# 0} [with the digit zero] now to reset the modes you changed.)
1129 The related command @kbd{M-# w} operates on a single word, which
1130 generally means a single number, inside text. It uses any
1131 non-numeric characters rather than blank lines to delimit the
1132 formula it reads. Here's an example of its use:
1135 A slope of one-third corresponds to an angle of 1 degrees.
1138 Place the cursor on the @samp{1}, then type @kbd{M-# w} to enable
1139 Embedded Mode on that number. Now type @kbd{3 /} (to get one-third),
1140 and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
1141 then @w{@kbd{M-# w}} again to exit Embedded mode.
1144 A slope of one-third corresponds to an angle of 18.4349488229 degrees.
1147 @c [fix-ref Embedded Mode]
1148 @xref{Embedded Mode}, for full details.
1150 @node Other M-# Commands, , Embedded Mode Overview, Using Calc
1151 @subsection Other @kbd{M-#} Commands
1154 Two more Calc-related commands are @kbd{M-# g} and @kbd{M-# r},
1155 which ``grab'' data from a selected region of a buffer into the
1156 Calculator. The region is defined in the usual Emacs way, by
1157 a ``mark'' placed at one end of the region, and the Emacs
1158 cursor or ``point'' placed at the other.
1160 The @kbd{M-# g} command reads the region in the usual left-to-right,
1161 top-to-bottom order. The result is packaged into a Calc vector
1162 of numbers and placed on the stack. Calc (in its standard
1163 user interface) is then started. Type @kbd{v u} if you want
1164 to unpack this vector into separate numbers on the stack. Also,
1165 @kbd{C-u M-# g} interprets the region as a single number or
1168 The @kbd{M-# r} command reads a rectangle, with the point and
1169 mark defining opposite corners of the rectangle. The result
1170 is a matrix of numbers on the Calculator stack.
1172 Complementary to these is @kbd{M-# y}, which ``yanks'' the
1173 value at the top of the Calc stack back into an editing buffer.
1174 If you type @w{@kbd{M-# y}} while in such a buffer, the value is
1175 yanked at the current position. If you type @kbd{M-# y} while
1176 in the Calc buffer, Calc makes an educated guess as to which
1177 editing buffer you want to use. The Calc window does not have
1178 to be visible in order to use this command, as long as there
1179 is something on the Calc stack.
1181 Here, for reference, is the complete list of @kbd{M-#} commands.
1182 The shift, control, and meta keys are ignored for the keystroke
1183 following @kbd{M-#}.
1186 Commands for turning Calc on and off:
1190 Turn Calc on or off, employing the same user interface as last time.
1193 Turn Calc on or off using its standard bottom-of-the-screen
1194 interface. If Calc is already turned on but the cursor is not
1195 in the Calc window, move the cursor into the window.
1198 Same as @kbd{C}, but don't select the new Calc window. If
1199 Calc is already turned on and the cursor is in the Calc window,
1200 move it out of that window.
1203 Control whether @kbd{M-# c} and @kbd{M-# k} use the full screen.
1206 Use Quick Mode for a single short calculation.
1209 Turn Calc Keypad mode on or off.
1212 Turn Calc Embedded mode on or off at the current formula.
1215 Turn Calc Embedded mode on or off, select the interesting part.
1218 Turn Calc Embedded mode on or off at the current word (number).
1221 Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
1224 Quit Calc; turn off standard, Keypad, or Embedded mode if on.
1225 (This is like @kbd{q} or @key{OFF} inside of Calc.)
1232 Commands for moving data into and out of the Calculator:
1236 Grab the region into the Calculator as a vector.
1239 Grab the rectangular region into the Calculator as a matrix.
1242 Grab the rectangular region and compute the sums of its columns.
1245 Grab the rectangular region and compute the sums of its rows.
1248 Yank a value from the Calculator into the current editing buffer.
1255 Commands for use with Embedded Mode:
1259 ``Activate'' the current buffer. Locate all formulas that
1260 contain @samp{:=} or @samp{=>} symbols and record their locations
1261 so that they can be updated automatically as variables are changed.
1264 Duplicate the current formula immediately below and select
1268 Insert a new formula at the current point.
1271 Move the cursor to the next active formula in the buffer.
1274 Move the cursor to the previous active formula in the buffer.
1277 Update (i.e., as if by the @kbd{=} key) the formula at the current point.
1280 Edit (as if by @code{calc-edit}) the formula at the current point.
1287 Miscellaneous commands:
1291 Run the Emacs Info system to read the Calc manual.
1292 (This is the same as @kbd{h i} inside of Calc.)
1295 Run the Emacs Info system to read the Calc Tutorial.
1298 Run the Emacs Info system to read the Calc Summary.
1301 Load Calc entirely into memory. (Normally the various parts
1302 are loaded only as they are needed.)
1305 Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
1306 and record them as the current keyboard macro.
1309 (This is the ``zero'' digit key.) Reset the Calculator to
1310 its default state: Empty stack, and default mode settings.
1311 With any prefix argument, reset everything but the stack.
1314 @node History and Acknowledgements, , Using Calc, Getting Started
1315 @section History and Acknowledgements
1318 Calc was originally started as a two-week project to occupy a lull
1319 in the author's schedule. Basically, a friend asked if I remembered
1320 the value of @c{$2^{32}$}
1321 @cite{2^32}. I didn't offhand, but I said, ``that's
1322 easy, just call up an @code{xcalc}.'' @code{Xcalc} duly reported
1323 that the answer to our question was @samp{4.294967e+09}---with no way to
1324 see the full ten digits even though we knew they were there in the
1325 program's memory! I was so annoyed, I vowed to write a calculator
1326 of my own, once and for all.
1328 I chose Emacs Lisp, a) because I had always been curious about it
1329 and b) because, being only a text editor extension language after
1330 all, Emacs Lisp would surely reach its limits long before the project
1331 got too far out of hand.
1333 To make a long story short, Emacs Lisp turned out to be a distressingly
1334 solid implementation of Lisp, and the humble task of calculating
1335 turned out to be more open-ended than one might have expected.
1337 Emacs Lisp doesn't have built-in floating point math, so it had to be
1338 simulated in software. In fact, Emacs integers will only comfortably
1339 fit six decimal digits or so---not enough for a decent calculator. So
1340 I had to write my own high-precision integer code as well, and once I had
1341 this I figured that arbitrary-size integers were just as easy as large
1342 integers. Arbitrary floating-point precision was the logical next step.
1343 Also, since the large integer arithmetic was there anyway it seemed only
1344 fair to give the user direct access to it, which in turn made it practical
1345 to support fractions as well as floats. All these features inspired me
1346 to look around for other data types that might be worth having.
1348 Around this time, my friend Rick Koshi showed me his nifty new HP-28
1349 calculator. It allowed the user to manipulate formulas as well as
1350 numerical quantities, and it could also operate on matrices. I decided
1351 that these would be good for Calc to have, too. And once things had
1352 gone this far, I figured I might as well take a look at serious algebra
1353 systems like Mathematica, Macsyma, and Maple for further ideas. Since
1354 these systems did far more than I could ever hope to implement, I decided
1355 to focus on rewrite rules and other programming features so that users
1356 could implement what they needed for themselves.
1358 Rick complained that matrices were hard to read, so I put in code to
1359 format them in a 2D style. Once these routines were in place, Big mode
1360 was obligatory. Gee, what other language modes would be useful?
1362 Scott Hemphill and Allen Knutson, two friends with a strong mathematical
1363 bent, contributed ideas and algorithms for a number of Calc features
1364 including modulo forms, primality testing, and float-to-fraction conversion.
1366 Units were added at the eager insistence of Mass Sivilotti. Later,
1367 Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
1368 expert assistance with the units table. As far as I can remember, the
1369 idea of using algebraic formulas and variables to represent units dates
1370 back to an ancient article in Byte magazine about muMath, an early
1371 algebra system for microcomputers.
1373 Many people have contributed to Calc by reporting bugs and suggesting
1374 features, large and small. A few deserve special mention: Tim Peters,
1375 who helped develop the ideas that led to the selection commands, rewrite
1376 rules, and many other algebra features; @c{Fran\c cois}
1377 @asis{Francois} Pinard, who contributed
1378 an early prototype of the Calc Summary appendix as well as providing
1379 valuable suggestions in many other areas of Calc; Carl Witty, whose eagle
1380 eyes discovered many typographical and factual errors in the Calc manual;
1381 Tim Kay, who drove the development of Embedded mode; Ove Ewerlid, who
1382 made many suggestions relating to the algebra commands and contributed
1383 some code for polynomial operations; Randal Schwartz, who suggested the
1384 @code{calc-eval} function; Robert J. Chassell, who suggested the Calc
1385 Tutorial and exercises; and Juha Sarlin, who first worked out how to split
1386 Calc into quickly-loading parts. Bob Weiner helped immensely with the
1389 @cindex Bibliography
1390 @cindex Knuth, Art of Computer Programming
1391 @cindex Numerical Recipes
1392 @c Should these be expanded into more complete references?
1393 Among the books used in the development of Calc were Knuth's @emph{Art
1394 of Computer Programming} (especially volume II, @emph{Seminumerical
1395 Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
1396 and Vetterling; Bevington's @emph{Data Reduction and Error Analysis for
1397 the Physical Sciences}; @emph{Concrete Mathematics} by Graham, Knuth,
1398 and Patashnik; Steele's @emph{Common Lisp, the Language}; the @emph{CRC
1399 Standard Math Tables} (William H. Beyer, ed.); and Abramowitz and
1400 Stegun's venerable @emph{Handbook of Mathematical Functions}. I
1401 consulted the user's manuals for the HP-28 and HP-48 calculators, as
1402 well as for the programs Mathematica, SMP, Macsyma, Maple, MathCAD,
1403 Gnuplot, and others. Also, of course, Calc could not have been written
1404 without the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil
1405 Lewis and Dan LaLiberte.
1407 Final thanks go to Richard Stallman, without whose fine implementations
1408 of the Emacs editor, language, and environment, Calc would have been
1409 finished in two weeks.
1414 @c This node is accessed by the `M-# t' command.
1415 @node Interactive Tutorial, , , Top
1419 Some brief instructions on using the Emacs Info system for this tutorial:
1421 Press the space bar and Delete keys to go forward and backward in a
1422 section by screenfuls (or use the regular Emacs scrolling commands
1425 Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
1426 If the section has a @dfn{menu}, press a digit key like @kbd{1}
1427 or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to
1428 go back up from a sub-section to the menu it is part of.
1430 Exercises in the tutorial all have cross-references to the
1431 appropriate page of the ``answers'' section. Press @kbd{f}, then
1432 the exercise number, to see the answer to an exercise. After
1433 you have followed a cross-reference, you can press the letter
1434 @kbd{l} to return to where you were before.
1436 You can press @kbd{?} at any time for a brief summary of Info commands.
1438 Press @kbd{1} now to enter the first section of the Tutorial.
1445 @node Tutorial, Introduction, Getting Started, Top
1449 This chapter explains how to use Calc and its many features, in
1450 a step-by-step, tutorial way. You are encouraged to run Calc and
1451 work along with the examples as you read (@pxref{Starting Calc}).
1452 If you are already familiar with advanced calculators, you may wish
1454 to skip on to the rest of this manual.
1456 @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
1458 @c [fix-ref Embedded Mode]
1459 This tutorial describes the standard user interface of Calc only.
1460 The ``Quick Mode'' and ``Keypad Mode'' interfaces are fairly
1461 self-explanatory. @xref{Embedded Mode}, for a description of
1462 the ``Embedded Mode'' interface.
1465 The easiest way to read this tutorial on-line is to have two windows on
1466 your Emacs screen, one with Calc and one with the Info system. (If you
1467 have a printed copy of the manual you can use that instead.) Press
1468 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1469 press @kbd{M-# i} to start the Info system or to switch into its window.
1470 Or, you may prefer to use the tutorial in printed form.
1473 The easiest way to read this tutorial on-line is to have two windows on
1474 your Emacs screen, one with Calc and one with the Info system. (If you
1475 have a printed copy of the manual you can use that instead.) Press
1476 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1477 press @kbd{M-# i} to start the Info system or to switch into its window.
1480 This tutorial is designed to be done in sequence. But the rest of this
1481 manual does not assume you have gone through the tutorial. The tutorial
1482 does not cover everything in the Calculator, but it touches on most
1486 You may wish to print out a copy of the Calc Summary and keep notes on
1487 it as you learn Calc. @xref{Installation}, to see how to make a printed
1488 summary. @xref{Summary}.
1491 The Calc Summary at the end of the reference manual includes some blank
1492 space for your own use. You may wish to keep notes there as you learn
1498 * Arithmetic Tutorial::
1499 * Vector/Matrix Tutorial::
1501 * Algebra Tutorial::
1502 * Programming Tutorial::
1504 * Answers to Exercises::
1507 @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
1508 @section Basic Tutorial
1511 In this section, we learn how RPN and algebraic-style calculations
1512 work, how to undo and redo an operation done by mistake, and how
1513 to control various modes of the Calculator.
1516 * RPN Tutorial:: Basic operations with the stack.
1517 * Algebraic Tutorial:: Algebraic entry; variables.
1518 * Undo Tutorial:: If you make a mistake: Undo and the trail.
1519 * Modes Tutorial:: Common mode-setting commands.
1522 @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
1523 @subsection RPN Calculations and the Stack
1525 @cindex RPN notation
1528 Calc normally uses RPN notation. You may be familiar with the RPN
1529 system from Hewlett-Packard calculators, FORTH, or PostScript.
1530 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1535 Calc normally uses RPN notation. You may be familiar with the RPN
1536 system from Hewlett-Packard calculators, FORTH, or PostScript.
1537 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1541 The central component of an RPN calculator is the @dfn{stack}. A
1542 calculator stack is like a stack of dishes. New dishes (numbers) are
1543 added at the top of the stack, and numbers are normally only removed
1544 from the top of the stack.
1548 In an operation like @cite{2+3}, the 2 and 3 are called the @dfn{operands}
1549 and the @cite{+} is the @dfn{operator}. In an RPN calculator you always
1550 enter the operands first, then the operator. Each time you type a
1551 number, Calc adds or @dfn{pushes} it onto the top of the Stack.
1552 When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
1553 number of operands from the stack and pushes back the result.
1555 Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
1556 @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to
1557 the @key{ENTER} key on traditional RPN calculators.) Try this now if
1558 you wish; type @kbd{M-# c} to switch into the Calc window (you can type
1559 @kbd{M-# c} again or @kbd{M-# o} to switch back to the Tutorial window).
1560 The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
1561 The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
1562 and pushes the result (5) back onto the stack. Here's how the stack
1563 will look at various points throughout the calculation:@refill
1571 M-# c 2 @key{RET} 3 @key{RET} + @key{DEL}
1575 The @samp{.} symbol is a marker that represents the top of the stack.
1576 Note that the ``top'' of the stack is really shown at the bottom of
1577 the Stack window. This may seem backwards, but it turns out to be
1578 less distracting in regular use.
1580 @cindex Stack levels
1581 @cindex Levels of stack
1582 The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
1583 numbers}. Old RPN calculators always had four stack levels called
1584 @cite{x}, @cite{y}, @cite{z}, and @cite{t}. Calc's stack can grow
1585 as large as you like, so it uses numbers instead of letters. Some
1586 stack-manipulation commands accept a numeric argument that says
1587 which stack level to work on. Normal commands like @kbd{+} always
1588 work on the top few levels of the stack.@refill
1590 @c [fix-ref Truncating the Stack]
1591 The Stack buffer is just an Emacs buffer, and you can move around in
1592 it using the regular Emacs motion commands. But no matter where the
1593 cursor is, even if you have scrolled the @samp{.} marker out of
1594 view, most Calc commands always move the cursor back down to level 1
1595 before doing anything. It is possible to move the @samp{.} marker
1596 upwards through the stack, temporarily ``hiding'' some numbers from
1597 commands like @kbd{+}. This is called @dfn{stack truncation} and
1598 we will not cover it in this tutorial; @pxref{Truncating the Stack},
1599 if you are interested.
1601 You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
1602 @key{RET} +}. That's because if you type any operator name or
1603 other non-numeric key when you are entering a number, the Calculator
1604 automatically enters that number and then does the requested command.
1605 Thus @kbd{2 @key{RET} 3 +} will work just as well.@refill
1607 Examples in this tutorial will often omit @key{RET} even when the
1608 stack displays shown would only happen if you did press @key{RET}:
1621 Here, after pressing @kbd{3} the stack would really show @samp{1: 2}
1622 with @samp{Calc:@: 3} in the minibuffer. In these situations, you can
1623 press the optional @key{RET} to see the stack as the figure shows.
1625 (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises
1626 at various points. Try them if you wish. Answers to all the exercises
1627 are located at the end of the Tutorial chapter. Each exercise will
1628 include a cross-reference to its particular answer. If you are
1629 reading with the Emacs Info system, press @kbd{f} and the
1630 exercise number to go to the answer, then the letter @kbd{l} to
1631 return to where you were.)
1634 Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2
1635 @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for
1636 multiplication.) Figure it out by hand, then try it with Calc to see
1637 if you're right. @xref{RPN Answer 1, 1}. (@bullet{})
1639 (@bullet{}) @strong{Exercise 2.} Compute @c{$(2\times4) + (7\times9.4) + {5\over4}$}
1640 @cite{2*4 + 7*9.5 + 5/4} using the
1641 stack. @xref{RPN Answer 2, 2}. (@bullet{})
1643 The @key{DEL} key is called Backspace on some keyboards. It is
1644 whatever key you would use to correct a simple typing error when
1645 regularly using Emacs. The @key{DEL} key pops and throws away the
1646 top value on the stack. (You can still get that value back from
1647 the Trail if you should need it later on.) There are many places
1648 in this tutorial where we assume you have used @key{DEL} to erase the
1649 results of the previous example at the beginning of a new example.
1650 In the few places where it is really important to use @key{DEL} to
1651 clear away old results, the text will remind you to do so.
1653 (It won't hurt to let things accumulate on the stack, except that
1654 whenever you give a display-mode-changing command Calc will have to
1655 spend a long time reformatting such a large stack.)
1657 Since the @kbd{-} key is also an operator (it subtracts the top two
1658 stack elements), how does one enter a negative number? Calc uses
1659 the @kbd{_} (underscore) key to act like the minus sign in a number.
1660 So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
1661 will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
1663 You can also press @kbd{n}, which means ``change sign.'' It changes
1664 the number at the top of the stack (or the number being entered)
1665 from positive to negative or vice-versa: @kbd{5 n @key{RET}}.
1667 @cindex Duplicating a stack entry
1668 If you press @key{RET} when you're not entering a number, the effect
1669 is to duplicate the top number on the stack. Consider this calculation:
1673 1: 3 2: 3 1: 9 2: 9 1: 81
1677 3 @key{RET} @key{RET} * @key{RET} *
1682 (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
1683 to raise 3 to the fourth power.)
1685 The space-bar key (denoted @key{SPC} here) performs the same function
1686 as @key{RET}; you could replace all three occurrences of @key{RET} in
1687 the above example with @key{SPC} and the effect would be the same.
1689 @cindex Exchanging stack entries
1690 Another stack manipulation key is @key{TAB}. This exchanges the top
1691 two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +}
1692 to get 5, and then you realize what you really wanted to compute
1693 was @cite{20 / (2+3)}.
1697 1: 5 2: 5 2: 20 1: 4
1701 2 @key{RET} 3 + 20 @key{TAB} /
1706 Planning ahead, the calculation would have gone like this:
1710 1: 20 2: 20 3: 20 2: 20 1: 4
1715 20 @key{RET} 2 @key{RET} 3 + /
1719 A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
1720 @key{TAB}). It rotates the top three elements of the stack upward,
1721 bringing the object in level 3 to the top.
1725 1: 10 2: 10 3: 10 3: 20 3: 30
1726 . 1: 20 2: 20 2: 30 2: 10
1730 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB}
1734 (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
1735 on the stack. Figure out how to add one to the number in level 2
1736 without affecting the rest of the stack. Also figure out how to add
1737 one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{})
1739 Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
1740 arguments from the stack and push a result. Operations like @kbd{n} and
1741 @kbd{Q} (square root) pop a single number and push the result. You can
1742 think of them as simply operating on the top element of the stack.
1746 1: 3 1: 9 2: 9 1: 25 1: 5
1750 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q
1755 (Note that capital @kbd{Q} means to hold down the Shift key while
1756 typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.)
1758 @cindex Pythagorean Theorem
1759 Here we've used the Pythagorean Theorem to determine the hypotenuse of a
1760 right triangle. Calc actually has a built-in command for that called
1761 @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
1762 We can still enter it by its full name using @kbd{M-x} notation:
1770 3 @key{RET} 4 @key{RET} M-x calc-hypot
1774 All Calculator commands begin with the word @samp{calc-}. Since it
1775 gets tiring to type this, Calc provides an @kbd{x} key which is just
1776 like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
1785 3 @key{RET} 4 @key{RET} x hypot
1789 What happens if you take the square root of a negative number?
1793 1: 4 1: -4 1: (0, 2)
1801 The notation @cite{(a, b)} represents a complex number.
1802 Complex numbers are more traditionally written @c{$a + b i$}
1804 Calc can display in this format, too, but for now we'll stick to the
1805 @cite{(a, b)} notation.
1807 If you don't know how complex numbers work, you can safely ignore this
1808 feature. Complex numbers only arise from operations that would be
1809 errors in a calculator that didn't have complex numbers. (For example,
1810 taking the square root or logarithm of a negative number produces a
1813 Complex numbers are entered in the notation shown. The @kbd{(} and
1814 @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
1818 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3)
1826 You can perform calculations while entering parts of incomplete objects.
1827 However, an incomplete object cannot actually participate in a calculation:
1831 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ...
1841 Adding 5 to an incomplete object makes no sense, so the last command
1842 produces an error message and leaves the stack the same.
1844 Incomplete objects can't participate in arithmetic, but they can be
1845 moved around by the regular stack commands.
1849 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3)
1850 1: 3 2: 3 2: ( ... 2 .
1854 2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} )
1859 Note that the @kbd{,} (comma) key did not have to be used here.
1860 When you press @kbd{)} all the stack entries between the incomplete
1861 entry and the top are collected, so there's never really a reason
1862 to use the comma. It's up to you.
1864 (@bullet{}) @strong{Exercise 4.} To enter the complex number @cite{(2, 3)},
1865 your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened?
1866 (Joe thought of a clever way to correct his mistake in only two
1867 keystrokes, but it didn't quite work. Try it to find out why.)
1868 @xref{RPN Answer 4, 4}. (@bullet{})
1870 Vectors are entered the same way as complex numbers, but with square
1871 brackets in place of parentheses. We'll meet vectors again later in
1874 Any Emacs command can be given a @dfn{numeric prefix argument} by
1875 typing a series of @key{META}-digits beforehand. If @key{META} is
1876 awkward for you, you can instead type @kbd{C-u} followed by the
1877 necessary digits. Numeric prefix arguments can be negative, as in
1878 @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric
1879 prefix arguments in a variety of ways. For example, a numeric prefix
1880 on the @kbd{+} operator adds any number of stack entries at once:
1884 1: 10 2: 10 3: 10 3: 10 1: 60
1885 . 1: 20 2: 20 2: 20 .
1889 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 +
1893 For stack manipulation commands like @key{RET}, a positive numeric
1894 prefix argument operates on the top @var{n} stack entries at once. A
1895 negative argument operates on the entry in level @var{n} only. An
1896 argument of zero operates on the entire stack. In this example, we copy
1897 the second-to-top element of the stack:
1901 1: 10 2: 10 3: 10 3: 10 4: 10
1902 . 1: 20 2: 20 2: 20 3: 20
1907 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET}
1911 @cindex Clearing the stack
1912 @cindex Emptying the stack
1913 Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
1914 (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
1917 @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
1918 @subsection Algebraic-Style Calculations
1921 If you are not used to RPN notation, you may prefer to operate the
1922 Calculator in ``algebraic mode,'' which is closer to the way
1923 non-RPN calculators work. In algebraic mode, you enter formulas
1924 in traditional @cite{2+3} notation.
1926 You don't really need any special ``mode'' to enter algebraic formulas.
1927 You can enter a formula at any time by pressing the apostrophe (@kbd{'})
1928 key. Answer the prompt with the desired formula, then press @key{RET}.
1929 The formula is evaluated and the result is pushed onto the RPN stack.
1930 If you don't want to think in RPN at all, you can enter your whole
1931 computation as a formula, read the result from the stack, then press
1932 @key{DEL} to delete it from the stack.
1934 Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
1935 The result should be the number 9.
1937 Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
1938 @samp{/}, and @samp{^}. You can use parentheses to make the order
1939 of evaluation clear. In the absence of parentheses, @samp{^} is
1940 evaluated first, then @samp{*}, then @samp{/}, then finally
1941 @samp{+} and @samp{-}. For example, the expression
1944 2 + 3*4*5 / 6*7^8 - 9
1951 2 + ((3*4*5) / (6*(7^8)) - 9
1955 or, in large mathematical notation,
1970 $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
1975 The result of this expression will be the number @i{-6.99999826533}.
1977 Calc's order of evaluation is the same as for most computer languages,
1978 except that @samp{*} binds more strongly than @samp{/}, as the above
1979 example shows. As in normal mathematical notation, the @samp{*} symbol
1980 can often be omitted: @samp{2 a} is the same as @samp{2*a}.
1982 Operators at the same level are evaluated from left to right, except
1983 that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is
1984 equivalent to @samp{(2-3)-4} or @i{-5}, whereas @samp{2^3^4} is equivalent
1985 to @samp{2^(3^4)} (a very large integer; try it!).
1987 If you tire of typing the apostrophe all the time, there is an
1988 ``algebraic mode'' you can select in which Calc automatically senses
1989 when you are about to type an algebraic expression. To enter this
1990 mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator
1991 should appear in the Calc window's mode line.)
1993 Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
1995 In algebraic mode, when you press any key that would normally begin
1996 entering a number (such as a digit, a decimal point, or the @kbd{_}
1997 key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
2000 Functions which do not have operator symbols like @samp{+} and @samp{*}
2001 must be entered in formulas using function-call notation. For example,
2002 the function name corresponding to the square-root key @kbd{Q} is
2003 @code{sqrt}. To compute a square root in a formula, you would use
2004 the notation @samp{sqrt(@var{x})}.
2006 Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should
2007 be @cite{0.16227766017}.
2009 Note that if the formula begins with a function name, you need to use
2010 the apostrophe even if you are in algebraic mode. If you type @kbd{arcsin}
2011 out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
2012 command, and the @kbd{csin} will be taken as the name of the rewrite
2015 Some people prefer to enter complex numbers and vectors in algebraic
2016 form because they find RPN entry with incomplete objects to be too
2017 distracting, even though they otherwise use Calc as an RPN calculator.
2019 Still in algebraic mode, type:
2023 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1)
2024 . 1: (1, -2) . 1: 1 .
2027 (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} +
2031 Algebraic mode allows us to enter complex numbers without pressing
2032 an apostrophe first, but it also means we need to press @key{RET}
2033 after every entry, even for a simple number like @cite{1}.
2035 (You can type @kbd{C-u m a} to enable a special ``incomplete algebraic
2036 mode'' in which the @kbd{(} and @kbd{[} keys use algebraic entry even
2037 though regular numeric keys still use RPN numeric entry. There is also
2038 a ``total algebraic mode,'' started by typing @kbd{m t}, in which all
2039 normal keys begin algebraic entry. You must then use the @key{META} key
2040 to type Calc commands: @kbd{M-m t} to get back out of total algebraic
2041 mode, @kbd{M-q} to quit, etc. Total algebraic mode is not supported
2044 If you're still in algebraic mode, press @kbd{m a} again to turn it off.
2046 Actual non-RPN calculators use a mixture of algebraic and RPN styles.
2047 In general, operators of two numbers (like @kbd{+} and @kbd{*})
2048 use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
2049 use RPN form. Also, a non-RPN calculator allows you to see the
2050 intermediate results of a calculation as you go along. You can
2051 accomplish this in Calc by performing your calculation as a series
2052 of algebraic entries, using the @kbd{$} sign to tie them together.
2053 In an algebraic formula, @kbd{$} represents the number on the top
2054 of the stack. Here, we perform the calculation @c{$\sqrt{2\times4+1}$}
2056 which on a traditional calculator would be done by pressing
2057 @kbd{2 * 4 + 1 =} and then the square-root key.
2064 ' 2*4 @key{RET} $+1 @key{RET} Q
2069 Notice that we didn't need to press an apostrophe for the @kbd{$+1},
2070 because the dollar sign always begins an algebraic entry.
2072 (@bullet{}) @strong{Exercise 1.} How could you get the same effect as
2073 pressing @kbd{Q} but using an algebraic entry instead? How about
2074 if the @kbd{Q} key on your keyboard were broken?
2075 @xref{Algebraic Answer 1, 1}. (@bullet{})
2077 The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
2078 entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
2080 Algebraic formulas can include @dfn{variables}. To store in a
2081 variable, press @kbd{s s}, then type the variable name, then press
2082 @key{RET}. (There are actually two flavors of store command:
2083 @kbd{s s} stores a number in a variable but also leaves the number
2084 on the stack, while @w{@kbd{s t}} removes a number from the stack and
2085 stores it in the variable.) A variable name should consist of one
2086 or more letters or digits, beginning with a letter.
2090 1: 17 . 1: a + a^2 1: 306
2093 17 s t a @key{RET} ' a+a^2 @key{RET} =
2098 The @kbd{=} key @dfn{evaluates} a formula by replacing all its
2099 variables by the values that were stored in them.
2101 For RPN calculations, you can recall a variable's value on the
2102 stack either by entering its name as a formula and pressing @kbd{=},
2103 or by using the @kbd{s r} command.
2107 1: 17 2: 17 3: 17 2: 17 1: 306
2108 . 1: 17 2: 17 1: 289 .
2112 s r a @key{RET} ' a @key{RET} = 2 ^ +
2116 If you press a single digit for a variable name (as in @kbd{s t 3}, you
2117 get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
2118 They are ``quick'' simply because you don't have to type the letter
2119 @code{q} or the @key{RET} after their names. In fact, you can type
2120 simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
2121 @kbd{t 3} and @w{@kbd{r 3}}.
2123 Any variables in an algebraic formula for which you have not stored
2124 values are left alone, even when you evaluate the formula.
2128 1: 2 a + 2 b 1: 34 + 2 b
2135 Calls to function names which are undefined in Calc are also left
2136 alone, as are calls for which the value is undefined.
2140 1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
2143 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
2148 In this example, the first call to @code{log10} works, but the other
2149 calls are not evaluated. In the second call, the logarithm is
2150 undefined for that value of the argument; in the third, the argument
2151 is symbolic, and in the fourth, there are too many arguments. In the
2152 fifth case, there is no function called @code{foo}. You will see a
2153 ``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
2154 Press the @kbd{w} (``why'') key to see any other messages that may
2155 have arisen from the last calculation. In this case you will get
2156 ``logarithm of zero,'' then ``number expected: @code{x}''. Calc
2157 automatically displays the first message only if the message is
2158 sufficiently important; for example, Calc considers ``wrong number
2159 of arguments'' and ``logarithm of zero'' to be important enough to
2160 report automatically, while a message like ``number expected: @code{x}''
2161 will only show up if you explicitly press the @kbd{w} key.
2163 (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y},
2164 stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
2165 @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)},
2166 expecting @samp{10 (1+y)}, but it didn't work. Why not?
2167 @xref{Algebraic Answer 2, 2}. (@bullet{})
2169 (@bullet{}) @strong{Exercise 3.} What result would you expect
2170 @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}?
2171 @xref{Algebraic Answer 3, 3}. (@bullet{})
2173 One interesting way to work with variables is to use the
2174 @dfn{evaluates-to} (@samp{=>}) operator. It works like this:
2175 Enter a formula algebraically in the usual way, but follow
2176 the formula with an @samp{=>} symbol. (There is also an @kbd{s =}
2177 command which builds an @samp{=>} formula using the stack.) On
2178 the stack, you will see two copies of the formula with an @samp{=>}
2179 between them. The lefthand formula is exactly like you typed it;
2180 the righthand formula has been evaluated as if by typing @kbd{=}.
2184 2: 2 + 3 => 5 2: 2 + 3 => 5
2185 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b
2188 ' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET}
2193 Notice that the instant we stored a new value in @code{a}, all
2194 @samp{=>} operators already on the stack that referred to @cite{a}
2195 were updated to use the new value. With @samp{=>}, you can push a
2196 set of formulas on the stack, then change the variables experimentally
2197 to see the effects on the formulas' values.
2199 You can also ``unstore'' a variable when you are through with it:
2204 1: 2 a + 2 b => 2 a + 2 b
2211 We will encounter formulas involving variables and functions again
2212 when we discuss the algebra and calculus features of the Calculator.
2214 @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
2215 @subsection Undo and Redo
2218 If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
2219 the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
2220 and restart Calc (@kbd{M-# M-# M-# M-#}) to make sure things start off
2221 with a clean slate. Now:
2225 1: 2 2: 2 1: 8 2: 2 1: 6
2233 You can undo any number of times. Calc keeps a complete record of
2234 all you have done since you last opened the Calc window. After the
2235 above example, you could type:
2247 You can also type @kbd{D} to ``redo'' a command that you have undone
2252 . 1: 2 2: 2 1: 6 1: 6
2261 It was not possible to redo past the @cite{6}, since that was placed there
2262 by something other than an undo command.
2265 You can think of undo and redo as a sort of ``time machine.'' Press
2266 @kbd{U} to go backward in time, @kbd{D} to go forward. If you go
2267 backward and do something (like @kbd{*}) then, as any science fiction
2268 reader knows, you have changed your future and you cannot go forward
2269 again. Thus, the inability to redo past the @cite{6} even though there
2270 was an earlier undo command.
2272 You can always recall an earlier result using the Trail. We've ignored
2273 the trail so far, but it has been faithfully recording everything we
2274 did since we loaded the Calculator. If the Trail is not displayed,
2275 press @kbd{t d} now to turn it on.
2277 Let's try grabbing an earlier result. The @cite{8} we computed was
2278 undone by a @kbd{U} command, and was lost even to Redo when we pressed
2279 @kbd{*}, but it's still there in the trail. There should be a little
2280 @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
2281 entry. If there isn't, press @kbd{t ]} to reset the trail pointer.
2282 Now, press @w{@kbd{t p}} to move the arrow onto the line containing
2283 @cite{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
2286 If you press @kbd{t ]} again, you will see that even our Yank command
2287 went into the trail.
2289 Let's go further back in time. Earlier in the tutorial we computed
2290 a huge integer using the formula @samp{2^3^4}. We don't remember
2291 what it was, but the first digits were ``241''. Press @kbd{t r}
2292 (which stands for trail-search-reverse), then type @kbd{241}.
2293 The trail cursor will jump back to the next previous occurrence of
2294 the string ``241'' in the trail. This is just a regular Emacs
2295 incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
2296 continue the search forwards or backwards as you like.
2298 To finish the search, press @key{RET}. This halts the incremental
2299 search and leaves the trail pointer at the thing we found. Now we
2300 can type @kbd{t y} to yank that number onto the stack. If we hadn't
2301 remembered the ``241'', we could simply have searched for @kbd{2^3^4},
2302 then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
2304 You may have noticed that all the trail-related commands begin with
2305 the letter @kbd{t}. (The store-and-recall commands, on the other hand,
2306 all began with @kbd{s}.) Calc has so many commands that there aren't
2307 enough keys for all of them, so various commands are grouped into
2308 two-letter sequences where the first letter is called the @dfn{prefix}
2309 key. If you type a prefix key by accident, you can press @kbd{C-g}
2310 to cancel it. (In fact, you can press @kbd{C-g} to cancel almost
2311 anything in Emacs.) To get help on a prefix key, press that key
2312 followed by @kbd{?}. Some prefixes have several lines of help,
2313 so you need to press @kbd{?} repeatedly to see them all. This may
2314 not work under Lucid Emacs, but you can also type @kbd{h h} to
2315 see all the help at once.
2317 Try pressing @kbd{t ?} now. You will see a line of the form,
2320 trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t-
2324 The word ``trail'' indicates that the @kbd{t} prefix key contains
2325 trail-related commands. Each entry on the line shows one command,
2326 with a single capital letter showing which letter you press to get
2327 that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
2328 @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?}
2329 again to see more @kbd{t}-prefix commands. Notice that the commands
2330 are roughly divided (by semicolons) into related groups.
2332 When you are in the help display for a prefix key, the prefix is
2333 still active. If you press another key, like @kbd{y} for example,
2334 it will be interpreted as a @kbd{t y} command. If all you wanted
2335 was to look at the help messages, press @kbd{C-g} afterwards to cancel
2338 One more way to correct an error is by editing the stack entries.
2339 The actual Stack buffer is marked read-only and must not be edited
2340 directly, but you can press @kbd{`} (the backquote or accent grave)
2341 to edit a stack entry.
2343 Try entering @samp{3.141439} now. If this is supposed to represent
2345 @cite{pi}, it's got several errors. Press @kbd{`} to edit this number.
2346 Now use the normal Emacs cursor motion and editing keys to change
2347 the second 4 to a 5, and to transpose the 3 and the 9. When you
2348 press @key{RET}, the number on the stack will be replaced by your
2349 new number. This works for formulas, vectors, and all other types
2350 of values you can put on the stack. The @kbd{`} key also works
2351 during entry of a number or algebraic formula.
2353 @node Modes Tutorial, , Undo Tutorial, Basic Tutorial
2354 @subsection Mode-Setting Commands
2357 Calc has many types of @dfn{modes} that affect the way it interprets
2358 your commands or the way it displays data. We have already seen one
2359 mode, namely algebraic mode. There are many others, too; we'll
2360 try some of the most common ones here.
2362 Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
2363 Notice the @samp{12} on the Calc window's mode line:
2366 --%%-Calc: 12 Deg (Calculator)----All------
2370 Most of the symbols there are Emacs things you don't need to worry
2371 about, but the @samp{12} and the @samp{Deg} are mode indicators.
2372 The @samp{12} means that calculations should always be carried to
2373 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /},
2374 we get @cite{0.142857142857} with exactly 12 digits, not counting
2375 leading and trailing zeros.
2377 You can set the precision to anything you like by pressing @kbd{p},
2378 then entering a suitable number. Try pressing @kbd{p 30 @key{RET}},
2379 then doing @kbd{1 @key{RET} 7 /} again:
2384 2: 0.142857142857142857142857142857
2389 Although the precision can be set arbitrarily high, Calc always
2390 has to have @emph{some} value for the current precision. After
2391 all, the true value @cite{1/7} is an infinitely repeating decimal;
2392 Calc has to stop somewhere.
2394 Of course, calculations are slower the more digits you request.
2395 Press @w{@kbd{p 12}} now to set the precision back down to the default.
2397 Calculations always use the current precision. For example, even
2398 though we have a 30-digit value for @cite{1/7} on the stack, if
2399 we use it in a calculation in 12-digit mode it will be rounded
2400 down to 12 digits before it is used. Try it; press @key{RET} to
2401 duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET}
2402 key didn't round the number, because it doesn't do any calculation.
2403 But the instant we pressed @kbd{+}, the number was rounded down.
2408 2: 0.142857142857142857142857142857
2415 In fact, since we added a digit on the left, we had to lose one
2416 digit on the right from even the 12-digit value of @cite{1/7}.
2418 How did we get more than 12 digits when we computed @samp{2^3^4}? The
2419 answer is that Calc makes a distinction between @dfn{integers} and
2420 @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number
2421 that does not contain a decimal point. There is no such thing as an
2422 ``infinitely repeating fraction integer,'' so Calc doesn't have to limit
2423 itself. If you asked for @samp{2^10000} (don't try this!), you would
2424 have to wait a long time but you would eventually get an exact answer.
2425 If you ask for @samp{2.^10000}, you will quickly get an answer which is
2426 correct only to 12 places. The decimal point tells Calc that it should
2427 use floating-point arithmetic to get the answer, not exact integer
2430 You can use the @kbd{F} (@code{calc-floor}) command to convert a
2431 floating-point value to an integer, and @kbd{c f} (@code{calc-float})
2432 to convert an integer to floating-point form.
2434 Let's try entering that last calculation:
2438 1: 2. 2: 2. 1: 1.99506311689e3010
2442 2.0 @key{RET} 10000 @key{RET} ^
2447 @cindex Scientific notation, entry of
2448 Notice the letter @samp{e} in there. It represents ``times ten to the
2449 power of,'' and is used by Calc automatically whenever writing the
2450 number out fully would introduce more extra zeros than you probably
2451 want to see. You can enter numbers in this notation, too.
2455 1: 2. 2: 2. 1: 1.99506311678e3010
2459 2.0 @key{RET} 1e4 @key{RET} ^
2463 @cindex Round-off errors
2465 Hey, the answer is different! Look closely at the middle columns
2466 of the two examples. In the first, the stack contained the
2467 exact integer @cite{10000}, but in the second it contained
2468 a floating-point value with a decimal point. When you raise a
2469 number to an integer power, Calc uses repeated squaring and
2470 multiplication to get the answer. When you use a floating-point
2471 power, Calc uses logarithms and exponentials. As you can see,
2472 a slight error crept in during one of these methods. Which
2473 one should we trust? Let's raise the precision a bit and find
2478 . 1: 2. 2: 2. 1: 1.995063116880828e3010
2482 p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET}
2487 @cindex Guard digits
2488 Presumably, it doesn't matter whether we do this higher-precision
2489 calculation using an integer or floating-point power, since we
2490 have added enough ``guard digits'' to trust the first 12 digits
2491 no matter what. And the verdict is@dots{} Integer powers were more
2492 accurate; in fact, the result was only off by one unit in the
2495 @cindex Guard digits
2496 Calc does many of its internal calculations to a slightly higher
2497 precision, but it doesn't always bump the precision up enough.
2498 In each case, Calc added about two digits of precision during
2499 its calculation and then rounded back down to 12 digits
2500 afterward. In one case, it was enough; in the other, it
2501 wasn't. If you really need @var{x} digits of precision, it
2502 never hurts to do the calculation with a few extra guard digits.
2504 What if we want guard digits but don't want to look at them?
2505 We can set the @dfn{float format}. Calc supports four major
2506 formats for floating-point numbers, called @dfn{normal},
2507 @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
2508 notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f},
2509 @kbd{d s}, and @kbd{d e}, respectively. In each case, you can
2510 supply a numeric prefix argument which says how many digits
2511 should be displayed. As an example, let's put a few numbers
2512 onto the stack and try some different display modes. First,
2513 use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
2518 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2519 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000
2520 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450
2521 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345
2524 d n M-3 d n d s M-3 d s M-3 d f
2529 Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
2530 to three significant digits, but then when we typed @kbd{d s} all
2531 five significant figures reappeared. The float format does not
2532 affect how numbers are stored, it only affects how they are
2533 displayed. Only the current precision governs the actual rounding
2534 of numbers in the Calculator's memory.
2536 Engineering notation, not shown here, is like scientific notation
2537 except the exponent (the power-of-ten part) is always adjusted to be
2538 a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result
2539 there will be one, two, or three digits before the decimal point.
2541 Whenever you change a display-related mode, Calc redraws everything
2542 in the stack. This may be slow if there are many things on the stack,
2543 so Calc allows you to type shift-@kbd{H} before any mode command to
2544 prevent it from updating the stack. Anything Calc displays after the
2545 mode-changing command will appear in the new format.
2549 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2550 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345.
2551 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45
2552 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345
2555 H d s @key{DEL} U @key{TAB} d @key{SPC} d n
2560 Here the @kbd{H d s} command changes to scientific notation but without
2561 updating the screen. Deleting the top stack entry and undoing it back
2562 causes it to show up in the new format; swapping the top two stack
2563 entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the
2564 whole stack. The @kbd{d n} command changes back to the normal float
2565 format; since it doesn't have an @kbd{H} prefix, it also updates all
2566 the stack entries to be in @kbd{d n} format.
2568 Notice that the integer @cite{12345} was not affected by any
2569 of the float formats. Integers are integers, and are always
2572 @cindex Large numbers, readability
2573 Large integers have their own problems. Let's look back at
2574 the result of @kbd{2^3^4}.
2577 2417851639229258349412352
2581 Quick---how many digits does this have? Try typing @kbd{d g}:
2584 2,417,851,639,229,258,349,412,352
2588 Now how many digits does this have? It's much easier to tell!
2589 We can actually group digits into clumps of any size. Some
2590 people prefer @kbd{M-5 d g}:
2593 24178,51639,22925,83494,12352
2596 Let's see what happens to floating-point numbers when they are grouped.
2597 First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
2598 to get ourselves into trouble. Now, type @kbd{1e13 /}:
2601 24,17851,63922.9258349412352
2605 The integer part is grouped but the fractional part isn't. Now try
2606 @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
2609 24,17851,63922.92583,49412,352
2612 If you find it hard to tell the decimal point from the commas, try
2613 changing the grouping character to a space with @kbd{d , @key{SPC}}:
2616 24 17851 63922.92583 49412 352
2619 Type @kbd{d , ,} to restore the normal grouping character, then
2620 @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to
2621 restore the default precision.
2623 Press @kbd{U} enough times to get the original big integer back.
2624 (Notice that @kbd{U} does not undo each mode-setting command; if
2625 you want to undo a mode-setting command, you have to do it yourself.)
2626 Now, type @kbd{d r 16 @key{RET}}:
2629 16#200000000000000000000
2633 The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
2634 Suddenly it looks pretty simple; this should be no surprise, since we
2635 got this number by computing a power of two, and 16 is a power of 2.
2636 In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
2640 2#1000000000000000000000000000000000000000000000000000000 @dots{}
2644 We don't have enough space here to show all the zeros! They won't
2645 fit on a typical screen, either, so you will have to use horizontal
2646 scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the
2647 stack window left and right by half its width. Another way to view
2648 something large is to press @kbd{`} (back-quote) to edit the top of
2649 stack in a separate window. (Press @kbd{M-# M-#} when you are done.)
2651 You can enter non-decimal numbers using the @kbd{#} symbol, too.
2652 Let's see what the hexadecimal number @samp{5FE} looks like in
2653 binary. Type @kbd{16#5FE} (the letters can be typed in upper or
2654 lower case; they will always appear in upper case). It will also
2655 help to turn grouping on with @kbd{d g}:
2661 Notice that @kbd{d g} groups by fours by default if the display radix
2662 is binary or hexadecimal, but by threes if it is decimal, octal, or any
2665 Now let's see that number in decimal; type @kbd{d r 10}:
2671 Numbers are not @emph{stored} with any particular radix attached. They're
2672 just numbers; they can be entered in any radix, and are always displayed
2673 in whatever radix you've chosen with @kbd{d r}. The current radix applies
2674 to integers, fractions, and floats.
2676 @cindex Roundoff errors, in non-decimal numbers
2677 (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third
2678 as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got
2679 @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied
2680 that by three, he got @samp{3#0.222222...} instead of the expected
2681 @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief,
2682 saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got
2683 @samp{3#0.10000001} (some zeros omitted). What's going on here?
2684 @xref{Modes Answer 1, 1}. (@bullet{})
2686 @cindex Scientific notation, in non-decimal numbers
2687 (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal
2688 modes in the natural way (the exponent is a power of the radix instead of
2689 a power of ten, although the exponent itself is always written in decimal).
2690 Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number
2691 @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}.
2692 What is wrong with this picture? What could we write instead that would
2693 work better? @xref{Modes Answer 2, 2}. (@bullet{})
2695 The @kbd{m} prefix key has another set of modes, relating to the way
2696 Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix
2697 modes generally affect the way things look, @kbd{m}-prefix modes affect
2698 the way they are actually computed.
2700 The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice
2701 the @samp{Deg} indicator in the mode line. This means that if you use
2702 a command that interprets a number as an angle, it will assume the
2703 angle is measured in degrees. For example,
2707 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5
2715 The shift-@kbd{S} command computes the sine of an angle. The sine
2716 of 45 degrees is @c{$\sqrt{2}/2$}
2717 @cite{sqrt(2)/2}; squaring this yields @cite{2/4 = 0.5}.
2718 However, there has been a slight roundoff error because the
2719 representation of @c{$\sqrt{2}/2$}
2720 @cite{sqrt(2)/2} wasn't exact. The @kbd{c 1}
2721 command is a handy way to clean up numbers in this case; it
2722 temporarily reduces the precision by one digit while it
2723 re-rounds the number on the top of the stack.
2725 @cindex Roundoff errors, examples
2726 (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine
2727 of 45 degrees as shown above, then, hoping to avoid an inexact
2728 result, he increased the precision to 16 digits before squaring.
2729 What happened? @xref{Modes Answer 3, 3}. (@bullet{})
2731 To do this calculation in radians, we would type @kbd{m r} first.
2732 (The indicator changes to @samp{Rad}.) 45 degrees corresponds to
2734 @cite{pi/4} radians. To get @c{$\pi$}
2735 @cite{pi}, press the @kbd{P} key. (Once
2736 again, this is a shifted capital @kbd{P}. Remember, unshifted
2737 @kbd{p} sets the precision.)
2741 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187
2748 Likewise, inverse trigonometric functions generate results in
2749 either radians or degrees, depending on the current angular mode.
2753 1: 0.707106781187 1: 0.785398163398 1: 45.
2756 .5 Q m r I S m d U I S
2761 Here we compute the Inverse Sine of @c{$\sqrt{0.5}$}
2762 @cite{sqrt(0.5)}, first in
2763 radians, then in degrees.
2765 Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
2770 1: 45 1: 0.785398163397 1: 45.
2777 Another interesting mode is @dfn{fraction mode}. Normally,
2778 dividing two integers produces a floating-point result if the
2779 quotient can't be expressed as an exact integer. Fraction mode
2780 causes integer division to produce a fraction, i.e., a rational
2785 2: 12 1: 1.33333333333 1: 4:3
2789 12 @key{RET} 9 / m f U / m f
2794 In the first case, we get an approximate floating-point result.
2795 In the second case, we get an exact fractional result (four-thirds).
2797 You can enter a fraction at any time using @kbd{:} notation.
2798 (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
2799 because @kbd{/} is already used to divide the top two stack
2800 elements.) Calculations involving fractions will always
2801 produce exact fractional results; fraction mode only says
2802 what to do when dividing two integers.
2804 @cindex Fractions vs. floats
2805 @cindex Floats vs. fractions
2806 (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact,
2807 why would you ever use floating-point numbers instead?
2808 @xref{Modes Answer 4, 4}. (@bullet{})
2810 Typing @kbd{m f} doesn't change any existing values in the stack.
2811 In the above example, we had to Undo the division and do it over
2812 again when we changed to fraction mode. But if you use the
2813 evaluates-to operator you can get commands like @kbd{m f} to
2818 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3
2821 ' 12/9 => @key{RET} p 4 @key{RET} m f
2826 In this example, the righthand side of the @samp{=>} operator
2827 on the stack is recomputed when we change the precision, then
2828 again when we change to fraction mode. All @samp{=>} expressions
2829 on the stack are recomputed every time you change any mode that
2830 might affect their values.
2832 @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
2833 @section Arithmetic Tutorial
2836 In this section, we explore the arithmetic and scientific functions
2837 available in the Calculator.
2839 The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
2840 and @kbd{^}. Each normally takes two numbers from the top of the stack
2841 and pushes back a result. The @kbd{n} and @kbd{&} keys perform
2842 change-sign and reciprocal operations, respectively.
2846 1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
2853 @cindex Binary operators
2854 You can apply a ``binary operator'' like @kbd{+} across any number of
2855 stack entries by giving it a numeric prefix. You can also apply it
2856 pairwise to several stack elements along with the top one if you use
2861 3: 2 1: 9 3: 2 4: 2 3: 12
2862 2: 3 . 2: 3 3: 3 2: 13
2863 1: 4 1: 4 2: 4 1: 14
2867 2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 +
2871 @cindex Unary operators
2872 You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
2873 stack entries with a numeric prefix, too.
2878 2: 3 2: 0.333333333333 2: 3.
2882 2 @key{RET} 3 @key{RET} 4 M-3 & M-2 &
2886 Notice that the results here are left in floating-point form.
2887 We can convert them back to integers by pressing @kbd{F}, the
2888 ``floor'' function. This function rounds down to the next lower
2889 integer. There is also @kbd{R}, which rounds to the nearest
2907 Since dividing-and-flooring (i.e., ``integer quotient'') is such a
2908 common operation, Calc provides a special command for that purpose, the
2909 backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which
2910 computes the remainder that would arise from a @kbd{\} operation, i.e.,
2911 the ``modulo'' of two numbers. For example,
2915 2: 1234 1: 12 2: 1234 1: 34
2919 1234 @key{RET} 100 \ U %
2923 These commands actually work for any real numbers, not just integers.
2927 2: 3.1415 1: 3 2: 3.1415 1: 0.1415
2931 3.1415 @key{RET} 1 \ U %
2935 (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a
2936 frill, since you could always do the same thing with @kbd{/ F}. Think
2937 of a situation where this is not true---@kbd{/ F} would be inadequate.
2938 Now think of a way you could get around the problem if Calc didn't
2939 provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{})
2941 We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
2942 commands. Other commands along those lines are @kbd{C} (cosine),
2943 @kbd{T} (tangent), @kbd{E} (@cite{e^x}) and @kbd{L} (natural
2944 logarithm). These can be modified by the @kbd{I} (inverse) and
2945 @kbd{H} (hyperbolic) prefix keys.
2947 Let's compute the sine and cosine of an angle, and verify the
2948 identity @c{$\sin^2x + \cos^2x = 1$}
2949 @cite{sin(x)^2 + cos(x)^2 = 1}. We'll
2950 arbitrarily pick @i{-64} degrees as a good value for @cite{x}. With
2951 the angular mode set to degrees (type @w{@kbd{m d}}), do:
2955 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
2956 1: -64 1: -0.89879 1: -64 1: 0.43837 .
2959 64 n @key{RET} @key{RET} S @key{TAB} C f h
2964 (For brevity, we're showing only five digits of the results here.
2965 You can of course do these calculations to any precision you like.)
2967 Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
2968 of squares, command.
2970 Another identity is @c{$\displaystyle\tan x = {\sin x \over \cos x}$}
2971 @cite{tan(x) = sin(x) / cos(x)}.
2975 2: -0.89879 1: -2.0503 1: -64.
2983 A physical interpretation of this calculation is that if you move
2984 @cite{0.89879} units downward and @cite{0.43837} units to the right,
2985 your direction of motion is @i{-64} degrees from horizontal. Suppose
2986 we move in the opposite direction, up and to the left:
2990 2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
2991 1: 0.43837 1: -0.43837 . .
2999 How can the angle be the same? The answer is that the @kbd{/} operation
3000 loses information about the signs of its inputs. Because the quotient
3001 is negative, we know exactly one of the inputs was negative, but we
3002 can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which
3003 computes the inverse tangent of the quotient of a pair of numbers.
3004 Since you feed it the two original numbers, it has enough information
3005 to give you a full 360-degree answer.
3009 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
3010 1: -0.43837 . 2: -0.89879 1: -64. .
3014 U U f T M-@key{RET} M-2 n f T -
3019 The resulting angles differ by 180 degrees; in other words, they
3020 point in opposite directions, just as we would expect.
3022 The @key{META}-@key{RET} we used in the third step is the
3023 ``last-arguments'' command. It is sort of like Undo, except that it
3024 restores the arguments of the last command to the stack without removing
3025 the command's result. It is useful in situations like this one,
3026 where we need to do several operations on the same inputs. We could
3027 have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
3028 the top two stack elements right after the @kbd{U U}, then a pair of
3029 @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
3031 A similar identity is supposed to hold for hyperbolic sines and cosines,
3032 except that it is the @emph{difference}
3033 @c{$\cosh^2x - \sinh^2x$}
3034 @cite{cosh(x)^2 - sinh(x)^2} that always equals one.
3035 Let's try to verify this identity.@refill
3039 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
3040 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
3043 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^
3048 @cindex Roundoff errors, examples
3049 Something's obviously wrong, because when we subtract these numbers
3050 the answer will clearly be zero! But if you think about it, if these
3051 numbers @emph{did} differ by one, it would be in the 55th decimal
3052 place. The difference we seek has been lost entirely to roundoff
3055 We could verify this hypothesis by doing the actual calculation with,
3056 say, 60 decimal places of precision. This will be slow, but not
3057 enormously so. Try it if you wish; sure enough, the answer is
3058 0.99999, reasonably close to 1.
3060 Of course, a more reasonable way to verify the identity is to use
3061 a more reasonable value for @cite{x}!
3063 @cindex Common logarithm
3064 Some Calculator commands use the Hyperbolic prefix for other purposes.
3065 The logarithm and exponential functions, for example, work to the base
3066 @cite{e} normally but use base-10 instead if you use the Hyperbolic
3071 1: 1000 1: 6.9077 1: 1000 1: 3
3079 First, we mistakenly compute a natural logarithm. Then we undo
3080 and compute a common logarithm instead.
3082 The @kbd{B} key computes a general base-@var{b} logarithm for any
3087 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
3088 1: 10 . . 1: 2.71828 .
3091 1000 @key{RET} 10 B H E H P B
3096 Here we first use @kbd{B} to compute the base-10 logarithm, then use
3097 the ``hyperbolic'' exponential as a cheap hack to recover the number
3098 1000, then use @kbd{B} again to compute the natural logarithm. Note
3099 that @kbd{P} with the hyperbolic prefix pushes the constant @cite{e}
3102 You may have noticed that both times we took the base-10 logarithm
3103 of 1000, we got an exact integer result. Calc always tries to give
3104 an exact rational result for calculations involving rational numbers
3105 where possible. But when we used @kbd{H E}, the result was a
3106 floating-point number for no apparent reason. In fact, if we had
3107 computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
3108 exact integer 1000. But the @kbd{H E} command is rigged to generate
3109 a floating-point result all of the time so that @kbd{1000 H E} will
3110 not waste time computing a thousand-digit integer when all you
3111 probably wanted was @samp{1e1000}.
3113 (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to
3114 the @kbd{B} command for which Calc could find an exact rational
3115 result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{})
3117 The Calculator also has a set of functions relating to combinatorics
3118 and statistics. You may be familiar with the @dfn{factorial} function,
3119 which computes the product of all the integers up to a given number.
3123 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
3131 Recall, the @kbd{c f} command converts the integer or fraction at the
3132 top of the stack to floating-point format. If you take the factorial
3133 of a floating-point number, you get a floating-point result
3134 accurate to the current precision. But if you give @kbd{!} an
3135 exact integer, you get an exact integer result (158 digits long
3138 If you take the factorial of a non-integer, Calc uses a generalized
3139 factorial function defined in terms of Euler's Gamma function
3142 (which is itself available as the @kbd{f g} command).
3146 3: 4. 3: 24. 1: 5.5 1: 52.342777847
3147 2: 4.5 2: 52.3427777847 . .
3151 M-3 ! M-0 @key{DEL} 5.5 f g
3156 Here we verify the identity @c{$n! = \Gamma(n+1)$}
3157 @cite{@var{n}!@: = gamma(@var{n}+1)}.
3159 The binomial coefficient @var{n}-choose-@var{m}@c{ or $\displaystyle {n \choose m}$}
3160 @asis{} is defined by
3161 @c{$\displaystyle {n! \over m! \, (n-m)!}$}
3162 @cite{n!@: / m!@: (n-m)!} for all reals @cite{n} and
3163 @cite{m}. The intermediate results in this formula can become quite
3164 large even if the final result is small; the @kbd{k c} command computes
3165 a binomial coefficient in a way that avoids large intermediate
3168 The @kbd{k} prefix key defines several common functions out of
3169 combinatorics and number theory. Here we compute the binomial
3170 coefficient 30-choose-20, then determine its prime factorization.
3174 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
3178 30 @key{RET} 20 k c k f
3183 You can verify these prime factors by using @kbd{v u} to ``unpack''
3184 this vector into 8 separate stack entries, then @kbd{M-8 *} to
3185 multiply them back together. The result is the original number,
3189 Suppose a program you are writing needs a hash table with at least
3190 10000 entries. It's best to use a prime number as the actual size
3191 of a hash table. Calc can compute the next prime number after 10000:
3195 1: 10000 1: 10007 1: 9973
3203 Just for kicks we've also computed the next prime @emph{less} than
3206 @c [fix-ref Financial Functions]
3207 @xref{Financial Functions}, for a description of the Calculator
3208 commands that deal with business and financial calculations (functions
3209 like @code{pv}, @code{rate}, and @code{sln}).
3211 @c [fix-ref Binary Number Functions]
3212 @xref{Binary Functions}, to read about the commands for operating
3213 on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
3215 @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
3216 @section Vector/Matrix Tutorial
3219 A @dfn{vector} is a list of numbers or other Calc data objects.
3220 Calc provides a large set of commands that operate on vectors. Some
3221 are familiar operations from vector analysis. Others simply treat
3222 a vector as a list of objects.
3225 * Vector Analysis Tutorial::
3230 @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
3231 @subsection Vector Analysis
3234 If you add two vectors, the result is a vector of the sums of the
3235 elements, taken pairwise.
3239 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3]
3243 [1,2,3] s 1 [7 6 0] s 2 +
3248 Note that we can separate the vector elements with either commas or
3249 spaces. This is true whether we are using incomplete vectors or
3250 algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these
3251 vectors so we can easily reuse them later.
3253 If you multiply two vectors, the result is the sum of the products
3254 of the elements taken pairwise. This is called the @dfn{dot product}
3268 The dot product of two vectors is equal to the product of their
3269 lengths times the cosine of the angle between them. (Here the vector
3270 is interpreted as a line from the origin @cite{(0,0,0)} to the
3271 specified point in three-dimensional space.) The @kbd{A}
3272 (absolute value) command can be used to compute the length of a
3277 3: 19 3: 19 1: 0.550782 1: 56.579
3278 2: [1, 2, 3] 2: 3.741657 . .
3279 1: [7, 6, 0] 1: 9.219544
3282 M-@key{RET} M-2 A * / I C
3287 First we recall the arguments to the dot product command, then
3288 we compute the absolute values of the top two stack entries to
3289 obtain the lengths of the vectors, then we divide the dot product
3290 by the product of the lengths to get the cosine of the angle.
3291 The inverse cosine finds that the angle between the vectors
3292 is about 56 degrees.
3294 @cindex Cross product
3295 @cindex Perpendicular vectors
3296 The @dfn{cross product} of two vectors is a vector whose length
3297 is the product of the lengths of the inputs times the sine of the
3298 angle between them, and whose direction is perpendicular to both
3299 input vectors. Unlike the dot product, the cross product is
3300 defined only for three-dimensional vectors. Let's double-check
3301 our computation of the angle using the cross product.
3305 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579
3306 1: [7, 6, 0] 2: [1, 2, 3] . .
3310 r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S
3315 First we recall the original vectors and compute their cross product,
3316 which we also store for later reference. Now we divide the vector
3317 by the product of the lengths of the original vectors. The length of
3318 this vector should be the sine of the angle; sure enough, it is!
3320 @c [fix-ref General Mode Commands]
3321 Vector-related commands generally begin with the @kbd{v} prefix key.
3322 Some are uppercase letters and some are lowercase. To make it easier
3323 to type these commands, the shift-@kbd{V} prefix key acts the same as
3324 the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all
3325 prefix keys have this property.)
3327 If we take the dot product of two perpendicular vectors we expect
3328 to get zero, since the cosine of 90 degrees is zero. Let's check
3329 that the cross product is indeed perpendicular to both inputs:
3333 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0
3334 1: [-18, 21, -8] . 1: [-18, 21, -8] .
3337 r 1 r 3 * @key{DEL} r 2 r 3 *
3341 @cindex Normalizing a vector
3342 @cindex Unit vectors
3343 (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the
3344 stack, what keystrokes would you use to @dfn{normalize} the
3345 vector, i.e., to reduce its length to one without changing its
3346 direction? @xref{Vector Answer 1, 1}. (@bullet{})
3348 (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be
3349 at any of several positions along a ruler. You have a list of
3350 those positions in the form of a vector, and another list of the
3351 probabilities for the particle to be at the corresponding positions.
3352 Find the average position of the particle.
3353 @xref{Vector Answer 2, 2}. (@bullet{})
3355 @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
3356 @subsection Matrices
3359 A @dfn{matrix} is just a vector of vectors, all the same length.
3360 This means you can enter a matrix using nested brackets. You can
3361 also use the semicolon character to enter a matrix. We'll show
3366 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3367 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3370 [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET}
3375 We'll be using this matrix again, so type @kbd{s 4} to save it now.
3377 Note that semicolons work with incomplete vectors, but they work
3378 better in algebraic entry. That's why we use the apostrophe in
3381 When two matrices are multiplied, the lefthand matrix must have
3382 the same number of columns as the righthand matrix has rows.
3383 Row @cite{i}, column @cite{j} of the result is effectively the
3384 dot product of row @cite{i} of the left matrix by column @cite{j}
3385 of the right matrix.
3387 If we try to duplicate this matrix and multiply it by itself,
3388 the dimensions are wrong and the multiplication cannot take place:
3392 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ]
3393 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3401 Though rather hard to read, this is a formula which shows the product
3402 of two matrices. The @samp{*} function, having invalid arguments, has
3403 been left in symbolic form.
3405 We can multiply the matrices if we @dfn{transpose} one of them first.
3409 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ]
3410 [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ]
3411 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ]
3416 U v t * U @key{TAB} *
3420 Matrix multiplication is not commutative; indeed, switching the
3421 order of the operands can even change the dimensions of the result
3422 matrix, as happened here!
3424 If you multiply a plain vector by a matrix, it is treated as a
3425 single row or column depending on which side of the matrix it is
3426 on. The result is a plain vector which should also be interpreted
3427 as a row or column as appropriate.
3431 2: [ [ 1, 2, 3 ] 1: [14, 32]
3440 Multiplying in the other order wouldn't work because the number of
3441 rows in the matrix is different from the number of elements in the
3444 (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows
3445 of the above @c{$2\times3$}
3446 @asis{2x3} matrix to get @cite{[6, 15]}. Now use @samp{*} to
3447 sum along the columns to get @cite{[5, 7, 9]}.
3448 @xref{Matrix Answer 1, 1}. (@bullet{})
3450 @cindex Identity matrix
3451 An @dfn{identity matrix} is a square matrix with ones along the
3452 diagonal and zeros elsewhere. It has the property that multiplication
3453 by an identity matrix, on the left or on the right, always produces
3454 the original matrix.
3458 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3459 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3460 . 1: [ [ 1, 0, 0 ] .
3465 r 4 v i 3 @key{RET} *
3469 If a matrix is square, it is often possible to find its @dfn{inverse},
3470 that is, a matrix which, when multiplied by the original matrix, yields
3471 an identity matrix. The @kbd{&} (reciprocal) key also computes the
3472 inverse of a matrix.
3476 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ]
3477 [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ]
3478 [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ]
3486 The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
3487 matrices together. Here we have used it to add a new row onto
3488 our matrix to make it square.
3490 We can multiply these two matrices in either order to get an identity.
3494 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ]
3495 [ 0., 1., 0. ] [ 0., 1., 0. ]
3496 [ 0., 0., 1. ] ] [ 0., 0., 1. ] ]
3499 M-@key{RET} * U @key{TAB} *
3503 @cindex Systems of linear equations
3504 @cindex Linear equations, systems of
3505 Matrix inverses are related to systems of linear equations in algebra.
3506 Suppose we had the following set of equations:
3520 $$ \openup1\jot \tabskip=0pt plus1fil
3521 \halign to\displaywidth{\tabskip=0pt
3522 $\hfil#$&$\hfil{}#{}$&
3523 $\hfil#$&$\hfil{}#{}$&
3524 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3533 This can be cast into the matrix equation,
3538 [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ]
3539 [ 4, 5, 6 ] * [ b ] = [ 2 ]
3540 [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ]
3547 $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
3549 \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
3554 We can solve this system of equations by multiplying both sides by the
3555 inverse of the matrix. Calc can do this all in one step:
3559 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333]
3570 The result is the @cite{[a, b, c]} vector that solves the equations.
3571 (Dividing by a square matrix is equivalent to multiplying by its
3574 Let's verify this solution:
3578 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.]
3581 1: [-12.6, 15.2, -3.93333]
3589 Note that we had to be careful about the order in which we multiplied
3590 the matrix and vector. If we multiplied in the other order, Calc would
3591 assume the vector was a row vector in order to make the dimensions
3592 come out right, and the answer would be incorrect. If you
3593 don't feel safe letting Calc take either interpretation of your
3594 vectors, use explicit @c{$N\times1$}
3595 @asis{Nx1} or @c{$1\times N$}
3596 @asis{1xN} matrices instead.
3597 In this case, you would enter the original column vector as
3598 @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
3600 (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make
3601 vectors and matrices that include variables. Solve the following
3602 system of equations to get expressions for @cite{x} and @cite{y}
3603 in terms of @cite{a} and @cite{b}.
3616 $$ \eqalign{ x &+ a y = 6 \cr
3623 @xref{Matrix Answer 2, 2}. (@bullet{})
3625 @cindex Least-squares for over-determined systems
3626 @cindex Over-determined systems of equations
3627 (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined''
3628 if it has more equations than variables. It is often the case that
3629 there are no values for the variables that will satisfy all the
3630 equations at once, but it is still useful to find a set of values
3631 which ``nearly'' satisfy all the equations. In terms of matrix equations,
3632 you can't solve @cite{A X = B} directly because the matrix @cite{A}
3633 is not square for an over-determined system. Matrix inversion works
3634 only for square matrices. One common trick is to multiply both sides
3635 on the left by the transpose of @cite{A}:
3637 @samp{trn(A)*A*X = trn(A)*B}.
3641 $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
3644 @cite{trn(A)*A} is a square matrix so a solution is possible. It
3645 turns out that the @cite{X} vector you compute in this way will be a
3646 ``least-squares'' solution, which can be regarded as the ``closest''
3647 solution to the set of equations. Use Calc to solve the following
3648 over-determined system:@refill
3663 $$ \openup1\jot \tabskip=0pt plus1fil
3664 \halign to\displaywidth{\tabskip=0pt
3665 $\hfil#$&$\hfil{}#{}$&
3666 $\hfil#$&$\hfil{}#{}$&
3667 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3671 2a&+&4b&+&6c&=11 \cr}
3677 @xref{Matrix Answer 3, 3}. (@bullet{})
3679 @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
3680 @subsection Vectors as Lists
3684 Although Calc has a number of features for manipulating vectors and
3685 matrices as mathematical objects, you can also treat vectors as
3686 simple lists of values. For example, we saw that the @kbd{k f}
3687 command returns a vector which is a list of the prime factors of a
3690 You can pack and unpack stack entries into vectors:
3694 3: 10 1: [10, 20, 30] 3: 10
3703 You can also build vectors out of consecutive integers, or out
3704 of many copies of a given value:
3708 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4]
3709 . 1: 17 1: [17, 17, 17, 17]
3712 v x 4 @key{RET} 17 v b 4 @key{RET}
3716 You can apply an operator to every element of a vector using the
3721 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68]
3729 In the first step, we multiply the vector of integers by the vector
3730 of 17's elementwise. In the second step, we raise each element to
3731 the power two. (The general rule is that both operands must be
3732 vectors of the same length, or else one must be a vector and the
3733 other a plain number.) In the final step, we take the square root
3736 (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two
3738 @cite{2^-4} to @cite{2^4}. @xref{List Answer 1, 1}. (@bullet{})
3740 You can also @dfn{reduce} a binary operator across a vector.
3741 For example, reducing @samp{*} computes the product of all the
3742 elements in the vector:
3746 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123
3754 In this example, we decompose 123123 into its prime factors, then
3755 multiply those factors together again to yield the original number.
3757 We could compute a dot product ``by hand'' using mapping and
3762 2: [1, 2, 3] 1: [7, 12, 0] 1: 19
3771 Recalling two vectors from the previous section, we compute the
3772 sum of pairwise products of the elements to get the same answer
3773 for the dot product as before.
3775 A slight variant of vector reduction is the @dfn{accumulate} operation,
3776 @kbd{V U}. This produces a vector of the intermediate results from
3777 a corresponding reduction. Here we compute a table of factorials:
3781 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720]
3784 v x 6 @key{RET} V U *
3788 Calc allows vectors to grow as large as you like, although it gets
3789 rather slow if vectors have more than about a hundred elements.
3790 Actually, most of the time is spent formatting these large vectors
3791 for display, not calculating on them. Try the following experiment
3792 (if your computer is very fast you may need to substitute a larger
3797 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ...
3800 v x 500 @key{RET} 1 V M +
3804 Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
3805 experiment again. In @kbd{v .} mode, long vectors are displayed
3806 ``abbreviated'' like this:
3810 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501]
3813 v x 500 @key{RET} 1 V M +
3818 (where now the @samp{...} is actually part of the Calc display).
3819 You will find both operations are now much faster. But notice that
3820 even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
3821 Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
3822 experiment one more time. Operations on long vectors are now quite
3823 fast! (But of course if you use @kbd{t .} you will lose the ability
3824 to get old vectors back using the @kbd{t y} command.)
3826 An easy way to view a full vector when @kbd{v .} mode is active is
3827 to press @kbd{`} (back-quote) to edit the vector; editing always works
3828 with the full, unabbreviated value.
3830 @cindex Least-squares for fitting a straight line
3831 @cindex Fitting data to a line
3832 @cindex Line, fitting data to
3833 @cindex Data, extracting from buffers
3834 @cindex Columns of data, extracting
3835 As a larger example, let's try to fit a straight line to some data,
3836 using the method of least squares. (Calc has a built-in command for
3837 least-squares curve fitting, but we'll do it by hand here just to
3838 practice working with vectors.) Suppose we have the following list
3839 of values in a file we have loaded into Emacs:
3866 If you are reading this tutorial in printed form, you will find it
3867 easiest to press @kbd{M-# i} to enter the on-line Info version of
3868 the manual and find this table there. (Press @kbd{g}, then type
3869 @kbd{List Tutorial}, to jump straight to this section.)
3871 Position the cursor at the upper-left corner of this table, just
3872 to the left of the @cite{1.34}. Press @kbd{C-@@} to set the mark.
3873 (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
3874 Now position the cursor to the lower-right, just after the @cite{1.354}.
3875 You have now defined this region as an Emacs ``rectangle.'' Still
3876 in the Info buffer, type @kbd{M-# r}. This command
3877 (@code{calc-grab-rectangle}) will pop you back into the Calculator, with
3878 the contents of the rectangle you specified in the form of a matrix.@refill
3882 1: [ [ 1.34, 0.234 ]
3889 (You may wish to use @kbd{v .} mode to abbreviate the display of this
3892 We want to treat this as a pair of lists. The first step is to
3893 transpose this matrix into a pair of rows. Remember, a matrix is
3894 just a vector of vectors. So we can unpack the matrix into a pair
3895 of row vectors on the stack.
3899 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ]
3900 [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ]
3908 Let's store these in quick variables 1 and 2, respectively.
3912 1: [1.34, 1.41, 1.49, ... ] .
3920 (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
3921 stored value from the stack.)
3923 In a least squares fit, the slope @cite{m} is given by the formula
3927 m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
3933 $$ m = {N \sum x y - \sum x \sum y \over
3934 N \sum x^2 - \left( \sum x \right)^2} $$
3940 @cite{sum(x)} represents the sum of all the values of @cite{x}.
3941 While there is an actual @code{sum} function in Calc, it's easier to
3942 sum a vector using a simple reduction. First, let's compute the four
3943 different sums that this formula uses.
3950 r 1 V R + t 3 r 1 2 V M ^ V R + t 4
3957 1: 13.613 1: 33.36554
3960 r 2 V R + t 5 r 1 r 2 V M * V R + t 6
3966 These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
3967 respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and
3972 These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
3973 respectively. (We could have used \kbd{*} to compute $\sum x^2$ and
3977 Finally, we also need @cite{N}, the number of data points. This is just
3978 the length of either of our lists.
3990 (That's @kbd{v} followed by a lower-case @kbd{l}.)
3992 Now we grind through the formula:
3996 1: 633.94526 2: 633.94526 1: 67.23607
4000 r 7 r 6 * r 3 r 5 * -
4007 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679
4008 1: 1862.0057 2: 1862.0057 1: 128.9488 .
4012 r 7 r 4 * r 3 2 ^ - / t 8
4016 That gives us the slope @cite{m}. The y-intercept @cite{b} can now
4017 be found with the simple formula,
4021 b = (sum(y) - m sum(x)) / N
4027 $$ b = {\sum y - m \sum x \over N} $$
4034 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978
4038 r 5 r 8 r 3 * - r 7 / t 9
4042 Let's ``plot'' this straight line approximation, @c{$y \approx m x + b$}
4043 @cite{m x + b}, and compare it with the original data.@refill
4047 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ]
4055 Notice that multiplying a vector by a constant, and adding a constant
4056 to a vector, can be done without mapping commands since these are
4057 common operations from vector algebra. As far as Calc is concerned,
4058 we've just been doing geometry in 19-dimensional space!
4060 We can subtract this vector from our original @cite{y} vector to get
4061 a feel for the error of our fit. Let's find the maximum error:
4065 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897
4073 First we compute a vector of differences, then we take the absolute
4074 values of these differences, then we reduce the @code{max} function
4075 across the vector. (The @code{max} function is on the two-key sequence
4076 @kbd{f x}; because it is so common to use @code{max} in a vector
4077 operation, the letters @kbd{X} and @kbd{N} are also accepted for
4078 @code{max} and @code{min} in this context. In general, you answer
4079 the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
4080 invokes the function you want. You could have typed @kbd{V R f x} or
4081 even @kbd{V R x max @key{RET}} if you had preferred.)
4083 If your system has the GNUPLOT program, you can see graphs of your
4084 data and your straight line to see how well they match. (If you have
4085 GNUPLOT 3.0, the following instructions will work regardless of the
4086 kind of display you have. Some GNUPLOT 2.0, non-X-windows systems
4087 may require additional steps to view the graphs.)
4089 Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}''
4090 vectors onto the stack and press @kbd{g f}. This ``fast'' graphing
4091 command does everything you need to do for simple, straightforward
4096 2: [1.34, 1.41, 1.49, ... ]
4097 1: [0.234, 0.298, 0.402, ... ]
4104 If all goes well, you will shortly get a new window containing a graph
4105 of the data. (If not, contact your GNUPLOT or Calc installer to find
4106 out what went wrong.) In the X window system, this will be a separate
4107 graphics window. For other kinds of displays, the default is to
4108 display the graph in Emacs itself using rough character graphics.
4109 Press @kbd{q} when you are done viewing the character graphics.
4111 Next, let's add the line we got from our least-squares fit.
4113 (If you are reading this tutorial on-line while running Calc, typing
4114 @kbd{g a} may cause the tutorial to disappear from its window and be
4115 replaced by a buffer named @samp{*Gnuplot Commands*}. The tutorial
4116 will reappear when you terminate GNUPLOT by typing @kbd{g q}.)
4121 2: [1.34, 1.41, 1.49, ... ]
4122 1: [0.273, 0.309, 0.351, ... ]
4125 @key{DEL} r 0 g a g p
4129 It's not very useful to get symbols to mark the data points on this
4130 second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q}
4131 when you are done to remove the X graphics window and terminate GNUPLOT.
4133 (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do
4134 least squares fitting to a general system of equations. Our 19 data
4135 points are really 19 equations of the form @cite{y_i = m x_i + b} for
4136 different pairs of @cite{(x_i,y_i)}. Use the matrix-transpose method
4137 to solve for @cite{m} and @cite{b}, duplicating the above result.
4138 @xref{List Answer 2, 2}. (@bullet{})
4140 @cindex Geometric mean
4141 (@bullet{}) @strong{Exercise 3.} If the input data do not form a
4142 rectangle, you can use @w{@kbd{M-# g}} (@code{calc-grab-region})
4143 to grab the data the way Emacs normally works with regions---it reads
4144 left-to-right, top-to-bottom, treating line breaks the same as spaces.
4145 Use this command to find the geometric mean of the following numbers.
4146 (The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
4155 The @kbd{M-# g} command accepts numbers separated by spaces or commas,
4156 with or without surrounding vector brackets.
4157 @xref{List Answer 3, 3}. (@bullet{})
4160 As another example, a theorem about binomial coefficients tells
4161 us that the alternating sum of binomial coefficients
4162 @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
4163 on up to @var{n}-choose-@var{n},
4164 always comes out to zero. Let's verify this
4165 for @cite{n=6}.@refill
4168 As another example, a theorem about binomial coefficients tells
4169 us that the alternating sum of binomial coefficients
4170 ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
4171 always comes out to zero. Let's verify this
4177 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6]
4187 1: [1, -6, 15, -20, 15, -6, 1] 1: 0
4190 V M ' (-1)^$ choose(6,$) @key{RET} V R +
4194 The @kbd{V M '} command prompts you to enter any algebraic expression
4195 to define the function to map over the vector. The symbol @samp{$}
4196 inside this expression represents the argument to the function.
4197 The Calculator applies this formula to each element of the vector,
4198 substituting each element's value for the @samp{$} sign(s) in turn.
4200 To define a two-argument function, use @samp{$$} for the first
4201 argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is
4202 equivalent to @kbd{V M -}. This is analogous to regular algebraic
4203 entry, where @samp{$$} would refer to the next-to-top stack entry
4204 and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
4205 would act exactly like @kbd{-}.
4207 Notice that the @kbd{V M '} command has recorded two things in the
4208 trail: The result, as usual, and also a funny-looking thing marked
4209 @samp{oper} that represents the operator function you typed in.
4210 The function is enclosed in @samp{< >} brackets, and the argument is
4211 denoted by a @samp{#} sign. If there were several arguments, they
4212 would be shown as @samp{#1}, @samp{#2}, and so on. (For example,
4213 @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
4214 trail.) This object is a ``nameless function''; you can use nameless
4215 @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
4216 Nameless function notation has the interesting, occasionally useful
4217 property that a nameless function is not actually evaluated until
4218 it is used. For example, @kbd{V M ' $+random(2.0)} evaluates
4219 @samp{random(2.0)} once and adds that random number to all elements
4220 of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
4221 @samp{random(2.0)} separately for each vector element.
4223 Another group of operators that are often useful with @kbd{V M} are
4224 the relational operators: @kbd{a =}, for example, compares two numbers
4225 and gives the result 1 if they are equal, or 0 if not. Similarly,
4226 @w{@kbd{a <}} checks for one number being less than another.
4228 Other useful vector operations include @kbd{v v}, to reverse a
4229 vector end-for-end; @kbd{V S}, to sort the elements of a vector
4230 into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
4231 one row or column of a matrix, or (in both cases) to extract one
4232 element of a plain vector. With a negative argument, @kbd{v r}
4233 and @kbd{v c} instead delete one row, column, or vector element.
4235 @cindex Divisor functions
4236 (@bullet{}) @strong{Exercise 4.} The @cite{k}th @dfn{divisor function}
4240 is the sum of the @cite{k}th powers of all the divisors of an
4241 integer @cite{n}. Figure out a method for computing the divisor
4242 function for reasonably small values of @cite{n}. As a test,
4243 the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
4244 @xref{List Answer 4, 4}. (@bullet{})
4246 @cindex Square-free numbers
4247 @cindex Duplicate values in a list
4248 (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a
4249 list of prime factors for a number. Sometimes it is important to
4250 know that a number is @dfn{square-free}, i.e., that no prime occurs
4251 more than once in its list of prime factors. Find a sequence of
4252 keystrokes to tell if a number is square-free; your method should
4253 leave 1 on the stack if it is, or 0 if it isn't.
4254 @xref{List Answer 5, 5}. (@bullet{})
4256 @cindex Triangular lists
4257 (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks
4258 like the following diagram. (You may wish to use the @kbd{v /}
4259 command to enable multi-line display of vectors.)
4268 [1, 2, 3, 4, 5, 6] ]
4273 @xref{List Answer 6, 6}. (@bullet{})
4275 (@bullet{}) @strong{Exercise 7.} Build the following list of lists.
4283 [10, 11, 12, 13, 14],
4284 [15, 16, 17, 18, 19, 20] ]
4289 @xref{List Answer 7, 7}. (@bullet{})
4291 @cindex Maximizing a function over a list of values
4292 @c [fix-ref Numerical Solutions]
4293 (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's
4295 @cite{J1} function @samp{besJ(1,x)} for @cite{x} from 0 to 5
4297 Find the value of @cite{x} (from among the above set of values) for
4298 which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method,
4299 i.e., just reading along the list by hand to find the largest value
4300 is not allowed! (There is an @kbd{a X} command which does this kind
4301 of thing automatically; @pxref{Numerical Solutions}.)
4302 @xref{List Answer 8, 8}. (@bullet{})@refill
4304 @cindex Digits, vectors of
4305 (@bullet{}) @strong{Exercise 9.} You are given an integer in the range
4306 @c{$0 \le N < 10^m$}
4307 @cite{0 <= N < 10^m} for @cite{m=12} (i.e., an integer of less than
4308 twelve digits). Convert this integer into a vector of @cite{m}
4309 digits, each in the range from 0 to 9. In vector-of-digits notation,
4310 add one to this integer to produce a vector of @cite{m+1} digits
4311 (since there could be a carry out of the most significant digit).
4312 Convert this vector back into a regular integer. A good integer
4313 to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{})
4315 (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use
4316 @kbd{V R a =} to test if all numbers in a list were equal. What
4317 happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{})
4319 (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one
4321 @cite{pi}. The area of the @c{$2\times2$}
4322 @asis{2x2} square that encloses that
4323 circle is 4. So if we throw @var{n} darts at random points in the square,
4325 @cite{pi/4} of them will land inside the circle. This gives us
4326 an entertaining way to estimate the value of @c{$\pi$}
4327 @cite{pi}. The @w{@kbd{k r}}
4328 command picks a random number between zero and the value on the stack.
4329 We could get a random floating-point number between @i{-1} and 1 by typing
4330 @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @cite{(x,y)} points in
4331 this square, then use vector mapping and reduction to count how many
4332 points lie inside the unit circle. Hint: Use the @kbd{v b} command.
4333 @xref{List Answer 11, 11}. (@bullet{})
4335 @cindex Matchstick problem
4336 (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides
4337 another way to calculate @c{$\pi$}
4338 @cite{pi}. Say you have an infinite field
4339 of vertical lines with a spacing of one inch. Toss a one-inch matchstick
4340 onto the field. The probability that the matchstick will land crossing
4341 a line turns out to be @c{$2/\pi$}
4342 @cite{2/pi}. Toss 100 matchsticks to estimate
4344 @cite{pi}. (If you want still more fun, the probability that the GCD
4345 (@w{@kbd{k g}}) of two large integers is one turns out to be @c{$6/\pi^2$}
4347 That provides yet another way to estimate @c{$\pi$}
4349 @xref{List Answer 12, 12}. (@bullet{})
4351 (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in
4352 double-quote marks, @samp{"hello"}, creates a vector of the numerical
4353 (ASCII) codes of the characters (here, @cite{[104, 101, 108, 108, 111]}).
4354 Sometimes it is convenient to compute a @dfn{hash code} of a string,
4355 which is just an integer that represents the value of that string.
4356 Two equal strings have the same hash code; two different strings
4357 @dfn{probably} have different hash codes. (For example, Calc has
4358 over 400 function names, but Emacs can quickly find the definition for
4359 any given name because it has sorted the functions into ``buckets'' by
4360 their hash codes. Sometimes a few names will hash into the same bucket,
4361 but it is easier to search among a few names than among all the names.)
4362 One popular hash function is computed as follows: First set @cite{h = 0}.
4363 Then, for each character from the string in turn, set @cite{h = 3h + c_i}
4364 where @cite{c_i} is the character's ASCII code. If we have 511 buckets,
4365 we then take the hash code modulo 511 to get the bucket number. Develop a
4366 simple command or commands for converting string vectors into hash codes.
4367 The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
4368 511 is 121. @xref{List Answer 13, 13}. (@bullet{})
4370 (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U}
4371 commands do nested function evaluations. @kbd{H V U} takes a starting
4372 value and a number of steps @var{n} from the stack; it then applies the
4373 function you give to the starting value 0, 1, 2, up to @var{n} times
4374 and returns a vector of the results. Use this command to create a
4375 ``random walk'' of 50 steps. Start with the two-dimensional point
4376 @cite{(0,0)}; then take one step a random distance between @i{-1} and 1
4377 in both @cite{x} and @cite{y}; then take another step, and so on. Use the
4378 @kbd{g f} command to display this random walk. Now modify your random
4379 walk to walk a unit distance, but in a random direction, at each step.
4380 (Hint: The @code{sincos} function returns a vector of the cosine and
4381 sine of an angle.) @xref{List Answer 14, 14}. (@bullet{})
4383 @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
4384 @section Types Tutorial
4387 Calc understands a variety of data types as well as simple numbers.
4388 In this section, we'll experiment with each of these types in turn.
4390 The numbers we've been using so far have mainly been either @dfn{integers}
4391 or @dfn{floats}. We saw that floats are usually a good approximation to
4392 the mathematical concept of real numbers, but they are only approximations
4393 and are susceptible to roundoff error. Calc also supports @dfn{fractions},
4394 which can exactly represent any rational number.
4398 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414
4402 10 ! 49 @key{RET} : 2 + &
4407 The @kbd{:} command divides two integers to get a fraction; @kbd{/}
4408 would normally divide integers to get a floating-point result.
4409 Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
4410 since the @kbd{:} would otherwise be interpreted as part of a
4411 fraction beginning with 49.
4413 You can convert between floating-point and fractional format using
4414 @kbd{c f} and @kbd{c F}:
4418 1: 1.35027217629e-5 1: 7:518414
4425 The @kbd{c F} command replaces a floating-point number with the
4426 ``simplest'' fraction whose floating-point representation is the
4427 same, to within the current precision.
4431 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113
4434 P c F @key{DEL} p 5 @key{RET} P c F
4438 (@bullet{}) @strong{Exercise 1.} A calculation has produced the
4439 result 1.26508260337. You suspect it is the square root of the
4440 product of @c{$\pi$}
4441 @cite{pi} and some rational number. Is it? (Be sure
4442 to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{})
4444 @dfn{Complex numbers} can be stored in both rectangular and polar form.
4448 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.)
4456 The square root of @i{-9} is by default rendered in rectangular form
4457 (@w{@cite{0 + 3i}}), but we can convert it to polar form (3 with a
4458 phase angle of 90 degrees). All the usual arithmetic and scientific
4459 operations are defined on both types of complex numbers.
4461 Another generalized kind of number is @dfn{infinity}. Infinity
4462 isn't really a number, but it can sometimes be treated like one.
4463 Calc uses the symbol @code{inf} to represent positive infinity,
4464 i.e., a value greater than any real number. Naturally, you can
4465 also write @samp{-inf} for minus infinity, a value less than any
4466 real number. The word @code{inf} can only be input using
4471 2: inf 2: -inf 2: -inf 2: -inf 1: nan
4472 1: -17 1: -inf 1: -inf 1: inf .
4475 ' inf @key{RET} 17 n * @key{RET} 72 + A +
4480 Since infinity is infinitely large, multiplying it by any finite
4481 number (like @i{-17}) has no effect, except that since @i{-17}
4482 is negative, it changes a plus infinity to a minus infinity.
4483 (``A huge positive number, multiplied by @i{-17}, yields a huge
4484 negative number.'') Adding any finite number to infinity also
4485 leaves it unchanged. Taking an absolute value gives us plus
4486 infinity again. Finally, we add this plus infinity to the minus
4487 infinity we had earlier. If you work it out, you might expect
4488 the answer to be @i{-72} for this. But the 72 has been completely
4489 lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
4490 the finite difference between them, if any, is undetectable.
4491 So we say the result is @dfn{indeterminate}, which Calc writes
4492 with the symbol @code{nan} (for Not A Number).
4494 Dividing by zero is normally treated as an error, but you can get
4495 Calc to write an answer in terms of infinity by pressing @kbd{m i}
4496 to turn on ``infinite mode.''
4500 3: nan 2: nan 2: nan 2: nan 1: nan
4501 2: 1 1: 1 / 0 1: uinf 1: uinf .
4505 1 @key{RET} 0 / m i U / 17 n * +
4510 Dividing by zero normally is left unevaluated, but after @kbd{m i}
4511 it instead gives an infinite result. The answer is actually
4512 @code{uinf}, ``undirected infinity.'' If you look at a graph of
4513 @cite{1 / x} around @w{@cite{x = 0}}, you'll see that it goes toward
4514 plus infinity as you approach zero from above, but toward minus
4515 infinity as you approach from below. Since we said only @cite{1 / 0},
4516 Calc knows that the answer is infinite but not in which direction.
4517 That's what @code{uinf} means. Notice that multiplying @code{uinf}
4518 by a negative number still leaves plain @code{uinf}; there's no
4519 point in saying @samp{-uinf} because the sign of @code{uinf} is
4520 unknown anyway. Finally, we add @code{uinf} to our @code{nan},
4521 yielding @code{nan} again. It's easy to see that, because
4522 @code{nan} means ``totally unknown'' while @code{uinf} means
4523 ``unknown sign but known to be infinite,'' the more mysterious
4524 @code{nan} wins out when it is combined with @code{uinf}, or, for
4525 that matter, with anything else.
4527 (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer
4528 for each of these formulas: @samp{inf / inf}, @samp{exp(inf)},
4529 @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
4530 @samp{abs(uinf)}, @samp{ln(0)}.
4531 @xref{Types Answer 2, 2}. (@bullet{})
4533 (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan},
4534 which stands for an unknown value. Can @code{nan} stand for
4535 a complex number? Can it stand for infinity?
4536 @xref{Types Answer 3, 3}. (@bullet{})
4538 @dfn{HMS forms} represent a value in terms of hours, minutes, and
4543 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2.
4544 . . 1: 1@@ 45' 0." .
4547 2@@ 30' @key{RET} 1 + @key{RET} 2 / /
4551 HMS forms can also be used to hold angles in degrees, minutes, and
4556 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721
4564 First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
4565 form, then we take the sine of that angle. Note that the trigonometric
4566 functions will accept HMS forms directly as input.
4569 (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is
4570 47 minutes and 26 seconds long, and contains 17 songs. What is the
4571 average length of a song on @emph{Abbey Road}? If the Extended Disco
4572 Version of @emph{Abbey Road} added 20 seconds to the length of each
4573 song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{})
4575 A @dfn{date form} represents a date, or a date and time. Dates must
4576 be entered using algebraic entry. Date forms are surrounded by
4577 @samp{< >} symbols; most standard formats for dates are recognized.
4581 2: <Sun Jan 13, 1991> 1: 2.25
4582 1: <6:00pm Thu Jan 10, 1991> .
4585 ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} -
4590 In this example, we enter two dates, then subtract to find the
4591 number of days between them. It is also possible to add an
4592 HMS form or a number (of days) to a date form to get another
4597 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991>
4604 @c [fix-ref Date Arithmetic]
4606 The @kbd{t N} (``now'') command pushes the current date and time on the
4607 stack; then we add two days, ten hours and five minutes to the date and
4608 time. Other date-and-time related commands include @kbd{t J}, which
4609 does Julian day conversions, @kbd{t W}, which finds the beginning of
4610 the week in which a date form lies, and @kbd{t I}, which increments a
4611 date by one or several months. @xref{Date Arithmetic}, for more.
4613 (@bullet{}) @strong{Exercise 5.} How many days until the next
4614 Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{})
4616 (@bullet{}) @strong{Exercise 6.} How many leap years will there be
4617 between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{})
4619 @cindex Slope and angle of a line
4620 @cindex Angle and slope of a line
4621 An @dfn{error form} represents a mean value with an attached standard
4622 deviation, or error estimate. Suppose our measurements indicate that
4623 a certain telephone pole is about 30 meters away, with an estimated
4624 error of 1 meter, and 8 meters tall, with an estimated error of 0.2
4625 meters. What is the slope of a line from here to the top of the
4626 pole, and what is the equivalent angle in degrees?
4630 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594
4634 8 p .2 @key{RET} 30 p 1 / I T
4639 This means that the angle is about 15 degrees, and, assuming our
4640 original error estimates were valid standard deviations, there is about
4641 a 60% chance that the result is correct within 0.59 degrees.
4643 @cindex Torus, volume of
4644 (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is
4646 @w{@cite{2 pi^2 R r^2}} where @cite{R} is the radius of the circle that
4647 defines the center of the tube and @cite{r} is the radius of the tube
4648 itself. Suppose @cite{R} is 20 cm and @cite{r} is 4 cm, each known to
4649 within 5 percent. What is the volume and the relative uncertainty of
4650 the volume? @xref{Types Answer 7, 7}. (@bullet{})
4652 An @dfn{interval form} represents a range of values. While an
4653 error form is best for making statistical estimates, intervals give
4654 you exact bounds on an answer. Suppose we additionally know that
4655 our telephone pole is definitely between 28 and 31 meters away,
4656 and that it is between 7.7 and 8.1 meters tall.
4660 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1]
4664 [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T
4669 If our bounds were correct, then the angle to the top of the pole
4670 is sure to lie in the range shown.
4672 The square brackets around these intervals indicate that the endpoints
4673 themselves are allowable values. In other words, the distance to the
4674 telephone pole is between 28 and 31, @emph{inclusive}. You can also
4675 make an interval that is exclusive of its endpoints by writing
4676 parentheses instead of square brackets. You can even make an interval
4677 which is inclusive (``closed'') on one end and exclusive (``open'') on
4682 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3)
4686 [ 1 .. 10 ) & [ 2 .. 3 ) *
4691 The Calculator automatically keeps track of which end values should
4692 be open and which should be closed. You can also make infinite or
4693 semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
4696 (@bullet{}) @strong{Exercise 8.} What answer would you expect from
4697 @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What
4698 about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
4699 zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}?
4700 @xref{Types Answer 8, 8}. (@bullet{})
4702 (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number
4703 are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same
4704 answer. Would you expect this still to hold true for interval forms?
4705 If not, which of these will result in a larger interval?
4706 @xref{Types Answer 9, 9}. (@bullet{})
4708 A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
4709 For example, arithmetic involving time is generally done modulo 12
4714 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24
4717 17 M 24 @key{RET} 10 + n 5 /
4722 In this last step, Calc has found a new number which, when multiplied
4723 by 5 modulo 24, produces the original number, 21. If @var{m} is prime
4724 it is always possible to find such a number. For non-prime @var{m}
4725 like 24, it is only sometimes possible.
4729 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16
4732 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 %
4737 These two calculations get the same answer, but the first one is
4738 much more efficient because it avoids the huge intermediate value
4739 that arises in the second one.
4741 @cindex Fermat, primality test of
4742 (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat
4743 says that @c{\w{$x^{n-1} \bmod n = 1$}}
4744 @cite{x^(n-1) mod n = 1} if @cite{n} is a prime number
4745 and @cite{x} is an integer less than @cite{n}. If @cite{n} is
4746 @emph{not} a prime number, this will @emph{not} be true for most
4747 values of @cite{x}. Thus we can test informally if a number is
4748 prime by trying this formula for several values of @cite{x}.
4749 Use this test to tell whether the following numbers are prime:
4750 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{})
4752 It is possible to use HMS forms as parts of error forms, intervals,
4753 modulo forms, or as the phase part of a polar complex number.
4754 For example, the @code{calc-time} command pushes the current time
4755 of day on the stack as an HMS/modulo form.
4759 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0"
4767 This calculation tells me it is six hours and 22 minutes until midnight.
4769 (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year
4770 is about @c{$\pi \times 10^7$}
4771 @w{@cite{pi * 10^7}} seconds. What time will it be that
4772 many seconds from right now? @xref{Types Answer 11, 11}. (@bullet{})
4774 (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging
4775 for the CD release of the Extended Disco Version of @emph{Abbey Road}.
4776 You are told that the songs will actually be anywhere from 20 to 60
4777 seconds longer than the originals. One CD can hold about 75 minutes
4778 of music. Should you order single or double packages?
4779 @xref{Types Answer 12, 12}. (@bullet{})
4781 Another kind of data the Calculator can manipulate is numbers with
4782 @dfn{units}. This isn't strictly a new data type; it's simply an
4783 application of algebraic expressions, where we use variables with
4784 suggestive names like @samp{cm} and @samp{in} to represent units
4785 like centimeters and inches.
4789 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m
4792 ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b
4797 We enter the quantity ``2 inches'' (actually an algebraic expression
4798 which means two times the variable @samp{in}), then we convert it
4799 first to centimeters, then to fathoms, then finally to ``base'' units,
4800 which in this case means meters.
4804 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm
4807 ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET}
4814 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2
4822 Since units expressions are really just formulas, taking the square
4823 root of @samp{acre} is undefined. After all, @code{acre} might be an
4824 algebraic variable that you will someday assign a value. We use the
4825 ``units-simplify'' command to simplify the expression with variables
4826 being interpreted as unit names.
4828 In the final step, we have converted not to a particular unit, but to a
4829 units system. The ``cgs'' system uses centimeters instead of meters
4830 as its standard unit of length.
4832 There is a wide variety of units defined in the Calculator.
4836 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c
4839 ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET}
4844 We express a speed first in miles per hour, then in kilometers per
4845 hour, then again using a slightly more explicit notation, then
4846 finally in terms of fractions of the speed of light.
4848 Temperature conversions are a bit more tricky. There are two ways to
4849 interpret ``20 degrees Fahrenheit''---it could mean an actual
4850 temperature, or it could mean a change in temperature. For normal
4851 units there is no difference, but temperature units have an offset
4852 as well as a scale factor and so there must be two explicit commands
4857 1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC
4860 ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} c f
4865 First we convert a change of 20 degrees Fahrenheit into an equivalent
4866 change in degrees Celsius (or Centigrade). Then, we convert the
4867 absolute temperature 20 degrees Fahrenheit into Celsius. Since
4868 this comes out as an exact fraction, we then convert to floating-point
4869 for easier comparison with the other result.
4871 For simple unit conversions, you can put a plain number on the stack.
4872 Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
4873 When you use this method, you're responsible for remembering which
4874 numbers are in which units:
4878 1: 55 1: 88.5139 1: 8.201407e-8
4881 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET}
4885 To see a complete list of built-in units, type @kbd{u v}. Press
4886 @w{@kbd{M-# c}} again to re-enter the Calculator when you're done looking
4889 (@bullet{}) @strong{Exercise 13.} How many seconds are there really
4890 in a year? @xref{Types Answer 13, 13}. (@bullet{})
4892 @cindex Speed of light
4893 (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by
4894 the speed of light (and of electricity, which is nearly as fast).
4895 Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
4896 cabinet is one meter across. Is speed of light going to be a
4897 significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{})
4899 (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about
4900 five yards in an hour. He has obtained a supply of Power Pills; each
4901 Power Pill he eats doubles his speed. How many Power Pills can he
4902 swallow and still travel legally on most US highways?
4903 @xref{Types Answer 15, 15}. (@bullet{})
4905 @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
4906 @section Algebra and Calculus Tutorial
4909 This section shows how to use Calc's algebra facilities to solve
4910 equations, do simple calculus problems, and manipulate algebraic
4914 * Basic Algebra Tutorial::
4915 * Rewrites Tutorial::
4918 @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
4919 @subsection Basic Algebra
4922 If you enter a formula in algebraic mode that refers to variables,
4923 the formula itself is pushed onto the stack. You can manipulate
4924 formulas as regular data objects.
4928 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y)
4931 ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} *
4935 (@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and
4936 @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
4937 Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{})
4939 There are also commands for doing common algebraic operations on
4940 formulas. Continuing with the formula from the last example,
4944 1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y
4952 First we ``expand'' using the distributive law, then we ``collect''
4953 terms involving like powers of @cite{x}.
4955 Let's find the value of this expression when @cite{x} is 2 and @cite{y}
4960 1: 17 x^2 - 6 x^4 + 3 1: -25
4963 1:2 s l y @key{RET} 2 s l x @key{RET}
4968 The @kbd{s l} command means ``let''; it takes a number from the top of
4969 the stack and temporarily assigns it as the value of the variable
4970 you specify. It then evaluates (as if by the @kbd{=} key) the
4971 next expression on the stack. After this command, the variable goes
4972 back to its original value, if any.
4974 (An earlier exercise in this tutorial involved storing a value in the
4975 variable @code{x}; if this value is still there, you will have to
4976 unstore it with @kbd{s u x @key{RET}} before the above example will work
4979 @cindex Maximum of a function using Calculus
4980 Let's find the maximum value of our original expression when @cite{y}
4981 is one-half and @cite{x} ranges over all possible values. We can
4982 do this by taking the derivative with respect to @cite{x} and examining
4983 values of @cite{x} for which the derivative is zero. If the second
4984 derivative of the function at that value of @cite{x} is negative,
4985 the function has a local maximum there.
4989 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3
4992 U @key{DEL} s 1 a d x @key{RET} s 2
4997 Well, the derivative is clearly zero when @cite{x} is zero. To find
4998 the other root(s), let's divide through by @cite{x} and then solve:
5002 1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2
5005 ' x @key{RET} / a x a s
5012 1: 34 - 24 x^2 = 0 1: x = 1.19023
5015 0 a = s 3 a S x @key{RET}
5020 Notice the use of @kbd{a s} to ``simplify'' the formula. When the
5021 default algebraic simplifications don't do enough, you can use
5022 @kbd{a s} to tell Calc to spend more time on the job.
5024 Now we compute the second derivative and plug in our values of @cite{x}:
5028 1: 1.19023 2: 1.19023 2: 1.19023
5029 . 1: 34 x - 24 x^3 1: 34 - 72 x^2
5032 a . r 2 a d x @key{RET} s 4
5037 (The @kbd{a .} command extracts just the righthand side of an equation.
5038 Another method would have been to use @kbd{v u} to unpack the equation
5039 @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
5040 to delete the @samp{x}.)
5044 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34
5048 @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET}
5053 The first of these second derivatives is negative, so we know the function
5054 has a maximum value at @cite{x = 1.19023}. (The function also has a
5055 local @emph{minimum} at @cite{x = 0}.)
5057 When we solved for @cite{x}, we got only one value even though
5058 @cite{34 - 24 x^2 = 0} is a quadratic equation that ought to have
5059 two solutions. The reason is that @w{@kbd{a S}} normally returns a
5060 single ``principal'' solution. If it needs to come up with an
5061 arbitrary sign (as occurs in the quadratic formula) it picks @cite{+}.
5062 If it needs an arbitrary integer, it picks zero. We can get a full
5063 solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
5067 1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023
5070 r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET}
5075 Calc has invented the variable @samp{s1} to represent an unknown sign;
5076 it is supposed to be either @i{+1} or @i{-1}. Here we have used
5077 the ``let'' command to evaluate the expression when the sign is negative.
5078 If we plugged this into our second derivative we would get the same,
5079 negative, answer, so @cite{x = -1.19023} is also a maximum.
5081 To find the actual maximum value, we must plug our two values of @cite{x}
5082 into the original formula.
5086 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3
5090 r 1 r 5 s l @key{RET}
5095 (Here we see another way to use @kbd{s l}; if its input is an equation
5096 with a variable on the lefthand side, then @kbd{s l} treats the equation
5097 like an assignment to that variable if you don't give a variable name.)
5099 It's clear that this will have the same value for either sign of
5100 @code{s1}, but let's work it out anyway, just for the exercise:
5104 2: [-1, 1] 1: [15.04166, 15.04166]
5105 1: 24.08333 s1^2 ... .
5108 [ 1 n , 1 ] @key{TAB} V M $ @key{RET}
5113 Here we have used a vector mapping operation to evaluate the function
5114 at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '}
5115 except that it takes the formula from the top of the stack. The
5116 formula is interpreted as a function to apply across the vector at the
5117 next-to-top stack level. Since a formula on the stack can't contain
5118 @samp{$} signs, Calc assumes the variables in the formula stand for
5119 different arguments. It prompts you for an @dfn{argument list}, giving
5120 the list of all variables in the formula in alphabetical order as the
5121 default list. In this case the default is @samp{(s1)}, which is just
5122 what we want so we simply press @key{RET} at the prompt.
5124 If there had been several different values, we could have used
5125 @w{@kbd{V R X}} to find the global maximum.
5127 Calc has a built-in @kbd{a P} command that solves an equation using
5128 @w{@kbd{H a S}} and returns a vector of all the solutions. It simply
5129 automates the job we just did by hand. Applied to our original
5130 cubic polynomial, it would produce the vector of solutions
5131 @cite{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command
5132 which finds a local maximum of a function. It uses a numerical search
5133 method rather than examining the derivatives, and thus requires you
5134 to provide some kind of initial guess to show it where to look.)
5136 (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a
5137 polynomial (such as the output of an @kbd{a P} command), what
5138 sequence of commands would you use to reconstruct the original
5139 polynomial? (The answer will be unique to within a constant
5140 multiple; choose the solution where the leading coefficient is one.)
5141 @xref{Algebra Answer 2, 2}. (@bullet{})
5143 The @kbd{m s} command enables ``symbolic mode,'' in which formulas
5144 like @samp{sqrt(5)} that can't be evaluated exactly are left in
5145 symbolic form rather than giving a floating-point approximate answer.
5146 Fraction mode (@kbd{m f}) is also useful when doing algebra.
5150 2: 34 x - 24 x^3 2: 34 x - 24 x^3
5151 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0]
5154 r 2 @key{RET} m s m f a P x @key{RET}
5158 One more mode that makes reading formulas easier is ``Big mode.''
5167 1: [-----, -----, 0]
5176 Here things like powers, square roots, and quotients and fractions
5177 are displayed in a two-dimensional pictorial form. Calc has other
5178 language modes as well, such as C mode, FORTRAN mode, and @TeX{} mode.
5182 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3
5183 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/
5194 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
5195 1: @{2 \over 3@} \sqrt@{5@}
5198 d T ' 2 \sqrt@{5@} \over 3 @key{RET}
5203 As you can see, language modes affect both entry and display of
5204 formulas. They affect such things as the names used for built-in
5205 functions, the set of arithmetic operators and their precedences,
5206 and notations for vectors and matrices.
5208 Notice that @samp{sqrt(51)} may cause problems with older
5209 implementations of C and FORTRAN, which would require something more
5210 like @samp{sqrt(51.0)}. It is always wise to check over the formulas
5211 produced by the various language modes to make sure they are fully
5214 Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You
5215 may prefer to remain in Big mode, but all the examples in the tutorial
5216 are shown in normal mode.)
5218 @cindex Area under a curve
5219 What is the area under the portion of this curve from @cite{x = 1} to @cite{2}?
5220 This is simply the integral of the function:
5224 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x
5232 We want to evaluate this at our two values for @cite{x} and subtract.
5233 One way to do it is again with vector mapping and reduction:
5237 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666
5238 1: 5.6666 x^3 ... . .
5240 [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5244 (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @cite{y}
5245 of @c{$x \sin \pi x$}
5246 @w{@cite{x sin(pi x)}} (where the sine is calculated in radians).
5247 Find the values of the integral for integers @cite{y} from 1 to 5.
5248 @xref{Algebra Answer 3, 3}. (@bullet{})
5250 Calc's integrator can do many simple integrals symbolically, but many
5251 others are beyond its capabilities. Suppose we wish to find the area
5252 under the curve @c{$\sin x \ln x$}
5253 @cite{sin(x) ln(x)} over the same range of @cite{x}. If
5254 you entered this formula and typed @kbd{a i x @key{RET}} (don't bother to try
5255 this), Calc would work for a long time but would be unable to find a
5256 solution. In fact, there is no closed-form solution to this integral.
5259 @cindex Integration, numerical
5260 @cindex Numerical integration
5261 One approach would be to do the integral numerically. It is not hard
5262 to do this by hand using vector mapping and reduction. It is rather
5263 slow, though, since the sine and logarithm functions take a long time.
5264 We can save some time by reducing the working precision.
5268 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9]
5273 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
5278 (Note that we have used the extended version of @kbd{v x}; we could
5279 also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.)
5283 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ]
5287 ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET}
5302 (If you got wildly different results, did you remember to switch
5305 Here we have divided the curve into ten segments of equal width;
5306 approximating these segments as rectangular boxes (i.e., assuming
5307 the curve is nearly flat at that resolution), we compute the areas
5308 of the boxes (height times width), then sum the areas. (It is
5309 faster to sum first, then multiply by the width, since the width
5310 is the same for every box.)
5312 The true value of this integral turns out to be about 0.374, so
5313 we're not doing too well. Let's try another approach.
5317 1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
5320 r 1 a t x=1 @key{RET} 4 @key{RET}
5325 Here we have computed the Taylor series expansion of the function
5326 about the point @cite{x=1}. We can now integrate this polynomial
5327 approximation, since polynomials are easy to integrate.
5331 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761
5334 a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5339 Better! By increasing the precision and/or asking for more terms
5340 in the Taylor series, we can get a result as accurate as we like.
5341 (Taylor series converge better away from singularities in the
5342 function such as the one at @code{ln(0)}, so it would also help to
5343 expand the series about the points @cite{x=2} or @cite{x=1.5} instead
5346 @cindex Simpson's rule
5347 @cindex Integration by Simpson's rule
5348 (@bullet{}) @strong{Exercise 4.} Our first method approximated the
5349 curve by stairsteps of width 0.1; the total area was then the sum
5350 of the areas of the rectangles under these stairsteps. Our second
5351 method approximated the function by a polynomial, which turned out
5352 to be a better approximation than stairsteps. A third method is
5353 @dfn{Simpson's rule}, which is like the stairstep method except
5354 that the steps are not required to be flat. Simpson's rule boils
5355 down to the formula,
5359 (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
5360 + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
5367 \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
5368 \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
5374 where @cite{n} (which must be even) is the number of slices and @cite{h}
5375 is the width of each slice. These are 10 and 0.1 in our example.
5376 For reference, here is the corresponding formula for the stairstep
5381 h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
5382 + f(a+(n-2)*h) + f(a+(n-1)*h))
5388 $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
5389 + f(a+(n-2)h) + f(a+(n-1)h)) $$
5393 Compute the integral from 1 to 2 of @c{$\sin x \ln x$}
5394 @cite{sin(x) ln(x)} using
5395 Simpson's rule with 10 slices. @xref{Algebra Answer 4, 4}. (@bullet{})
5397 Calc has a built-in @kbd{a I} command for doing numerical integration.
5398 It uses @dfn{Romberg's method}, which is a more sophisticated cousin
5399 of Simpson's rule. In particular, it knows how to keep refining the
5400 result until the current precision is satisfied.
5402 @c [fix-ref Selecting Sub-Formulas]
5403 Aside from the commands we've seen so far, Calc also provides a
5404 large set of commands for operating on parts of formulas. You
5405 indicate the desired sub-formula by placing the cursor on any part
5406 of the formula before giving a @dfn{selection} command. Selections won't
5407 be covered in the tutorial; @pxref{Selecting Subformulas}, for
5408 details and examples.
5410 @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
5411 @c to 2^((n-1)*(r-1)).
5413 @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
5414 @subsection Rewrite Rules
5417 No matter how many built-in commands Calc provided for doing algebra,
5418 there would always be something you wanted to do that Calc didn't have
5419 in its repertoire. So Calc also provides a @dfn{rewrite rule} system
5420 that you can use to define your own algebraic manipulations.
5422 Suppose we want to simplify this trigonometric formula:
5426 1: 1 / cos(x) - sin(x) tan(x)
5429 ' 1/cos(x) - sin(x) tan(x) @key{RET} s 1
5434 If we were simplifying this by hand, we'd probably replace the
5435 @samp{tan} with a @samp{sin/cos} first, then combine over a common
5436 denominator. There is no Calc command to do the former; the @kbd{a n}
5437 algebra command will do the latter but we'll do both with rewrite
5438 rules just for practice.
5440 Rewrite rules are written with the @samp{:=} symbol.
5444 1: 1 / cos(x) - sin(x)^2 / cos(x)
5447 a r tan(a) := sin(a)/cos(a) @key{RET}
5452 (The ``assignment operator'' @samp{:=} has several uses in Calc. All
5453 by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
5454 but when it is given to the @kbd{a r} command, that command interprets
5455 it as a rewrite rule.)
5457 The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
5458 rewrite rule. Calc searches the formula on the stack for parts that
5459 match the pattern. Variables in a rewrite pattern are called
5460 @dfn{meta-variables}, and when matching the pattern each meta-variable
5461 can match any sub-formula. Here, the meta-variable @samp{a} matched
5462 the actual variable @samp{x}.
5464 When the pattern part of a rewrite rule matches a part of the formula,
5465 that part is replaced by the righthand side with all the meta-variables
5466 substituted with the things they matched. So the result is
5467 @samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then
5468 mix this in with the rest of the original formula.
5470 To merge over a common denominator, we can use another simple rule:
5474 1: (1 - sin(x)^2) / cos(x)
5477 a r a/x + b/x := (a+b)/x @key{RET}
5481 This rule points out several interesting features of rewrite patterns.
5482 First, if a meta-variable appears several times in a pattern, it must
5483 match the same thing everywhere. This rule detects common denominators
5484 because the same meta-variable @samp{x} is used in both of the
5487 Second, meta-variable names are independent from variables in the
5488 target formula. Notice that the meta-variable @samp{x} here matches
5489 the subformula @samp{cos(x)}; Calc never confuses the two meanings of
5492 And third, rewrite patterns know a little bit about the algebraic
5493 properties of formulas. The pattern called for a sum of two quotients;
5494 Calc was able to match a difference of two quotients by matching
5495 @samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}.
5497 @c [fix-ref Algebraic Properties of Rewrite Rules]
5498 We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
5499 the rule. It would have worked just the same in all cases. (If we
5500 really wanted the rule to apply only to @samp{+} or only to @samp{-},
5501 we could have used the @code{plain} symbol. @xref{Algebraic Properties
5502 of Rewrite Rules}, for some examples of this.)
5504 One more rewrite will complete the job. We want to use the identity
5505 @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
5506 the identity in a way that matches our formula. The obvious rule
5507 would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows
5508 that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The
5509 latter rule has a more general pattern so it will work in many other
5514 1: (1 + cos(x)^2 - 1) / cos(x) 1: cos(x)
5517 a r sin(x)^2 := 1 - cos(x)^2 @key{RET} a s
5521 You may ask, what's the point of using the most general rule if you
5522 have to type it in every time anyway? The answer is that Calc allows
5523 you to store a rewrite rule in a variable, then give the variable
5524 name in the @kbd{a r} command. In fact, this is the preferred way to
5525 use rewrites. For one, if you need a rule once you'll most likely
5526 need it again later. Also, if the rule doesn't work quite right you
5527 can simply Undo, edit the variable, and run the rule again without
5528 having to retype it.
5532 ' tan(x) := sin(x)/cos(x) @key{RET} s t tsc @key{RET}
5533 ' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET}
5534 ' sin(x)^2 := 1 - cos(x)^2 @key{RET} s t sinsqr @key{RET}
5536 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5539 r 1 a r tsc @key{RET} a r merge @key{RET} a r sinsqr @key{RET} a s
5543 To edit a variable, type @kbd{s e} and the variable name, use regular
5544 Emacs editing commands as necessary, then type @kbd{M-# M-#} or
5545 @kbd{C-c C-c} to store the edited value back into the variable.
5546 You can also use @w{@kbd{s e}} to create a new variable if you wish.
5548 Notice that the first time you use each rule, Calc puts up a ``compiling''
5549 message briefly. The pattern matcher converts rules into a special
5550 optimized pattern-matching language rather than using them directly.
5551 This allows @kbd{a r} to apply even rather complicated rules very
5552 efficiently. If the rule is stored in a variable, Calc compiles it
5553 only once and stores the compiled form along with the variable. That's
5554 another good reason to store your rules in variables rather than
5555 entering them on the fly.
5557 (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get symbolic
5558 mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
5559 Using a rewrite rule, simplify this formula by multiplying both
5560 sides by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have
5561 to be expanded by the distributive law; do this with another
5562 rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{})
5564 The @kbd{a r} command can also accept a vector of rewrite rules, or
5565 a variable containing a vector of rules.
5569 1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ]
5572 ' [tsc,merge,sinsqr] @key{RET} =
5579 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5582 s t trig @key{RET} r 1 a r trig @key{RET} a s
5586 @c [fix-ref Nested Formulas with Rewrite Rules]
5587 Calc tries all the rules you give against all parts of the formula,
5588 repeating until no further change is possible. (The exact order in
5589 which things are tried is rather complex, but for simple rules like
5590 the ones we've used here the order doesn't really matter.
5591 @xref{Nested Formulas with Rewrite Rules}.)
5593 Calc actually repeats only up to 100 times, just in case your rule set
5594 has gotten into an infinite loop. You can give a numeric prefix argument
5595 to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does
5596 only one rewrite at a time.
5600 1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x)
5603 r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET}
5607 You can type @kbd{M-0 a r} if you want no limit at all on the number
5608 of rewrites that occur.
5610 Rewrite rules can also be @dfn{conditional}. Simply follow the rule
5611 with a @samp{::} symbol and the desired condition. For example,
5615 1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
5618 ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET}
5625 1: 1 + exp(3 pi i) + 1
5628 a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET}
5633 (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
5634 which will be zero only when @samp{k} is an even integer.)
5636 An interesting point is that the variables @samp{pi} and @samp{i}
5637 were matched literally rather than acting as meta-variables.
5638 This is because they are special-constant variables. The special
5639 constants @samp{e}, @samp{phi}, and so on also match literally.
5640 A common error with rewrite
5641 rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
5642 to match any @samp{f} with five arguments but in fact matching
5643 only when the fifth argument is literally @samp{e}!@refill
5645 @cindex Fibonacci numbers
5650 Rewrite rules provide an interesting way to define your own functions.
5651 Suppose we want to define @samp{fib(n)} to produce the @var{n}th
5652 Fibonacci number. The first two Fibonacci numbers are each 1;
5653 later numbers are formed by summing the two preceding numbers in
5654 the sequence. This is easy to express in a set of three rules:
5658 ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib
5663 ' fib(7) @key{RET} a r fib @key{RET}
5667 One thing that is guaranteed about the order that rewrites are tried
5668 is that, for any given subformula, earlier rules in the rule set will
5669 be tried for that subformula before later ones. So even though the
5670 first and third rules both match @samp{fib(1)}, we know the first will
5671 be used preferentially.
5673 This rule set has one dangerous bug: Suppose we apply it to the
5674 formula @samp{fib(x)}? (Don't actually try this.) The third rule
5675 will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
5676 Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
5677 fib(x-4)}, and so on, expanding forever. What we really want is to apply
5678 the third rule only when @samp{n} is an integer greater than two. Type
5679 @w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
5682 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
5690 1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0)
5693 ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET}
5698 We've created a new function, @code{fib}, and a new command,
5699 @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
5700 this formula.'' To make things easier still, we can tell Calc to
5701 apply these rules automatically by storing them in the special
5702 variable @code{EvalRules}.
5706 1: [fib(1) := ...] . 1: [8, 13]
5709 s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET}
5713 It turns out that this rule set has the problem that it does far
5714 more work than it needs to when @samp{n} is large. Consider the
5715 first few steps of the computation of @samp{fib(6)}:
5721 fib(4) + fib(3) + fib(3) + fib(2) =
5722 fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
5727 Note that @samp{fib(3)} appears three times here. Unless Calc's
5728 algebraic simplifier notices the multiple @samp{fib(3)}s and combines
5729 them (and, as it happens, it doesn't), this rule set does lots of
5730 needless recomputation. To cure the problem, type @code{s e EvalRules}
5731 to edit the rules (or just @kbd{s E}, a shorthand command for editing
5732 @code{EvalRules}) and add another condition:
5735 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
5739 If a @samp{:: remember} condition appears anywhere in a rule, then if
5740 that rule succeeds Calc will add another rule that describes that match
5741 to the front of the rule set. (Remembering works in any rule set, but
5742 for technical reasons it is most effective in @code{EvalRules}.) For
5743 example, if the rule rewrites @samp{fib(7)} to something that evaluates
5744 to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
5746 Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
5747 type @kbd{s E} again to see what has happened to the rule set.
5749 With the @code{remember} feature, our rule set can now compute
5750 @samp{fib(@var{n})} in just @var{n} steps. In the process it builds
5751 up a table of all Fibonacci numbers up to @var{n}. After we have
5752 computed the result for a particular @var{n}, we can get it back
5753 (and the results for all smaller @var{n}) later in just one step.
5755 All Calc operations will run somewhat slower whenever @code{EvalRules}
5756 contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to
5757 un-store the variable.
5759 (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate
5760 a problem to reduce the amount of recursion necessary to solve it.
5761 Create a rule that, in about @var{n} simple steps and without recourse
5762 to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
5763 @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
5764 @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is
5765 rather clunky to use, so add a couple more rules to make the ``user
5766 interface'' the same as for our first version: enter @samp{fib(@var{n})},
5767 get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{})
5769 There are many more things that rewrites can do. For example, there
5770 are @samp{&&&} and @samp{|||} pattern operators that create ``and''
5771 and ``or'' combinations of rules. As one really simple example, we
5772 could combine our first two Fibonacci rules thusly:
5775 [fib(1 ||| 2) := 1, fib(n) := ... ]
5779 That means ``@code{fib} of something matching either 1 or 2 rewrites
5782 You can also make meta-variables optional by enclosing them in @code{opt}.
5783 For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
5784 @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x}
5785 matches all of these forms, filling in a default of zero for @samp{a}
5786 and one for @samp{b}.
5788 (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x}
5789 on the stack and tried to use the rule
5790 @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened?
5791 @xref{Rewrites Answer 3, 3}. (@bullet{})
5793 (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @cite{a},
5794 divide @cite{a} by two if it is even, otherwise compute @cite{3 a + 1}.
5795 Now repeat this step over and over. A famous unproved conjecture
5796 is that for any starting @cite{a}, the sequence always eventually
5797 reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of
5798 rules that convert this into @samp{seq(1, @var{n})} where @var{n}
5799 is the number of steps it took the sequence to reach the value 1.
5800 Now enhance the rules to accept @samp{seq(@var{a})} as a starting
5801 configuration, and to stop with just the number @var{n} by itself.
5802 Now make the result be a vector of values in the sequence, from @var{a}
5803 to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
5804 and @var{y}.) For example, rewriting @samp{seq(6)} should yield the
5805 vector @cite{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
5806 @xref{Rewrites Answer 4, 4}. (@bullet{})
5808 (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function
5809 @samp{nterms(@var{x})} that returns the number of terms in the sum
5810 @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes
5811 is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
5812 so that @cite{2 - 3 (x + y) + x y} is a sum of three terms.)
5813 @xref{Rewrites Answer 5, 5}. (@bullet{})
5815 (@bullet{}) @strong{Exercise 6.} Calc considers the form @cite{0^0}
5816 to be ``indeterminate,'' and leaves it unevaluated (assuming infinite
5817 mode is not enabled). Some people prefer to define @cite{0^0 = 1},
5818 so that the identity @cite{x^0 = 1} can safely be used for all @cite{x}.
5819 Find a way to make Calc follow this convention. What happens if you
5820 now type @kbd{m i} to turn on infinite mode?
5821 @xref{Rewrites Answer 6, 6}. (@bullet{})
5823 (@bullet{}) @strong{Exercise 7.} A Taylor series for a function is an
5824 infinite series that exactly equals the value of that function at
5825 values of @cite{x} near zero.
5829 cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
5833 \turnoffactive \let\rm\goodrm
5835 $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
5839 The @kbd{a t} command produces a @dfn{truncated Taylor series} which
5840 is obtained by dropping all the terms higher than, say, @cite{x^2}.
5841 Calc represents the truncated Taylor series as a polynomial in @cite{x}.
5842 Mathematicians often write a truncated series using a ``big-O'' notation
5843 that records what was the lowest term that was truncated.
5847 cos(x) = 1 - x^2 / 2! + O(x^3)
5851 \turnoffactive \let\rm\goodrm
5853 $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
5858 The meaning of @cite{O(x^3)} is ``a quantity which is negligibly small
5859 if @cite{x^3} is considered negligibly small as @cite{x} goes to zero.''
5861 The exercise is to create rewrite rules that simplify sums and products of
5862 power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
5863 For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
5864 on the stack, we want to be able to type @kbd{*} and get the result
5865 @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are
5866 rearranged or if @kbd{a s} needs to be typed after rewriting. (This one
5867 is rather tricky; the solution at the end of this chapter uses 6 rewrite
5868 rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is
5869 a number.) @xref{Rewrites Answer 7, 7}. (@bullet{})
5871 @c [fix-ref Rewrite Rules]
5872 @xref{Rewrite Rules}, for the whole story on rewrite rules.
5874 @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
5875 @section Programming Tutorial
5878 The Calculator is written entirely in Emacs Lisp, a highly extensible
5879 language. If you know Lisp, you can program the Calculator to do
5880 anything you like. Rewrite rules also work as a powerful programming
5881 system. But Lisp and rewrite rules take a while to master, and often
5882 all you want to do is define a new function or repeat a command a few
5883 times. Calc has features that allow you to do these things easily.
5885 (Note that the programming commands relating to user-defined keys
5886 are not yet supported under Lucid Emacs 19.)
5888 One very limited form of programming is defining your own functions.
5889 Calc's @kbd{Z F} command allows you to define a function name and
5890 key sequence to correspond to any formula. Programming commands use
5891 the shift-@kbd{Z} prefix; the user commands they create use the lower
5892 case @kbd{z} prefix.
5896 1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6
5899 ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y
5903 This polynomial is a Taylor series approximation to @samp{exp(x)}.
5904 The @kbd{Z F} command asks a number of questions. The above answers
5905 say that the key sequence for our function should be @kbd{z e}; the
5906 @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
5907 function in algebraic formulas should also be @code{myexp}; the
5908 default argument list @samp{(x)} is acceptable; and finally @kbd{y}
5909 answers the question ``leave it in symbolic form for non-constant
5914 1: 1.3495 2: 1.3495 3: 1.3495
5915 . 1: 1.34986 2: 1.34986
5919 .3 z e .3 E ' a+1 @key{RET} z e
5924 First we call our new @code{exp} approximation with 0.3 as an
5925 argument, and compare it with the true @code{exp} function. Then
5926 we note that, as requested, if we try to give @kbd{z e} an
5927 argument that isn't a plain number, it leaves the @code{myexp}
5928 function call in symbolic form. If we had answered @kbd{n} to the
5929 final question, @samp{myexp(a + 1)} would have evaluated by plugging
5930 in @samp{a + 1} for @samp{x} in the defining formula.
5932 @cindex Sine integral Si(x)
5937 (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function
5939 @cite{Si(x)} is defined as the integral of @samp{sin(t)/t} for
5940 @cite{t = 0} to @cite{x} in radians. (It was invented because this
5941 integral has no solution in terms of basic functions; if you give it
5942 to Calc's @kbd{a i} command, it will ponder it for a long time and then
5943 give up.) We can use the numerical integration command, however,
5944 which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
5945 with any integrand @samp{f(t)}. Define a @kbd{z s} command and
5946 @code{Si} function that implement this. You will need to edit the
5947 default argument list a bit. As a test, @samp{Si(1)} should return
5948 0.946083. (Hint: @code{ninteg} will run a lot faster if you reduce
5949 the precision to, say, six digits beforehand.)
5950 @xref{Programming Answer 1, 1}. (@bullet{})
5952 The simplest way to do real ``programming'' of Emacs is to define a
5953 @dfn{keyboard macro}. A keyboard macro is simply a sequence of
5954 keystrokes which Emacs has stored away and can play back on demand.
5955 For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
5956 you may wish to program a keyboard macro to type this for you.
5960 1: y = sqrt(x) 1: x = y^2
5963 ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x )
5965 1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1
5968 ' y=cos(x) @key{RET} X
5973 When you type @kbd{C-x (}, Emacs begins recording. But it is also
5974 still ready to execute your keystrokes, so you're really ``training''
5975 Emacs by walking it through the procedure once. When you type
5976 @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to
5977 re-execute the same keystrokes.
5979 You can give a name to your macro by typing @kbd{Z K}.
5983 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y))
5986 Z K x @key{RET} ' y=x^4 @key{RET} z x
5991 Notice that we use shift-@kbd{Z} to define the command, and lower-case
5992 @kbd{z} to call it up.
5994 Keyboard macros can call other macros.
5998 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y
6001 ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X
6005 (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate
6006 the item in level 3 of the stack, without disturbing the rest of
6007 the stack. @xref{Programming Answer 2, 2}. (@bullet{})
6009 (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute
6010 the following functions:
6014 Compute @c{$\displaystyle{\sin x \over x}$}
6015 @cite{sin(x) / x}, where @cite{x} is the number on the
6019 Compute the base-@cite{b} logarithm, just like the @kbd{B} key except
6020 the arguments are taken in the opposite order.
6023 Produce a vector of integers from 1 to the integer on the top of
6027 @xref{Programming Answer 3, 3}. (@bullet{})
6029 (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute
6030 the average (mean) value of a list of numbers.
6031 @xref{Programming Answer 4, 4}. (@bullet{})
6033 In many programs, some of the steps must execute several times.
6034 Calc has @dfn{looping} commands that allow this. Loops are useful
6035 inside keyboard macros, but actually work at any time.
6039 1: x^6 2: x^6 1: 360 x^2
6043 ' x^6 @key{RET} 4 Z < a d x @key{RET} Z >
6048 Here we have computed the fourth derivative of @cite{x^6} by
6049 enclosing a derivative command in a ``repeat loop'' structure.
6050 This structure pops a repeat count from the stack, then
6051 executes the body of the loop that many times.
6053 If you make a mistake while entering the body of the loop,
6054 type @w{@kbd{Z C-g}} to cancel the loop command.
6056 @cindex Fibonacci numbers
6057 Here's another example:
6066 1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z >
6071 The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
6072 numbers, respectively. (To see what's going on, try a few repetitions
6073 of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
6074 key if you have one, makes a copy of the number in level 2.)
6076 @cindex Golden ratio
6077 @cindex Phi, golden ratio
6078 A fascinating property of the Fibonacci numbers is that the @cite{n}th
6079 Fibonacci number can be found directly by computing @c{$\phi^n / \sqrt{5}$}
6080 @cite{phi^n / sqrt(5)}
6081 and then rounding to the nearest integer, where @c{$\phi$ (``phi'')}
6083 ``golden ratio,'' is @c{$(1 + \sqrt{5}) / 2$}
6084 @cite{(1 + sqrt(5)) / 2}. (For convenience, this constant is available
6085 from the @code{phi} variable, or the @kbd{I H P} command.)
6089 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946
6096 @cindex Continued fractions
6097 (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction}
6098 representation of @c{$\phi$}
6099 @cite{phi} is @c{$1 + 1/(1 + 1/(1 + 1/( \ldots )))$}
6100 @cite{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
6101 We can compute an approximate value by carrying this however far
6102 and then replacing the innermost @c{$1/( \ldots )$}
6103 @cite{1/( ...@: )} by 1. Approximate
6105 @cite{phi} using a twenty-term continued fraction.
6106 @xref{Programming Answer 5, 5}. (@bullet{})
6108 (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for
6109 Fibonacci numbers can be expressed in terms of matrices. Given a
6110 vector @w{@cite{[a, b]}} determine a matrix which, when multiplied by this
6111 vector, produces the vector @cite{[b, c]}, where @cite{a}, @cite{b} and
6112 @cite{c} are three successive Fibonacci numbers. Now write a program
6113 that, given an integer @cite{n}, computes the @cite{n}th Fibonacci number
6114 using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{})
6116 @cindex Harmonic numbers
6117 A more sophisticated kind of loop is the @dfn{for} loop. Suppose
6118 we wish to compute the 20th ``harmonic'' number, which is equal to
6119 the sum of the reciprocals of the integers from 1 to 20.
6128 0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z )
6133 The ``for'' loop pops two numbers, the lower and upper limits, then
6134 repeats the body of the loop as an internal counter increases from
6135 the lower limit to the upper one. Just before executing the loop
6136 body, it pushes the current loop counter. When the loop body
6137 finishes, it pops the ``step,'' i.e., the amount by which to
6138 increment the loop counter. As you can see, our loop always
6141 This harmonic number function uses the stack to hold the running
6142 total as well as for the various loop housekeeping functions. If
6143 you find this disorienting, you can sum in a variable instead:
6147 1: 0 2: 1 . 1: 3.597739
6151 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7
6156 The @kbd{s +} command adds the top-of-stack into the value in a
6157 variable (and removes that value from the stack).
6159 It's worth noting that many jobs that call for a ``for'' loop can
6160 also be done more easily by Calc's high-level operations. Two
6161 other ways to compute harmonic numbers are to use vector mapping
6162 and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
6163 or to use the summation command @kbd{a +}. Both of these are
6164 probably easier than using loops. However, there are some
6165 situations where loops really are the way to go:
6167 (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first
6168 harmonic number which is greater than 4.0.
6169 @xref{Programming Answer 7, 7}. (@bullet{})
6171 Of course, if we're going to be using variables in our programs,
6172 we have to worry about the programs clobbering values that the
6173 caller was keeping in those same variables. This is easy to
6178 . 1: 0.6667 1: 0.6667 3: 0.6667
6183 Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET}
6188 When we type @kbd{Z `} (that's a back-quote character), Calc saves
6189 its mode settings and the contents of the ten ``quick variables''
6190 for later reference. When we type @kbd{Z '} (that's an apostrophe
6191 now), Calc restores those saved values. Thus the @kbd{p 4} and
6192 @kbd{s 7} commands have no effect outside this sequence. Wrapping
6193 this around the body of a keyboard macro ensures that it doesn't
6194 interfere with what the user of the macro was doing. Notice that
6195 the contents of the stack, and the values of named variables,
6196 survive past the @kbd{Z '} command.
6198 @cindex Bernoulli numbers, approximate
6199 The @dfn{Bernoulli numbers} are a sequence with the interesting
6200 property that all of the odd Bernoulli numbers are zero, and the
6201 even ones, while difficult to compute, can be roughly approximated
6202 by the formula @c{$\displaystyle{2 n! \over (2 \pi)^n}$}
6203 @cite{2 n!@: / (2 pi)^n}. Let's write a keyboard
6204 macro to compute (approximate) Bernoulli numbers. (Calc has a
6205 command, @kbd{k b}, to compute exact Bernoulli numbers, but
6206 this command is very slow for large @cite{n} since the higher
6207 Bernoulli numbers are very large fractions.)
6214 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
6219 You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
6220 @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if''
6221 command. For the purposes of @w{@kbd{Z [}}, the condition is ``true''
6222 if the value it pops from the stack is a nonzero number, or ``false''
6223 if it pops zero or something that is not a number (like a formula).
6224 Here we take our integer argument modulo 2; this will be nonzero
6225 if we're asking for an odd Bernoulli number.
6227 The actual tenth Bernoulli number is @cite{5/66}.
6231 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659
6236 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
6240 Just to exercise loops a bit more, let's compute a table of even
6245 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...]
6250 [ ] 2 @key{RET} 30 Z ( X | 2 Z )
6255 The vertical-bar @kbd{|} is the vector-concatenation command. When
6256 we execute it, the list we are building will be in stack level 2
6257 (initially this is an empty list), and the next Bernoulli number
6258 will be in level 1. The effect is to append the Bernoulli number
6259 onto the end of the list. (To create a table of exact fractional
6260 Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
6261 sequence of keystrokes.)
6263 With loops and conditionals, you can program essentially anything
6264 in Calc. One other command that makes looping easier is @kbd{Z /},
6265 which takes a condition from the stack and breaks out of the enclosing
6266 loop if the condition is true (non-zero). You can use this to make
6267 ``while'' and ``until'' style loops.
6269 If you make a mistake when entering a keyboard macro, you can edit
6270 it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}.
6271 One technique is to enter a throwaway dummy definition for the macro,
6272 then enter the real one in the edit command.
6276 1: 3 1: 3 Keyboard Macro Editor.
6277 . . Original keys: 1 @key{RET} 2 +
6283 C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h
6288 This shows the screen display assuming you have the @file{macedit}
6289 keyboard macro editing package installed, which is usually the case
6290 since a copy of @file{macedit} comes bundled with Calc.
6292 A keyboard macro is stored as a pure keystroke sequence. The
6293 @file{macedit} package (invoked by @kbd{Z E}) scans along the
6294 macro and tries to decode it back into human-readable steps.
6295 If a key or keys are simply shorthand for some command with a
6296 @kbd{M-x} name, that name is shown. Anything that doesn't correspond
6297 to a @kbd{M-x} command is written as a @samp{type} command.
6299 Let's edit in a new definition, for computing harmonic numbers.
6300 First, erase the three lines of the old definition. Then, type
6301 in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
6302 to copy it from this page of the Info file; you can skip typing
6303 the comments that begin with @samp{#}).
6306 calc-kbd-push # Save local values (Z `)
6307 type "0" # Push a zero
6308 calc-store-into # Store it in variable 1
6310 type "1" # Initial value for loop
6311 calc-roll-down # This is the @key{TAB} key; swap initial & final
6312 calc-kbd-for # Begin "for" loop...
6313 calc-inv # Take reciprocal
6314 calc-store-plus # Add to accumulator
6316 type "1" # Loop step is 1
6317 calc-kbd-end-for # End "for" loop
6318 calc-recall # Now recall final accumulated value
6320 calc-kbd-pop # Restore values (Z ')
6324 Press @kbd{M-# M-#} to finish editing and return to the Calculator.
6335 If you don't know how to write a particular command in @file{macedit}
6336 format, you can always write it as keystrokes in a @code{type} command.
6337 There is also a @code{keys} command which interprets the rest of the
6338 line as standard Emacs keystroke names. In fact, @file{macedit} defines
6339 a handy @code{read-kbd-macro} command which reads the current region
6340 of the current buffer as a sequence of keystroke names, and defines that
6341 sequence on the @kbd{X} (and @kbd{C-x e}) key. Because this is so
6342 useful, Calc puts this command on the @kbd{M-# m} key. Try reading in
6343 this macro in the following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
6344 one end of the text below, then type @kbd{M-# m} at the other.
6356 (@bullet{}) @strong{Exercise 8.} A general algorithm for solving
6357 equations numerically is @dfn{Newton's Method}. Given the equation
6358 @cite{f(x) = 0} for any function @cite{f}, and an initial guess
6359 @cite{x_0} which is reasonably close to the desired solution, apply
6360 this formula over and over:
6364 new_x = x - f(x)/f'(x)
6369 $$ x_{\goodrm new} = x - {f(x) \over f'(x)} $$
6374 where @cite{f'(x)} is the derivative of @cite{f}. The @cite{x}
6375 values will quickly converge to a solution, i.e., eventually
6377 @cite{new_x} and @cite{x} will be equal to within the limits
6378 of the current precision. Write a program which takes a formula
6379 involving the variable @cite{x}, and an initial guess @cite{x_0},
6380 on the stack, and produces a value of @cite{x} for which the formula
6381 is zero. Use it to find a solution of @c{$\sin(\cos x) = 0.5$}
6382 @cite{sin(cos(x)) = 0.5}
6383 near @cite{x = 4.5}. (Use angles measured in radians.) Note that
6384 the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
6385 method when it is able. @xref{Programming Answer 8, 8}. (@bullet{})
6387 @cindex Digamma function
6388 @cindex Gamma constant, Euler's
6389 @cindex Euler's gamma constant
6390 (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function @c{$\psi(z)$ (``psi'')}
6392 is defined as the derivative of @c{$\ln \Gamma(z)$}
6393 @cite{ln(gamma(z))}. For large
6394 values of @cite{z}, it can be approximated by the infinite sum
6398 psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
6404 $$ \psi(z) \approx \ln z - {1\over2z} -
6405 \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
6412 @cite{sum} represents the sum over @cite{n} from 1 to infinity
6413 (or to some limit high enough to give the desired accuracy), and
6414 the @code{bern} function produces (exact) Bernoulli numbers.
6415 While this sum is not guaranteed to converge, in practice it is safe.
6416 An interesting mathematical constant is Euler's gamma, which is equal
6417 to about 0.5772. One way to compute it is by the formula,
6418 @c{$\gamma = -\psi(1)$}
6419 @cite{gamma = -psi(1)}. Unfortunately, 1 isn't a large enough argument
6420 for the above formula to work (5 is a much safer value for @cite{z}).
6421 Fortunately, we can compute @c{$\psi(1)$}
6422 @cite{psi(1)} from @c{$\psi(5)$}
6424 the recurrence @c{$\psi(z+1) = \psi(z) + {1 \over z}$}
6425 @cite{psi(z+1) = psi(z) + 1/z}. Your task: Develop
6426 a program to compute @c{$\psi(z)$}
6427 @cite{psi(z)}; it should ``pump up'' @cite{z}
6428 if necessary to be greater than 5, then use the above summation
6429 formula. Use looping commands to compute the sum. Use your function
6430 to compute @c{$\gamma$}
6431 @cite{gamma} to twelve decimal places. (Calc has a built-in command
6432 for Euler's constant, @kbd{I P}, which you can use to check your answer.)
6433 @xref{Programming Answer 9, 9}. (@bullet{})
6435 @cindex Polynomial, list of coefficients
6436 (@bullet{}) @strong{Exercise 10.} Given a polynomial in @cite{x} and
6437 a number @cite{m} on the stack, where the polynomial is of degree
6438 @cite{m} or less (i.e., does not have any terms higher than @cite{x^m}),
6439 write a program to convert the polynomial into a list-of-coefficients
6440 notation. For example, @cite{5 x^4 + (x + 1)^2} with @cite{m = 6}
6441 should produce the list @cite{[1, 2, 1, 0, 5, 0, 0]}. Also develop
6442 a way to convert from this form back to the standard algebraic form.
6443 @xref{Programming Answer 10, 10}. (@bullet{})
6446 (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the
6447 first kind} are defined by the recurrences,
6451 s(n,n) = 1 for n >= 0,
6452 s(n,0) = 0 for n > 0,
6453 s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1.
6459 $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr
6460 s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr
6461 s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
6462 \hbox{for } n \ge m \ge 1.}
6466 (These numbers are also sometimes written $\displaystyle{n \brack m}$.)
6469 This can be implemented using a @dfn{recursive} program in Calc; the
6470 program must invoke itself in order to calculate the two righthand
6471 terms in the general formula. Since it always invokes itself with
6472 ``simpler'' arguments, it's easy to see that it must eventually finish
6473 the computation. Recursion is a little difficult with Emacs keyboard
6474 macros since the macro is executed before its definition is complete.
6475 So here's the recommended strategy: Create a ``dummy macro'' and assign
6476 it to a key with, e.g., @kbd{Z K s}. Now enter the true definition,
6477 using the @kbd{z s} command to call itself recursively, then assign it
6478 to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run
6479 the complete recursive program. (Another way is to use @w{@kbd{Z E}}
6480 or @kbd{M-# m} (@code{read-kbd-macro}) to read the whole macro at once,
6481 thus avoiding the ``training'' phase.) The task: Write a program
6482 that computes Stirling numbers of the first kind, given @cite{n} and
6483 @cite{m} on the stack. Test it with @emph{small} inputs like
6484 @cite{s(4,2)}. (There is a built-in command for Stirling numbers,
6485 @kbd{k s}, which you can use to check your answers.)
6486 @xref{Programming Answer 11, 11}. (@bullet{})
6488 The programming commands we've seen in this part of the tutorial
6489 are low-level, general-purpose operations. Often you will find
6490 that a higher-level function, such as vector mapping or rewrite
6491 rules, will do the job much more easily than a detailed, step-by-step
6494 (@bullet{}) @strong{Exercise 12.} Write another program for
6495 computing Stirling numbers of the first kind, this time using
6496 rewrite rules. Once again, @cite{n} and @cite{m} should be taken
6497 from the stack. @xref{Programming Answer 12, 12}. (@bullet{})
6502 This ends the tutorial section of the Calc manual. Now you know enough
6503 about Calc to use it effectively for many kinds of calculations. But
6504 Calc has many features that were not even touched upon in this tutorial.
6506 The rest of this manual tells the whole story.
6508 @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
6511 @node Answers to Exercises, , Programming Tutorial, Tutorial
6512 @section Answers to Exercises
6515 This section includes answers to all the exercises in the Calc tutorial.
6518 * RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
6519 * RPN Answer 2:: 2*4 + 7*9.5 + 5/4
6520 * RPN Answer 3:: Operating on levels 2 and 3
6521 * RPN Answer 4:: Joe's complex problems
6522 * Algebraic Answer 1:: Simulating Q command
6523 * Algebraic Answer 2:: Joe's algebraic woes
6524 * Algebraic Answer 3:: 1 / 0
6525 * Modes Answer 1:: 3#0.1 = 3#0.0222222?
6526 * Modes Answer 2:: 16#f.e8fe15
6527 * Modes Answer 3:: Joe's rounding bug
6528 * Modes Answer 4:: Why floating point?
6529 * Arithmetic Answer 1:: Why the \ command?
6530 * Arithmetic Answer 2:: Tripping up the B command
6531 * Vector Answer 1:: Normalizing a vector
6532 * Vector Answer 2:: Average position
6533 * Matrix Answer 1:: Row and column sums
6534 * Matrix Answer 2:: Symbolic system of equations
6535 * Matrix Answer 3:: Over-determined system
6536 * List Answer 1:: Powers of two
6537 * List Answer 2:: Least-squares fit with matrices
6538 * List Answer 3:: Geometric mean
6539 * List Answer 4:: Divisor function
6540 * List Answer 5:: Duplicate factors
6541 * List Answer 6:: Triangular list
6542 * List Answer 7:: Another triangular list
6543 * List Answer 8:: Maximum of Bessel function
6544 * List Answer 9:: Integers the hard way
6545 * List Answer 10:: All elements equal
6546 * List Answer 11:: Estimating pi with darts
6547 * List Answer 12:: Estimating pi with matchsticks
6548 * List Answer 13:: Hash codes
6549 * List Answer 14:: Random walk
6550 * Types Answer 1:: Square root of pi times rational
6551 * Types Answer 2:: Infinities
6552 * Types Answer 3:: What can "nan" be?
6553 * Types Answer 4:: Abbey Road
6554 * Types Answer 5:: Friday the 13th
6555 * Types Answer 6:: Leap years
6556 * Types Answer 7:: Erroneous donut
6557 * Types Answer 8:: Dividing intervals
6558 * Types Answer 9:: Squaring intervals
6559 * Types Answer 10:: Fermat's primality test
6560 * Types Answer 11:: pi * 10^7 seconds
6561 * Types Answer 12:: Abbey Road on CD
6562 * Types Answer 13:: Not quite pi * 10^7 seconds
6563 * Types Answer 14:: Supercomputers and c
6564 * Types Answer 15:: Sam the Slug
6565 * Algebra Answer 1:: Squares and square roots
6566 * Algebra Answer 2:: Building polynomial from roots
6567 * Algebra Answer 3:: Integral of x sin(pi x)
6568 * Algebra Answer 4:: Simpson's rule
6569 * Rewrites Answer 1:: Multiplying by conjugate
6570 * Rewrites Answer 2:: Alternative fib rule
6571 * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x
6572 * Rewrites Answer 4:: Sequence of integers
6573 * Rewrites Answer 5:: Number of terms in sum
6574 * Rewrites Answer 6:: Defining 0^0 = 1
6575 * Rewrites Answer 7:: Truncated Taylor series
6576 * Programming Answer 1:: Fresnel's C(x)
6577 * Programming Answer 2:: Negate third stack element
6578 * Programming Answer 3:: Compute sin(x) / x, etc.
6579 * Programming Answer 4:: Average value of a list
6580 * Programming Answer 5:: Continued fraction phi
6581 * Programming Answer 6:: Matrix Fibonacci numbers
6582 * Programming Answer 7:: Harmonic number greater than 4
6583 * Programming Answer 8:: Newton's method
6584 * Programming Answer 9:: Digamma function
6585 * Programming Answer 10:: Unpacking a polynomial
6586 * Programming Answer 11:: Recursive Stirling numbers
6587 * Programming Answer 12:: Stirling numbers with rewrites
6590 @c The following kludgery prevents the individual answers from
6591 @c being entered on the table of contents.
6593 \global\let\oldwrite=\write
6594 \gdef\skipwrite#1#2{\let\write=\oldwrite}
6595 \global\let\oldchapternofonts=\chapternofonts
6596 \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
6599 @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
6600 @subsection RPN Tutorial Exercise 1
6603 @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
6605 The result is @c{$1 - (2 \times (3 + 4)) = -13$}
6606 @cite{1 - (2 * (3 + 4)) = -13}.
6608 @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
6609 @subsection RPN Tutorial Exercise 2
6612 @c{$2\times4 + 7\times9.5 + {5\over4} = 75.75$}
6613 @cite{2*4 + 7*9.5 + 5/4 = 75.75}
6615 After computing the intermediate term @c{$2\times4 = 8$}
6616 @cite{2*4 = 8}, you can leave
6617 that result on the stack while you compute the second term. With
6618 both of these results waiting on the stack you can then compute the
6619 final term, then press @kbd{+ +} to add everything up.
6628 2 @key{RET} 4 * 7 @key{RET} 9.5 *
6635 4: 8 3: 8 2: 8 1: 75.75
6636 3: 66.5 2: 66.5 1: 67.75 .
6645 Alternatively, you could add the first two terms before going on
6646 with the third term.
6650 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75
6651 1: 66.5 . 2: 5 1: 1.25 .
6655 ... + 5 @key{RET} 4 / +
6659 On an old-style RPN calculator this second method would have the
6660 advantage of using only three stack levels. But since Calc's stack
6661 can grow arbitrarily large this isn't really an issue. Which method
6662 you choose is purely a matter of taste.
6664 @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
6665 @subsection RPN Tutorial Exercise 3
6668 The @key{TAB} key provides a way to operate on the number in level 2.
6672 3: 10 3: 10 4: 10 3: 10 3: 10
6673 2: 20 2: 30 3: 30 2: 30 2: 21
6674 1: 30 1: 20 2: 20 1: 21 1: 30
6678 @key{TAB} 1 + @key{TAB}
6682 Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
6686 3: 10 3: 21 3: 21 3: 30 3: 11
6687 2: 21 2: 30 2: 30 2: 11 2: 21
6688 1: 30 1: 10 1: 11 1: 21 1: 30
6691 M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB}
6695 @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
6696 @subsection RPN Tutorial Exercise 4
6699 Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
6700 but using both the comma and the space at once yields:
6704 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ...
6705 . 1: 2 . 1: (2, ... 1: (2, 3)
6712 Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
6713 extra incomplete object to the top of the stack and delete it.
6714 But a feature of Calc is that @key{DEL} on an incomplete object
6715 deletes just one component out of that object, so he had to press
6716 @key{DEL} twice to finish the job.
6720 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3)
6721 1: (2, 3) 1: (2, ... 1: ( ... .
6724 @key{TAB} @key{DEL} @key{DEL}
6728 (As it turns out, deleting the second-to-top stack entry happens often
6729 enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
6730 @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
6731 the ``feature'' that tripped poor Joe.)
6733 @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
6734 @subsection Algebraic Entry Tutorial Exercise 1
6737 Type @kbd{' sqrt($) @key{RET}}.
6739 If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
6740 Or, RPN style, @kbd{0.5 ^}.
6742 (Actually, @samp{$^1:2}, using the fraction one-half as the power, is
6743 a closer equivalent, since @samp{9^0.5} yields @cite{3.0} whereas
6744 @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @cite{3}.)
6746 @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
6747 @subsection Algebraic Entry Tutorial Exercise 2
6750 In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
6751 name with @samp{1+y} as its argument. Assigning a value to a variable
6752 has no relation to a function by the same name. Joe needed to use an
6753 explicit @samp{*} symbol here: @samp{2 x*(1+y)}.
6755 @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
6756 @subsection Algebraic Entry Tutorial Exercise 3
6759 The result from @kbd{1 @key{RET} 0 /} will be the formula @cite{1 / 0}.
6760 The ``function'' @samp{/} cannot be evaluated when its second argument
6761 is zero, so it is left in symbolic form. When you now type @kbd{0 *},
6762 the result will be zero because Calc uses the general rule that ``zero
6763 times anything is zero.''
6765 @c [fix-ref Infinities]
6766 The @kbd{m i} command enables an @dfn{infinite mode} in which @cite{1 / 0}
6767 results in a special symbol that represents ``infinity.'' If you
6768 multiply infinity by zero, Calc uses another special new symbol to
6769 show that the answer is ``indeterminate.'' @xref{Infinities}, for
6770 further discussion of infinite and indeterminate values.
6772 @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
6773 @subsection Modes Tutorial Exercise 1
6776 Calc always stores its numbers in decimal, so even though one-third has
6777 an exact base-3 representation (@samp{3#0.1}), it is still stored as
6778 0.3333333 (chopped off after 12 or however many decimal digits) inside
6779 the calculator's memory. When this inexact number is converted back
6780 to base 3 for display, it may still be slightly inexact. When we
6781 multiply this number by 3, we get 0.999999, also an inexact value.
6783 When Calc displays a number in base 3, it has to decide how many digits
6784 to show. If the current precision is 12 (decimal) digits, that corresponds
6785 to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an
6786 exact integer, Calc shows only 25 digits, with the result that stored
6787 numbers carry a little bit of extra information that may not show up on
6788 the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666
6789 happened to round to a pleasing value when it lost that last 0.15 of a
6790 digit, but it was still inexact in Calc's memory. When he divided by 2,
6791 he still got the dreaded inexact value 0.333333. (Actually, he divided
6792 0.666667 by 2 to get 0.333334, which is why he got something a little
6793 higher than @code{3#0.1} instead of a little lower.)
6795 If Joe didn't want to be bothered with all this, he could have typed
6796 @kbd{M-24 d n} to display with one less digit than the default. (If
6797 you give @kbd{d n} a negative argument, it uses default-minus-that,
6798 so @kbd{M-- d n} would be an easier way to get the same effect.) Those
6799 inexact results would still be lurking there, but they would now be
6800 rounded to nice, natural-looking values for display purposes. (Remember,
6801 @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
6802 off one digit will round the number up to @samp{0.1}.) Depending on the
6803 nature of your work, this hiding of the inexactness may be a benefit or
6804 a danger. With the @kbd{d n} command, Calc gives you the choice.
6806 Incidentally, another consequence of all this is that if you type
6807 @kbd{M-30 d n} to display more digits than are ``really there,''
6808 you'll see garbage digits at the end of the number. (In decimal
6809 display mode, with decimally-stored numbers, these garbage digits are
6810 always zero so they vanish and you don't notice them.) Because Calc
6811 rounds off that 0.15 digit, there is the danger that two numbers could
6812 be slightly different internally but still look the same. If you feel
6813 uneasy about this, set the @kbd{d n} precision to be a little higher
6814 than normal; you'll get ugly garbage digits, but you'll always be able
6815 to tell two distinct numbers apart.
6817 An interesting side note is that most computers store their
6818 floating-point numbers in binary, and convert to decimal for display.
6819 Thus everyday programs have the same problem: Decimal 0.1 cannot be
6820 represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
6821 comes out as an inexact approximation to 1 on some machines (though
6822 they generally arrange to hide it from you by rounding off one digit as
6823 we did above). Because Calc works in decimal instead of binary, you can
6824 be sure that numbers that look exact @emph{are} exact as long as you stay
6825 in decimal display mode.
6827 It's not hard to show that any number that can be represented exactly
6828 in binary, octal, or hexadecimal is also exact in decimal, so the kinds
6829 of problems we saw in this exercise are likely to be severe only when
6830 you use a relatively unusual radix like 3.
6832 @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
6833 @subsection Modes Tutorial Exercise 2
6835 If the radix is 15 or higher, we can't use the letter @samp{e} to mark
6836 the exponent because @samp{e} is interpreted as a digit. When Calc
6837 needs to display scientific notation in a high radix, it writes
6838 @samp{16#F.E8F*16.^15}. You can enter a number like this as an
6839 algebraic entry. Also, pressing @kbd{e} without any digits before it
6840 normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
6841 puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
6842 way to enter this number.
6844 The reason Calc puts a decimal point in the @samp{16.^} is to prevent
6845 huge integers from being generated if the exponent is large (consider
6846 @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
6847 exact integer and then throw away most of the digits when we multiply
6848 it by the floating-point @samp{16#1.23}). While this wouldn't normally
6849 matter for display purposes, it could give you a nasty surprise if you
6850 copied that number into a file and later moved it back into Calc.
6852 @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
6853 @subsection Modes Tutorial Exercise 3
6856 The answer he got was @cite{0.5000000000006399}.
6858 The problem is not that the square operation is inexact, but that the
6859 sine of 45 that was already on the stack was accurate to only 12 places.
6860 Arbitrary-precision calculations still only give answers as good as
6863 The real problem is that there is no 12-digit number which, when
6864 squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]}
6865 commands decrease or increase a number by one unit in the last
6866 place (according to the current precision). They are useful for
6867 determining facts like this.
6871 1: 0.707106781187 1: 0.500000000001
6881 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999
6888 A high-precision calculation must be carried out in high precision
6889 all the way. The only number in the original problem which was known
6890 exactly was the quantity 45 degrees, so the precision must be raised
6891 before anything is done after the number 45 has been entered in order
6892 for the higher precision to be meaningful.
6894 @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
6895 @subsection Modes Tutorial Exercise 4
6898 Many calculations involve real-world quantities, like the width and
6899 height of a piece of wood or the volume of a jar. Such quantities
6900 can't be measured exactly anyway, and if the data that is input to
6901 a calculation is inexact, doing exact arithmetic on it is a waste
6904 Fractions become unwieldy after too many calculations have been
6905 done with them. For example, the sum of the reciprocals of the
6906 integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is
6907 9304682830147:2329089562800. After a point it will take a long
6908 time to add even one more term to this sum, but a floating-point
6909 calculation of the sum will not have this problem.
6911 Also, rational numbers cannot express the results of all calculations.
6912 There is no fractional form for the square root of two, so if you type
6913 @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
6915 @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
6916 @subsection Arithmetic Tutorial Exercise 1
6919 Dividing two integers that are larger than the current precision may
6920 give a floating-point result that is inaccurate even when rounded
6921 down to an integer. Consider @cite{123456789 / 2} when the current
6922 precision is 6 digits. The true answer is @cite{61728394.5}, but
6923 with a precision of 6 this will be rounded to @c{$12345700.0/2.0 = 61728500.0$}
6924 @cite{12345700.@: / 2.@: = 61728500.}.
6925 The result, when converted to an integer, will be off by 106.
6927 Here are two solutions: Raise the precision enough that the
6928 floating-point round-off error is strictly to the right of the
6929 decimal point. Or, convert to fraction mode so that @cite{123456789 / 2}
6930 produces the exact fraction @cite{123456789:2}, which can be rounded
6931 down by the @kbd{F} command without ever switching to floating-point
6934 @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
6935 @subsection Arithmetic Tutorial Exercise 2
6938 @kbd{27 @key{RET} 9 B} could give the exact result @cite{3:2}, but it
6939 does a floating-point calculation instead and produces @cite{1.5}.
6941 Calc will find an exact result for a logarithm if the result is an integer
6942 or the reciprocal of an integer. But there is no efficient way to search
6943 the space of all possible rational numbers for an exact answer, so Calc
6946 @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
6947 @subsection Vector Tutorial Exercise 1
6950 Duplicate the vector, compute its length, then divide the vector
6951 by its length: @kbd{@key{RET} A /}.
6955 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1.
6956 . 1: 3.74165738677 . .
6963 The final @kbd{A} command shows that the normalized vector does
6964 indeed have unit length.
6966 @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
6967 @subsection Vector Tutorial Exercise 2
6970 The average position is equal to the sum of the products of the
6971 positions times their corresponding probabilities. This is the
6972 definition of the dot product operation. So all you need to do
6973 is to put the two vectors on the stack and press @kbd{*}.
6975 @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
6976 @subsection Matrix Tutorial Exercise 1
6979 The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to
6980 get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
6982 @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
6983 @subsection Matrix Tutorial Exercise 2
6996 $$ \eqalign{ x &+ a y = 6 \cr
7002 Just enter the righthand side vector, then divide by the lefthand side
7007 1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ]
7012 ' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} /
7016 This can be made more readable using @kbd{d B} to enable ``big'' display
7022 1: [6 - -----, -----]
7027 Type @kbd{d N} to return to ``normal'' display mode afterwards.
7029 @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
7030 @subsection Matrix Tutorial Exercise 3
7033 To solve @c{$A^T A \, X = A^T B$}
7034 @cite{trn(A) * A * X = trn(A) * B}, first we compute
7036 @cite{A2 = trn(A) * A} and @c{$B' = A^T B$}
7037 @cite{B2 = trn(A) * B}; now, we have a
7038 system @c{$A' X = B'$}
7039 @cite{A2 * X = B2} which we can solve using Calc's @samp{/}
7055 $$ \openup1\jot \tabskip=0pt plus1fil
7056 \halign to\displaywidth{\tabskip=0pt
7057 $\hfil#$&$\hfil{}#{}$&
7058 $\hfil#$&$\hfil{}#{}$&
7059 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
7063 2a&+&4b&+&6c&=11 \cr}
7068 The first step is to enter the coefficient matrix. We'll store it in
7069 quick variable number 7 for later reference. Next, we compute the
7075 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96]
7076 [ 4, 5, 6 ] [ 2, 5, 6, 4 ] .
7077 [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ]
7078 [ 2, 4, 6 ] ] 1: [6, 2, 3, 11]
7081 ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] *
7086 Now we compute the matrix @c{$A'$}
7087 @cite{A2} and divide.
7091 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64]
7092 1: [ [ 70, 72, 39 ] .
7102 (The actual computed answer will be slightly inexact due to
7105 Notice that the answers are similar to those for the @c{$3\times3$}
7107 solved in the text. That's because the fourth equation that was
7108 added to the system is almost identical to the first one multiplied
7109 by two. (If it were identical, we would have gotten the exact same
7110 answer since the @c{$4\times3$}
7111 @asis{4x3} system would be equivalent to the original @c{$3\times3$}
7115 Since the first and fourth equations aren't quite equivalent, they
7116 can't both be satisfied at once. Let's plug our answers back into
7117 the original system of equations to see how well they match.
7121 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2]
7133 This is reasonably close to our original @cite{B} vector,
7134 @cite{[6, 2, 3, 11]}.
7136 @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
7137 @subsection List Tutorial Exercise 1
7140 We can use @kbd{v x} to build a vector of integers. This needs to be
7141 adjusted to get the range of integers we desire. Mapping @samp{-}
7142 across the vector will accomplish this, although it turns out the
7143 plain @samp{-} key will work just as well.
7148 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4]
7151 2 v x 9 @key{RET} 5 V M - or 5 -
7156 Now we use @kbd{V M ^} to map the exponentiation operator across the
7161 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
7168 @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
7169 @subsection List Tutorial Exercise 2
7172 Given @cite{x} and @cite{y} vectors in quick variables 1 and 2 as before,
7173 the first job is to form the matrix that describes the problem.
7183 $$ m \times x + b \times 1 = y $$
7187 Thus we want a @c{$19\times2$}
7188 @asis{19x2} matrix with our @cite{x} vector as one column and
7189 ones as the other column. So, first we build the column of ones, then
7190 we combine the two columns to form our @cite{A} matrix.
7194 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ]
7195 1: [1, 1, 1, ...] [ 1.41, 1 ]
7199 r 1 1 v b 19 @key{RET} M-2 v p v t s 3
7204 Now we compute @c{$A^T y$}
7205 @cite{trn(A) * y} and @c{$A^T A$}
7206 @cite{trn(A) * A} and divide.
7210 1: [33.36554, 13.613] 2: [33.36554, 13.613]
7211 . 1: [ [ 98.0003, 41.63 ]
7215 v t r 2 * r 3 v t r 3 *
7220 (Hey, those numbers look familiar!)
7224 1: [0.52141679, -0.425978]
7231 Since we were solving equations of the form @c{$m \times x + b \times 1 = y$}
7232 @cite{m*x + b*1 = y}, these
7233 numbers should be @cite{m} and @cite{b}, respectively. Sure enough, they
7234 agree exactly with the result computed using @kbd{V M} and @kbd{V R}!
7236 The moral of this story: @kbd{V M} and @kbd{V R} will probably solve
7237 your problem, but there is often an easier way using the higher-level
7238 arithmetic functions!
7240 @c [fix-ref Curve Fitting]
7241 In fact, there is a built-in @kbd{a F} command that does least-squares
7242 fits. @xref{Curve Fitting}.
7244 @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
7245 @subsection List Tutorial Exercise 3
7248 Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
7249 whatever) to set the mark, then move to the other end of the list
7250 and type @w{@kbd{M-# g}}.
7254 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
7259 To make things interesting, let's assume we don't know at a glance
7260 how many numbers are in this list. Then we could type:
7264 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ]
7265 1: [2.3, 6, 22, ... ] 1: 126356422.5
7275 2: 126356422.5 2: 126356422.5 1: 7.94652913734
7276 1: [2.3, 6, 22, ... ] 1: 9 .
7284 (The @kbd{I ^} command computes the @var{n}th root of a number.
7285 You could also type @kbd{& ^} to take the reciprocal of 9 and
7286 then raise the number to that power.)
7288 @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
7289 @subsection List Tutorial Exercise 4
7292 A number @cite{j} is a divisor of @cite{n} if @c{$n \mathbin{\hbox{\code{\%}}} j = 0$}
7293 @samp{n % j = 0}. The first
7294 step is to get a vector that identifies the divisors.
7298 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...]
7299 1: [1, 2, 3, 4, ...] 1: 0 .
7302 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2
7307 This vector has 1's marking divisors of 30 and 0's marking non-divisors.
7309 The zeroth divisor function is just the total number of divisors.
7310 The first divisor function is the sum of the divisors.
7315 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72
7316 1: [1, 1, 1, 0, ...] . .
7319 V R + r 1 r 2 V M * V R +
7324 Once again, the last two steps just compute a dot product for which
7325 a simple @kbd{*} would have worked equally well.
7327 @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
7328 @subsection List Tutorial Exercise 5
7331 The obvious first step is to obtain the list of factors with @kbd{k f}.
7332 This list will always be in sorted order, so if there are duplicates
7333 they will be right next to each other. A suitable method is to compare
7334 the list with a copy of itself shifted over by one.
7338 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0]
7339 . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19]
7342 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} |
7349 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0
7357 Note that we have to arrange for both vectors to have the same length
7358 so that the mapping operation works; no prime factor will ever be
7359 zero, so adding zeros on the left and right is safe. From then on
7360 the job is pretty straightforward.
7362 Incidentally, Calc provides the @c{\dfn{M\"obius} $\mu$}
7363 @dfn{Moebius mu} function which is
7364 zero if and only if its argument is square-free. It would be a much
7365 more convenient way to do the above test in practice.
7367 @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
7368 @subsection List Tutorial Exercise 6
7371 First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
7372 to get a list of lists of integers!
7374 @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
7375 @subsection List Tutorial Exercise 7
7378 Here's one solution. First, compute the triangular list from the previous
7379 exercise and type @kbd{1 -} to subtract one from all the elements.
7392 The numbers down the lefthand edge of the list we desire are called
7393 the ``triangular numbers'' (now you know why!). The @cite{n}th
7394 triangular number is the sum of the integers from 1 to @cite{n}, and
7395 can be computed directly by the formula @c{$n (n+1) \over 2$}
7396 @cite{n * (n+1) / 2}.
7400 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7401 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15]
7404 v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET}
7409 Adding this list to the above list of lists produces the desired
7418 [10, 11, 12, 13, 14],
7419 [15, 16, 17, 18, 19, 20] ]
7426 If we did not know the formula for triangular numbers, we could have
7427 computed them using a @kbd{V U +} command. We could also have
7428 gotten them the hard way by mapping a reduction across the original
7433 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7434 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15]
7442 (This means ``map a @kbd{V R +} command across the vector,'' and
7443 since each element of the main vector is itself a small vector,
7444 @kbd{V R +} computes the sum of its elements.)
7446 @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
7447 @subsection List Tutorial Exercise 8
7450 The first step is to build a list of values of @cite{x}.
7454 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5]
7457 v x 21 @key{RET} 1 - 4 / s 1
7461 Next, we compute the Bessel function values.
7465 1: [0., 0.124, 0.242, ..., -0.328]
7468 V M ' besJ(1,$) @key{RET}
7473 (Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
7475 A way to isolate the maximum value is to compute the maximum using
7476 @kbd{V R X}, then compare all the Bessel values with that maximum.
7480 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ]
7484 @key{RET} V R X V M a = @key{RET} V R + @key{DEL}
7489 It's a good idea to verify, as in the last step above, that only
7490 one value is equal to the maximum. (After all, a plot of @c{$\sin x$}
7492 might have many points all equal to the maximum value, 1.)
7494 The vector we have now has a single 1 in the position that indicates
7495 the maximum value of @cite{x}. Now it is a simple matter to convert
7496 this back into the corresponding value itself.
7500 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75
7501 1: [0, 0.25, 0.5, ... ] . .
7508 If @kbd{a =} had produced more than one @cite{1} value, this method
7509 would have given the sum of all maximum @cite{x} values; not very
7510 useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector})
7511 instead. This command deletes all elements of a ``data'' vector that
7512 correspond to zeros in a ``mask'' vector, leaving us with, in this
7513 example, a vector of maximum @cite{x} values.
7515 The built-in @kbd{a X} command maximizes a function using more
7516 efficient methods. Just for illustration, let's use @kbd{a X}
7517 to maximize @samp{besJ(1,x)} over this same interval.
7521 2: besJ(1, x) 1: [1.84115, 0.581865]
7525 ' besJ(1,x), [0..5] @key{RET} a X x @key{RET}
7530 The output from @kbd{a X} is a vector containing the value of @cite{x}
7531 that maximizes the function, and the function's value at that maximum.
7532 As you can see, our simple search got quite close to the right answer.
7534 @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
7535 @subsection List Tutorial Exercise 9
7538 Step one is to convert our integer into vector notation.
7542 1: 25129925999 3: 25129925999
7544 1: [11, 10, 9, ..., 1, 0]
7547 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
7554 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ]
7555 2: [100000000000, ... ] .
7563 (Recall, the @kbd{\} command computes an integer quotient.)
7567 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
7574 Next we must increment this number. This involves adding one to
7575 the last digit, plus handling carries. There is a carry to the
7576 left out of a digit if that digit is a nine and all the digits to
7577 the right of it are nines.
7581 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ]
7591 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
7599 Accumulating @kbd{*} across a vector of ones and zeros will preserve
7600 only the initial run of ones. These are the carries into all digits
7601 except the rightmost digit. Concatenating a one on the right takes
7602 care of aligning the carries properly, and also adding one to the
7607 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
7608 1: [0, 0, 2, 5, ... ] .
7611 0 r 2 | V M + 10 V M %
7616 Here we have concatenated 0 to the @emph{left} of the original number;
7617 this takes care of shifting the carries by one with respect to the
7618 digits that generated them.
7620 Finally, we must convert this list back into an integer.
7624 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ]
7625 2: 1000000000000 1: [1000000000000, 100000000000, ... ]
7626 1: [100000000000, ... ] .
7629 10 @key{RET} 12 ^ r 1 |
7636 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000
7644 Another way to do this final step would be to reduce the formula
7645 @w{@samp{10 $$ + $}} across the vector of digits.
7649 1: [0, 0, 2, 5, ... ] 1: 25129926000
7652 V R ' 10 $$ + $ @key{RET}
7656 @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
7657 @subsection List Tutorial Exercise 10
7660 For the list @cite{[a, b, c, d]}, the result is @cite{((a = b) = c) = d},
7661 which will compare @cite{a} and @cite{b} to produce a 1 or 0, which is
7662 then compared with @cite{c} to produce another 1 or 0, which is then
7663 compared with @cite{d}. This is not at all what Joe wanted.
7665 Here's a more correct method:
7669 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7]
7673 ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET}
7680 1: [1, 1, 1, 0, 1] 1: 0
7687 @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
7688 @subsection List Tutorial Exercise 11
7691 The circle of unit radius consists of those points @cite{(x,y)} for which
7692 @cite{x^2 + y^2 < 1}. We start by generating a vector of @cite{x^2}
7693 and a vector of @cite{y^2}.
7695 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7700 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.]
7701 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81]
7704 v . t . 2. v b 100 @key{RET} @key{RET} V M k r
7711 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036]
7712 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094]
7715 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^
7719 Now we sum the @cite{x^2} and @cite{y^2} values, compare with 1 to
7720 get a vector of 1/0 truth values, then sum the truth values.
7724 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84
7732 The ratio @cite{84/100} should approximate the ratio @c{$\pi/4$}
7737 1: 0.84 1: 3.36 2: 3.36 1: 1.0695
7745 Our estimate, 3.36, is off by about 7%. We could get a better estimate
7746 by taking more points (say, 1000), but it's clear that this method is
7749 (Naturally, since this example uses random numbers your own answer
7750 will be slightly different from the one shown here!)
7752 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7753 return to full-sized display of vectors.
7755 @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
7756 @subsection List Tutorial Exercise 12
7759 This problem can be made a lot easier by taking advantage of some
7760 symmetries. First of all, after some thought it's clear that the
7761 @cite{y} axis can be ignored altogether. Just pick a random @cite{x}
7762 component for one end of the match, pick a random direction @c{$\theta$}
7764 and see if @cite{x} and @c{$x + \cos \theta$}
7765 @cite{x + cos(theta)} (which is the @cite{x}
7766 coordinate of the other endpoint) cross a line. The lines are at
7767 integer coordinates, so this happens when the two numbers surround
7770 Since the two endpoints are equivalent, we may as well choose the leftmost
7771 of the two endpoints as @cite{x}. Then @cite{theta} is an angle pointing
7772 to the right, in the range -90 to 90 degrees. (We could use radians, but
7773 it would feel like cheating to refer to @c{$\pi/2$}
7774 @cite{pi/2} radians while trying
7775 to estimate @c{$\pi$}
7778 In fact, since the field of lines is infinite we can choose the
7779 coordinates 0 and 1 for the lines on either side of the leftmost
7780 endpoint. The rightmost endpoint will be between 0 and 1 if the
7781 match does not cross a line, or between 1 and 2 if it does. So:
7782 Pick random @cite{x} and @c{$\theta$}
7783 @cite{theta}, compute @c{$x + \cos \theta$}
7784 @cite{x + cos(theta)},
7785 and count how many of the results are greater than one. Simple!
7787 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7792 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72]
7793 . 1: [78.4, 64.5, ..., -42.9]
7796 v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 -
7801 (The next step may be slow, depending on the speed of your computer.)
7805 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45]
7806 1: [0.20, 0.43, ..., 0.73] .
7816 1: [0, 1, ..., 1] 1: 0.64 1: 3.125
7819 1 V M a > V R + 100 / 2 @key{TAB} /
7823 Let's try the third method, too. We'll use random integers up to
7824 one million. The @kbd{k r} command with an integer argument picks
7829 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975]
7830 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450]
7833 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r
7840 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56
7843 V M k g 1 V M a = V R + 100 /
7857 For a proof of this property of the GCD function, see section 4.5.2,
7858 exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
7860 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7861 return to full-sized display of vectors.
7863 @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
7864 @subsection List Tutorial Exercise 13
7867 First, we put the string on the stack as a vector of ASCII codes.
7871 1: [84, 101, 115, ..., 51]
7874 "Testing, 1, 2, 3 @key{RET}
7879 Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
7880 there was no need to type an apostrophe. Also, Calc didn't mind that
7881 we omitted the closing @kbd{"}. (The same goes for all closing delimiters
7882 like @kbd{)} and @kbd{]} at the end of a formula.
7884 We'll show two different approaches here. In the first, we note that
7885 if the input vector is @cite{[a, b, c, d]}, then the hash code is
7886 @cite{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words,
7887 it's a sum of descending powers of three times the ASCII codes.
7891 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51]
7892 1: 16 1: [15, 14, 13, ..., 0]
7895 @key{RET} v l v x 16 @key{RET} -
7902 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121
7903 1: [14348907, ..., 1] . .
7906 3 @key{TAB} V M ^ * 511 %
7911 Once again, @kbd{*} elegantly summarizes most of the computation.
7912 But there's an even more elegant approach: Reduce the formula
7913 @kbd{3 $$ + $} across the vector. Recall that this represents a
7914 function of two arguments that computes its first argument times three
7915 plus its second argument.
7919 1: [84, 101, 115, ..., 51] 1: 1960915098
7922 "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET}
7927 If you did the decimal arithmetic exercise, this will be familiar.
7928 Basically, we're turning a base-3 vector of digits into an integer,
7929 except that our ``digits'' are much larger than real digits.
7931 Instead of typing @kbd{511 %} again to reduce the result, we can be
7932 cleverer still and notice that rather than computing a huge integer
7933 and taking the modulo at the end, we can take the modulo at each step
7934 without affecting the result. While this means there are more
7935 arithmetic operations, the numbers we operate on remain small so
7936 the operations are faster.
7940 1: [84, 101, 115, ..., 51] 1: 121
7943 "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET}
7947 Why does this work? Think about a two-step computation:
7948 @w{@cite{3 (3a + b) + c}}. Taking a result modulo 511 basically means
7949 subtracting off enough 511's to put the result in the desired range.
7950 So the result when we take the modulo after every step is,
7954 3 (3 a + b - 511 m) + c - 511 n
7960 $$ 3 (3 a + b - 511 m) + c - 511 n $$
7965 for some suitable integers @cite{m} and @cite{n}. Expanding out by
7966 the distributive law yields
7970 9 a + 3 b + c - 511*3 m - 511 n
7976 $$ 9 a + 3 b + c - 511\times3 m - 511 n $$
7981 The @cite{m} term in the latter formula is redundant because any
7982 contribution it makes could just as easily be made by the @cite{n}
7983 term. So we can take it out to get an equivalent formula with
7988 9 a + 3 b + c - 511 n'
7994 $$ 9 a + 3 b + c - 511 n' $$
7999 which is just the formula for taking the modulo only at the end of
8000 the calculation. Therefore the two methods are essentially the same.
8002 Later in the tutorial we will encounter @dfn{modulo forms}, which
8003 basically automate the idea of reducing every intermediate result
8004 modulo some value @var{m}.
8006 @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
8007 @subsection List Tutorial Exercise 14
8009 We want to use @kbd{H V U} to nest a function which adds a random
8010 step to an @cite{(x,y)} coordinate. The function is a bit long, but
8011 otherwise the problem is quite straightforward.
8015 2: [0, 0] 1: [ [ 0, 0 ]
8016 1: 50 [ 0.4288, -0.1695 ]
8017 . [ -0.4787, -0.9027 ]
8020 [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
8024 Just as the text recommended, we used @samp{< >} nameless function
8025 notation to keep the two @code{random} calls from being evaluated
8026 before nesting even begins.
8028 We now have a vector of @cite{[x, y]} sub-vectors, which by Calc's
8029 rules acts like a matrix. We can transpose this matrix and unpack
8030 to get a pair of vectors, @cite{x} and @cite{y}, suitable for graphing.
8034 2: [ 0, 0.4288, -0.4787, ... ]
8035 1: [ 0, -0.1696, -0.9027, ... ]
8042 Incidentally, because the @cite{x} and @cite{y} are completely
8043 independent in this case, we could have done two separate commands
8044 to create our @cite{x} and @cite{y} vectors of numbers directly.
8046 To make a random walk of unit steps, we note that @code{sincos} of
8047 a random direction exactly gives us an @cite{[x, y]} step of unit
8048 length; in fact, the new nesting function is even briefer, though
8049 we might want to lower the precision a bit for it.
8053 2: [0, 0] 1: [ [ 0, 0 ]
8054 1: 50 [ 0.1318, 0.9912 ]
8055 . [ -0.5965, 0.3061 ]
8058 [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET}
8062 Another @kbd{v t v u g f} sequence will graph this new random walk.
8064 An interesting twist on these random walk functions would be to use
8065 complex numbers instead of 2-vectors to represent points on the plane.
8066 In the first example, we'd use something like @samp{random + random*(0,1)},
8067 and in the second we could use polar complex numbers with random phase
8068 angles. (This exercise was first suggested in this form by Randal
8071 @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
8072 @subsection Types Tutorial Exercise 1
8075 If the number is the square root of @c{$\pi$}
8076 @cite{pi} times a rational number,
8077 then its square, divided by @c{$\pi$}
8078 @cite{pi}, should be a rational number.
8082 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627
8090 Technically speaking this is a rational number, but not one that is
8091 likely to have arisen in the original problem. More likely, it just
8092 happens to be the fraction which most closely represents some
8093 irrational number to within 12 digits.
8095 But perhaps our result was not quite exact. Let's reduce the
8096 precision slightly and try again:
8100 1: 0.509433962268 1: 27:53
8103 U p 10 @key{RET} c F
8108 Aha! It's unlikely that an irrational number would equal a fraction
8109 this simple to within ten digits, so our original number was probably
8110 @c{$\sqrt{27 \pi / 53}$}
8111 @cite{sqrt(27 pi / 53)}.
8113 Notice that we didn't need to re-round the number when we reduced the
8114 precision. Remember, arithmetic operations always round their inputs
8115 to the current precision before they begin.
8117 @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
8118 @subsection Types Tutorial Exercise 2
8121 @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer.
8122 But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
8124 @samp{exp(inf) = inf}. It's tempting to say that the exponential
8125 of infinity must be ``bigger'' than ``regular'' infinity, but as
8126 far as Calc is concerned all infinities are as just as big.
8127 In other words, as @cite{x} goes to infinity, @cite{e^x} also goes
8128 to infinity, but the fact the @cite{e^x} grows much faster than
8129 @cite{x} is not relevant here.
8131 @samp{exp(-inf) = 0}. Here we have a finite answer even though
8132 the input is infinite.
8134 @samp{sqrt(-inf) = (0, 1) inf}. Remember that @cite{(0, 1)}
8135 represents the imaginary number @cite{i}. Here's a derivation:
8136 @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
8137 The first part is, by definition, @cite{i}; the second is @code{inf}
8138 because, once again, all infinities are the same size.
8140 @samp{sqrt(uinf) = uinf}. In fact, we do know something about the
8141 direction because @code{sqrt} is defined to return a value in the
8142 right half of the complex plane. But Calc has no notation for this,
8143 so it settles for the conservative answer @code{uinf}.
8145 @samp{abs(uinf) = inf}. No matter which direction @cite{x} points,
8146 @samp{abs(x)} always points along the positive real axis.
8148 @samp{ln(0) = -inf}. Here we have an infinite answer to a finite
8149 input. As in the @cite{1 / 0} case, Calc will only use infinities
8150 here if you have turned on ``infinite'' mode. Otherwise, it will
8151 treat @samp{ln(0)} as an error.
8153 @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
8154 @subsection Types Tutorial Exercise 3
8157 We can make @samp{inf - inf} be any real number we like, say,
8158 @cite{a}, just by claiming that we added @cite{a} to the first
8159 infinity but not to the second. This is just as true for complex
8160 values of @cite{a}, so @code{nan} can stand for a complex number.
8161 (And, similarly, @code{uinf} can stand for an infinity that points
8162 in any direction in the complex plane, such as @samp{(0, 1) inf}).
8164 In fact, we can multiply the first @code{inf} by two. Surely
8165 @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
8166 So @code{nan} can even stand for infinity. Obviously it's just
8167 as easy to make it stand for minus infinity as for plus infinity.
8169 The moral of this story is that ``infinity'' is a slippery fish
8170 indeed, and Calc tries to handle it by having a very simple model
8171 for infinities (only the direction counts, not the ``size''); but
8172 Calc is careful to write @code{nan} any time this simple model is
8173 unable to tell what the true answer is.
8175 @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
8176 @subsection Types Tutorial Exercise 4
8180 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765"
8184 0@@ 47' 26" @key{RET} 17 /
8189 The average song length is two minutes and 47.4 seconds.
8193 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005"
8202 The album would be 53 minutes and 6 seconds long.
8204 @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
8205 @subsection Types Tutorial Exercise 5
8208 Let's suppose it's January 14, 1991. The easiest thing to do is
8209 to keep trying 13ths of months until Calc reports a Friday.
8210 We can do this by manually entering dates, or by using @kbd{t I}:
8214 1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991>
8217 ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I
8222 (Calc assumes the current year if you don't say otherwise.)
8224 This is getting tedious---we can keep advancing the date by typing
8225 @kbd{t I} over and over again, but let's automate the job by using
8226 vector mapping. The @kbd{t I} command actually takes a second
8227 ``how-many-months'' argument, which defaults to one. This
8228 argument is exactly what we want to map over:
8232 2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
8233 1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
8234 . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
8237 v x 6 @key{RET} V M t I
8242 Et voil@`a, September 13, 1991 is a Friday.
8249 ' <sep 13> - <jan 14> @key{RET}
8254 And the answer to our original question: 242 days to go.
8256 @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
8257 @subsection Types Tutorial Exercise 6
8260 The full rule for leap years is that they occur in every year divisible
8261 by four, except that they don't occur in years divisible by 100, except
8262 that they @emph{do} in years divisible by 400. We could work out the
8263 answer by carefully counting the years divisible by four and the
8264 exceptions, but there is a much simpler way that works even if we
8265 don't know the leap year rule.
8267 Let's assume the present year is 1991. Years have 365 days, except
8268 that leap years (whenever they occur) have 366 days. So let's count
8269 the number of days between now and then, and compare that to the
8270 number of years times 365. The number of extra days we find must be
8271 equal to the number of leap years there were.
8275 1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593
8276 . 1: <Tue Jan 1, 1991> .
8279 ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} -
8286 3: 2925593 2: 2925593 2: 2925593 1: 1943
8287 2: 10001 1: 8010 1: 2923650 .
8291 10001 @key{RET} 1991 - 365 * -
8295 @c [fix-ref Date Forms]
8297 There will be 1943 leap years before the year 10001. (Assuming,
8298 of course, that the algorithm for computing leap years remains
8299 unchanged for that long. @xref{Date Forms}, for some interesting
8300 background information in that regard.)
8302 @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
8303 @subsection Types Tutorial Exercise 7
8306 The relative errors must be converted to absolute errors so that
8307 @samp{+/-} notation may be used.
8315 20 @key{RET} .05 * 4 @key{RET} .05 *
8319 Now we simply chug through the formula.
8323 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21
8326 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ *
8330 It turns out the @kbd{v u} command will unpack an error form as
8331 well as a vector. This saves us some retyping of numbers.
8335 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21
8340 @key{RET} v u @key{TAB} /
8345 Thus the volume is 6316 cubic centimeters, within about 11 percent.
8347 @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
8348 @subsection Types Tutorial Exercise 8
8351 The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}.
8352 Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
8353 close to zero, its reciprocal can get arbitrarily large, so the answer
8354 is an interval that effectively means, ``any number greater than 0.1''
8355 but with no upper bound.
8357 The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
8359 Calc normally treats division by zero as an error, so that the formula
8360 @w{@samp{1 / 0}} is left unsimplified. Our third problem,
8361 @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
8362 is now a member of the interval. So Calc leaves this one unevaluated, too.
8364 If you turn on ``infinite'' mode by pressing @kbd{m i}, you will
8365 instead get the answer @samp{[0.1 .. inf]}, which includes infinity
8366 as a possible value.
8368 The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
8369 Zero is buried inside the interval, but it's still a possible value.
8370 It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
8371 will be either greater than @i{0.1}, or less than @i{-0.1}. Thus
8372 the interval goes from minus infinity to plus infinity, with a ``hole''
8373 in it from @i{-0.1} to @i{0.1}. Calc doesn't have any way to
8374 represent this, so it just reports @samp{[-inf .. inf]} as the answer.
8375 It may be disappointing to hear ``the answer lies somewhere between
8376 minus infinity and plus infinity, inclusive,'' but that's the best
8377 that interval arithmetic can do in this case.
8379 @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
8380 @subsection Types Tutorial Exercise 9
8384 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9]
8385 . 1: [0 .. 9] 1: [-9 .. 9]
8388 [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} *
8393 In the first case the result says, ``if a number is between @i{-3} and
8394 3, its square is between 0 and 9.'' The second case says, ``the product
8395 of two numbers each between @i{-3} and 3 is between @i{-9} and 9.''
8397 An interval form is not a number; it is a symbol that can stand for
8398 many different numbers. Two identical-looking interval forms can stand
8399 for different numbers.
8401 The same issue arises when you try to square an error form.
8403 @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
8404 @subsection Types Tutorial Exercise 10
8407 Testing the first number, we might arbitrarily choose 17 for @cite{x}.
8411 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613
8415 17 M 811749613 @key{RET} 811749612 ^
8420 Since 533694123 is (considerably) different from 1, the number 811749613
8423 It's awkward to type the number in twice as we did above. There are
8424 various ways to avoid this, and algebraic entry is one. In fact, using
8425 a vector mapping operation we can perform several tests at once. Let's
8426 use this method to test the second number.
8430 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ]
8434 [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET}
8439 The result is three ones (modulo @cite{n}), so it's very probable that
8440 15485863 is prime. (In fact, this number is the millionth prime.)
8442 Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
8443 would have been hopelessly inefficient, since they would have calculated
8444 the power using full integer arithmetic.
8446 Calc has a @kbd{k p} command that does primality testing. For small
8447 numbers it does an exact test; for large numbers it uses a variant
8448 of the Fermat test we used here. You can use @kbd{k p} repeatedly
8449 to prove that a large integer is prime with any desired probability.
8451 @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
8452 @subsection Types Tutorial Exercise 11
8455 There are several ways to insert a calculated number into an HMS form.
8456 One way to convert a number of seconds to an HMS form is simply to
8457 multiply the number by an HMS form representing one second:
8461 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359"
8472 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0"
8473 1: 15@@ 27' 16" mod 24@@ 0' 0" .
8481 It will be just after six in the morning.
8483 The algebraic @code{hms} function can also be used to build an
8488 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359"
8491 ' hms(0, 0, 1e7 pi) @key{RET} =
8496 The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
8497 the actual number 3.14159...
8499 @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
8500 @subsection Types Tutorial Exercise 12
8503 As we recall, there are 17 songs of about 2 minutes and 47 seconds
8508 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"]
8509 1: [0@@ 0' 20" .. 0@@ 1' 0"] .
8512 [ 0@@ 20" .. 0@@ 1' ] +
8519 1: [0@@ 52' 59." .. 1@@ 4' 19."]
8527 No matter how long it is, the album will fit nicely on one CD.
8529 @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
8530 @subsection Types Tutorial Exercise 13
8533 Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds.
8535 @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
8536 @subsection Types Tutorial Exercise 14
8539 How long will it take for a signal to get from one end of the computer
8544 1: m / c 1: 3.3356 ns
8547 ' 1 m / c @key{RET} u c ns @key{RET}
8552 (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
8556 1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356
8560 ' 4.1 ns @key{RET} / u s
8565 Thus a signal could take up to 81 percent of a clock cycle just to
8566 go from one place to another inside the computer, assuming the signal
8567 could actually attain the full speed of light. Pretty tight!
8569 @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
8570 @subsection Types Tutorial Exercise 15
8573 The speed limit is 55 miles per hour on most highways. We want to
8574 find the ratio of Sam's speed to the US speed limit.
8578 1: 55 mph 2: 55 mph 3: 11 hr mph / yd
8582 ' 55 mph @key{RET} ' 5 yd/hr @key{RET} /
8586 The @kbd{u s} command cancels out these units to get a plain
8587 number. Now we take the logarithm base two to find the final
8588 answer, assuming that each successive pill doubles his speed.
8592 1: 19360. 2: 19360. 1: 14.24
8601 Thus Sam can take up to 14 pills without a worry.
8603 @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
8604 @subsection Algebra Tutorial Exercise 1
8607 @c [fix-ref Declarations]
8608 The result @samp{sqrt(x)^2} is simplified back to @cite{x} by the
8609 Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens
8610 if @w{@cite{x = -4}}.) If @cite{x} is real, this formula could be
8611 simplified to @samp{abs(x)}, but for general complex arguments even
8612 that is not safe. (@xref{Declarations}, for a way to tell Calc
8613 that @cite{x} is known to be real.)
8615 @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
8616 @subsection Algebra Tutorial Exercise 2
8619 Suppose our roots are @cite{[a, b, c]}. We want a polynomial which
8620 is zero when @cite{x} is any of these values. The trivial polynomial
8621 @cite{x-a} is zero when @cite{x=a}, so the product @cite{(x-a)(x-b)(x-c)}
8622 will do the job. We can use @kbd{a c x} to write this in a more
8627 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0]
8637 1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x
8640 V M ' x-$ @key{RET} V R *
8647 1: x^3 - 1.41666 x 1: 34 x - 24 x^3
8650 a c x @key{RET} 24 n * a x
8655 Sure enough, our answer (multiplied by a suitable constant) is the
8656 same as the original polynomial.
8658 @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
8659 @subsection Algebra Tutorial Exercise 3
8663 1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2
8666 ' x sin(pi x) @key{RET} m r a i x @key{RET}
8674 2: (sin(pi x) - pi x cos(pi x)) / pi^2
8677 ' [y,1] @key{RET} @key{TAB}
8684 1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
8694 1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
8704 1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
8714 1: [0., -0.95493, 0.63662, -1.5915, 1.2732]
8717 v x 5 @key{RET} @key{TAB} V M $ @key{RET}
8721 @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
8722 @subsection Algebra Tutorial Exercise 4
8725 The hard part is that @kbd{V R +} is no longer sufficient to add up all
8726 the contributions from the slices, since the slices have varying
8727 coefficients. So first we must come up with a vector of these
8728 coefficients. Here's one way:
8732 2: -1 2: 3 1: [4, 2, ..., 4]
8733 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] .
8736 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} -
8743 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1]
8751 Now we compute the function values. Note that for this method we need
8752 eleven values, including both endpoints of the desired interval.
8756 2: [1, 4, 2, ..., 4, 1]
8757 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.]
8760 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
8767 2: [1, 4, 2, ..., 4, 1]
8768 1: [0., 0.084941, 0.16993, ... ]
8771 ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET}
8776 Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
8781 1: 11.22 1: 1.122 1: 0.374
8789 Wow! That's even better than the result from the Taylor series method.
8791 @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
8792 @subsection Rewrites Tutorial Exercise 1
8795 We'll use Big mode to make the formulas more readable.
8801 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: --------
8807 ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B
8812 Multiplying by the conjugate helps because @cite{(a+b) (a-b) = a^2 - b^2}.
8817 1: (2 + V 2 ) (V 2 - 1)
8820 a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
8828 1: 2 + V 2 - 2 1: V 2
8831 a r a*(b+c) := a*b + a*c a s
8836 (We could have used @kbd{a x} instead of a rewrite rule for the
8839 The multiply-by-conjugate rule turns out to be useful in many
8840 different circumstances, such as when the denominator involves
8841 sines and cosines or the imaginary constant @code{i}.
8843 @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
8844 @subsection Rewrites Tutorial Exercise 2
8847 Here is the rule set:
8851 [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
8853 fib(n, x, y) := fib(n-1, y, x+y) ]
8858 The first rule turns a one-argument @code{fib} that people like to write
8859 into a three-argument @code{fib} that makes computation easier. The
8860 second rule converts back from three-argument form once the computation
8861 is done. The third rule does the computation itself. It basically
8862 says that if @cite{x} and @cite{y} are two consecutive Fibonacci numbers,
8863 then @cite{y} and @cite{x+y} are the next (overlapping) pair of Fibonacci
8866 Notice that because the number @cite{n} was ``validated'' by the
8867 conditions on the first rule, there is no need to put conditions on
8868 the other rules because the rule set would never get that far unless
8869 the input were valid. That further speeds computation, since no
8870 extra conditions need to be checked at every step.
8872 Actually, a user with a nasty sense of humor could enter a bad
8873 three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
8874 which would get the rules into an infinite loop. One thing that would
8875 help keep this from happening by accident would be to use something like
8876 @samp{ZzFib} instead of @code{fib} as the name of the three-argument
8879 @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
8880 @subsection Rewrites Tutorial Exercise 3
8883 He got an infinite loop. First, Calc did as expected and rewrote
8884 @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to
8885 apply the rule again, and found that @samp{f(2, 3, x)} looks like
8886 @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
8887 @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)}
8888 around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r}
8889 to make sure the rule applied only once.
8891 (Actually, even the first step didn't work as he expected. What Calc
8892 really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
8893 treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
8894 to it. While this may seem odd, it's just as valid a solution as the
8895 ``obvious'' one. One way to fix this would be to add the condition
8896 @samp{:: variable(x)} to the rule, to make sure the thing that matches
8897 @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
8898 on the lefthand side, so that the rule matches the actual variable
8899 @samp{x} rather than letting @samp{x} stand for something else.)
8901 @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
8902 @subsection Rewrites Tutorial Exercise 4
8909 Here is a suitable set of rules to solve the first part of the problem:
8913 [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0,
8914 seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
8918 Given the initial formula @samp{seq(6, 0)}, application of these
8919 rules produces the following sequence of formulas:
8933 whereupon neither of the rules match, and rewriting stops.
8935 We can pretty this up a bit with a couple more rules:
8939 [ seq(n) := seq(n, 0),
8946 Now, given @samp{seq(6)} as the starting configuration, we get 8
8949 The change to return a vector is quite simple:
8953 [ seq(n) := seq(n, []) :: integer(n) :: n > 0,
8955 seq(n, v) := seq(n/2, v | n) :: n%2 = 0,
8956 seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
8961 Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
8963 Notice that the @cite{n > 1} guard is no longer necessary on the last
8964 rule since the @cite{n = 1} case is now detected by another rule.
8965 But a guard has been added to the initial rule to make sure the
8966 initial value is suitable before the computation begins.
8968 While still a good idea, this guard is not as vitally important as it
8969 was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
8970 will not get into an infinite loop. Calc will not be able to prove
8971 the symbol @samp{x} is either even or odd, so none of the rules will
8972 apply and the rewrites will stop right away.
8974 @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
8975 @subsection Rewrites Tutorial Exercise 5
8982 If @cite{x} is the sum @cite{a + b}, then `@t{nterms(}@var{x}@t{)}' must
8983 be `@t{nterms(}@var{a}@t{)}' plus `@t{nterms(}@var{b}@t{)}'. If @cite{x}
8984 is not a sum, then `@t{nterms(}@var{x}@t{)}' = 1.
8988 [ nterms(a + b) := nterms(a) + nterms(b),
8994 Here we have taken advantage of the fact that earlier rules always
8995 match before later rules; @samp{nterms(x)} will only be tried if we
8996 already know that @samp{x} is not a sum.
8998 @node Rewrites Answer 6, Rewrites Answer 7, Rewrites Answer 5, Answers to Exercises
8999 @subsection Rewrites Tutorial Exercise 6
9001 Just put the rule @samp{0^0 := 1} into @code{EvalRules}. For example,
9002 before making this definition we have:
9006 2: [-2, -1, 0, 1, 2] 1: [1, 1, 0^0, 1, 1]
9010 v x 5 @key{RET} 3 - 0 V M ^
9019 2: [-2, -1, 0, 1, 2] 1: [1, 1, 1, 1, 1]
9023 U ' 0^0:=1 @key{RET} s t EvalRules @key{RET} V M ^
9027 Perhaps more surprisingly, this rule still works with infinite mode
9028 turned on. Calc tries @code{EvalRules} before any built-in rules for
9029 a function. This allows you to override the default behavior of any
9030 Calc feature: Even though Calc now wants to evaluate @cite{0^0} to
9031 @code{nan}, your rule gets there first and evaluates it to 1 instead.
9033 Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
9034 What happens? (Be sure to remove this rule afterward, or you might get
9035 a nasty surprise when you use Calc to balance your checkbook!)
9037 @node Rewrites Answer 7, Programming Answer 1, Rewrites Answer 6, Answers to Exercises
9038 @subsection Rewrites Tutorial Exercise 7
9041 Here is a rule set that will do the job:
9045 [ a*(b + c) := a*b + a*c,
9046 opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
9047 :: constant(a) :: constant(b),
9048 opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
9049 :: constant(a) :: constant(b),
9050 a O(x^n) := O(x^n) :: constant(a),
9051 x^opt(m) O(x^n) := O(x^(n+m)),
9052 O(x^n) O(x^m) := O(x^(n+m)) ]
9056 If we really want the @kbd{+} and @kbd{*} keys to operate naturally
9057 on power series, we should put these rules in @code{EvalRules}. For
9058 testing purposes, it is better to put them in a different variable,
9059 say, @code{O}, first.
9061 The first rule just expands products of sums so that the rest of the
9062 rules can assume they have an expanded-out polynomial to work with.
9063 Note that this rule does not mention @samp{O} at all, so it will
9064 apply to any product-of-sum it encounters---this rule may surprise
9065 you if you put it into @code{EvalRules}!
9067 In the second rule, the sum of two O's is changed to the smaller O.
9068 The optional constant coefficients are there mostly so that
9069 @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
9070 as well as @samp{O(x^2) + O(x^3)}.
9072 The third rule absorbs higher powers of @samp{x} into O's.
9074 The fourth rule says that a constant times a negligible quantity
9075 is still negligible. (This rule will also match @samp{O(x^3) / 4},
9076 with @samp{a = 1/4}.)
9078 The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
9079 (It is easy to see that if one of these forms is negligible, the other
9080 is, too.) Notice the @samp{x^opt(m)} to pick up terms like
9081 @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1}
9082 but not 1 as @samp{x^0}. This turns out to be exactly what we want here.
9084 The sixth rule is the corresponding rule for products of two O's.
9086 Another way to solve this problem would be to create a new ``data type''
9087 that represents truncated power series. We might represent these as
9088 function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
9089 a vector of coefficients for @cite{x^0}, @cite{x^1}, @cite{x^2}, and so
9090 on. Rules would exist for sums and products of such @code{series}
9091 objects, and as an optional convenience could also know how to combine a
9092 @code{series} object with a normal polynomial. (With this, and with a
9093 rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
9094 you could still enter power series in exactly the same notation as
9095 before.) Operations on such objects would probably be more efficient,
9096 although the objects would be a bit harder to read.
9098 @c [fix-ref Compositions]
9099 Some other symbolic math programs provide a power series data type
9100 similar to this. Mathematica, for example, has an object that looks
9101 like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
9102 @var{nmax}, @var{den}]}, where @var{x0} is the point about which the
9103 power series is taken (we've been assuming this was always zero),
9104 and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
9105 with fractional or negative powers. Also, the @code{PowerSeries}
9106 objects have a special display format that makes them look like
9107 @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions},
9108 for a way to do this in Calc, although for something as involved as
9109 this it would probably be better to write the formatting routine
9112 @node Programming Answer 1, Programming Answer 2, Rewrites Answer 7, Answers to Exercises
9113 @subsection Programming Tutorial Exercise 1
9116 Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
9117 @kbd{Z F}, and answer the questions. Since this formula contains two
9118 variables, the default argument list will be @samp{(t x)}. We want to
9119 change this to @samp{(x)} since @cite{t} is really a dummy variable
9120 to be used within @code{ninteg}.
9122 The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
9123 (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
9125 @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
9126 @subsection Programming Tutorial Exercise 2
9129 One way is to move the number to the top of the stack, operate on
9130 it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
9132 Another way is to negate the top three stack entries, then negate
9133 again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}.
9135 Finally, it turns out that a negative prefix argument causes a
9136 command like @kbd{n} to operate on the specified stack entry only,
9137 which is just what we want: @kbd{C-x ( M-- 3 n C-x )}.
9139 Just for kicks, let's also do it algebraically:
9140 @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
9142 @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
9143 @subsection Programming Tutorial Exercise 3
9146 Each of these functions can be computed using the stack, or using
9147 algebraic entry, whichever way you prefer:
9150 Computing @c{$\displaystyle{\sin x \over x}$}
9153 Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}.
9155 Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}.
9158 Computing the logarithm:
9160 Using the stack: @kbd{C-x ( @key{TAB} B C-x )}
9162 Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}.
9165 Computing the vector of integers:
9167 Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that
9168 @kbd{C-u v x} takes the vector size, starting value, and increment
9171 Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a
9172 number from the stack and uses it as the prefix argument for the
9175 Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}.
9177 @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
9178 @subsection Programming Tutorial Exercise 4
9181 Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
9183 @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
9184 @subsection Programming Tutorial Exercise 5
9188 2: 1 1: 1.61803398502 2: 1.61803398502
9189 1: 20 . 1: 1.61803398875
9192 1 @key{RET} 20 Z < & 1 + Z > I H P
9197 This answer is quite accurate.
9199 @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
9200 @subsection Programming Tutorial Exercise 6
9206 [ [ 0, 1 ] * [a, b] = [b, a + b]
9211 Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @cite{n+1}
9212 and @cite{n+2}. Here's one program that does the job:
9215 C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
9219 This program is quite efficient because Calc knows how to raise a
9220 matrix (or other value) to the power @cite{n} in only @c{$\log_2 n$}
9222 steps. For example, this program can compute the 1000th Fibonacci
9223 number (a 209-digit integer!) in about 10 steps; even though the
9224 @kbd{Z < ... Z >} solution had much simpler steps, it would have
9225 required so many steps that it would not have been practical.
9227 @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
9228 @subsection Programming Tutorial Exercise 7
9231 The trick here is to compute the harmonic numbers differently, so that
9232 the loop counter itself accumulates the sum of reciprocals. We use
9233 a separate variable to hold the integer counter.
9241 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z )
9246 The body of the loop goes as follows: First save the harmonic sum
9247 so far in variable 2. Then delete it from the stack; the for loop
9248 itself will take care of remembering it for us. Next, recall the
9249 count from variable 1, add one to it, and feed its reciprocal to
9250 the for loop to use as the step value. The for loop will increase
9251 the ``loop counter'' by that amount and keep going until the
9252 loop counter exceeds 4.
9257 1: 3.99498713092 2: 3.99498713092
9261 r 1 r 2 @key{RET} 31 & +
9265 Thus we find that the 30th harmonic number is 3.99, and the 31st
9266 harmonic number is 4.02.
9268 @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
9269 @subsection Programming Tutorial Exercise 8
9272 The first step is to compute the derivative @cite{f'(x)} and thus
9273 the formula @c{$\displaystyle{x - {f(x) \over f'(x)}}$}
9274 @cite{x - f(x)/f'(x)}.
9276 (Because this definition is long, it will be repeated in concise form
9277 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9278 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9279 keystrokes without executing them. In the following diagrams we'll
9280 pretend Calc actually executed the keystrokes as you typed them,
9281 just for purposes of illustration.)
9285 2: sin(cos(x)) - 0.5 3: 4.5
9286 1: 4.5 2: sin(cos(x)) - 0.5
9287 . 1: -(sin(x) cos(cos(x)))
9290 ' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET}
9298 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
9301 / ' x @key{RET} @key{TAB} - t 1
9305 Now, we enter the loop. We'll use a repeat loop with a 20-repetition
9306 limit just in case the method fails to converge for some reason.
9307 (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
9308 repetitions are done.)
9312 1: 4.5 3: 4.5 2: 4.5
9313 . 2: x + (sin(cos(x)) ... 1: 5.24196456928
9317 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9321 This is the new guess for @cite{x}. Now we compare it with the
9322 old one to see if we've converged.
9326 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348
9331 @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x )
9335 The loop converges in just a few steps to this value. To check
9336 the result, we can simply substitute it back into the equation.
9344 @key{RET} ' sin(cos($)) @key{RET}
9348 Let's test the new definition again:
9356 ' x^2-9 @key{RET} 1 X
9360 Once again, here's the full Newton's Method definition:
9364 C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1
9365 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9366 @key{RET} M-@key{TAB} a = Z /
9373 @c [fix-ref Nesting and Fixed Points]
9374 It turns out that Calc has a built-in command for applying a formula
9375 repeatedly until it converges to a number. @xref{Nesting and Fixed Points},
9376 to see how to use it.
9378 @c [fix-ref Root Finding]
9379 Also, of course, @kbd{a R} is a built-in command that uses Newton's
9380 method (among others) to look for numerical solutions to any equation.
9381 @xref{Root Finding}.
9383 @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
9384 @subsection Programming Tutorial Exercise 9
9387 The first step is to adjust @cite{z} to be greater than 5. A simple
9388 ``for'' loop will do the job here. If @cite{z} is less than 5, we
9389 reduce the problem using @c{$\psi(z) = \psi(z+1) - 1/z$}
9390 @cite{psi(z) = psi(z+1) - 1/z}. We go
9391 on to compute @c{$\psi(z+1)$}
9392 @cite{psi(z+1)}, and remember to add back a factor of
9393 @cite{-1/z} when we're done. This step is repeated until @cite{z > 5}.
9395 (Because this definition is long, it will be repeated in concise form
9396 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9397 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9398 keystrokes without executing them. In the following diagrams we'll
9399 pretend Calc actually executed the keystrokes as you typed them,
9400 just for purposes of illustration.)
9407 1.0 @key{RET} C-x ( Z ` s 1 0 t 2
9411 Here, variable 1 holds @cite{z} and variable 2 holds the adjustment
9412 factor. If @cite{z < 5}, we use a loop to increase it.
9414 (By the way, we started with @samp{1.0} instead of the integer 1 because
9415 otherwise the calculation below will try to do exact fractional arithmetic,
9416 and will never converge because fractions compare equal only if they
9417 are exactly equal, not just equal to within the current precision.)
9426 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9430 Now we compute the initial part of the sum: @c{$\ln z - {1 \over 2z}$}
9432 minus the adjustment factor.
9436 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743
9437 1: 0.0833333333333 1: 2.28333333333 .
9444 Now we evaluate the series. We'll use another ``for'' loop counting
9445 up the value of @cite{2 n}. (Calc does have a summation command,
9446 @kbd{a +}, but we'll use loops just to get more practice with them.)
9450 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749
9451 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3
9456 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9463 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892
9464 2: -0.5749 2: -0.5772 1: 0 .
9465 1: 2.3148e-3 1: -0.5749 .
9468 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x )
9472 This is the value of @c{$-\gamma$}
9473 @cite{- gamma}, with a slight bit of roundoff error.
9474 To get a full 12 digits, let's use a higher precision:
9478 2: -0.577215664892 2: -0.577215664892
9479 1: 1. 1: -0.577215664901532
9481 1. @key{RET} p 16 @key{RET} X
9485 Here's the complete sequence of keystrokes:
9490 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9492 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9493 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
9500 @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
9501 @subsection Programming Tutorial Exercise 10
9504 Taking the derivative of a term of the form @cite{x^n} will produce
9505 a term like @c{$n x^{n-1}$}
9506 @cite{n x^(n-1)}. Taking the derivative of a constant
9507 produces zero. From this it is easy to see that the @cite{n}th
9508 derivative of a polynomial, evaluated at @cite{x = 0}, will equal the
9509 coefficient on the @cite{x^n} term times @cite{n!}.
9511 (Because this definition is long, it will be repeated in concise form
9512 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9513 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9514 keystrokes without executing them. In the following diagrams we'll
9515 pretend Calc actually executed the keystrokes as you typed them,
9516 just for purposes of illustration.)
9520 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2
9525 ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB}
9530 Variable 1 will accumulate the vector of coefficients.
9534 2: 0 3: 0 2: 5 x^4 + ...
9535 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1
9539 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9544 Note that @kbd{s | 1} appends the top-of-stack value to the vector
9545 in a variable; it is completely analogous to @kbd{s + 1}. We could
9546 have written instead, @kbd{r 1 @key{TAB} | t 1}.
9550 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0]
9553 a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x )
9557 To convert back, a simple method is just to map the coefficients
9558 against a table of powers of @cite{x}.
9562 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0]
9563 1: 6 1: [0, 1, 2, 3, 4, 5, 6]
9566 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x
9573 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4
9574 1: [1, x, x^2, x^3, ... ] .
9577 ' x @key{RET} @key{TAB} V M ^ *
9581 Once again, here are the whole polynomial to/from vector programs:
9585 C-x ( Z ` [ ] t 1 0 @key{TAB}
9586 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9592 C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x )
9596 @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
9597 @subsection Programming Tutorial Exercise 11
9600 First we define a dummy program to go on the @kbd{z s} key. The true
9601 @w{@kbd{z s}} key is supposed to take two numbers from the stack and
9602 return one number, so @key{DEL} as a dummy definition will make
9603 sure the stack comes out right.
9611 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2
9615 The last step replaces the 2 that was eaten during the creation
9616 of the dummy @kbd{z s} command. Now we move on to the real
9617 definition. The recurrence needs to be rewritten slightly,
9618 to the form @cite{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
9620 (Because this definition is long, it will be repeated in concise form
9621 below. You can use @kbd{M-# m} to load it from there.)
9631 C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z :
9638 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3
9639 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2
9640 2: 2 . . 2: 3 2: 3 1: 3
9644 @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9649 (Note that the value 3 that our dummy @kbd{z s} produces is not correct;
9650 it is merely a placeholder that will do just as well for now.)
9654 3: 3 4: 3 3: 3 2: 3 1: -6
9655 2: 3 3: 3 2: 3 1: 9 .
9660 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9667 1: -6 2: 4 1: 11 2: 11
9671 Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s
9675 Even though the result that we got during the definition was highly
9676 bogus, once the definition is complete the @kbd{z s} command gets
9679 Here's the full program once again:
9683 C-x ( M-2 @key{RET} a =
9684 Z [ @key{DEL} @key{DEL} 1
9686 Z [ @key{DEL} @key{DEL} 0
9687 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9688 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9695 You can read this definition using @kbd{M-# m} (@code{read-kbd-macro})
9696 followed by @kbd{Z K s}, without having to make a dummy definition
9697 first, because @code{read-kbd-macro} doesn't need to execute the
9698 definition as it reads it in. For this reason, @code{M-# m} is often
9699 the easiest way to create recursive programs in Calc.
9701 @node Programming Answer 12, , Programming Answer 11, Answers to Exercises
9702 @subsection Programming Tutorial Exercise 12
9705 This turns out to be a much easier way to solve the problem. Let's
9706 denote Stirling numbers as calls of the function @samp{s}.
9708 First, we store the rewrite rules corresponding to the definition of
9709 Stirling numbers in a convenient variable:
9712 s e StirlingRules @key{RET}
9713 [ s(n,n) := 1 :: n >= 0,
9714 s(n,0) := 0 :: n > 0,
9715 s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
9719 Now, it's just a matter of applying the rules:
9723 2: 4 1: s(4, 2) 1: 11
9727 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x )
9731 As in the case of the @code{fib} rules, it would be useful to put these
9732 rules in @code{EvalRules} and to add a @samp{:: remember} condition to
9735 @c This ends the table-of-contents kludge from above:
9737 \global\let\chapternofonts=\oldchapternofonts
9742 @node Introduction, Data Types, Tutorial, Top
9743 @chapter Introduction
9746 This chapter is the beginning of the Calc reference manual.
9747 It covers basic concepts such as the stack, algebraic and
9748 numeric entry, undo, numeric prefix arguments, etc.
9751 @c (Chapter 2, the Tutorial, has been printed in a separate volume.)
9759 * Quick Calculator::
9761 * Prefix Arguments::
9764 * Multiple Calculators::
9765 * Troubleshooting Commands::
9768 @node Basic Commands, Help Commands, Introduction, Introduction
9769 @section Basic Commands
9774 @cindex Starting the Calculator
9775 @cindex Running the Calculator
9776 To start the Calculator in its standard interface, type @kbd{M-x calc}.
9777 By default this creates a pair of small windows, @samp{*Calculator*}
9778 and @samp{*Calc Trail*}. The former displays the contents of the
9779 Calculator stack and is manipulated exclusively through Calc commands.
9780 It is possible (though not usually necessary) to create several Calc
9781 Mode buffers each of which has an independent stack, undo list, and
9782 mode settings. There is exactly one Calc Trail buffer; it records a
9783 list of the results of all calculations that have been done. The
9784 Calc Trail buffer uses a variant of Calc Mode, so Calculator commands
9785 still work when the trail buffer's window is selected. It is possible
9786 to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
9787 still exists and is updated silently. @xref{Trail Commands}.@refill
9795 In most installations, the @kbd{M-# c} key sequence is a more
9796 convenient way to start the Calculator. Also, @kbd{M-# M-#} and
9797 @kbd{M-# #} are synonyms for @kbd{M-# c} unless you last used Calc
9798 in its ``keypad'' mode.
9802 @pindex calc-execute-extended-command
9803 Most Calc commands use one or two keystrokes. Lower- and upper-case
9804 letters are distinct. Commands may also be entered in full @kbd{M-x} form;
9805 for some commands this is the only form. As a convenience, the @kbd{x}
9806 key (@code{calc-execute-extended-command})
9807 is like @kbd{M-x} except that it enters the initial string @samp{calc-}
9808 for you. For example, the following key sequences are equivalent:
9809 @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.@refill
9811 @cindex Extensions module
9812 @cindex @file{calc-ext} module
9813 The Calculator exists in many parts. When you type @kbd{M-# c}, the
9814 Emacs ``auto-load'' mechanism will bring in only the first part, which
9815 contains the basic arithmetic functions. The other parts will be
9816 auto-loaded the first time you use the more advanced commands like trig
9817 functions or matrix operations. This is done to improve the response time
9818 of the Calculator in the common case when all you need to do is a
9819 little arithmetic. If for some reason the Calculator fails to load an
9820 extension module automatically, you can force it to load all the
9821 extensions by using the @kbd{M-# L} (@code{calc-load-everything})
9822 command. @xref{Mode Settings}.@refill
9824 If you type @kbd{M-x calc} or @kbd{M-# c} with any numeric prefix argument,
9825 the Calculator is loaded if necessary, but it is not actually started.
9826 If the argument is positive, the @file{calc-ext} extensions are also
9827 loaded if necessary. User-written Lisp code that wishes to make use
9828 of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
9829 to auto-load the Calculator.@refill
9833 If you type @kbd{M-# b}, then next time you use @kbd{M-# c} you
9834 will get a Calculator that uses the full height of the Emacs screen.
9835 When full-screen mode is on, @kbd{M-# c} runs the @code{full-calc}
9836 command instead of @code{calc}. From the Unix shell you can type
9837 @samp{emacs -f full-calc} to start a new Emacs specifically for use
9838 as a calculator. When Calc is started from the Emacs command line
9839 like this, Calc's normal ``quit'' commands actually quit Emacs itself.
9842 @pindex calc-other-window
9843 The @kbd{M-# o} command is like @kbd{M-# c} except that the Calc
9844 window is not actually selected. If you are already in the Calc
9845 window, @kbd{M-# o} switches you out of it. (The regular Emacs
9846 @kbd{C-x o} command would also work for this, but it has a
9847 tendency to drop you into the Calc Trail window instead, which
9848 @kbd{M-# o} takes care not to do.)
9853 For one quick calculation, you can type @kbd{M-# q} (@code{quick-calc})
9854 which prompts you for a formula (like @samp{2+3/4}). The result is
9855 displayed at the bottom of the Emacs screen without ever creating
9856 any special Calculator windows. @xref{Quick Calculator}.
9861 Finally, if you are using the X window system you may want to try
9862 @kbd{M-# k} (@code{calc-keypad}) which runs Calc with a
9863 ``calculator keypad'' picture as well as a stack display. Click on
9864 the keys with the mouse to operate the calculator. @xref{Keypad Mode}.
9868 @cindex Quitting the Calculator
9869 @cindex Exiting the Calculator
9870 The @kbd{q} key (@code{calc-quit}) exits Calc Mode and closes the
9871 Calculator's window(s). It does not delete the Calculator buffers.
9872 If you type @kbd{M-x calc} again, the Calculator will reappear with the
9873 contents of the stack intact. Typing @kbd{M-# c} or @kbd{M-# M-#}
9874 again from inside the Calculator buffer is equivalent to executing
9875 @code{calc-quit}; you can think of @kbd{M-# M-#} as toggling the
9876 Calculator on and off.@refill
9879 The @kbd{M-# x} command also turns the Calculator off, no matter which
9880 user interface (standard, Keypad, or Embedded) is currently active.
9881 It also cancels @code{calc-edit} mode if used from there.
9884 @pindex calc-refresh
9885 @cindex Refreshing a garbled display
9886 @cindex Garbled displays, refreshing
9887 The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
9888 of the Calculator buffer from memory. Use this if the contents of the
9889 buffer have been damaged somehow.
9894 The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
9895 ``home'' position at the bottom of the Calculator buffer.
9899 @pindex calc-scroll-left
9900 @pindex calc-scroll-right
9901 @cindex Horizontal scrolling
9903 @cindex Wide text, scrolling
9904 The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
9905 @code{calc-scroll-right}. These are just like the normal horizontal
9906 scrolling commands except that they scroll one half-screen at a time by
9907 default. (Calc formats its output to fit within the bounds of the
9908 window whenever it can.)@refill
9912 @pindex calc-scroll-down
9913 @pindex calc-scroll-up
9914 @cindex Vertical scrolling
9915 The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
9916 and @code{calc-scroll-up}. They scroll up or down by one-half the
9917 height of the Calc window.@refill
9921 The @kbd{M-# 0} command (@code{calc-reset}; that's @kbd{M-#} followed
9922 by a zero) resets the Calculator to its default state. This clears
9923 the stack, resets all the modes, clears the caches (@pxref{Caches}),
9924 and so on. (It does @emph{not} erase the values of any variables.)
9925 With a numeric prefix argument, @kbd{M-# 0} preserves the contents
9926 of the stack but resets everything else.
9928 @pindex calc-version
9929 The @kbd{M-x calc-version} command displays the current version number
9930 of Calc and the name of the person who installed it on your system.
9931 (This information is also present in the @samp{*Calc Trail*} buffer,
9932 and in the output of the @kbd{h h} command.)
9934 @node Help Commands, Stack Basics, Basic Commands, Introduction
9935 @section Help Commands
9938 @cindex Help commands
9941 The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
9942 Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
9943 @key{ESC} and @kbd{C-x} prefixes. You can type
9944 @kbd{?} after a prefix to see a list of commands beginning with that
9945 prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again
9946 to see additional commands for that prefix.)
9949 @pindex calc-full-help
9950 The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
9951 responses at once. When printed, this makes a nice, compact (three pages)
9952 summary of Calc keystrokes.
9954 In general, the @kbd{h} key prefix introduces various commands that
9955 provide help within Calc. Many of the @kbd{h} key functions are
9956 Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
9962 The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
9963 to read this manual on-line. This is basically the same as typing
9964 @kbd{C-h i} (the regular way to run the Info system), then, if Info
9965 is not already in the Calc manual, selecting the beginning of the
9966 manual. The @kbd{M-# i} command is another way to read the Calc
9967 manual; it is different from @kbd{h i} in that it works any time,
9968 not just inside Calc. The plain @kbd{i} key is also equivalent to
9969 @kbd{h i}, though this key is obsolete and may be replaced with a
9970 different command in a future version of Calc.
9974 @pindex calc-tutorial
9975 The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
9976 the Tutorial section of the Calc manual. It is like @kbd{h i},
9977 except that it selects the starting node of the tutorial rather
9978 than the beginning of the whole manual. (It actually selects the
9979 node ``Interactive Tutorial'' which tells a few things about
9980 using the Info system before going on to the actual tutorial.)
9981 The @kbd{M-# t} key is equivalent to @kbd{h t} (but it works at
9986 @pindex calc-info-summary
9987 The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
9988 on the Summary node of the Calc manual. @xref{Summary}. The @kbd{M-# s}
9989 key is equivalent to @kbd{h s}.
9992 @pindex calc-describe-key
9993 The @kbd{h k} (@code{calc-describe-key}) command looks up a key
9994 sequence in the Calc manual. For example, @kbd{h k H a S} looks
9995 up the documentation on the @kbd{H a S} (@code{calc-solve-for})
9996 command. This works by looking up the textual description of
9997 the key(s) in the Key Index of the manual, then jumping to the
9998 node indicated by the index.
10000 Most Calc commands do not have traditional Emacs documentation
10001 strings, since the @kbd{h k} command is both more convenient and
10002 more instructive. This means the regular Emacs @kbd{C-h k}
10003 (@code{describe-key}) command will not be useful for Calc keystrokes.
10006 @pindex calc-describe-key-briefly
10007 The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
10008 key sequence and displays a brief one-line description of it at
10009 the bottom of the screen. It looks for the key sequence in the
10010 Summary node of the Calc manual; if it doesn't find the sequence
10011 there, it acts just like its regular Emacs counterpart @kbd{C-h c}
10012 (@code{describe-key-briefly}). For example, @kbd{h c H a S}
10013 gives the description:
10016 H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes)
10020 which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
10021 takes a value @cite{a} from the stack, prompts for a value @cite{v},
10022 then applies the algebraic function @code{fsolve} to these values.
10023 The @samp{?=notes} message means you can now type @kbd{?} to see
10024 additional notes from the summary that apply to this command.
10027 @pindex calc-describe-function
10028 The @kbd{h f} (@code{calc-describe-function}) command looks up an
10029 algebraic function or a command name in the Calc manual. The
10030 prompt initially contains @samp{calcFunc-}; follow this with an
10031 algebraic function name to look up that function in the Function
10032 Index. Or, backspace and enter a command name beginning with
10033 @samp{calc-} to look it up in the Command Index. This command
10034 will also look up operator symbols that can appear in algebraic
10035 formulas, like @samp{%} and @samp{=>}.
10038 @pindex calc-describe-variable
10039 The @kbd{h v} (@code{calc-describe-variable}) command looks up a
10040 variable in the Calc manual. The prompt initially contains the
10041 @samp{var-} prefix; just add a variable name like @code{pi} or
10042 @code{PlotRejects}.
10045 @pindex describe-bindings
10046 The @kbd{h b} (@code{calc-describe-bindings}) command is just like
10047 @kbd{C-h b}, except that only local (Calc-related) key bindings are
10051 The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
10052 the ``news'' or change history of Calc. This is kept in the file
10053 @file{README}, which Calc looks for in the same directory as the Calc
10059 The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
10060 distribution, and warranty information about Calc. These work by
10061 pulling up the appropriate parts of the ``Copying'' or ``Reporting
10062 Bugs'' sections of the manual.
10064 @node Stack Basics, Numeric Entry, Help Commands, Introduction
10065 @section Stack Basics
10068 @cindex Stack basics
10069 @c [fix-tut RPN Calculations and the Stack]
10070 Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN
10073 To add the numbers 1 and 2 in Calc you would type the keys:
10074 @kbd{1 @key{RET} 2 +}.
10075 (@key{RET} corresponds to the @key{ENTER} key on most calculators.)
10076 The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The
10077 @kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
10078 and pushes the result (3) back onto the stack. This number is ready for
10079 further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the
10080 3 and 5, subtracts them, and pushes the result (@i{-2}).@refill
10082 Note that the ``top'' of the stack actually appears at the @emph{bottom}
10083 of the buffer. A line containing a single @samp{.} character signifies
10084 the end of the buffer; Calculator commands operate on the number(s)
10085 directly above this line. The @kbd{d t} (@code{calc-truncate-stack})
10086 command allows you to move the @samp{.} marker up and down in the stack;
10087 @pxref{Truncating the Stack}.
10090 @pindex calc-line-numbering
10091 Stack elements are numbered consecutively, with number 1 being the top of
10092 the stack. These line numbers are ordinarily displayed on the lefthand side
10093 of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls
10094 whether these numbers appear. (Line numbers may be turned off since they
10095 slow the Calculator down a bit and also clutter the display.)
10098 @pindex calc-realign
10099 The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
10100 the cursor to its top-of-stack ``home'' position. It also undoes any
10101 horizontal scrolling in the window. If you give it a numeric prefix
10102 argument, it instead moves the cursor to the specified stack element.
10104 The @key{RET} (or equivalent @key{SPC}) key is only required to separate
10105 two consecutive numbers.
10106 (After all, if you typed @kbd{1 2} by themselves the Calculator
10107 would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not}
10108 right after typing a number, the key duplicates the number on the top of
10109 the stack. @kbd{@key{RET} *} is thus a handy way to square a number.@refill
10111 The @key{DEL} key pops and throws away the top number on the stack.
10112 The @key{TAB} key swaps the top two objects on the stack.
10113 @xref{Stack and Trail}, for descriptions of these and other stack-related
10116 @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
10117 @section Numeric Entry
10123 @cindex Numeric entry
10124 @cindex Entering numbers
10125 Pressing a digit or other numeric key begins numeric entry using the
10126 minibuffer. The number is pushed on the stack when you press the @key{RET}
10127 or @key{SPC} keys. If you press any other non-numeric key, the number is
10128 pushed onto the stack and the appropriate operation is performed. If
10129 you press a numeric key which is not valid, the key is ignored.
10131 @cindex Minus signs
10132 @cindex Negative numbers, entering
10134 There are three different concepts corresponding to the word ``minus,''
10135 typified by @cite{a-b} (subtraction), @cite{-x}
10136 (change-sign), and @cite{-5} (negative number). Calc uses three
10137 different keys for these operations, respectively:
10138 @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts
10139 the two numbers on the top of the stack. The @kbd{n} key changes the sign
10140 of the number on the top of the stack or the number currently being entered.
10141 The @kbd{_} key begins entry of a negative number or changes the sign of
10142 the number currently being entered. The following sequences all enter the
10143 number @i{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
10144 @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.@refill
10146 Some other keys are active during numeric entry, such as @kbd{#} for
10147 non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
10148 These notations are described later in this manual with the corresponding
10149 data types. @xref{Data Types}.
10151 During numeric entry, the only editing key available is @key{DEL}.
10153 @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
10154 @section Algebraic Entry
10158 @pindex calc-algebraic-entry
10159 @cindex Algebraic notation
10160 @cindex Formulas, entering
10161 Calculations can also be entered in algebraic form. This is accomplished
10162 by typing the apostrophe key, @kbd{'}, followed by the expression in
10163 standard format: @kbd{@key{'} 2+3*4 @key{RET}} computes
10164 @c{$2+(3\times4) = 14$}
10165 @cite{2+(3*4) = 14} and pushes that on the stack. If you wish you can
10166 ignore the RPN aspect of Calc altogether and simply enter algebraic
10167 expressions in this way. You may want to use @key{DEL} every so often to
10168 clear previous results off the stack.@refill
10170 You can press the apostrophe key during normal numeric entry to switch
10171 the half-entered number into algebraic entry mode. One reason to do this
10172 would be to use the full Emacs cursor motion and editing keys, which are
10173 available during algebraic entry but not during numeric entry.
10175 In the same vein, during either numeric or algebraic entry you can
10176 press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
10177 you complete your half-finished entry in a separate buffer.
10178 @xref{Editing Stack Entries}.
10181 @pindex calc-algebraic-mode
10182 @cindex Algebraic mode
10183 If you prefer algebraic entry, you can use the command @kbd{m a}
10184 (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode,
10185 digits and other keys that would normally start numeric entry instead
10186 start full algebraic entry; as long as your formula begins with a digit
10187 you can omit the apostrophe. Open parentheses and square brackets also
10188 begin algebraic entry. You can still do RPN calculations in this mode,
10189 but you will have to press @key{RET} to terminate every number:
10190 @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
10191 thing as @kbd{2*3+4 @key{RET}}.@refill
10193 @cindex Incomplete algebraic mode
10194 If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
10195 command, it enables Incomplete Algebraic mode; this is like regular
10196 Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
10197 only. Numeric keys still begin a numeric entry in this mode.
10200 @pindex calc-total-algebraic-mode
10201 @cindex Total algebraic mode
10202 The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
10203 stronger algebraic-entry mode, in which @emph{all} regular letter and
10204 punctuation keys begin algebraic entry. Use this if you prefer typing
10205 @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
10206 @kbd{a f}, and so on. To type regular Calc commands when you are in
10207 ``total'' algebraic mode, hold down the @key{META} key. Thus @kbd{M-q}
10208 is the command to quit Calc, @kbd{M-p} sets the precision, and
10209 @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns total algebraic
10210 mode back off again. Meta keys also terminate algebraic entry, so
10211 that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol
10212 @samp{Alg*} will appear in the mode line whenever you are in this mode.
10214 Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
10215 algebraic formula. You can then use the normal Emacs editing keys to
10216 modify this formula to your liking before pressing @key{RET}.
10219 @cindex Formulas, referring to stack
10220 Within a formula entered from the keyboard, the symbol @kbd{$}
10221 represents the number on the top of the stack. If an entered formula
10222 contains any @kbd{$} characters, the Calculator replaces the top of
10223 stack with that formula rather than simply pushing the formula onto the
10224 stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
10225 @key{RET}} replaces it with 6. Note that the @kbd{$} key always
10226 initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
10227 first character in the new formula.@refill
10229 Higher stack elements can be accessed from an entered formula with the
10230 symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements
10231 removed (to be replaced by the entered values) equals the number of dollar
10232 signs in the longest such symbol in the formula. For example, @samp{$$+$$$}
10233 adds the second and third stack elements, replacing the top three elements
10234 with the answer. (All information about the top stack element is thus lost
10235 since no single @samp{$} appears in this formula.)@refill
10237 A slightly different way to refer to stack elements is with a dollar
10238 sign followed by a number: @samp{$1}, @samp{$2}, and so on are much
10239 like @samp{$}, @samp{$$}, etc., except that stack entries referred
10240 to numerically are not replaced by the algebraic entry. That is, while
10241 @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
10242 on the stack and pushes an additional 6.
10244 If a sequence of formulas are entered separated by commas, each formula
10245 is pushed onto the stack in turn. For example, @samp{1,2,3} pushes
10246 those three numbers onto the stack (leaving the 3 at the top), and
10247 @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also,
10248 @samp{$,$$} exchanges the top two elements of the stack, just like the
10251 You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
10252 of @key{RET}. This uses @kbd{=} to evaluate the variables in each
10253 formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes
10254 the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
10256 If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
10257 instead of @key{RET}, Calc disables the default simplifications
10258 (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
10259 is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3
10260 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @cite{1+2};
10261 you might then press @kbd{=} when it is time to evaluate this formula.
10263 @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
10264 @section ``Quick Calculator'' Mode
10269 @cindex Quick Calculator
10270 There is another way to invoke the Calculator if all you need to do
10271 is make one or two quick calculations. Type @kbd{M-# q} (or
10272 @kbd{M-x quick-calc}), then type any formula as an algebraic entry.
10273 The Calculator will compute the result and display it in the echo
10274 area, without ever actually putting up a Calc window.
10276 You can use the @kbd{$} character in a Quick Calculator formula to
10277 refer to the previous Quick Calculator result. Older results are
10278 not retained; the Quick Calculator has no effect on the full
10279 Calculator's stack or trail. If you compute a result and then
10280 forget what it was, just run @code{M-# q} again and enter
10281 @samp{$} as the formula.
10283 If this is the first time you have used the Calculator in this Emacs
10284 session, the @kbd{M-# q} command will create the @code{*Calculator*}
10285 buffer and perform all the usual initializations; it simply will
10286 refrain from putting that buffer up in a new window. The Quick
10287 Calculator refers to the @code{*Calculator*} buffer for all mode
10288 settings. Thus, for example, to set the precision that the Quick
10289 Calculator uses, simply run the full Calculator momentarily and use
10290 the regular @kbd{p} command.
10292 If you use @code{M-# q} from inside the Calculator buffer, the
10293 effect is the same as pressing the apostrophe key (algebraic entry).
10295 The result of a Quick calculation is placed in the Emacs ``kill ring''
10296 as well as being displayed. A subsequent @kbd{C-y} command will
10297 yank the result into the editing buffer. You can also use this
10298 to yank the result into the next @kbd{M-# q} input line as a more
10299 explicit alternative to @kbd{$} notation, or to yank the result
10300 into the Calculator stack after typing @kbd{M-# c}.
10302 If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
10303 of @key{RET}, the result is inserted immediately into the current
10304 buffer rather than going into the kill ring.
10306 Quick Calculator results are actually evaluated as if by the @kbd{=}
10307 key (which replaces variable names by their stored values, if any).
10308 If the formula you enter is an assignment to a variable using the
10309 @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
10310 then the result of the evaluation is stored in that Calc variable.
10311 @xref{Store and Recall}.
10313 If the result is an integer and the current display radix is decimal,
10314 the number will also be displayed in hex and octal formats. If the
10315 integer is in the range from 1 to 126, it will also be displayed as
10316 an ASCII character.
10318 For example, the quoted character @samp{"x"} produces the vector
10319 result @samp{[120]} (because 120 is the ASCII code of the lower-case
10320 `x'; @pxref{Strings}). Since this is a vector, not an integer, it
10321 is displayed only according to the current mode settings. But
10322 running Quick Calc again and entering @samp{120} will produce the
10323 result @samp{120 (16#78, 8#170, x)} which shows the number in its
10324 decimal, hexadecimal, octal, and ASCII forms.
10326 Please note that the Quick Calculator is not any faster at loading
10327 or computing the answer than the full Calculator; the name ``quick''
10328 merely refers to the fact that it's much less hassle to use for
10329 small calculations.
10331 @node Prefix Arguments, Undo, Quick Calculator, Introduction
10332 @section Numeric Prefix Arguments
10335 Many Calculator commands use numeric prefix arguments. Some, such as
10336 @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
10337 the prefix argument or use a default if you don't use a prefix.
10338 Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
10339 and prompt for a number if you don't give one as a prefix.@refill
10341 As a rule, stack-manipulation commands accept a numeric prefix argument
10342 which is interpreted as an index into the stack. A positive argument
10343 operates on the top @var{n} stack entries; a negative argument operates
10344 on the @var{n}th stack entry in isolation; and a zero argument operates
10345 on the entire stack.
10347 Most commands that perform computations (such as the arithmetic and
10348 scientific functions) accept a numeric prefix argument that allows the
10349 operation to be applied across many stack elements. For unary operations
10350 (that is, functions of one argument like absolute value or complex
10351 conjugate), a positive prefix argument applies that function to the top
10352 @var{n} stack entries simultaneously, and a negative argument applies it
10353 to the @var{n}th stack entry only. For binary operations (functions of
10354 two arguments like addition, GCD, and vector concatenation), a positive
10355 prefix argument ``reduces'' the function across the top @var{n}
10356 stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
10357 @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
10358 @var{n} stack elements with the top stack element as a second argument
10359 (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
10360 This feature is not available for operations which use the numeric prefix
10361 argument for some other purpose.
10363 Numeric prefixes are specified the same way as always in Emacs: Press
10364 a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
10365 or press @kbd{C-u} followed by digits. Some commands treat plain
10366 @kbd{C-u} (without any actual digits) specially.@refill
10369 @pindex calc-num-prefix
10370 You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
10371 top of the stack and enter it as the numeric prefix for the next command.
10372 For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
10373 (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
10374 to the fourth power and set the precision to that value.@refill
10376 Conversely, if you have typed a numeric prefix argument the @kbd{~} key
10377 pushes it onto the stack in the form of an integer.
10379 @node Undo, Error Messages, Prefix Arguments, Introduction
10380 @section Undoing Mistakes
10386 @cindex Mistakes, undoing
10387 @cindex Undoing mistakes
10388 @cindex Errors, undoing
10389 The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
10390 If that operation added or dropped objects from the stack, those objects
10391 are removed or restored. If it was a ``store'' operation, you are
10392 queried whether or not to restore the variable to its original value.
10393 The @kbd{U} key may be pressed any number of times to undo successively
10394 farther back in time; with a numeric prefix argument it undoes a
10395 specified number of operations. The undo history is cleared only by the
10396 @kbd{q} (@code{calc-quit}) command. (Recall that @kbd{M-# c} is
10397 synonymous with @code{calc-quit} while inside the Calculator; this
10398 also clears the undo history.)
10400 Currently the mode-setting commands (like @code{calc-precision}) are not
10401 undoable. You can undo past a point where you changed a mode, but you
10402 will need to reset the mode yourself.
10406 @cindex Redoing after an Undo
10407 The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
10408 mistakenly undone. Pressing @kbd{U} with a negative prefix argument is
10409 equivalent to executing @code{calc-redo}. You can redo any number of
10410 times, up to the number of recent consecutive undo commands. Redo
10411 information is cleared whenever you give any command that adds new undo
10412 information, i.e., if you undo, then enter a number on the stack or make
10413 any other change, then it will be too late to redo.
10415 @kindex M-@key{RET}
10416 @pindex calc-last-args
10417 @cindex Last-arguments feature
10418 @cindex Arguments, restoring
10419 The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
10420 it restores the arguments of the most recent command onto the stack;
10421 however, it does not remove the result of that command. Given a numeric
10422 prefix argument, this command applies to the @cite{n}th most recent
10423 command which removed items from the stack; it pushes those items back
10426 The @kbd{K} (@code{calc-keep-args}) command provides a related function
10427 to @kbd{M-@key{RET}}. @xref{Stack and Trail}.
10429 It is also possible to recall previous results or inputs using the trail.
10430 @xref{Trail Commands}.
10432 The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
10434 @node Error Messages, Multiple Calculators, Undo, Introduction
10435 @section Error Messages
10440 @cindex Errors, messages
10441 @cindex Why did an error occur?
10442 Many situations that would produce an error message in other calculators
10443 simply create unsimplified formulas in the Emacs Calculator. For example,
10444 @kbd{1 @key{RET} 0 /} pushes the formula @cite{1 / 0}; @w{@kbd{0 L}} pushes
10445 the formula @samp{ln(0)}. Floating-point overflow and underflow are also
10446 reasons for this to happen.
10448 When a function call must be left in symbolic form, Calc usually
10449 produces a message explaining why. Messages that are probably
10450 surprising or indicative of user errors are displayed automatically.
10451 Other messages are simply kept in Calc's memory and are displayed only
10452 if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if
10453 the same computation results in several messages. (The first message
10454 will end with @samp{[w=more]} in this case.)
10457 @pindex calc-auto-why
10458 The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
10459 are displayed automatically. (Calc effectively presses @kbd{w} for you
10460 after your computation finishes.) By default, this occurs only for
10461 ``important'' messages. The other possible modes are to report
10462 @emph{all} messages automatically, or to report none automatically (so
10463 that you must always press @kbd{w} yourself to see the messages).
10465 @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
10466 @section Multiple Calculators
10469 @pindex another-calc
10470 It is possible to have any number of Calc Mode buffers at once.
10471 Usually this is done by executing @kbd{M-x another-calc}, which
10472 is similar to @kbd{M-# c} except that if a @samp{*Calculator*}
10473 buffer already exists, a new, independent one with a name of the
10474 form @samp{*Calculator*<@var{n}>} is created. You can also use the
10475 command @code{calc-mode} to put any buffer into Calculator mode, but
10476 this would ordinarily never be done.
10478 The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
10479 it only closes its window. Use @kbd{M-x kill-buffer} to destroy a
10482 Each Calculator buffer keeps its own stack, undo list, and mode settings
10483 such as precision, angular mode, and display formats. In Emacs terms,
10484 variables such as @code{calc-stack} are buffer-local variables. The
10485 global default values of these variables are used only when a new
10486 Calculator buffer is created. The @code{calc-quit} command saves
10487 the stack and mode settings of the buffer being quit as the new defaults.
10489 There is only one trail buffer, @samp{*Calc Trail*}, used by all
10490 Calculator buffers.
10492 @node Troubleshooting Commands, , Multiple Calculators, Introduction
10493 @section Troubleshooting Commands
10496 This section describes commands you can use in case a computation
10497 incorrectly fails or gives the wrong answer.
10499 @xref{Reporting Bugs}, if you find a problem that appears to be due
10500 to a bug or deficiency in Calc.
10503 * Autoloading Problems::
10504 * Recursion Depth::
10509 @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
10510 @subsection Autoloading Problems
10513 The Calc program is split into many component files; components are
10514 loaded automatically as you use various commands that require them.
10515 Occasionally Calc may lose track of when a certain component is
10516 necessary; typically this means you will type a command and it won't
10517 work because some function you've never heard of was undefined.
10520 @pindex calc-load-everything
10521 If this happens, the easiest workaround is to type @kbd{M-# L}
10522 (@code{calc-load-everything}) to force all the parts of Calc to be
10523 loaded right away. This will cause Emacs to take up a lot more
10524 memory than it would otherwise, but it's guaranteed to fix the problem.
10526 If you seem to run into this problem no matter what you do, or if
10527 even the @kbd{M-# L} command crashes, Calc may have been improperly
10528 installed. @xref{Installation}, for details of the installation
10531 @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
10532 @subsection Recursion Depth
10537 @pindex calc-more-recursion-depth
10538 @pindex calc-less-recursion-depth
10539 @cindex Recursion depth
10540 @cindex ``Computation got stuck'' message
10541 @cindex @code{max-lisp-eval-depth}
10542 @cindex @code{max-specpdl-size}
10543 Calc uses recursion in many of its calculations. Emacs Lisp keeps a
10544 variable @code{max-lisp-eval-depth} which limits the amount of recursion
10545 possible in an attempt to recover from program bugs. If a calculation
10546 ever halts incorrectly with the message ``Computation got stuck or
10547 ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
10548 to increase this limit. (Of course, this will not help if the
10549 calculation really did get stuck due to some problem inside Calc.)@refill
10551 The limit is always increased (multiplied) by a factor of two. There
10552 is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
10553 decreases this limit by a factor of two, down to a minimum value of 200.
10554 The default value is 1000.
10556 These commands also double or halve @code{max-specpdl-size}, another
10557 internal Lisp recursion limit. The minimum value for this limit is 600.
10559 @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
10564 @cindex Flushing caches
10565 Calc saves certain values after they have been computed once. For
10566 example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
10568 @cite{pi} to about 20 decimal places; if the current precision
10569 is greater than this, it will recompute @c{$\pi$}
10570 @cite{pi} using a series
10571 approximation. This value will not need to be recomputed ever again
10572 unless you raise the precision still further. Many operations such as
10573 logarithms and sines make use of similarly cached values such as
10575 @cite{pi/4} and @c{$\ln 2$}
10576 @cite{ln(2)}. The visible effect of caching is that
10577 high-precision computations may seem to do extra work the first time.
10578 Other things cached include powers of two (for the binary arithmetic
10579 functions), matrix inverses and determinants, symbolic integrals, and
10580 data points computed by the graphing commands.
10582 @pindex calc-flush-caches
10583 If you suspect a Calculator cache has become corrupt, you can use the
10584 @code{calc-flush-caches} command to reset all caches to the empty state.
10585 (This should only be necessary in the event of bugs in the Calculator.)
10586 The @kbd{M-# 0} (with the zero key) command also resets caches along
10587 with all other aspects of the Calculator's state.
10589 @node Debugging Calc, , Caches, Troubleshooting Commands
10590 @subsection Debugging Calc
10593 A few commands exist to help in the debugging of Calc commands.
10594 @xref{Programming}, to see the various ways that you can write
10595 your own Calc commands.
10598 @pindex calc-timing
10599 The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
10600 in which the timing of slow commands is reported in the Trail.
10601 Any Calc command that takes two seconds or longer writes a line
10602 to the Trail showing how many seconds it took. This value is
10603 accurate only to within one second.
10605 All steps of executing a command are included; in particular, time
10606 taken to format the result for display in the stack and trail is
10607 counted. Some prompts also count time taken waiting for them to
10608 be answered, while others do not; this depends on the exact
10609 implementation of the command. For best results, if you are timing
10610 a sequence that includes prompts or multiple commands, define a
10611 keyboard macro to run the whole sequence at once. Calc's @kbd{X}
10612 command (@pxref{Keyboard Macros}) will then report the time taken
10613 to execute the whole macro.
10615 Another advantage of the @kbd{X} command is that while it is
10616 executing, the stack and trail are not updated from step to step.
10617 So if you expect the output of your test sequence to leave a result
10618 that may take a long time to format and you don't wish to count
10619 this formatting time, end your sequence with a @key{DEL} keystroke
10620 to clear the result from the stack. When you run the sequence with
10621 @kbd{X}, Calc will never bother to format the large result.
10623 Another thing @kbd{Z T} does is to increase the Emacs variable
10624 @code{gc-cons-threshold} to a much higher value (two million; the
10625 usual default in Calc is 250,000) for the duration of each command.
10626 This generally prevents garbage collection during the timing of
10627 the command, though it may cause your Emacs process to grow
10628 abnormally large. (Garbage collection time is a major unpredictable
10629 factor in the timing of Emacs operations.)
10631 Another command that is useful when debugging your own Lisp
10632 extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
10633 the error handler that changes the ``@code{max-lisp-eval-depth}
10634 exceeded'' message to the much more friendly ``Computation got
10635 stuck or ran too long.'' This handler interferes with the Emacs
10636 Lisp debugger's @code{debug-on-error} mode. Errors are reported
10637 in the handler itself rather than at the true location of the
10638 error. After you have executed @code{calc-pass-errors}, Lisp
10639 errors will be reported correctly but the user-friendly message
10642 @node Data Types, Stack and Trail, Introduction, Top
10643 @chapter Data Types
10646 This chapter discusses the various types of objects that can be placed
10647 on the Calculator stack, how they are displayed, and how they are
10648 entered. (@xref{Data Type Formats}, for information on how these data
10649 types are represented as underlying Lisp objects.)@refill
10651 Integers, fractions, and floats are various ways of describing real
10652 numbers. HMS forms also for many purposes act as real numbers. These
10653 types can be combined to form complex numbers, modulo forms, error forms,
10654 or interval forms. (But these last four types cannot be combined
10655 arbitrarily:@: error forms may not contain modulo forms, for example.)
10656 Finally, all these types of numbers may be combined into vectors,
10657 matrices, or algebraic formulas.
10660 * Integers:: The most basic data type.
10661 * Fractions:: This and above are called @dfn{rationals}.
10662 * Floats:: This and above are called @dfn{reals}.
10663 * Complex Numbers:: This and above are called @dfn{numbers}.
10665 * Vectors and Matrices::
10672 * Incomplete Objects::
10677 @node Integers, Fractions, Data Types, Data Types
10682 The Calculator stores integers to arbitrary precision. Addition,
10683 subtraction, and multiplication of integers always yields an exact
10684 integer result. (If the result of a division or exponentiation of
10685 integers is not an integer, it is expressed in fractional or
10686 floating-point form according to the current Fraction Mode.
10687 @xref{Fraction Mode}.)
10689 A decimal integer is represented as an optional sign followed by a
10690 sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to
10691 insert a comma at every third digit for display purposes, but you
10692 must not type commas during the entry of numbers.@refill
10695 A non-decimal integer is represented as an optional sign, a radix
10696 between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11
10697 and above, the letters A through Z (upper- or lower-case) count as
10698 digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how
10699 to set the default radix for display of integers. Numbers of any radix
10700 may be entered at any time. If you press @kbd{#} at the beginning of a
10701 number, the current display radix is used.@refill
10703 @node Fractions, Floats, Integers, Data Types
10708 A @dfn{fraction} is a ratio of two integers. Fractions are traditionally
10709 written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key
10710 performs RPN division; the following two sequences push the number
10711 @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
10712 assuming Fraction Mode has been enabled.)
10713 When the Calculator produces a fractional result it always reduces it to
10714 simplest form, which may in fact be an integer.@refill
10716 Fractions may also be entered in a three-part form, where @samp{2:3:4}
10717 represents two-and-three-quarters. @xref{Fraction Formats}, for fraction
10718 display formats.@refill
10720 Non-decimal fractions are entered and displayed as
10721 @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
10722 form). The numerator and denominator always use the same radix.@refill
10724 @node Floats, Complex Numbers, Fractions, Data Types
10728 @cindex Floating-point numbers
10729 A floating-point number or @dfn{float} is a number stored in scientific
10730 notation. The number of significant digits in the fractional part is
10731 governed by the current floating precision (@pxref{Precision}). The
10732 range of acceptable values is from @c{$10^{-3999999}$}
10733 @cite{10^-3999999} (inclusive)
10734 to @c{$10^{4000000}$}
10736 (exclusive), plus the corresponding negative
10739 Calculations that would exceed the allowable range of values (such
10740 as @samp{exp(exp(20))}) are left in symbolic form by Calc. The
10741 messages ``floating-point overflow'' or ``floating-point underflow''
10742 indicate that during the calculation a number would have been produced
10743 that was too large or too close to zero, respectively, to be represented
10744 by Calc. This does not necessarily mean the final result would have
10745 overflowed, just that an overflow occurred while computing the result.
10746 (In fact, it could report an underflow even though the final result
10747 would have overflowed!)
10749 If a rational number and a float are mixed in a calculation, the result
10750 will in general be expressed as a float. Commands that require an integer
10751 value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
10752 floats, i.e., floating-point numbers with nothing after the decimal point.
10754 Floats are identified by the presence of a decimal point and/or an
10755 exponent. In general a float consists of an optional sign, digits
10756 including an optional decimal point, and an optional exponent consisting
10757 of an @samp{e}, an optional sign, and up to seven exponent digits.
10758 For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
10761 Floating-point numbers are normally displayed in decimal notation with
10762 all significant figures shown. Exceedingly large or small numbers are
10763 displayed in scientific notation. Various other display options are
10764 available. @xref{Float Formats}.
10766 @cindex Accuracy of calculations
10767 Floating-point numbers are stored in decimal, not binary. The result
10768 of each operation is rounded to the nearest value representable in the
10769 number of significant digits specified by the current precision,
10770 rounding away from zero in the case of a tie. Thus (in the default
10771 display mode) what you see is exactly what you get. Some operations such
10772 as square roots and transcendental functions are performed with several
10773 digits of extra precision and then rounded down, in an effort to make the
10774 final result accurate to the full requested precision. However,
10775 accuracy is not rigorously guaranteed. If you suspect the validity of a
10776 result, try doing the same calculation in a higher precision. The
10777 Calculator's arithmetic is not intended to be IEEE-conformant in any
10780 While floats are always @emph{stored} in decimal, they can be entered
10781 and displayed in any radix just like integers and fractions. The
10782 notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point
10783 number whose digits are in the specified radix. Note that the @samp{.}
10784 is more aptly referred to as a ``radix point'' than as a decimal
10785 point in this case. The number @samp{8#123.4567} is defined as
10786 @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can use
10787 @samp{e} notation to write a non-decimal number in scientific notation.
10788 The exponent is written in decimal, and is considered to be a power
10789 of the radix: @samp{8#1234567e-4}. If the radix is 15 or above, the
10790 letter @samp{e} is a digit, so scientific notation must be written
10791 out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the
10792 Modes Tutorial explore some of the properties of non-decimal floats.
10794 @node Complex Numbers, Infinities, Floats, Data Types
10795 @section Complex Numbers
10798 @cindex Complex numbers
10799 There are two supported formats for complex numbers: rectangular and
10800 polar. The default format is rectangular, displayed in the form
10801 @samp{(@var{real},@var{imag})} where @var{real} is the real part and
10802 @var{imag} is the imaginary part, each of which may be any real number.
10803 Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
10804 notation; @pxref{Complex Formats}.@refill
10806 Polar complex numbers are displayed in the form `@t{(}@var{r}@t{;}@c{$\theta$}
10808 where @var{r} is the nonnegative magnitude and @c{$\theta$}
10809 @var{theta} is the argument
10810 or phase angle. The range of @c{$\theta$}
10811 @var{theta} depends on the current angular
10812 mode (@pxref{Angular Modes}); it is generally between @i{-180} and
10813 @i{+180} degrees or the equivalent range in radians.@refill
10815 Complex numbers are entered in stages using incomplete objects.
10816 @xref{Incomplete Objects}.
10818 Operations on rectangular complex numbers yield rectangular complex
10819 results, and similarly for polar complex numbers. Where the two types
10820 are mixed, or where new complex numbers arise (as for the square root of
10821 a negative real), the current @dfn{Polar Mode} is used to determine the
10822 type. @xref{Polar Mode}.
10824 A complex result in which the imaginary part is zero (or the phase angle
10825 is 0 or 180 degrees or @c{$\pi$}
10826 @cite{pi} radians) is automatically converted to a real
10829 @node Infinities, Vectors and Matrices, Complex Numbers, Data Types
10830 @section Infinities
10834 @cindex @code{inf} variable
10835 @cindex @code{uinf} variable
10836 @cindex @code{nan} variable
10840 The word @code{inf} represents the mathematical concept of @dfn{infinity}.
10841 Calc actually has three slightly different infinity-like values:
10842 @code{inf}, @code{uinf}, and @code{nan}. These are just regular
10843 variable names (@pxref{Variables}); you should avoid using these
10844 names for your own variables because Calc gives them special
10845 treatment. Infinities, like all variable names, are normally
10846 entered using algebraic entry.
10848 Mathematically speaking, it is not rigorously correct to treat
10849 ``infinity'' as if it were a number, but mathematicians often do
10850 so informally. When they say that @samp{1 / inf = 0}, what they
10851 really mean is that @cite{1 / x}, as @cite{x} becomes larger and
10852 larger, becomes arbitrarily close to zero. So you can imagine
10853 that if @cite{x} got ``all the way to infinity,'' then @cite{1 / x}
10854 would go all the way to zero. Similarly, when they say that
10855 @samp{exp(inf) = inf}, they mean that @c{$e^x$}
10856 @cite{exp(x)} grows without
10857 bound as @cite{x} grows. The symbol @samp{-inf} likewise stands
10858 for an infinitely negative real value; for example, we say that
10859 @samp{exp(-inf) = 0}. You can have an infinity pointing in any
10860 direction on the complex plane: @samp{sqrt(-inf) = i inf}.
10862 The same concept of limits can be used to define @cite{1 / 0}. We
10863 really want the value that @cite{1 / x} approaches as @cite{x}
10864 approaches zero. But if all we have is @cite{1 / 0}, we can't
10865 tell which direction @cite{x} was coming from. If @cite{x} was
10866 positive and decreasing toward zero, then we should say that
10867 @samp{1 / 0 = inf}. But if @cite{x} was negative and increasing
10868 toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @cite{x}
10869 could be an imaginary number, giving the answer @samp{i inf} or
10870 @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean
10871 @dfn{undirected infinity}, i.e., a value which is infinitely
10872 large but with an unknown sign (or direction on the complex plane).
10874 Calc actually has three modes that say how infinities are handled.
10875 Normally, infinities never arise from calculations that didn't
10876 already have them. Thus, @cite{1 / 0} is treated simply as an
10877 error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode})
10878 command (@pxref{Infinite Mode}) enables a mode in which
10879 @cite{1 / 0} evaluates to @code{uinf} instead. There is also
10880 an alternative type of infinite mode which says to treat zeros
10881 as if they were positive, so that @samp{1 / 0 = inf}. While this
10882 is less mathematically correct, it may be the answer you want in
10885 Since all infinities are ``as large'' as all others, Calc simplifies,
10886 e.g., @samp{5 inf} to @samp{inf}. Another example is
10887 @samp{5 - inf = -inf}, where the @samp{-inf} is so large that
10888 adding a finite number like five to it does not affect it.
10889 Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
10890 that variables like @code{a} always stand for finite quantities.
10891 Just to show that infinities really are all the same size,
10892 note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
10895 It's not so easy to define certain formulas like @samp{0 * inf} and
10896 @samp{inf / inf}. Depending on where these zeros and infinities
10897 came from, the answer could be literally anything. The latter
10898 formula could be the limit of @cite{x / x} (giving a result of one),
10899 or @cite{2 x / x} (giving two), or @cite{x^2 / x} (giving @code{inf}),
10900 or @cite{x / x^2} (giving zero). Calc uses the symbol @code{nan}
10901 to represent such an @dfn{indeterminate} value. (The name ``nan''
10902 comes from analogy with the ``NAN'' concept of IEEE standard
10903 arithmetic; it stands for ``Not A Number.'' This is somewhat of a
10904 misnomer, since @code{nan} @emph{does} stand for some number or
10905 infinity, it's just that @emph{which} number it stands for
10906 cannot be determined.) In Calc's notation, @samp{0 * inf = nan}
10907 and @samp{inf / inf = nan}. A few other common indeterminate
10908 expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also,
10909 @samp{0 / 0 = nan} if you have turned on ``infinite mode''
10910 (as described above).
10912 Infinities are especially useful as parts of @dfn{intervals}.
10913 @xref{Interval Forms}.
10915 @node Vectors and Matrices, Strings, Infinities, Data Types
10916 @section Vectors and Matrices
10920 @cindex Plain vectors
10922 The @dfn{vector} data type is flexible and general. A vector is simply a
10923 list of zero or more data objects. When these objects are numbers, the
10924 whole is a vector in the mathematical sense. When these objects are
10925 themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
10926 A vector which is not a matrix is referred to here as a @dfn{plain vector}.
10928 A vector is displayed as a list of values separated by commas and enclosed
10929 in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by
10930 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex
10931 numbers, are entered as incomplete objects. @xref{Incomplete Objects}.
10932 During algebraic entry, vectors are entered all at once in the usual
10933 brackets-and-commas form. Matrices may be entered algebraically as nested
10934 vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
10935 with rows separated by semicolons. The commas may usually be omitted
10936 when entering vectors: @samp{[1 2 3]}. Curly braces may be used in
10937 place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
10940 Traditional vector and matrix arithmetic is also supported;
10941 @pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
10942 Many other operations are applied to vectors element-wise. For example,
10943 the complex conjugate of a vector is a vector of the complex conjugates
10944 of its elements.@refill
10950 Algebraic functions for building vectors include @samp{vec(a, b, c)}
10951 to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an @c{$n\times m$}
10952 @asis{@var{n}x@var{m}}
10953 matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
10954 from 1 to @samp{n}.
10956 @node Strings, HMS Forms, Vectors and Matrices, Data Types
10962 @cindex Character strings
10963 Character strings are not a special data type in the Calculator.
10964 Rather, a string is represented simply as a vector all of whose
10965 elements are integers in the range 0 to 255 (ASCII codes). You can
10966 enter a string at any time by pressing the @kbd{"} key. Quotation
10967 marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
10968 inside strings. Other notations introduced by backslashes are:
10984 Finally, a backslash followed by three octal digits produces any
10985 character from its ASCII code.
10988 @pindex calc-display-strings
10989 Strings are normally displayed in vector-of-integers form. The
10990 @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
10991 which any vectors of small integers are displayed as quoted strings
10994 The backslash notations shown above are also used for displaying
10995 strings. Characters 128 and above are not translated by Calc; unless
10996 you have an Emacs modified for 8-bit fonts, these will show up in
10997 backslash-octal-digits notation. For characters below 32, and
10998 for character 127, Calc uses the backslash-letter combination if
10999 there is one, or otherwise uses a @samp{\^} sequence.
11001 The only Calc feature that uses strings is @dfn{compositions};
11002 @pxref{Compositions}. Strings also provide a convenient
11003 way to do conversions between ASCII characters and integers.
11009 There is a @code{string} function which provides a different display
11010 format for strings. Basically, @samp{string(@var{s})}, where @var{s}
11011 is a vector of integers in the proper range, is displayed as the
11012 corresponding string of characters with no surrounding quotation
11013 marks or other modifications. Thus @samp{string("ABC")} (or
11014 @samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
11015 This happens regardless of whether @w{@kbd{d "}} has been used. The
11016 only way to turn it off is to use @kbd{d U} (unformatted language
11017 mode) which will display @samp{string("ABC")} instead.
11019 Control characters are displayed somewhat differently by @code{string}.
11020 Characters below 32, and character 127, are shown using @samp{^} notation
11021 (same as shown above, but without the backslash). The quote and
11022 backslash characters are left alone, as are characters 128 and above.
11028 The @code{bstring} function is just like @code{string} except that
11029 the resulting string is breakable across multiple lines if it doesn't
11030 fit all on one line. Potential break points occur at every space
11031 character in the string.
11033 @node HMS Forms, Date Forms, Strings, Data Types
11037 @cindex Hours-minutes-seconds forms
11038 @cindex Degrees-minutes-seconds forms
11039 @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
11040 argument, the interpretation is Degrees-Minutes-Seconds. All functions
11041 that operate on angles accept HMS forms. These are interpreted as
11042 degrees regardless of the current angular mode. It is also possible to
11043 use HMS as the angular mode so that calculated angles are expressed in
11044 degrees, minutes, and seconds.
11050 @kindex ' (HMS forms)
11054 @kindex " (HMS forms)
11058 @kindex h (HMS forms)
11062 @kindex o (HMS forms)
11066 @kindex m (HMS forms)
11070 @kindex s (HMS forms)
11071 The default format for HMS values is
11072 @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters
11073 @samp{h} (for ``hours'') or
11074 @samp{o} (approximating the ``degrees'' symbol) are accepted as well as
11075 @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
11076 accepted in place of @samp{"}.
11077 The @var{hours} value is an integer (or integer-valued float).
11078 The @var{mins} value is an integer or integer-valued float between 0 and 59.
11079 The @var{secs} value is a real number between 0 (inclusive) and 60
11080 (exclusive). A positive HMS form is interpreted as @var{hours} +
11081 @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted
11082 as @i{- @var{hours}} @i{-} @var{mins}/60 @i{-} @var{secs}/3600.
11083 Display format for HMS forms is quite flexible. @xref{HMS Formats}.@refill
11085 HMS forms can be added and subtracted. When they are added to numbers,
11086 the numbers are interpreted according to the current angular mode. HMS
11087 forms can also be multiplied and divided by real numbers. Dividing
11088 two HMS forms produces a real-valued ratio of the two angles.
11091 @cindex Time of day
11092 Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
11093 the stack as an HMS form.
11095 @node Date Forms, Modulo Forms, HMS Forms, Data Types
11096 @section Date Forms
11100 A @dfn{date form} represents a date and possibly an associated time.
11101 Simple date arithmetic is supported: Adding a number to a date
11102 produces a new date shifted by that many days; adding an HMS form to
11103 a date shifts it by that many hours. Subtracting two date forms
11104 computes the number of days between them (represented as a simple
11105 number). Many other operations, such as multiplying two date forms,
11106 are nonsensical and are not allowed by Calc.
11108 Date forms are entered and displayed enclosed in @samp{< >} brackets.
11109 The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
11110 or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
11111 Input is flexible; date forms can be entered in any of the usual
11112 notations for dates and times. @xref{Date Formats}.
11114 Date forms are stored internally as numbers, specifically the number
11115 of days since midnight on the morning of January 1 of the year 1 AD.
11116 If the internal number is an integer, the form represents a date only;
11117 if the internal number is a fraction or float, the form represents
11118 a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>}
11119 is represented by the number 726842.25. The standard precision of
11120 12 decimal digits is enough to ensure that a (reasonable) date and
11121 time can be stored without roundoff error.
11123 If the current precision is greater than 12, date forms will keep
11124 additional digits in the seconds position. For example, if the
11125 precision is 15, the seconds will keep three digits after the
11126 decimal point. Decreasing the precision below 12 may cause the
11127 time part of a date form to become inaccurate. This can also happen
11128 if astronomically high years are used, though this will not be an
11129 issue in everyday (or even everymillennium) use. Note that date
11130 forms without times are stored as exact integers, so roundoff is
11131 never an issue for them.
11133 You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
11134 (@code{calc-unpack}) commands to get at the numerical representation
11135 of a date form. @xref{Packing and Unpacking}.
11137 Date forms can go arbitrarily far into the future or past. Negative
11138 year numbers represent years BC. Calc uses a combination of the
11139 Gregorian and Julian calendars, following the history of Great
11140 Britain and the British colonies. This is the same calendar that
11141 is used by the @code{cal} program in most Unix implementations.
11143 @cindex Julian calendar
11144 @cindex Gregorian calendar
11145 Some historical background: The Julian calendar was created by
11146 Julius Caesar in the year 46 BC as an attempt to fix the gradual
11147 drift caused by the lack of leap years in the calendar used
11148 until that time. The Julian calendar introduced an extra day in
11149 all years divisible by four. After some initial confusion, the
11150 calendar was adopted around the year we call 8 AD. Some centuries
11151 later it became apparent that the Julian year of 365.25 days was
11152 itself not quite right. In 1582 Pope Gregory XIII introduced the
11153 Gregorian calendar, which added the new rule that years divisible
11154 by 100, but not by 400, were not to be considered leap years
11155 despite being divisible by four. Many countries delayed adoption
11156 of the Gregorian calendar because of religious differences;
11157 in Britain it was put off until the year 1752, by which time
11158 the Julian calendar had fallen eleven days behind the true
11159 seasons. So the switch to the Gregorian calendar in early
11160 September 1752 introduced a discontinuity: The day after
11161 Sep 2, 1752 is Sep 14, 1752. Calc follows this convention.
11162 To take another example, Russia waited until 1918 before
11163 adopting the new calendar, and thus needed to remove thirteen
11164 days (between Feb 1, 1918 and Feb 14, 1918). This means that
11165 Calc's reckoning will be inconsistent with Russian history between
11166 1752 and 1918, and similarly for various other countries.
11168 Today's timekeepers introduce an occasional ``leap second'' as
11169 well, but Calc does not take these minor effects into account.
11170 (If it did, it would have to report a non-integer number of days
11171 between, say, @samp{<12:00am Mon Jan 1, 1900>} and
11172 @samp{<12:00am Sat Jan 1, 2000>}.)
11174 Calc uses the Julian calendar for all dates before the year 1752,
11175 including dates BC when the Julian calendar technically had not
11176 yet been invented. Thus the claim that day number @i{-10000} is
11177 called ``August 16, 28 BC'' should be taken with a grain of salt.
11179 Please note that there is no ``year 0''; the day before
11180 @samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}. These are
11181 days 0 and @i{-1} respectively in Calc's internal numbering scheme.
11183 @cindex Julian day counting
11184 Another day counting system in common use is, confusingly, also
11185 called ``Julian.'' It was invented in 1583 by Joseph Justus
11186 Scaliger, who named it in honor of his father Julius Caesar
11187 Scaliger. For obscure reasons he chose to start his day
11188 numbering on Jan 1, 4713 BC at noon, which in Calc's scheme
11189 is @i{-1721423.5} (recall that Calc starts at midnight instead
11190 of noon). Thus to convert a Calc date code obtained by
11191 unpacking a date form into a Julian day number, simply add
11192 1721423.5. The Julian code for @samp{6:00am Jan 9, 1991}
11193 is 2448265.75. The built-in @kbd{t J} command performs
11194 this conversion for you.
11196 @cindex Unix time format
11197 The Unix operating system measures time as an integer number of
11198 seconds since midnight, Jan 1, 1970. To convert a Calc date
11199 value into a Unix time stamp, first subtract 719164 (the code
11200 for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
11201 seconds in a day) and press @kbd{R} to round to the nearest
11202 integer. If you have a date form, you can simply subtract the
11203 day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
11204 719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
11205 to convert from Unix time to a Calc date form. (Note that
11206 Unix normally maintains the time in the GMT time zone; you may
11207 need to subtract five hours to get New York time, or eight hours
11208 for California time. The same is usually true of Julian day
11209 counts.) The built-in @kbd{t U} command performs these
11212 @node Modulo Forms, Error Forms, Date Forms, Data Types
11213 @section Modulo Forms
11216 @cindex Modulo forms
11217 A @dfn{modulo form} is a real number which is taken modulo (i.e., within
11218 an integer multiple of) some value @var{M}. Arithmetic modulo @var{M}
11219 often arises in number theory. Modulo forms are written
11220 `@var{a} @t{mod} @var{M}',
11221 where @var{a} and @var{M} are real numbers or HMS forms, and
11223 @cite{0 <= a < @var{M}}.
11224 In many applications @cite{a} and @cite{M} will be
11225 integers but this is not required.@refill
11227 Modulo forms are not to be confused with the modulo operator @samp{%}.
11228 The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
11229 the result 7. Further computations treat this 7 as just a regular integer.
11230 The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
11231 further computations with this value are again reduced modulo 10 so that
11232 the result always lies in the desired range.
11234 When two modulo forms with identical @cite{M}'s are added or multiplied,
11235 the Calculator simply adds or multiplies the values, then reduces modulo
11236 @cite{M}. If one argument is a modulo form and the other a plain number,
11237 the plain number is treated like a compatible modulo form. It is also
11238 possible to raise modulo forms to powers; the result is the value raised
11239 to the power, then reduced modulo @cite{M}. (When all values involved
11240 are integers, this calculation is done much more efficiently than
11241 actually computing the power and then reducing.)
11243 @cindex Modulo division
11244 Two modulo forms `@var{a} @t{mod} @var{M}' and `@var{b} @t{mod} @var{M}'
11245 can be divided if @cite{a}, @cite{b}, and @cite{M} are all
11246 integers. The result is the modulo form which, when multiplied by
11247 `@var{b} @t{mod} @var{M}', produces `@var{a} @t{mod} @var{M}'. If
11248 there is no solution to this equation (which can happen only when
11249 @cite{M} is non-prime), or if any of the arguments are non-integers, the
11250 division is left in symbolic form. Other operations, such as square
11251 roots, are not yet supported for modulo forms. (Note that, although
11252 @w{`@t{(}@var{a} @t{mod} @var{M}@t{)^.5}'} will compute a ``modulo square root''
11253 in the sense of reducing @c{$\sqrt a$}
11254 @cite{sqrt(a)} modulo @cite{M}, this is not a
11255 useful definition from the number-theoretical point of view.)@refill
11260 @kindex M (modulo forms)
11264 @tindex mod (operator)
11265 To create a modulo form during numeric entry, press the shift-@kbd{M}
11266 key to enter the word @samp{mod}. As a special convenience, pressing
11267 shift-@kbd{M} a second time automatically enters the value of @cite{M}
11268 that was most recently used before. During algebraic entry, either
11269 type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
11270 Once again, pressing this a second time enters the current modulo.@refill
11272 You can also use @kbd{v p} and @kbd{%} to modify modulo forms.
11273 @xref{Building Vectors}. @xref{Basic Arithmetic}.
11275 It is possible to mix HMS forms and modulo forms. For example, an
11276 HMS form modulo 24 could be used to manipulate clock times; an HMS
11277 form modulo 360 would be suitable for angles. Making the modulo @cite{M}
11278 also be an HMS form eliminates troubles that would arise if the angular
11279 mode were inadvertently set to Radians, in which case
11280 @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
11283 Modulo forms cannot have variables or formulas for components. If you
11284 enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
11285 to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}.
11291 The algebraic function @samp{makemod(a, m)} builds the modulo form
11292 @w{@samp{a mod m}}.
11294 @node Error Forms, Interval Forms, Modulo Forms, Data Types
11295 @section Error Forms
11298 @cindex Error forms
11299 @cindex Standard deviations
11300 An @dfn{error form} is a number with an associated standard
11301 deviation, as in @samp{2.3 +/- 0.12}. The notation
11302 `@var{x} @t{+/-} @c{$\sigma$}
11303 @asis{sigma}' stands for an uncertain value which follows a normal or
11304 Gaussian distribution of mean @cite{x} and standard deviation or
11305 ``error'' @c{$\sigma$}
11306 @cite{sigma}. Both the mean and the error can be either numbers or
11307 formulas. Generally these are real numbers but the mean may also be
11308 complex. If the error is negative or complex, it is changed to its
11309 absolute value. An error form with zero error is converted to a
11310 regular number by the Calculator.@refill
11312 All arithmetic and transcendental functions accept error forms as input.
11313 Operations on the mean-value part work just like operations on regular
11314 numbers. The error part for any function @cite{f(x)} (such as @c{$\sin x$}
11316 is defined by the error of @cite{x} times the derivative of @cite{f}
11317 evaluated at the mean value of @cite{x}. For a two-argument function
11318 @cite{f(x,y)} (such as addition) the error is the square root of the sum
11319 of the squares of the errors due to @cite{x} and @cite{y}.
11322 f(x \hbox{\code{ +/- }} \sigma)
11323 &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
11324 f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
11325 &= f(x,y) \hbox{\code{ +/- }}
11326 \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
11328 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
11329 \right| \right)^2 } \cr
11333 definition assumes the errors in @cite{x} and @cite{y} are uncorrelated.
11334 A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
11335 is not the same as @samp{(2 +/- 1)^2}; the former represents the product
11336 of two independent values which happen to have the same probability
11337 distributions, and the latter is the product of one random value with itself.
11338 The former will produce an answer with less error, since on the average
11339 the two independent errors can be expected to cancel out.@refill
11341 Consult a good text on error analysis for a discussion of the proper use
11342 of standard deviations. Actual errors often are neither Gaussian-distributed
11343 nor uncorrelated, and the above formulas are valid only when errors
11344 are small. As an example, the error arising from
11345 `@t{sin(}@var{x} @t{+/-} @c{$\sigma$}
11346 @var{sigma}@t{)}' is
11347 `@c{$\sigma$\nobreak}
11348 @var{sigma} @t{abs(cos(}@var{x}@t{))}'. When @cite{x} is close to zero,
11351 close to one so the error in the sine is close to @c{$\sigma$}
11352 @cite{sigma}; this makes sense, since @c{$\sin x$}
11353 @cite{sin(x)} is approximately @cite{x} near zero, so a given
11354 error in @cite{x} will produce about the same error in the sine. Likewise,
11355 near 90 degrees @c{$\cos x$}
11356 @cite{cos(x)} is nearly zero and so the computed error is
11357 small: The sine curve is nearly flat in that region, so an error in @cite{x}
11358 has relatively little effect on the value of @c{$\sin x$}
11359 @cite{sin(x)}. However, consider
11360 @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so Calc will report
11361 zero error! We get an obviously wrong result because we have violated
11362 the small-error approximation underlying the error analysis. If the error
11363 in @cite{x} had been small, the error in @c{$\sin x$}
11364 @cite{sin(x)} would indeed have been negligible.@refill
11369 @kindex p (error forms)
11371 To enter an error form during regular numeric entry, use the @kbd{p}
11372 (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually
11373 typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
11374 @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-p} to
11375 type the @samp{+/-} symbol, or type it out by hand.
11377 Error forms and complex numbers can be mixed; the formulas shown above
11378 are used for complex numbers, too; note that if the error part evaluates
11379 to a complex number its absolute value (or the square root of the sum of
11380 the squares of the absolute values of the two error contributions) is
11381 used. Mathematically, this corresponds to a radially symmetric Gaussian
11382 distribution of numbers on the complex plane. However, note that Calc
11383 considers an error form with real components to represent a real number,
11384 not a complex distribution around a real mean.
11386 Error forms may also be composed of HMS forms. For best results, both
11387 the mean and the error should be HMS forms if either one is.
11393 The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
11395 @node Interval Forms, Incomplete Objects, Error Forms, Data Types
11396 @section Interval Forms
11399 @cindex Interval forms
11400 An @dfn{interval} is a subset of consecutive real numbers. For example,
11401 the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
11402 inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you
11403 obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if
11404 you multiply some number in the range @samp{[2 ..@: 4]} by some other
11405 number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
11406 from 1 to 8. Interval arithmetic is used to get a worst-case estimate
11407 of the possible range of values a computation will produce, given the
11408 set of possible values of the input.
11411 Calc supports several varieties of intervals, including @dfn{closed}
11412 intervals of the type shown above, @dfn{open} intervals such as
11413 @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
11414 @emph{exclusive}, and @dfn{semi-open} intervals in which one end
11415 uses a round parenthesis and the other a square bracket. In mathematical
11417 @samp{[2 ..@: 4]} means @cite{2 <= x <= 4}, whereas
11418 @samp{[2 ..@: 4)} represents @cite{2 <= x < 4},
11419 @samp{(2 ..@: 4]} represents @cite{2 < x <= 4}, and
11420 @samp{(2 ..@: 4)} represents @cite{2 < x < 4}.@refill
11423 Calc supports several varieties of intervals, including \dfn{closed}
11424 intervals of the type shown above, \dfn{open} intervals such as
11425 \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
11426 \emph{exclusive}, and \dfn{semi-open} intervals in which one end
11427 uses a round parenthesis and the other a square bracket. In mathematical
11430 [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr
11431 [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr
11432 (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr
11433 (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr
11437 The lower and upper limits of an interval must be either real numbers
11438 (or HMS or date forms), or symbolic expressions which are assumed to be
11439 real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit
11440 must be less than the upper limit. A closed interval containing only
11441 one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
11442 automatically. An interval containing no values at all (such as
11443 @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
11444 guaranteed to behave well when used in arithmetic. Note that the
11445 interval @samp{[3 .. inf)} represents all real numbers greater than
11446 or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
11447 In fact, @samp{[-inf .. inf]} represents all real numbers including
11448 the real infinities.
11450 Intervals are entered in the notation shown here, either as algebraic
11451 formulas, or using incomplete forms. (@xref{Incomplete Objects}.)
11452 In algebraic formulas, multiple periods in a row are collected from
11453 left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
11454 rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to
11455 get the other interpretation. If you omit the lower or upper limit,
11456 a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
11458 ``Infinite mode'' also affects operations on intervals
11459 (@pxref{Infinities}). Calc will always introduce an open infinity,
11460 as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities,
11461 @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in infinite mode;
11462 otherwise they are left unevaluated. Note that the ``direction'' of
11463 a zero is not an issue in this case since the zero is always assumed
11464 to be continuous with the rest of the interval. For intervals that
11465 contain zero inside them Calc is forced to give the result,
11466 @samp{1 / (-2 .. 2) = [-inf .. inf]}.
11468 While it may seem that intervals and error forms are similar, they are
11469 based on entirely different concepts of inexact quantities. An error
11470 form `@var{x} @t{+/-} @c{$\sigma$}
11471 @var{sigma}' means a variable is random, and its value could
11472 be anything but is ``probably'' within one @c{$\sigma$}
11473 @var{sigma} of the mean value @cite{x}.
11474 An interval `@t{[}@var{a} @t{..@:} @var{b}@t{]}' means a variable's value
11475 is unknown, but guaranteed to lie in the specified range. Error forms
11476 are statistical or ``average case'' approximations; interval arithmetic
11477 tends to produce ``worst case'' bounds on an answer.@refill
11479 Intervals may not contain complex numbers, but they may contain
11480 HMS forms or date forms.
11482 @xref{Set Operations}, for commands that interpret interval forms
11483 as subsets of the set of real numbers.
11489 The algebraic function @samp{intv(n, a, b)} builds an interval form
11490 from @samp{a} to @samp{b}; @samp{n} is an integer code which must
11491 be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
11494 Please note that in fully rigorous interval arithmetic, care would be
11495 taken to make sure that the computation of the lower bound rounds toward
11496 minus infinity, while upper bound computations round toward plus
11497 infinity. Calc's arithmetic always uses a round-to-nearest mode,
11498 which means that roundoff errors could creep into an interval
11499 calculation to produce intervals slightly smaller than they ought to
11500 be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
11501 should yield the interval @samp{[1..2]} again, but in fact it yields the
11502 (slightly too small) interval @samp{[1..1.9999999]} due to roundoff
11505 @node Incomplete Objects, Variables, Interval Forms, Data Types
11506 @section Incomplete Objects
11526 @cindex Incomplete vectors
11527 @cindex Incomplete complex numbers
11528 @cindex Incomplete interval forms
11529 When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
11530 vector, respectively, the effect is to push an @dfn{incomplete} complex
11531 number or vector onto the stack. The @kbd{,} key adds the value(s) at
11532 the top of the stack onto the current incomplete object. The @kbd{)}
11533 and @kbd{]} keys ``close'' the incomplete object after adding any values
11534 on the top of the stack in front of the incomplete object.
11536 As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
11537 pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )}
11538 pushes the complex number @samp{(1, 1.414)} (approximately).
11540 If several values lie on the stack in front of the incomplete object,
11541 all are collected and appended to the object. Thus the @kbd{,} key
11542 is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people
11543 prefer the equivalent @key{SPC} key to @key{RET}.@refill
11545 As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
11546 @kbd{,} adds a zero or duplicates the preceding value in the list being
11547 formed. Typing @key{DEL} during incomplete entry removes the last item
11551 The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
11552 numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for
11553 creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
11554 equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
11558 Incomplete entry is also used to enter intervals. For example,
11559 @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type
11560 the first period, it will be interpreted as a decimal point, but when
11561 you type a second period immediately afterward, it is re-interpreted as
11562 part of the interval symbol. Typing @kbd{..} corresponds to executing
11563 the @code{calc-dots} command.
11565 If you find incomplete entry distracting, you may wish to enter vectors
11566 and complex numbers as algebraic formulas by pressing the apostrophe key.
11568 @node Variables, Formulas, Incomplete Objects, Data Types
11572 @cindex Variables, in formulas
11573 A @dfn{variable} is somewhere between a storage register on a conventional
11574 calculator, and a variable in a programming language. (In fact, a Calc
11575 variable is really just an Emacs Lisp variable that contains a Calc number
11576 or formula.) A variable's name is normally composed of letters and digits.
11577 Calc also allows apostrophes and @code{#} signs in variable names.
11578 The Calc variable @code{foo} corresponds to the Emacs Lisp variable
11579 @code{var-foo}. Commands like @kbd{s s} (@code{calc-store}) that operate
11580 on variables can be made to use any arbitrary Lisp variable simply by
11581 backspacing over the @samp{var-} prefix in the minibuffer.@refill
11583 In a command that takes a variable name, you can either type the full
11584 name of a variable, or type a single digit to use one of the special
11585 convenience variables @code{var-q0} through @code{var-q9}. For example,
11586 @kbd{3 s s 2} stores the number 3 in variable @code{var-q2}, and
11587 @w{@kbd{3 s s foo @key{RET}}} stores that number in variable
11588 @code{var-foo}.@refill
11590 To push a variable itself (as opposed to the variable's value) on the
11591 stack, enter its name as an algebraic expression using the apostrophe
11592 (@key{'}) key. Variable names in algebraic formulas implicitly have
11593 @samp{var-} prefixed to their names. The @samp{#} character in variable
11594 names used in algebraic formulas corresponds to a dash @samp{-} in the
11595 Lisp variable name. If the name contains any dashes, the prefix @samp{var-}
11596 is @emph{not} automatically added. Thus the two formulas @samp{foo + 1}
11597 and @samp{var#foo + 1} both refer to the same variable.
11600 @pindex calc-evaluate
11601 @cindex Evaluation of variables in a formula
11602 @cindex Variables, evaluation
11603 @cindex Formulas, evaluation
11604 The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
11605 replacing all variables in the formula which have been given values by a
11606 @code{calc-store} or @code{calc-let} command by their stored values.
11607 Other variables are left alone. Thus a variable that has not been
11608 stored acts like an abstract variable in algebra; a variable that has
11609 been stored acts more like a register in a traditional calculator.
11610 With a positive numeric prefix argument, @kbd{=} evaluates the top
11611 @var{n} stack entries; with a negative argument, @kbd{=} evaluates
11612 the @var{n}th stack entry.
11614 @cindex @code{e} variable
11615 @cindex @code{pi} variable
11616 @cindex @code{i} variable
11617 @cindex @code{phi} variable
11618 @cindex @code{gamma} variable
11624 A few variables are called @dfn{special constants}. Their names are
11625 @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
11626 (@xref{Scientific Functions}.) When they are evaluated with @kbd{=},
11627 their values are calculated if necessary according to the current precision
11628 or complex polar mode. If you wish to use these symbols for other purposes,
11629 simply undefine or redefine them using @code{calc-store}.@refill
11631 The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
11632 infinite or indeterminate values. It's best not to use them as
11633 regular variables, since Calc uses special algebraic rules when
11634 it manipulates them. Calc displays a warning message if you store
11635 a value into any of these special variables.
11637 @xref{Store and Recall}, for a discussion of commands dealing with variables.
11639 @node Formulas, , Variables, Data Types
11644 @cindex Expressions
11645 @cindex Operators in formulas
11646 @cindex Precedence of operators
11647 When you press the apostrophe key you may enter any expression or formula
11648 in algebraic form. (Calc uses the terms ``expression'' and ``formula''
11649 interchangeably.) An expression is built up of numbers, variable names,
11650 and function calls, combined with various arithmetic operators.
11652 be used to indicate grouping. Spaces are ignored within formulas, except
11653 that spaces are not permitted within variable names or numbers.
11654 Arithmetic operators, in order from highest to lowest precedence, and
11655 with their equivalent function names, are:
11657 @samp{_} [@code{subscr}] (subscripts);
11659 postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
11661 prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x})
11662 and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
11664 @samp{+/-} [@code{sdev}] (the standard deviation symbol) and
11665 @samp{mod} [@code{makemod}] (the symbol for modulo forms);
11667 postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
11668 and postfix @samp{!!} [@code{dfact}] (double factorial);
11670 @samp{^} [@code{pow}] (raised-to-the-power-of);
11672 @samp{*} [@code{mul}];
11674 @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
11675 @samp{\} [@code{idiv}] (integer division);
11677 infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
11679 @samp{|} [@code{vconcat}] (vector concatenation);
11681 relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
11682 @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
11684 @samp{&&} [@code{land}] (logical ``and'');
11686 @samp{||} [@code{lor}] (logical ``or'');
11688 the C-style ``if'' operator @samp{a?b:c} [@code{if}];
11690 @samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
11692 @samp{&&&} [@code{pand}] (rewrite pattern ``and'');
11694 @samp{|||} [@code{por}] (rewrite pattern ``or'');
11696 @samp{:=} [@code{assign}] (for assignments and rewrite rules);
11698 @samp{::} [@code{condition}] (rewrite pattern condition);
11700 @samp{=>} [@code{evalto}].
11702 Note that, unlike in usual computer notation, multiplication binds more
11703 strongly than division: @samp{a*b/c*d} is equivalent to @c{$a b \over c d$}
11704 @cite{(a*b)/(c*d)}.
11706 @cindex Multiplication, implicit
11707 @cindex Implicit multiplication
11708 The multiplication sign @samp{*} may be omitted in many cases. In particular,
11709 if the righthand side is a number, variable name, or parenthesized
11710 expression, the @samp{*} may be omitted. Implicit multiplication has the
11711 same precedence as the explicit @samp{*} operator. The one exception to
11712 the rule is that a variable name followed by a parenthesized expression,
11714 is interpreted as a function call, not an implicit @samp{*}. In many
11715 cases you must use a space if you omit the @samp{*}: @samp{2a} is the
11716 same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
11717 is a variable called @code{ab}, @emph{not} the product of @samp{a} and
11718 @samp{b}! Also note that @samp{f (x)} is still a function call.@refill
11720 @cindex Implicit comma in vectors
11721 The rules are slightly different for vectors written with square brackets.
11722 In vectors, the space character is interpreted (like the comma) as a
11723 separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is
11724 equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
11725 to @samp{2*a*b + c*d}.
11726 Note that spaces around the brackets, and around explicit commas, are
11727 ignored. To force spaces to be interpreted as multiplication you can
11728 enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
11729 interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted
11730 between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.@refill
11732 Vectors that contain commas (not embedded within nested parentheses or
11733 brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector
11734 of two elements. Also, if it would be an error to treat spaces as
11735 separators, but not otherwise, then Calc will ignore spaces:
11736 @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
11737 a vector of two elements. Finally, vectors entered with curly braces
11738 instead of square brackets do not give spaces any special treatment.
11739 When Calc displays a vector that does not contain any commas, it will
11740 insert parentheses if necessary to make the meaning clear:
11741 @w{@samp{[(a b)]}}.
11743 The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
11744 or five modulo minus-two? Calc always interprets the leftmost symbol as
11745 an infix operator preferentially (modulo, in this case), so you would
11746 need to write @samp{(5%)-2} to get the former interpretation.
11748 @cindex Function call notation
11749 A function call is, e.g., @samp{sin(1+x)}. Function names follow the same
11750 rules as variable names except that the default prefix @samp{calcFunc-} is
11751 used (instead of @samp{var-}) for the internal Lisp form.
11752 Most mathematical Calculator commands like
11753 @code{calc-sin} have function equivalents like @code{sin}.
11754 If no Lisp function is defined for a function called by a formula, the
11755 call is left as it is during algebraic manipulation: @samp{f(x+y)} is
11756 left alone. Beware that many innocent-looking short names like @code{in}
11757 and @code{re} have predefined meanings which could surprise you; however,
11758 single letters or single letters followed by digits are always safe to
11759 use for your own function names. @xref{Function Index}.@refill
11761 In the documentation for particular commands, the notation @kbd{H S}
11762 (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
11763 command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
11764 represent the same operation.@refill
11766 Commands that interpret (``parse'') text as algebraic formulas include
11767 algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
11768 the contents of the editing buffer when you finish, the @kbd{M-# g}
11769 and @w{@kbd{M-# r}} commands, the @kbd{C-y} command, the X window system
11770 ``paste'' mouse operation, and Embedded Mode. All of these operations
11771 use the same rules for parsing formulas; in particular, language modes
11772 (@pxref{Language Modes}) affect them all in the same way.
11774 When you read a large amount of text into the Calculator (say a vector
11775 which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
11776 you may wish to include comments in the text. Calc's formula parser
11777 ignores the symbol @samp{%%} and anything following it on a line:
11780 [ a + b, %% the sum of "a" and "b"
11782 %% last line is coming up:
11787 This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
11789 @xref{Syntax Tables}, for a way to create your own operators and other
11790 input notations. @xref{Compositions}, for a way to create new display
11793 @xref{Algebra}, for commands for manipulating formulas symbolically.
11795 @node Stack and Trail, Mode Settings, Data Types, Top
11796 @chapter Stack and Trail Commands
11799 This chapter describes the Calc commands for manipulating objects on the
11800 stack and in the trail buffer. (These commands operate on objects of any
11801 type, such as numbers, vectors, formulas, and incomplete objects.)
11804 * Stack Manipulation::
11805 * Editing Stack Entries::
11810 @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
11811 @section Stack Manipulation Commands
11817 @cindex Duplicating stack entries
11818 To duplicate the top object on the stack, press @key{RET} or @key{SPC}
11819 (two equivalent keys for the @code{calc-enter} command).
11820 Given a positive numeric prefix argument, these commands duplicate
11821 several elements at the top of the stack.
11822 Given a negative argument,
11823 these commands duplicate the specified element of the stack.
11824 Given an argument of zero, they duplicate the entire stack.
11825 For example, with @samp{10 20 30} on the stack,
11826 @key{RET} creates @samp{10 20 30 30},
11827 @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
11828 @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
11829 @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.@refill
11833 The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
11834 have it, else on @kbd{C-j}) is like @code{calc-enter}
11835 except that the sign of the numeric prefix argument is interpreted
11836 oppositely. Also, with no prefix argument the default argument is 2.
11837 Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
11838 are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
11839 @samp{10 20 30 20}.@refill
11844 @cindex Removing stack entries
11845 @cindex Deleting stack entries
11846 To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
11847 The @kbd{C-d} key is a synonym for @key{DEL}.
11848 (If the top element is an incomplete object with at least one element, the
11849 last element is removed from it.) Given a positive numeric prefix argument,
11850 several elements are removed. Given a negative argument, the specified
11851 element of the stack is deleted. Given an argument of zero, the entire
11853 For example, with @samp{10 20 30} on the stack,
11854 @key{DEL} leaves @samp{10 20},
11855 @kbd{C-u 2 @key{DEL}} leaves @samp{10},
11856 @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
11857 @kbd{C-u 0 @key{DEL}} leaves an empty stack.@refill
11859 @kindex M-@key{DEL}
11860 @pindex calc-pop-above
11861 The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
11862 @key{LFD} is to @key{RET}: It interprets the sign of the numeric
11863 prefix argument in the opposite way, and the default argument is 2.
11864 Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
11865 leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
11866 the third stack element.
11869 @pindex calc-roll-down
11870 To exchange the top two elements of the stack, press @key{TAB}
11871 (@code{calc-roll-down}). Given a positive numeric prefix argument, the
11872 specified number of elements at the top of the stack are rotated downward.
11873 Given a negative argument, the entire stack is rotated downward the specified
11874 number of times. Given an argument of zero, the entire stack is reversed
11876 For example, with @samp{10 20 30 40 50} on the stack,
11877 @key{TAB} creates @samp{10 20 30 50 40},
11878 @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
11879 @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
11880 @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.@refill
11882 @kindex M-@key{TAB}
11883 @pindex calc-roll-up
11884 The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
11885 except that it rotates upward instead of downward. Also, the default
11886 with no prefix argument is to rotate the top 3 elements.
11887 For example, with @samp{10 20 30 40 50} on the stack,
11888 @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
11889 @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
11890 @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
11891 @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.@refill
11893 A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
11894 terms of moving a particular element to a new position in the stack.
11895 With a positive argument @var{n}, @key{TAB} moves the top stack
11896 element down to level @var{n}, making room for it by pulling all the
11897 intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the
11898 element at level @var{n} up to the top. (Compare with @key{LFD},
11899 which copies instead of moving the element in level @var{n}.)
11901 With a negative argument @i{-@var{n}}, @key{TAB} rotates the stack
11902 to move the object in level @var{n} to the deepest place in the
11903 stack, and the object in level @i{@var{n}+1} to the top. @kbd{M-@key{TAB}}
11904 rotates the deepest stack element to be in level @i{n}, also
11905 putting the top stack element in level @i{@var{n}+1}.
11907 @xref{Selecting Subformulas}, for a way to apply these commands to
11908 any portion of a vector or formula on the stack.
11910 @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
11911 @section Editing Stack Entries
11916 @pindex calc-edit-finish
11917 @cindex Editing the stack with Emacs
11918 The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary
11919 buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using
11920 regular Emacs commands. With a numeric prefix argument, it edits the
11921 specified number of stack entries at once. (An argument of zero edits
11922 the entire stack; a negative argument edits one specific stack entry.)
11924 When you are done editing, press @kbd{M-# M-#} to finish and return
11925 to Calc. The @key{RET} and @key{LFD} keys also work to finish most
11926 sorts of editing, though in some cases Calc leaves @key{RET} with its
11927 usual meaning (``insert a newline'') if it's a situation where you
11928 might want to insert new lines into the editing buffer. The traditional
11929 Emacs ``finish'' key sequence, @kbd{C-c C-c}, also works to finish
11930 editing and may be easier to type, depending on your keyboard.
11932 When you finish editing, the Calculator parses the lines of text in
11933 the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
11934 original stack elements in the original buffer with these new values,
11935 then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer
11936 continues to exist during editing, but for best results you should be
11937 careful not to change it until you have finished the edit. You can
11938 also cancel the edit by pressing @kbd{M-# x}.
11940 The formula is normally reevaluated as it is put onto the stack.
11941 For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
11942 @kbd{M-# M-#} will push 5 on the stack. If you use @key{LFD} to
11943 finish, Calc will put the result on the stack without evaluating it.
11945 If you give a prefix argument to @kbd{M-# M-#} (or @kbd{C-c C-c}),
11946 Calc will not kill the @samp{*Calc Edit*} buffer. You can switch
11947 back to that buffer and continue editing if you wish. However, you
11948 should understand that if you initiated the edit with @kbd{`}, the
11949 @kbd{M-# M-#} operation will be programmed to replace the top of the
11950 stack with the new edited value, and it will do this even if you have
11951 rearranged the stack in the meanwhile. This is not so much of a problem
11952 with other editing commands, though, such as @kbd{s e}
11953 (@code{calc-edit-variable}; @pxref{Operations on Variables}).
11955 If the @code{calc-edit} command involves more than one stack entry,
11956 each line of the @samp{*Calc Edit*} buffer is interpreted as a
11957 separate formula. Otherwise, the entire buffer is interpreted as
11958 one formula, with line breaks ignored. (You can use @kbd{C-o} or
11959 @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
11961 The @kbd{`} key also works during numeric or algebraic entry. The
11962 text entered so far is moved to the @code{*Calc Edit*} buffer for
11963 more extensive editing than is convenient in the minibuffer.
11965 @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
11966 @section Trail Commands
11969 @cindex Trail buffer
11970 The commands for manipulating the Calc Trail buffer are two-key sequences
11971 beginning with the @kbd{t} prefix.
11974 @pindex calc-trail-display
11975 The @kbd{t d} (@code{calc-trail-display}) command turns display of the
11976 trail on and off. Normally the trail display is toggled on if it was off,
11977 off if it was on. With a numeric prefix of zero, this command always
11978 turns the trail off; with a prefix of one, it always turns the trail on.
11979 The other trail-manipulation commands described here automatically turn
11980 the trail on. Note that when the trail is off values are still recorded
11981 there; they are simply not displayed. To set Emacs to turn the trail
11982 off by default, type @kbd{t d} and then save the mode settings with
11983 @kbd{m m} (@code{calc-save-modes}).
11986 @pindex calc-trail-in
11988 @pindex calc-trail-out
11989 The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
11990 (@code{calc-trail-out}) commands switch the cursor into and out of the
11991 Calc Trail window. In practice they are rarely used, since the commands
11992 shown below are a more convenient way to move around in the
11993 trail, and they work ``by remote control'' when the cursor is still
11994 in the Calculator window.@refill
11996 @cindex Trail pointer
11997 There is a @dfn{trail pointer} which selects some entry of the trail at
11998 any given time. The trail pointer looks like a @samp{>} symbol right
11999 before the selected number. The following commands operate on the
12000 trail pointer in various ways.
12003 @pindex calc-trail-yank
12004 @cindex Retrieving previous results
12005 The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
12006 the trail and pushes it onto the Calculator stack. It allows you to
12007 re-use any previously computed value without retyping. With a numeric
12008 prefix argument @var{n}, it yanks the value @var{n} lines above the current
12012 @pindex calc-trail-scroll-left
12014 @pindex calc-trail-scroll-right
12015 The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
12016 (@code{calc-trail-scroll-right}) commands horizontally scroll the trail
12017 window left or right by one half of its width.@refill
12020 @pindex calc-trail-next
12022 @pindex calc-trail-previous
12024 @pindex calc-trail-forward
12026 @pindex calc-trail-backward
12027 The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
12028 (@code{calc-trail-previous)} commands move the trail pointer down or up
12029 one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
12030 (@code{calc-trail-backward}) commands move the trail pointer down or up
12031 one screenful at a time. All of these commands accept numeric prefix
12032 arguments to move several lines or screenfuls at a time.@refill
12035 @pindex calc-trail-first
12037 @pindex calc-trail-last
12039 @pindex calc-trail-here
12040 The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
12041 (@code{calc-trail-last}) commands move the trail pointer to the first or
12042 last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command
12043 moves the trail pointer to the cursor position; unlike the other trail
12044 commands, @kbd{t h} works only when Calc Trail is the selected window.@refill
12047 @pindex calc-trail-isearch-forward
12049 @pindex calc-trail-isearch-backward
12051 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12052 (@code{calc-trail-isearch-backward}) commands perform an incremental
12053 search forward or backward through the trail. You can press @key{RET}
12054 to terminate the search; the trail pointer moves to the current line.
12055 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12056 it was when the search began.@refill
12059 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12060 (@code{calc-trail-isearch-backward}) com\-mands perform an incremental
12061 search forward or backward through the trail. You can press @key{RET}
12062 to terminate the search; the trail pointer moves to the current line.
12063 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12064 it was when the search began.
12068 @pindex calc-trail-marker
12069 The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
12070 line of text of your own choosing into the trail. The text is inserted
12071 after the line containing the trail pointer; this usually means it is
12072 added to the end of the trail. Trail markers are useful mainly as the
12073 targets for later incremental searches in the trail.
12076 @pindex calc-trail-kill
12077 The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
12078 from the trail. The line is saved in the Emacs kill ring suitable for
12079 yanking into another buffer, but it is not easy to yank the text back
12080 into the trail buffer. With a numeric prefix argument, this command
12081 kills the @var{n} lines below or above the selected one.
12083 The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
12084 elsewhere; @pxref{Vector and Matrix Formats}.
12086 @node Keep Arguments, , Trail Commands, Stack and Trail
12087 @section Keep Arguments
12091 @pindex calc-keep-args
12092 The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
12093 the following command. It prevents that command from removing its
12094 arguments from the stack. For example, after @kbd{2 @key{RET} 3 +},
12095 the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
12096 the stack contains the arguments and the result: @samp{2 3 5}.
12098 This works for all commands that take arguments off the stack. As
12099 another example, @kbd{K a s} simplifies a formula, pushing the
12100 simplified version of the formula onto the stack after the original
12101 formula (rather than replacing the original formula).
12103 Note that you could get the same effect by typing @kbd{@key{RET} a s},
12104 copying the formula and then simplifying the copy. One difference
12105 is that for a very large formula the time taken to format the
12106 intermediate copy in @kbd{@key{RET} a s} could be noticeable; @kbd{K a s}
12107 would avoid this extra work.
12109 Even stack manipulation commands are affected. @key{TAB} works by
12110 popping two values and pushing them back in the opposite order,
12111 so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
12113 A few Calc commands provide other ways of doing the same thing.
12114 For example, @kbd{' sin($)} replaces the number on the stack with
12115 its sine using algebraic entry; to push the sine and keep the
12116 original argument you could use either @kbd{' sin($1)} or
12117 @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s}
12118 command is effectively the same as @kbd{K s t}. @xref{Storing Variables}.
12120 Keyboard macros may interact surprisingly with the @kbd{K} prefix.
12121 If you have defined a keyboard macro to be, say, @samp{Q +} to add
12122 one number to the square root of another, then typing @kbd{K X} will
12123 execute @kbd{K Q +}, probably not what you expected. The @kbd{K}
12124 prefix will apply to just the first command in the macro rather than
12127 If you execute a command and then decide you really wanted to keep
12128 the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
12129 This command pushes the last arguments that were popped by any command
12130 onto the stack. Note that the order of things on the stack will be
12131 different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
12132 @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}.
12134 @node Mode Settings, Arithmetic, Stack and Trail, Top
12135 @chapter Mode Settings
12138 This chapter describes commands that set modes in the Calculator.
12139 They do not affect the contents of the stack, although they may change
12140 the @emph{appearance} or @emph{interpretation} of the stack's contents.
12143 * General Mode Commands::
12145 * Inverse and Hyperbolic::
12146 * Calculation Modes::
12147 * Simplification Modes::
12155 @node General Mode Commands, Precision, Mode Settings, Mode Settings
12156 @section General Mode Commands
12160 @pindex calc-save-modes
12161 @cindex Continuous memory
12162 @cindex Saving mode settings
12163 @cindex Permanent mode settings
12164 @cindex @file{.emacs} file, mode settings
12165 You can save all of the current mode settings in your @file{.emacs} file
12166 with the @kbd{m m} (@code{calc-save-modes}) command. This will cause
12167 Emacs to reestablish these modes each time it starts up. The modes saved
12168 in the file include everything controlled by the @kbd{m} and @kbd{d}
12169 prefix keys, the current precision and binary word size, whether or not
12170 the trail is displayed, the current height of the Calc window, and more.
12171 The current interface (used when you type @kbd{M-# M-#}) is also saved.
12172 If there were already saved mode settings in the file, they are replaced.
12173 Otherwise, the new mode information is appended to the end of the file.
12176 @pindex calc-mode-record-mode
12177 The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
12178 record the new mode settings (as if by pressing @kbd{m m}) every
12179 time a mode setting changes. If Embedded Mode is enabled, other
12180 options are available; @pxref{Mode Settings in Embedded Mode}.
12183 @pindex calc-settings-file-name
12184 The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
12185 choose a different place than your @file{.emacs} file for @kbd{m m},
12186 @kbd{Z P}, and similar commands to save permanent information.
12187 You are prompted for a file name. All Calc modes are then reset to
12188 their default values, then settings from the file you named are loaded
12189 if this file exists, and this file becomes the one that Calc will
12190 use in the future for commands like @kbd{m m}. The default settings
12191 file name is @file{~/.emacs}. You can see the current file name by
12192 giving a blank response to the @kbd{m F} prompt. See also the
12193 discussion of the @code{calc-settings-file} variable; @pxref{Installation}.
12195 If the file name you give contains the string @samp{.emacs} anywhere
12196 inside it, @kbd{m F} will not automatically load the new file. This
12197 is because you are presumably switching to your @file{~/.emacs} file,
12198 which may contain other things you don't want to reread. You can give
12199 a numeric prefix argument of 1 to @kbd{m F} to force it to read the
12200 file no matter what its name. Conversely, an argument of @i{-1} tells
12201 @kbd{m F} @emph{not} to read the new file. An argument of 2 or @i{-2}
12202 tells @kbd{m F} not to reset the modes to their defaults beforehand,
12203 which is useful if you intend your new file to have a variant of the
12204 modes present in the file you were using before.
12207 @pindex calc-always-load-extensions
12208 The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
12209 in which the first use of Calc loads the entire program, including all
12210 extensions modules. Otherwise, the extensions modules will not be loaded
12211 until the various advanced Calc features are used. Since this mode only
12212 has effect when Calc is first loaded, @kbd{m x} is usually followed by
12213 @kbd{m m} to make the mode-setting permanent. To load all of Calc just
12214 once, rather than always in the future, you can press @kbd{M-# L}.
12217 @pindex calc-shift-prefix
12218 The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
12219 all of Calc's letter prefix keys may be typed shifted as well as unshifted.
12220 If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
12221 you might find it easier to turn this mode on so that you can type
12222 @kbd{A S} instead. When this mode is enabled, the commands that used to
12223 be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
12224 now be invoked by pressing the shifted letter twice: @kbd{A A}. Note
12225 that the @kbd{v} prefix key always works both shifted and unshifted, and
12226 the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h}
12227 prefix is not affected by this mode. Press @kbd{m S} again to disable
12228 shifted-prefix mode.
12230 @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
12235 @pindex calc-precision
12236 @cindex Precision of calculations
12237 The @kbd{p} (@code{calc-precision}) command controls the precision to
12238 which floating-point calculations are carried. The precision must be
12239 at least 3 digits and may be arbitrarily high, within the limits of
12240 memory and time. This affects only floats: Integer and rational
12241 calculations are always carried out with as many digits as necessary.
12243 The @kbd{p} key prompts for the current precision. If you wish you
12244 can instead give the precision as a numeric prefix argument.
12246 Many internal calculations are carried to one or two digits higher
12247 precision than normal. Results are rounded down afterward to the
12248 current precision. Unless a special display mode has been selected,
12249 floats are always displayed with their full stored precision, i.e.,
12250 what you see is what you get. Reducing the current precision does not
12251 round values already on the stack, but those values will be rounded
12252 down before being used in any calculation. The @kbd{c 0} through
12253 @kbd{c 9} commands (@pxref{Conversions}) can be used to round an
12254 existing value to a new precision.@refill
12256 @cindex Accuracy of calculations
12257 It is important to distinguish the concepts of @dfn{precision} and
12258 @dfn{accuracy}. In the normal usage of these words, the number
12259 123.4567 has a precision of 7 digits but an accuracy of 4 digits.
12260 The precision is the total number of digits not counting leading
12261 or trailing zeros (regardless of the position of the decimal point).
12262 The accuracy is simply the number of digits after the decimal point
12263 (again not counting trailing zeros). In Calc you control the precision,
12264 not the accuracy of computations. If you were to set the accuracy
12265 instead, then calculations like @samp{exp(100)} would generate many
12266 more digits than you would typically need, while @samp{exp(-100)} would
12267 probably round to zero! In Calc, both these computations give you
12268 exactly 12 (or the requested number of) significant digits.
12270 The only Calc features that deal with accuracy instead of precision
12271 are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
12272 and the rounding functions like @code{floor} and @code{round}
12273 (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9}
12274 deal with both precision and accuracy depending on the magnitudes
12275 of the numbers involved.
12277 If you need to work with a particular fixed accuracy (say, dollars and
12278 cents with two digits after the decimal point), one solution is to work
12279 with integers and an ``implied'' decimal point. For example, $8.99
12280 divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
12281 (actually $1.49833 with our implied decimal point); pressing @kbd{R}
12282 would round this to 150 cents, i.e., $1.50.
12284 @xref{Floats}, for still more on floating-point precision and related
12287 @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
12288 @section Inverse and Hyperbolic Flags
12292 @pindex calc-inverse
12293 There is no single-key equivalent to the @code{calc-arcsin} function.
12294 Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
12295 the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
12296 The @kbd{I} key actually toggles the Inverse Flag. When this flag
12297 is set, the word @samp{Inv} appears in the mode line.@refill
12300 @pindex calc-hyperbolic
12301 Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
12302 Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
12303 If both of these flags are set at once, the effect will be
12304 @code{calc-arcsinh}. (The Hyperbolic flag is also used by some
12305 non-trigonometric commands; for example @kbd{H L} computes a base-10,
12306 instead of base-@i{e}, logarithm.)@refill
12308 Command names like @code{calc-arcsin} are provided for completeness, and
12309 may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to
12310 toggle the Inverse and/or Hyperbolic flags and then execute the
12311 corresponding base command (@code{calc-sin} in this case).
12313 The Inverse and Hyperbolic flags apply only to the next Calculator
12314 command, after which they are automatically cleared. (They are also
12315 cleared if the next keystroke is not a Calc command.) Digits you
12316 type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix
12317 arguments for the next command, not as numeric entries. The same
12318 is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to
12319 subtract and keep arguments).
12321 The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed
12322 elsewhere. @xref{Keep Arguments}.
12324 @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
12325 @section Calculation Modes
12328 The commands in this section are two-key sequences beginning with
12329 the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.)
12330 The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
12331 (@pxref{Algebraic Entry}).
12340 * Automatic Recomputation::
12341 * Working Message::
12344 @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
12345 @subsection Angular Modes
12348 @cindex Angular mode
12349 The Calculator supports three notations for angles: radians, degrees,
12350 and degrees-minutes-seconds. When a number is presented to a function
12351 like @code{sin} that requires an angle, the current angular mode is
12352 used to interpret the number as either radians or degrees. If an HMS
12353 form is presented to @code{sin}, it is always interpreted as
12354 degrees-minutes-seconds.
12356 Functions that compute angles produce a number in radians, a number in
12357 degrees, or an HMS form depending on the current angular mode. If the
12358 result is a complex number and the current mode is HMS, the number is
12359 instead expressed in degrees. (Complex-number calculations would
12360 normally be done in radians mode, though. Complex numbers are converted
12361 to degrees by calculating the complex result in radians and then
12362 multiplying by 180 over @c{$\pi$}
12366 @pindex calc-radians-mode
12368 @pindex calc-degrees-mode
12370 @pindex calc-hms-mode
12371 The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
12372 and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
12373 The current angular mode is displayed on the Emacs mode line.
12374 The default angular mode is degrees.@refill
12376 @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
12377 @subsection Polar Mode
12381 The Calculator normally ``prefers'' rectangular complex numbers in the
12382 sense that rectangular form is used when the proper form can not be
12383 decided from the input. This might happen by multiplying a rectangular
12384 number by a polar one, by taking the square root of a negative real
12385 number, or by entering @kbd{( 2 @key{SPC} 3 )}.
12388 @pindex calc-polar-mode
12389 The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
12390 preference between rectangular and polar forms. In polar mode, all
12391 of the above example situations would produce polar complex numbers.
12393 @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
12394 @subsection Fraction Mode
12397 @cindex Fraction mode
12398 @cindex Division of integers
12399 Division of two integers normally yields a floating-point number if the
12400 result cannot be expressed as an integer. In some cases you would
12401 rather get an exact fractional answer. One way to accomplish this is
12402 to multiply fractions instead: @kbd{6 @key{RET} 1:4 *} produces @cite{3:2}
12403 even though @kbd{6 @key{RET} 4 /} produces @cite{1.5}.
12406 @pindex calc-frac-mode
12407 To set the Calculator to produce fractional results for normal integer
12408 divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
12409 For example, @cite{8/4} produces @cite{2} in either mode,
12410 but @cite{6/4} produces @cite{3:2} in Fraction Mode, @cite{1.5} in
12413 At any time you can use @kbd{c f} (@code{calc-float}) to convert a
12414 fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
12415 float to a fraction. @xref{Conversions}.
12417 @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
12418 @subsection Infinite Mode
12421 @cindex Infinite mode
12422 The Calculator normally treats results like @cite{1 / 0} as errors;
12423 formulas like this are left in unsimplified form. But Calc can be
12424 put into a mode where such calculations instead produce ``infinite''
12428 @pindex calc-infinite-mode
12429 The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
12430 on and off. When the mode is off, infinities do not arise except
12431 in calculations that already had infinities as inputs. (One exception
12432 is that infinite open intervals like @samp{[0 .. inf)} can be
12433 generated; however, intervals closed at infinity (@samp{[0 .. inf]})
12434 will not be generated when infinite mode is off.)
12436 With infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
12437 an undirected infinity. @xref{Infinities}, for a discussion of the
12438 difference between @code{inf} and @code{uinf}. Also, @cite{0 / 0}
12439 evaluates to @code{nan}, the ``indeterminate'' symbol. Various other
12440 functions can also return infinities in this mode; for example,
12441 @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again,
12442 note that @samp{exp(inf) = inf} regardless of infinite mode because
12443 this calculation has infinity as an input.
12445 @cindex Positive infinite mode
12446 The @kbd{m i} command with a numeric prefix argument of zero,
12447 i.e., @kbd{C-u 0 m i}, turns on a ``positive infinite mode'' in
12448 which zero is treated as positive instead of being directionless.
12449 Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
12450 Note that zero never actually has a sign in Calc; there are no
12451 separate representations for @i{+0} and @i{-0}. Positive
12452 infinite mode merely changes the interpretation given to the
12453 single symbol, @samp{0}. One consequence of this is that, while
12454 you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
12455 is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
12457 @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
12458 @subsection Symbolic Mode
12461 @cindex Symbolic mode
12462 @cindex Inexact results
12463 Calculations are normally performed numerically wherever possible.
12464 For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
12465 algebraic expression, produces a numeric answer if the argument is a
12466 number or a symbolic expression if the argument is an expression:
12467 @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
12470 @pindex calc-symbolic-mode
12471 In @dfn{symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
12472 command, functions which would produce inexact, irrational results are
12473 left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
12477 @pindex calc-eval-num
12478 The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
12479 the expression at the top of the stack, by temporarily disabling
12480 @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
12481 Given a numeric prefix argument, it also
12482 sets the floating-point precision to the specified value for the duration
12483 of the command.@refill
12485 To evaluate a formula numerically without expanding the variables it
12486 contains, you can use the key sequence @kbd{m s a v m s} (this uses
12487 @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
12490 @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
12491 @subsection Matrix and Scalar Modes
12494 @cindex Matrix mode
12495 @cindex Scalar mode
12496 Calc sometimes makes assumptions during algebraic manipulation that
12497 are awkward or incorrect when vectors and matrices are involved.
12498 Calc has two modes, @dfn{matrix mode} and @dfn{scalar mode}, which
12499 modify its behavior around vectors in useful ways.
12502 @pindex calc-matrix-mode
12503 Press @kbd{m v} (@code{calc-matrix-mode}) once to enter matrix mode.
12504 In this mode, all objects are assumed to be matrices unless provably
12505 otherwise. One major effect is that Calc will no longer consider
12506 multiplication to be commutative. (Recall that in matrix arithmetic,
12507 @samp{A*B} is not the same as @samp{B*A}.) This assumption affects
12508 rewrite rules and algebraic simplification. Another effect of this
12509 mode is that calculations that would normally produce constants like
12510 0 and 1 (e.g., @cite{a - a} and @cite{a / a}, respectively) will now
12511 produce function calls that represent ``generic'' zero or identity
12512 matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function
12513 @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
12514 identity matrix; if @var{n} is omitted, it doesn't know what
12515 dimension to use and so the @code{idn} call remains in symbolic
12516 form. However, if this generic identity matrix is later combined
12517 with a matrix whose size is known, it will be converted into
12518 a true identity matrix of the appropriate size. On the other hand,
12519 if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
12520 will assume it really was a scalar after all and produce, e.g., 3.
12522 Press @kbd{m v} a second time to get scalar mode. Here, objects are
12523 assumed @emph{not} to be vectors or matrices unless provably so.
12524 For example, normally adding a variable to a vector, as in
12525 @samp{[x, y, z] + a}, will leave the sum in symbolic form because
12526 as far as Calc knows, @samp{a} could represent either a number or
12527 another 3-vector. In scalar mode, @samp{a} is assumed to be a
12528 non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
12530 Press @kbd{m v} a third time to return to the normal mode of operation.
12532 If you press @kbd{m v} with a numeric prefix argument @var{n}, you
12533 get a special ``dimensioned matrix mode'' in which matrices of
12534 unknown size are assumed to be @var{n}x@var{n} square matrices.
12535 Then, the function call @samp{idn(1)} will expand into an actual
12536 matrix rather than representing a ``generic'' matrix.
12538 @cindex Declaring scalar variables
12539 Of course these modes are approximations to the true state of
12540 affairs, which is probably that some quantities will be matrices
12541 and others will be scalars. One solution is to ``declare''
12542 certain variables or functions to be scalar-valued.
12543 @xref{Declarations}, to see how to make declarations in Calc.
12545 There is nothing stopping you from declaring a variable to be
12546 scalar and then storing a matrix in it; however, if you do, the
12547 results you get from Calc may not be valid. Suppose you let Calc
12548 get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
12549 @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as
12550 for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
12551 your earlier promise to Calc that @samp{a} would be scalar.
12553 Another way to mix scalars and matrices is to use selections
12554 (@pxref{Selecting Subformulas}). Use matrix mode when operating on
12555 your formula normally; then, to apply scalar mode to a certain part
12556 of the formula without affecting the rest just select that part,
12557 change into scalar mode and press @kbd{=} to resimplify the part
12558 under this mode, then change back to matrix mode before deselecting.
12560 @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
12561 @subsection Automatic Recomputation
12564 The @dfn{evaluates-to} operator, @samp{=>}, has the special
12565 property that any @samp{=>} formulas on the stack are recomputed
12566 whenever variable values or mode settings that might affect them
12567 are changed. @xref{Evaluates-To Operator}.
12570 @pindex calc-auto-recompute
12571 The @kbd{m C} (@code{calc-auto-recompute}) command turns this
12572 automatic recomputation on and off. If you turn it off, Calc will
12573 not update @samp{=>} operators on the stack (nor those in the
12574 attached Embedded Mode buffer, if there is one). They will not
12575 be updated unless you explicitly do so by pressing @kbd{=} or until
12576 you press @kbd{m C} to turn recomputation back on. (While automatic
12577 recomputation is off, you can think of @kbd{m C m C} as a command
12578 to update all @samp{=>} operators while leaving recomputation off.)
12580 To update @samp{=>} operators in an Embedded buffer while
12581 automatic recomputation is off, use @w{@kbd{M-# u}}.
12582 @xref{Embedded Mode}.
12584 @node Working Message, , Automatic Recomputation, Calculation Modes
12585 @subsection Working Messages
12588 @cindex Performance
12589 @cindex Working messages
12590 Since the Calculator is written entirely in Emacs Lisp, which is not
12591 designed for heavy numerical work, many operations are quite slow.
12592 The Calculator normally displays the message @samp{Working...} in the
12593 echo area during any command that may be slow. In addition, iterative
12594 operations such as square roots and trigonometric functions display the
12595 intermediate result at each step. Both of these types of messages can
12596 be disabled if you find them distracting.
12599 @pindex calc-working
12600 Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
12601 disable all ``working'' messages. Use a numeric prefix of 1 to enable
12602 only the plain @samp{Working...} message. Use a numeric prefix of 2 to
12603 see intermediate results as well. With no numeric prefix this displays
12604 the current mode.@refill
12606 While it may seem that the ``working'' messages will slow Calc down
12607 considerably, experiments have shown that their impact is actually
12608 quite small. But if your terminal is slow you may find that it helps
12609 to turn the messages off.
12611 @node Simplification Modes, Declarations, Calculation Modes, Mode Settings
12612 @section Simplification Modes
12615 The current @dfn{simplification mode} controls how numbers and formulas
12616 are ``normalized'' when being taken from or pushed onto the stack.
12617 Some normalizations are unavoidable, such as rounding floating-point
12618 results to the current precision, and reducing fractions to simplest
12619 form. Others, such as simplifying a formula like @cite{a+a} (or @cite{2+3}),
12620 are done by default but can be turned off when necessary.
12622 When you press a key like @kbd{+} when @cite{2} and @cite{3} are on the
12623 stack, Calc pops these numbers, normalizes them, creates the formula
12624 @cite{2+3}, normalizes it, and pushes the result. Of course the standard
12625 rules for normalizing @cite{2+3} will produce the result @cite{5}.
12627 Simplification mode commands consist of the lower-case @kbd{m} prefix key
12628 followed by a shifted letter.
12631 @pindex calc-no-simplify-mode
12632 The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
12633 simplifications. These would leave a formula like @cite{2+3} alone. In
12634 fact, nothing except simple numbers are ever affected by normalization
12638 @pindex calc-num-simplify-mode
12639 The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
12640 of any formulas except those for which all arguments are constants. For
12641 example, @cite{1+2} is simplified to @cite{3}, and @cite{a+(2-2)} is
12642 simplified to @cite{a+0} but no further, since one argument of the sum
12643 is not a constant. Unfortunately, @cite{(a+2)-2} is @emph{not} simplified
12644 because the top-level @samp{-} operator's arguments are not both
12645 constant numbers (one of them is the formula @cite{a+2}).
12646 A constant is a number or other numeric object (such as a constant
12647 error form or modulo form), or a vector all of whose
12648 elements are constant.@refill
12651 @pindex calc-default-simplify-mode
12652 The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
12653 default simplifications for all formulas. This includes many easy and
12654 fast algebraic simplifications such as @cite{a+0} to @cite{a}, and
12655 @cite{a + 2 a} to @cite{3 a}, as well as evaluating functions like
12656 @cite{@t{deriv}(x^2, x)} to @cite{2 x}.
12659 @pindex calc-bin-simplify-mode
12660 The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
12661 simplifications to a result and then, if the result is an integer,
12662 uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
12663 to the current binary word size. @xref{Binary Functions}. Real numbers
12664 are rounded to the nearest integer and then clipped; other kinds of
12665 results (after the default simplifications) are left alone.
12668 @pindex calc-alg-simplify-mode
12669 The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
12670 simplification; it applies all the default simplifications, and also
12671 the more powerful (and slower) simplifications made by @kbd{a s}
12672 (@code{calc-simplify}). @xref{Algebraic Simplifications}.
12675 @pindex calc-ext-simplify-mode
12676 The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
12677 algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
12678 command. @xref{Unsafe Simplifications}.
12681 @pindex calc-units-simplify-mode
12682 The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
12683 simplification; it applies the command @kbd{u s}
12684 (@code{calc-simplify-units}), which in turn
12685 is a superset of @kbd{a s}. In this mode, variable names which
12686 are identifiable as unit names (like @samp{mm} for ``millimeters'')
12687 are simplified with their unit definitions in mind.@refill
12689 A common technique is to set the simplification mode down to the lowest
12690 amount of simplification you will allow to be applied automatically, then
12691 use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
12692 perform higher types of simplifications on demand. @xref{Algebraic
12693 Definitions}, for another sample use of no-simplification mode.@refill
12695 @node Declarations, Display Modes, Simplification Modes, Mode Settings
12696 @section Declarations
12699 A @dfn{declaration} is a statement you make that promises you will
12700 use a certain variable or function in a restricted way. This may
12701 give Calc the freedom to do things that it couldn't do if it had to
12702 take the fully general situation into account.
12705 * Declaration Basics::
12706 * Kinds of Declarations::
12707 * Functions for Declarations::
12710 @node Declaration Basics, Kinds of Declarations, Declarations, Declarations
12711 @subsection Declaration Basics
12715 @pindex calc-declare-variable
12716 The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
12717 way to make a declaration for a variable. This command prompts for
12718 the variable name, then prompts for the declaration. The default
12719 at the declaration prompt is the previous declaration, if any.
12720 You can edit this declaration, or press @kbd{C-k} to erase it and
12721 type a new declaration. (Or, erase it and press @key{RET} to clear
12722 the declaration, effectively ``undeclaring'' the variable.)
12724 A declaration is in general a vector of @dfn{type symbols} and
12725 @dfn{range} values. If there is only one type symbol or range value,
12726 you can write it directly rather than enclosing it in a vector.
12727 For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
12728 be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
12729 declares @code{bar} to be a constant integer between 1 and 6.
12730 (Actually, you can omit the outermost brackets and Calc will
12731 provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
12733 @cindex @code{Decls} variable
12735 Declarations in Calc are kept in a special variable called @code{Decls}.
12736 This variable encodes the set of all outstanding declarations in
12737 the form of a matrix. Each row has two elements: A variable or
12738 vector of variables declared by that row, and the declaration
12739 specifier as described above. You can use the @kbd{s D} command to
12740 edit this variable if you wish to see all the declarations at once.
12741 @xref{Operations on Variables}, for a description of this command
12742 and the @kbd{s p} command that allows you to save your declarations
12743 permanently if you wish.
12745 Items being declared can also be function calls. The arguments in
12746 the call are ignored; the effect is to say that this function returns
12747 values of the declared type for any valid arguments. The @kbd{s d}
12748 command declares only variables, so if you wish to make a function
12749 declaration you will have to edit the @code{Decls} matrix yourself.
12751 For example, the declaration matrix
12757 [ f(1,2,3), [0 .. inf) ] ]
12762 declares that @code{foo} represents a real number, @code{j}, @code{k}
12763 and @code{n} represent integers, and the function @code{f} always
12764 returns a real number in the interval shown.
12767 If there is a declaration for the variable @code{All}, then that
12768 declaration applies to all variables that are not otherwise declared.
12769 It does not apply to function names. For example, using the row
12770 @samp{[All, real]} says that all your variables are real unless they
12771 are explicitly declared without @code{real} in some other row.
12772 The @kbd{s d} command declares @code{All} if you give a blank
12773 response to the variable-name prompt.
12775 @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
12776 @subsection Kinds of Declarations
12779 The type-specifier part of a declaration (that is, the second prompt
12780 in the @kbd{s d} command) can be a type symbol, an interval, or a
12781 vector consisting of zero or more type symbols followed by zero or
12782 more intervals or numbers that represent the set of possible values
12787 [ [ a, [1, 2, 3, 4, 5] ]
12789 [ c, [int, 1 .. 5] ] ]
12793 Here @code{a} is declared to contain one of the five integers shown;
12794 @code{b} is any number in the interval from 1 to 5 (any real number
12795 since we haven't specified), and @code{c} is any integer in that
12796 interval. Thus the declarations for @code{a} and @code{c} are
12797 nearly equivalent (see below).
12799 The type-specifier can be the empty vector @samp{[]} to say that
12800 nothing is known about a given variable's value. This is the same
12801 as not declaring the variable at all except that it overrides any
12802 @code{All} declaration which would otherwise apply.
12804 The initial value of @code{Decls} is the empty vector @samp{[]}.
12805 If @code{Decls} has no stored value or if the value stored in it
12806 is not valid, it is ignored and there are no declarations as far
12807 as Calc is concerned. (The @kbd{s d} command will replace such a
12808 malformed value with a fresh empty matrix, @samp{[]}, before recording
12809 the new declaration.) Unrecognized type symbols are ignored.
12811 The following type symbols describe what sorts of numbers will be
12812 stored in a variable:
12818 Numerical integers. (Integers or integer-valued floats.)
12820 Fractions. (Rational numbers which are not integers.)
12822 Rational numbers. (Either integers or fractions.)
12824 Floating-point numbers.
12826 Real numbers. (Integers, fractions, or floats. Actually,
12827 intervals and error forms with real components also count as
12830 Positive real numbers. (Strictly greater than zero.)
12832 Nonnegative real numbers. (Greater than or equal to zero.)
12834 Numbers. (Real or complex.)
12837 Calc uses this information to determine when certain simplifications
12838 of formulas are safe. For example, @samp{(x^y)^z} cannot be
12839 simplified to @samp{x^(y z)} in general; for example,
12840 @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @i{-3}.
12841 However, this simplification @emph{is} safe if @code{z} is known
12842 to be an integer, or if @code{x} is known to be a nonnegative
12843 real number. If you have given declarations that allow Calc to
12844 deduce either of these facts, Calc will perform this simplification
12847 Calc can apply a certain amount of logic when using declarations.
12848 For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
12849 has been declared @code{int}; Calc knows that an integer times an
12850 integer, plus an integer, must always be an integer. (In fact,
12851 Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
12852 it is able to determine that @samp{2n+1} must be an odd integer.)
12854 Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
12855 because Calc knows that the @code{abs} function always returns a
12856 nonnegative real. If you had a @code{myabs} function that also had
12857 this property, you could get Calc to recognize it by adding the row
12858 @samp{[myabs(), nonneg]} to the @code{Decls} matrix.
12860 One instance of this simplification is @samp{sqrt(x^2)} (since the
12861 @code{sqrt} function is effectively a one-half power). Normally
12862 Calc leaves this formula alone. After the command
12863 @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
12864 @samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
12865 simplify this formula all the way to @samp{x}.
12867 If there are any intervals or real numbers in the type specifier,
12868 they comprise the set of possible values that the variable or
12869 function being declared can have. In particular, the type symbol
12870 @code{real} is effectively the same as the range @samp{[-inf .. inf]}
12871 (note that infinity is included in the range of possible values);
12872 @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
12873 the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is
12874 redundant because the fact that the variable is real can be
12875 deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
12876 @samp{[rat, [-5 .. 5]]} are useful combinations.
12878 Note that the vector of intervals or numbers is in the same format
12879 used by Calc's set-manipulation commands. @xref{Set Operations}.
12881 The type specifier @samp{[1, 2, 3]} is equivalent to
12882 @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
12883 In other words, the range of possible values means only that
12884 the variable's value must be numerically equal to a number in
12885 that range, but not that it must be equal in type as well.
12886 Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
12887 and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
12889 If you use a conflicting combination of type specifiers, the
12890 results are unpredictable. An example is @samp{[pos, [0 .. 5]]},
12891 where the interval does not lie in the range described by the
12894 ``Real'' declarations mostly affect simplifications involving powers
12895 like the one described above. Another case where they are used
12896 is in the @kbd{a P} command which returns a list of all roots of a
12897 polynomial; if the variable has been declared real, only the real
12898 roots (if any) will be included in the list.
12900 ``Integer'' declarations are used for simplifications which are valid
12901 only when certain values are integers (such as @samp{(x^y)^z}
12904 Another command that makes use of declarations is @kbd{a s}, when
12905 simplifying equations and inequalities. It will cancel @code{x}
12906 from both sides of @samp{a x = b x} only if it is sure @code{x}
12907 is non-zero, say, because it has a @code{pos} declaration.
12908 To declare specifically that @code{x} is real and non-zero,
12909 use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
12910 current notation to say that @code{x} is nonzero but not necessarily
12911 real.) The @kbd{a e} command does ``unsafe'' simplifications,
12912 including cancelling @samp{x} from the equation when @samp{x} is
12913 not known to be nonzero.
12915 Another set of type symbols distinguish between scalars and vectors.
12919 The value is not a vector.
12921 The value is a vector.
12923 The value is a matrix (a rectangular vector of vectors).
12926 These type symbols can be combined with the other type symbols
12927 described above; @samp{[int, matrix]} describes an object which
12928 is a matrix of integers.
12930 Scalar/vector declarations are used to determine whether certain
12931 algebraic operations are safe. For example, @samp{[a, b, c] + x}
12932 is normally not simplified to @samp{[a + x, b + x, c + x]}, but
12933 it will be if @code{x} has been declared @code{scalar}. On the
12934 other hand, multiplication is usually assumed to be commutative,
12935 but the terms in @samp{x y} will never be exchanged if both @code{x}
12936 and @code{y} are known to be vectors or matrices. (Calc currently
12937 never distinguishes between @code{vector} and @code{matrix}
12940 @xref{Matrix Mode}, for a discussion of ``matrix mode'' and
12941 ``scalar mode,'' which are similar to declaring @samp{[All, matrix]}
12942 or @samp{[All, scalar]} but much more convenient.
12944 One more type symbol that is recognized is used with the @kbd{H a d}
12945 command for taking total derivatives of a formula. @xref{Calculus}.
12949 The value is a constant with respect to other variables.
12952 Calc does not check the declarations for a variable when you store
12953 a value in it. However, storing @i{-3.5} in a variable that has
12954 been declared @code{pos}, @code{int}, or @code{matrix} may have
12955 unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @cite{3.5}
12956 if it substitutes the value first, or to @cite{-3.5} if @code{x}
12957 was declared @code{pos} and the formula @samp{sqrt(x^2)} is
12958 simplified to @samp{x} before the value is substituted. Before
12959 using a variable for a new purpose, it is best to use @kbd{s d}
12960 or @kbd{s D} to check to make sure you don't still have an old
12961 declaration for the variable that will conflict with its new meaning.
12963 @node Functions for Declarations, , Kinds of Declarations, Declarations
12964 @subsection Functions for Declarations
12967 Calc has a set of functions for accessing the current declarations
12968 in a convenient manner. These functions return 1 if the argument
12969 can be shown to have the specified property, or 0 if the argument
12970 can be shown @emph{not} to have that property; otherwise they are
12971 left unevaluated. These functions are suitable for use with rewrite
12972 rules (@pxref{Conditional Rewrite Rules}) or programming constructs
12973 (@pxref{Conditionals in Macros}). They can be entered only using
12974 algebraic notation. @xref{Logical Operations}, for functions
12975 that perform other tests not related to declarations.
12977 For example, @samp{dint(17)} returns 1 because 17 is an integer, as
12978 do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
12979 @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
12980 Calc consults knowledge of its own built-in functions as well as your
12981 own declarations: @samp{dint(floor(x))} returns 1.
12995 The @code{dint} function checks if its argument is an integer.
12996 The @code{dnatnum} function checks if its argument is a natural
12997 number, i.e., a nonnegative integer. The @code{dnumint} function
12998 checks if its argument is numerically an integer, i.e., either an
12999 integer or an integer-valued float. Note that these and the other
13000 data type functions also accept vectors or matrices composed of
13001 suitable elements, and that real infinities @samp{inf} and @samp{-inf}
13002 are considered to be integers for the purposes of these functions.
13008 The @code{drat} function checks if its argument is rational, i.e.,
13009 an integer or fraction. Infinities count as rational, but intervals
13010 and error forms do not.
13016 The @code{dreal} function checks if its argument is real. This
13017 includes integers, fractions, floats, real error forms, and intervals.
13023 The @code{dimag} function checks if its argument is imaginary,
13024 i.e., is mathematically equal to a real number times @cite{i}.
13038 The @code{dpos} function checks for positive (but nonzero) reals.
13039 The @code{dneg} function checks for negative reals. The @code{dnonneg}
13040 function checks for nonnegative reals, i.e., reals greater than or
13041 equal to zero. Note that the @kbd{a s} command can simplify an
13042 expression like @cite{x > 0} to 1 or 0 using @code{dpos}, and that
13043 @kbd{a s} is effectively applied to all conditions in rewrite rules,
13044 so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
13045 are rarely necessary.
13051 The @code{dnonzero} function checks that its argument is nonzero.
13052 This includes all nonzero real or complex numbers, all intervals that
13053 do not include zero, all nonzero modulo forms, vectors all of whose
13054 elements are nonzero, and variables or formulas whose values can be
13055 deduced to be nonzero. It does not include error forms, since they
13056 represent values which could be anything including zero. (This is
13057 also the set of objects considered ``true'' in conditional contexts.)
13067 The @code{deven} function returns 1 if its argument is known to be
13068 an even integer (or integer-valued float); it returns 0 if its argument
13069 is known not to be even (because it is known to be odd or a non-integer).
13070 The @kbd{a s} command uses this to simplify a test of the form
13071 @samp{x % 2 = 0}. There is also an analogous @code{dodd} function.
13077 The @code{drange} function returns a set (an interval or a vector
13078 of intervals and/or numbers; @pxref{Set Operations}) that describes
13079 the set of possible values of its argument. If the argument is
13080 a variable or a function with a declaration, the range is copied
13081 from the declaration. Otherwise, the possible signs of the
13082 expression are determined using a method similar to @code{dpos},
13083 etc., and a suitable set like @samp{[0 .. inf]} is returned. If
13084 the expression is not provably real, the @code{drange} function
13085 remains unevaluated.
13091 The @code{dscalar} function returns 1 if its argument is provably
13092 scalar, or 0 if its argument is provably non-scalar. It is left
13093 unevaluated if this cannot be determined. (If matrix mode or scalar
13094 mode are in effect, this function returns 1 or 0, respectively,
13095 if it has no other information.) When Calc interprets a condition
13096 (say, in a rewrite rule) it considers an unevaluated formula to be
13097 ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
13098 provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
13099 is provably non-scalar; both are ``false'' if there is insufficient
13100 information to tell.
13102 @node Display Modes, Language Modes, Declarations, Mode Settings
13103 @section Display Modes
13106 The commands in this section are two-key sequences beginning with the
13107 @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
13108 (@code{calc-line-breaking}) commands are described elsewhere;
13109 @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
13110 Display formats for vectors and matrices are also covered elsewhere;
13111 @pxref{Vector and Matrix Formats}.@refill
13113 One thing all display modes have in common is their treatment of the
13114 @kbd{H} prefix. This prefix causes any mode command that would normally
13115 refresh the stack to leave the stack display alone. The word ``Dirty''
13116 will appear in the mode line when Calc thinks the stack display may not
13117 reflect the latest mode settings.
13119 @kindex d @key{RET}
13120 @pindex calc-refresh-top
13121 The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
13122 top stack entry according to all the current modes. Positive prefix
13123 arguments reformat the top @var{n} entries; negative prefix arguments
13124 reformat the specified entry, and a prefix of zero is equivalent to
13125 @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
13126 For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
13127 but reformats only the top two stack entries in the new mode.
13129 The @kbd{I} prefix has another effect on the display modes. The mode
13130 is set only temporarily; the top stack entry is reformatted according
13131 to that mode, then the original mode setting is restored. In other
13132 words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
13136 * Grouping Digits::
13138 * Complex Formats::
13139 * Fraction Formats::
13142 * Truncating the Stack::
13147 @node Radix Modes, Grouping Digits, Display Modes, Display Modes
13148 @subsection Radix Modes
13151 @cindex Radix display
13152 @cindex Non-decimal numbers
13153 @cindex Decimal and non-decimal numbers
13154 Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
13155 notation. Calc can actually display in any radix from two (binary) to 36.
13156 When the radix is above 10, the letters @code{A} to @code{Z} are used as
13157 digits. When entering such a number, letter keys are interpreted as
13158 potential digits rather than terminating numeric entry mode.
13164 @cindex Hexadecimal integers
13165 @cindex Octal integers
13166 The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
13167 binary, octal, hexadecimal, and decimal as the current display radix,
13168 respectively. Numbers can always be entered in any radix, though the
13169 current radix is used as a default if you press @kbd{#} without any initial
13170 digits. A number entered without a @kbd{#} is @emph{always} interpreted
13175 To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
13176 an integer from 2 to 36. You can specify the radix as a numeric prefix
13177 argument; otherwise you will be prompted for it.
13180 @pindex calc-leading-zeros
13181 @cindex Leading zeros
13182 Integers normally are displayed with however many digits are necessary to
13183 represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros})
13184 command causes integers to be padded out with leading zeros according to the
13185 current binary word size. (@xref{Binary Functions}, for a discussion of
13186 word size.) If the absolute value of the word size is @cite{w}, all integers
13187 are displayed with at least enough digits to represent @c{$2^w-1$}
13188 @cite{(2^w)-1} in the
13189 current radix. (Larger integers will still be displayed in their entirety.)
13191 @node Grouping Digits, Float Formats, Radix Modes, Display Modes
13192 @subsection Grouping Digits
13196 @pindex calc-group-digits
13197 @cindex Grouping digits
13198 @cindex Digit grouping
13199 Long numbers can be hard to read if they have too many digits. For
13200 example, the factorial of 30 is 33 digits long! Press @kbd{d g}
13201 (@code{calc-group-digits}) to enable @dfn{grouping} mode, in which digits
13202 are displayed in clumps of 3 or 4 (depending on the current radix)
13203 separated by commas.
13205 The @kbd{d g} command toggles grouping on and off.
13206 With a numerix prefix of 0, this command displays the current state of
13207 the grouping flag; with an argument of minus one it disables grouping;
13208 with a positive argument @cite{N} it enables grouping on every @cite{N}
13209 digits. For floating-point numbers, grouping normally occurs only
13210 before the decimal point. A negative prefix argument @cite{-N} enables
13211 grouping every @cite{N} digits both before and after the decimal point.@refill
13214 @pindex calc-group-char
13215 The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
13216 character as the grouping separator. The default is the comma character.
13217 If you find it difficult to read vectors of large integers grouped with
13218 commas, you may wish to use spaces or some other character instead.
13219 This command takes the next character you type, whatever it is, and
13220 uses it as the digit separator. As a special case, @kbd{d , \} selects
13221 @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
13223 Please note that grouped numbers will not generally be parsed correctly
13224 if re-read in textual form, say by the use of @kbd{M-# y} and @kbd{M-# g}.
13225 (@xref{Kill and Yank}, for details on these commands.) One exception is
13226 the @samp{\,} separator, which doesn't interfere with parsing because it
13227 is ignored by @TeX{} language mode.
13229 @node Float Formats, Complex Formats, Grouping Digits, Display Modes
13230 @subsection Float Formats
13233 Floating-point quantities are normally displayed in standard decimal
13234 form, with scientific notation used if the exponent is especially high
13235 or low. All significant digits are normally displayed. The commands
13236 in this section allow you to choose among several alternative display
13237 formats for floats.
13240 @pindex calc-normal-notation
13241 The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
13242 display format. All significant figures in a number are displayed.
13243 With a positive numeric prefix, numbers are rounded if necessary to
13244 that number of significant digits. With a negative numerix prefix,
13245 the specified number of significant digits less than the current
13246 precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the
13247 current precision is 12.)
13250 @pindex calc-fix-notation
13251 The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
13252 notation. The numeric argument is the number of digits after the
13253 decimal point, zero or more. This format will relax into scientific
13254 notation if a nonzero number would otherwise have been rounded all the
13255 way to zero. Specifying a negative number of digits is the same as
13256 for a positive number, except that small nonzero numbers will be rounded
13257 to zero rather than switching to scientific notation.
13260 @pindex calc-sci-notation
13261 @cindex Scientific notation, display of
13262 The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
13263 notation. A positive argument sets the number of significant figures
13264 displayed, of which one will be before and the rest after the decimal
13265 point. A negative argument works the same as for @kbd{d n} format.
13266 The default is to display all significant digits.
13269 @pindex calc-eng-notation
13270 @cindex Engineering notation, display of
13271 The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
13272 notation. This is similar to scientific notation except that the
13273 exponent is rounded down to a multiple of three, with from one to three
13274 digits before the decimal point. An optional numeric prefix sets the
13275 number of significant digits to display, as for @kbd{d s}.
13277 It is important to distinguish between the current @emph{precision} and
13278 the current @emph{display format}. After the commands @kbd{C-u 10 p}
13279 and @kbd{C-u 6 d n} the Calculator computes all results to ten
13280 significant figures but displays only six. (In fact, intermediate
13281 calculations are often carried to one or two more significant figures,
13282 but values placed on the stack will be rounded down to ten figures.)
13283 Numbers are never actually rounded to the display precision for storage,
13284 except by commands like @kbd{C-k} and @kbd{M-# y} which operate on the
13285 actual displayed text in the Calculator buffer.
13288 @pindex calc-point-char
13289 The @kbd{d .} (@code{calc-point-char}) command selects the character used
13290 as a decimal point. Normally this is a period; users in some countries
13291 may wish to change this to a comma. Note that this is only a display
13292 style; on entry, periods must always be used to denote floating-point
13293 numbers, and commas to separate elements in a list.
13295 @node Complex Formats, Fraction Formats, Float Formats, Display Modes
13296 @subsection Complex Formats
13300 @pindex calc-complex-notation
13301 There are three supported notations for complex numbers in rectangular
13302 form. The default is as a pair of real numbers enclosed in parentheses
13303 and separated by a comma: @samp{(a,b)}. The @kbd{d c}
13304 (@code{calc-complex-notation}) command selects this style.@refill
13307 @pindex calc-i-notation
13309 @pindex calc-j-notation
13310 The other notations are @kbd{d i} (@code{calc-i-notation}), in which
13311 numbers are displayed in @samp{a+bi} form, and @kbd{d j}
13312 (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
13313 in some disciplines.@refill
13315 @cindex @code{i} variable
13317 Complex numbers are normally entered in @samp{(a,b)} format.
13318 If you enter @samp{2+3i} as an algebraic formula, it will be stored as
13319 the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate
13320 this formula and you have not changed the variable @samp{i}, the @samp{i}
13321 will be interpreted as @samp{(0,1)} and the formula will be simplified
13322 to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not}
13323 interpret the formula @samp{2 + 3 * i} as a complex number.
13324 @xref{Variables}, under ``special constants.''@refill
13326 @node Fraction Formats, HMS Formats, Complex Formats, Display Modes
13327 @subsection Fraction Formats
13331 @pindex calc-over-notation
13332 Display of fractional numbers is controlled by the @kbd{d o}
13333 (@code{calc-over-notation}) command. By default, a number like
13334 eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command
13335 prompts for a one- or two-character format. If you give one character,
13336 that character is used as the fraction separator. Common separators are
13337 @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be
13338 used regardless of the display format; in particular, the @kbd{/} is used
13339 for RPN-style division, @emph{not} for entering fractions.)
13341 If you give two characters, fractions use ``integer-plus-fractional-part''
13342 notation. For example, the format @samp{+/} would display eight thirds
13343 as @samp{2+2/3}. If two colons are present in a number being entered,
13344 the number is interpreted in this form (so that the entries @kbd{2:2:3}
13345 and @kbd{8:3} are equivalent).
13347 It is also possible to follow the one- or two-character format with
13348 a number. For example: @samp{:10} or @samp{+/3}. In this case,
13349 Calc adjusts all fractions that are displayed to have the specified
13350 denominator, if possible. Otherwise it adjusts the denominator to
13351 be a multiple of the specified value. For example, in @samp{:6} mode
13352 the fraction @cite{1:6} will be unaffected, but @cite{2:3} will be
13353 displayed as @cite{4:6}, @cite{1:2} will be displayed as @cite{3:6},
13354 and @cite{1:8} will be displayed as @cite{3:24}. Integers are also
13355 affected by this mode: 3 is displayed as @cite{18:6}. Note that the
13356 format @samp{:1} writes fractions the same as @samp{:}, but it writes
13357 integers as @cite{n:1}.
13359 The fraction format does not affect the way fractions or integers are
13360 stored, only the way they appear on the screen. The fraction format
13361 never affects floats.
13363 @node HMS Formats, Date Formats, Fraction Formats, Display Modes
13364 @subsection HMS Formats
13368 @pindex calc-hms-notation
13369 The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
13370 HMS (hours-minutes-seconds) forms. It prompts for a string which
13371 consists basically of an ``hours'' marker, optional punctuation, a
13372 ``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
13373 Punctuation is zero or more spaces, commas, or semicolons. The hours
13374 marker is one or more non-punctuation characters. The minutes and
13375 seconds markers must be single non-punctuation characters.
13377 The default HMS format is @samp{@@ ' "}, producing HMS values of the form
13378 @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same
13379 value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o}
13380 keys are recognized as synonyms for @kbd{@@} regardless of display format.
13381 The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
13382 @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
13383 already been typed; otherwise, they have their usual meanings
13384 (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
13385 @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
13386 The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
13387 @kbd{o}) has already been pressed; otherwise it means to switch to algebraic
13390 @node Date Formats, Truncating the Stack, HMS Formats, Display Modes
13391 @subsection Date Formats
13395 @pindex calc-date-notation
13396 The @kbd{d d} (@code{calc-date-notation}) command controls the display
13397 of date forms (@pxref{Date Forms}). It prompts for a string which
13398 contains letters that represent the various parts of a date and time.
13399 To show which parts should be omitted when the form represents a pure
13400 date with no time, parts of the string can be enclosed in @samp{< >}
13401 marks. If you don't include @samp{< >} markers in the format, Calc
13402 guesses at which parts, if any, should be omitted when formatting
13405 The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
13406 An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
13407 If you enter a blank format string, this default format is
13410 Calc uses @samp{< >} notation for nameless functions as well as for
13411 dates. @xref{Specifying Operators}. To avoid confusion with nameless
13412 functions, your date formats should avoid using the @samp{#} character.
13415 * Date Formatting Codes::
13416 * Free-Form Dates::
13417 * Standard Date Formats::
13420 @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
13421 @subsubsection Date Formatting Codes
13424 When displaying a date, the current date format is used. All
13425 characters except for letters and @samp{<} and @samp{>} are
13426 copied literally when dates are formatted. The portion between
13427 @samp{< >} markers is omitted for pure dates, or included for
13428 date/time forms. Letters are interpreted according to the table
13431 When dates are read in during algebraic entry, Calc first tries to
13432 match the input string to the current format either with or without
13433 the time part. The punctuation characters (including spaces) must
13434 match exactly; letter fields must correspond to suitable text in
13435 the input. If this doesn't work, Calc checks if the input is a
13436 simple number; if so, the number is interpreted as a number of days
13437 since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and
13438 flexible algorithm which is described in the next section.
13440 Weekday names are ignored during reading.
13442 Two-digit year numbers are interpreted as lying in the range
13443 from 1941 to 2039. Years outside that range are always
13444 entered and displayed in full. Year numbers with a leading
13445 @samp{+} sign are always interpreted exactly, allowing the
13446 entry and display of the years 1 through 99 AD.
13448 Here is a complete list of the formatting codes for dates:
13452 Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
13454 Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
13456 Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
13458 Year: ``1991'' for 1991, ``23'' for 23 AD.
13460 Year: ``1991'' for 1991, ``+23'' for 23 AD.
13462 Year: ``ad'' or blank.
13464 Year: ``AD'' or blank.
13466 Year: ``ad '' or blank. (Note trailing space.)
13468 Year: ``AD '' or blank.
13470 Year: ``a.d.'' or blank.
13472 Year: ``A.D.'' or blank.
13474 Year: ``bc'' or blank.
13476 Year: ``BC'' or blank.
13478 Year: `` bc'' or blank. (Note leading space.)
13480 Year: `` BC'' or blank.
13482 Year: ``b.c.'' or blank.
13484 Year: ``B.C.'' or blank.
13486 Month: ``8'' for August.
13488 Month: ``08'' for August.
13490 Month: `` 8'' for August.
13492 Month: ``AUG'' for August.
13494 Month: ``Aug'' for August.
13496 Month: ``aug'' for August.
13498 Month: ``AUGUST'' for August.
13500 Month: ``August'' for August.
13502 Day: ``7'' for 7th day of month.
13504 Day: ``07'' for 7th day of month.
13506 Day: `` 7'' for 7th day of month.
13508 Weekday: ``0'' for Sunday, ``6'' for Saturday.
13510 Weekday: ``SUN'' for Sunday.
13512 Weekday: ``Sun'' for Sunday.
13514 Weekday: ``sun'' for Sunday.
13516 Weekday: ``SUNDAY'' for Sunday.
13518 Weekday: ``Sunday'' for Sunday.
13520 Day of year: ``34'' for Feb. 3.
13522 Day of year: ``034'' for Feb. 3.
13524 Day of year: `` 34'' for Feb. 3.
13526 Hour: ``5'' for 5 AM; ``17'' for 5 PM.
13528 Hour: ``05'' for 5 AM; ``17'' for 5 PM.
13530 Hour: `` 5'' for 5 AM; ``17'' for 5 PM.
13532 Hour: ``5'' for 5 AM and 5 PM.
13534 Hour: ``05'' for 5 AM and 5 PM.
13536 Hour: `` 5'' for 5 AM and 5 PM.
13538 AM/PM: ``a'' or ``p''.
13540 AM/PM: ``A'' or ``P''.
13542 AM/PM: ``am'' or ``pm''.
13544 AM/PM: ``AM'' or ``PM''.
13546 AM/PM: ``a.m.'' or ``p.m.''.
13548 AM/PM: ``A.M.'' or ``P.M.''.
13550 Minutes: ``7'' for 7.
13552 Minutes: ``07'' for 7.
13554 Minutes: `` 7'' for 7.
13556 Seconds: ``7'' for 7; ``7.23'' for 7.23.
13558 Seconds: ``07'' for 7; ``07.23'' for 7.23.
13560 Seconds: `` 7'' for 7; `` 7.23'' for 7.23.
13562 Optional seconds: ``07'' for 7; blank for 0.
13564 Optional seconds: `` 7'' for 7; blank for 0.
13566 Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991.
13568 Numeric date: ``726842'' for any time on Wed Jan 9, 1991.
13570 Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991.
13572 Julian date: ``2448266'' for any time on Wed Jan 9, 1991.
13574 Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991.
13576 Brackets suppression. An ``X'' at the front of the format
13577 causes the surrounding @w{@samp{< >}} delimiters to be omitted
13578 when formatting dates. Note that the brackets are still
13579 required for algebraic entry.
13582 If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
13583 colon is also omitted if the seconds part is zero.
13585 If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
13586 appear in the format, then negative year numbers are displayed
13587 without a minus sign. Note that ``aa'' and ``bb'' are mutually
13588 exclusive. Some typical usages would be @samp{YYYY AABB};
13589 @samp{AAAYYYYBBB}; @samp{YYYYBBB}.
13591 The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
13592 ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
13593 reading unless several of these codes are strung together with no
13594 punctuation in between, in which case the input must have exactly as
13595 many digits as there are letters in the format.
13597 The ``j,'' ``J,'' and ``U'' formats do not make any time zone
13598 adjustment. They effectively use @samp{julian(x,0)} and
13599 @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
13601 @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
13602 @subsubsection Free-Form Dates
13605 When reading a date form during algebraic entry, Calc falls back
13606 on the algorithm described here if the input does not exactly
13607 match the current date format. This algorithm generally
13608 ``does the right thing'' and you don't have to worry about it,
13609 but it is described here in full detail for the curious.
13611 Calc does not distinguish between upper- and lower-case letters
13612 while interpreting dates.
13614 First, the time portion, if present, is located somewhere in the
13615 text and then removed. The remaining text is then interpreted as
13618 A time is of the form @samp{hh:mm:ss}, possibly with the seconds
13619 part omitted and possibly with an AM/PM indicator added to indicate
13620 12-hour time. If the AM/PM is present, the minutes may also be
13621 omitted. The AM/PM part may be any of the words @samp{am},
13622 @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
13623 abbreviated to one letter, and the alternate forms @samp{a.m.},
13624 @samp{p.m.}, and @samp{mid} are also understood. Obviously
13625 @samp{noon} and @samp{midnight} are allowed only on 12:00:00.
13626 The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
13627 recognized with no number attached.
13629 If there is no AM/PM indicator, the time is interpreted in 24-hour
13632 To read the date portion, all words and numbers are isolated
13633 from the string; other characters are ignored. All words must
13634 be either month names or day-of-week names (the latter of which
13635 are ignored). Names can be written in full or as three-letter
13638 Large numbers, or numbers with @samp{+} or @samp{-} signs,
13639 are interpreted as years. If one of the other numbers is
13640 greater than 12, then that must be the day and the remaining
13641 number in the input is therefore the month. Otherwise, Calc
13642 assumes the month, day and year are in the same order that they
13643 appear in the current date format. If the year is omitted, the
13644 current year is taken from the system clock.
13646 If there are too many or too few numbers, or any unrecognizable
13647 words, then the input is rejected.
13649 If there are any large numbers (of five digits or more) other than
13650 the year, they are ignored on the assumption that they are something
13651 like Julian dates that were included along with the traditional
13652 date components when the date was formatted.
13654 One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
13655 may optionally be used; the latter two are equivalent to a
13656 minus sign on the year value.
13658 If you always enter a four-digit year, and use a name instead
13659 of a number for the month, there is no danger of ambiguity.
13661 @node Standard Date Formats, , Free-Form Dates, Date Formats
13662 @subsubsection Standard Date Formats
13665 There are actually ten standard date formats, numbered 0 through 9.
13666 Entering a blank line at the @kbd{d d} command's prompt gives
13667 you format number 1, Calc's usual format. You can enter any digit
13668 to select the other formats.
13670 To create your own standard date formats, give a numeric prefix
13671 argument from 0 to 9 to the @w{@kbd{d d}} command. The format you
13672 enter will be recorded as the new standard format of that
13673 number, as well as becoming the new current date format.
13674 You can save your formats permanently with the @w{@kbd{m m}}
13675 command (@pxref{Mode Settings}).
13679 @samp{N} (Numerical format)
13681 @samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format)
13683 @samp{D Mmm YYYY<, h:mm:SS>} (European format)
13685 @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format)
13687 @samp{M/D/Y< H:mm:SSpp>} (American slashed format)
13689 @samp{D.M.Y< h:mm:SS>} (European dotted format)
13691 @samp{M-D-Y< H:mm:SSpp>} (American dashed format)
13693 @samp{D-M-Y< h:mm:SS>} (European dashed format)
13695 @samp{j<, h:mm:ss>} (Julian day plus time)
13697 @samp{YYddd< hh:mm:ss>} (Year-day format)
13700 @node Truncating the Stack, Justification, Date Formats, Display Modes
13701 @subsection Truncating the Stack
13705 @pindex calc-truncate-stack
13706 @cindex Truncating the stack
13707 @cindex Narrowing the stack
13708 The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
13709 line that marks the top-of-stack up or down in the Calculator buffer.
13710 The number right above that line is considered to the be at the top of
13711 the stack. Any numbers below that line are ``hidden'' from all stack
13712 operations. This is similar to the Emacs ``narrowing'' feature, except
13713 that the values below the @samp{.} are @emph{visible}, just temporarily
13714 frozen. This feature allows you to keep several independent calculations
13715 running at once in different parts of the stack, or to apply a certain
13716 command to an element buried deep in the stack.@refill
13718 Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
13719 is on. Thus, this line and all those below it become hidden. To un-hide
13720 these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
13721 With a positive numeric prefix argument @cite{n}, @kbd{d t} hides the
13722 bottom @cite{n} values in the buffer. With a negative argument, it hides
13723 all but the top @cite{n} values. With an argument of zero, it hides zero
13724 values, i.e., moves the @samp{.} all the way down to the bottom.@refill
13727 @pindex calc-truncate-up
13729 @pindex calc-truncate-down
13730 The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
13731 (@code{calc-truncate-down}) commands move the @samp{.} up or down one
13732 line at a time (or several lines with a prefix argument).@refill
13734 @node Justification, Labels, Truncating the Stack, Display Modes
13735 @subsection Justification
13739 @pindex calc-left-justify
13741 @pindex calc-center-justify
13743 @pindex calc-right-justify
13744 Values on the stack are normally left-justified in the window. You can
13745 control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
13746 @kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
13747 (@code{calc-center-justify}). For example, in right-justification mode,
13748 stack entries are displayed flush-right against the right edge of the
13751 If you change the width of the Calculator window you may have to type
13752 @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
13755 Right-justification is especially useful together with fixed-point
13756 notation (see @code{d f}; @code{calc-fix-notation}). With these modes
13757 together, the decimal points on numbers will always line up.
13759 With a numeric prefix argument, the justification commands give you
13760 a little extra control over the display. The argument specifies the
13761 horizontal ``origin'' of a display line. It is also possible to
13762 specify a maximum line width using the @kbd{d b} command (@pxref{Normal
13763 Language Modes}). For reference, the precise rules for formatting and
13764 breaking lines are given below. Notice that the interaction between
13765 origin and line width is slightly different in each justification
13768 In left-justified mode, the line is indented by a number of spaces
13769 given by the origin (default zero). If the result is longer than the
13770 maximum line width, if given, or too wide to fit in the Calc window
13771 otherwise, then it is broken into lines which will fit; each broken
13772 line is indented to the origin.
13774 In right-justified mode, lines are shifted right so that the rightmost
13775 character is just before the origin, or just before the current
13776 window width if no origin was specified. If the line is too long
13777 for this, then it is broken; the current line width is used, if
13778 specified, or else the origin is used as a width if that is
13779 specified, or else the line is broken to fit in the window.
13781 In centering mode, the origin is the column number of the center of
13782 each stack entry. If a line width is specified, lines will not be
13783 allowed to go past that width; Calc will either indent less or
13784 break the lines if necessary. If no origin is specified, half the
13785 line width or Calc window width is used.
13787 Note that, in each case, if line numbering is enabled the display
13788 is indented an additional four spaces to make room for the line
13789 number. The width of the line number is taken into account when
13790 positioning according to the current Calc window width, but not
13791 when positioning by explicit origins and widths. In the latter
13792 case, the display is formatted as specified, and then uniformly
13793 shifted over four spaces to fit the line numbers.
13795 @node Labels, , Justification, Display Modes
13800 @pindex calc-left-label
13801 The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
13802 then displays that string to the left of every stack entry. If the
13803 entries are left-justified (@pxref{Justification}), then they will
13804 appear immediately after the label (unless you specified an origin
13805 greater than the length of the label). If the entries are centered
13806 or right-justified, the label appears on the far left and does not
13807 affect the horizontal position of the stack entry.
13809 Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
13812 @pindex calc-right-label
13813 The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
13814 label on the righthand side. It does not affect positioning of
13815 the stack entries unless they are right-justified. Also, if both
13816 a line width and an origin are given in right-justified mode, the
13817 stack entry is justified to the origin and the righthand label is
13818 justified to the line width.
13820 One application of labels would be to add equation numbers to
13821 formulas you are manipulating in Calc and then copying into a
13822 document (possibly using Embedded Mode). The equations would
13823 typically be centered, and the equation numbers would be on the
13824 left or right as you prefer.
13826 @node Language Modes, Modes Variable, Display Modes, Mode Settings
13827 @section Language Modes
13830 The commands in this section change Calc to use a different notation for
13831 entry and display of formulas, corresponding to the conventions of some
13832 other common language such as Pascal or @TeX{}. Objects displayed on the
13833 stack or yanked from the Calculator to an editing buffer will be formatted
13834 in the current language; objects entered in algebraic entry or yanked from
13835 another buffer will be interpreted according to the current language.
13837 The current language has no effect on things written to or read from the
13838 trail buffer, nor does it affect numeric entry. Only algebraic entry is
13839 affected. You can make even algebraic entry ignore the current language
13840 and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
13842 For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
13843 program; elsewhere in the program you need the derivatives of this formula
13844 with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C}
13845 to switch to C notation. Now use @code{C-u M-# g} to grab the formula
13846 into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
13847 to the first variable, and @kbd{M-# y} to yank the formula for the derivative
13848 back into your C program. Press @kbd{U} to undo the differentiation and
13849 repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
13851 Without being switched into C mode first, Calc would have misinterpreted
13852 the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
13853 @code{atan} was equivalent to Calc's built-in @code{arctan} function,
13854 and would have written the formula back with notations (like implicit
13855 multiplication) which would not have been legal for a C program.
13857 As another example, suppose you are maintaining a C program and a @TeX{}
13858 document, each of which needs a copy of the same formula. You can grab the
13859 formula from the program in C mode, switch to @TeX{} mode, and yank the
13860 formula into the document in @TeX{} math-mode format.
13862 Language modes are selected by typing the letter @kbd{d} followed by a
13863 shifted letter key.
13866 * Normal Language Modes::
13867 * C FORTRAN Pascal::
13868 * TeX Language Mode::
13869 * Eqn Language Mode::
13870 * Mathematica Language Mode::
13871 * Maple Language Mode::
13876 @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
13877 @subsection Normal Language Modes
13881 @pindex calc-normal-language
13882 The @kbd{d N} (@code{calc-normal-language}) command selects the usual
13883 notation for Calc formulas, as described in the rest of this manual.
13884 Matrices are displayed in a multi-line tabular format, but all other
13885 objects are written in linear form, as they would be typed from the
13889 @pindex calc-flat-language
13890 @cindex Matrix display
13891 The @kbd{d O} (@code{calc-flat-language}) command selects a language
13892 identical with the normal one, except that matrices are written in
13893 one-line form along with everything else. In some applications this
13894 form may be more suitable for yanking data into other buffers.
13897 @pindex calc-line-breaking
13898 @cindex Line breaking
13899 @cindex Breaking up long lines
13900 Even in one-line mode, long formulas or vectors will still be split
13901 across multiple lines if they exceed the width of the Calculator window.
13902 The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
13903 feature on and off. (It works independently of the current language.)
13904 If you give a numeric prefix argument of five or greater to the @kbd{d b}
13905 command, that argument will specify the line width used when breaking
13909 @pindex calc-big-language
13910 The @kbd{d B} (@code{calc-big-language}) command selects a language
13911 which uses textual approximations to various mathematical notations,
13912 such as powers, quotients, and square roots:
13922 in place of @samp{sqrt((a+1)/b + c^2)}.
13924 Subscripts like @samp{a_i} are displayed as actual subscripts in ``big''
13925 mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
13926 are displayed as @samp{a} with subscripts separated by commas:
13927 @samp{i, j}. They must still be entered in the usual underscore
13930 One slight ambiguity of Big notation is that
13939 can represent either the negative rational number @cite{-3:4}, or the
13940 actual expression @samp{-(3/4)}; but the latter formula would normally
13941 never be displayed because it would immediately be evaluated to
13942 @cite{-3:4} or @cite{-0.75}, so this ambiguity is not a problem in
13945 Non-decimal numbers are displayed with subscripts. Thus there is no
13946 way to tell the difference between @samp{16#C2} and @samp{C2_16},
13947 though generally you will know which interpretation is correct.
13948 Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
13951 In Big mode, stack entries often take up several lines. To aid
13952 readability, stack entries are separated by a blank line in this mode.
13953 You may find it useful to expand the Calc window's height using
13954 @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
13955 one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
13957 Long lines are currently not rearranged to fit the window width in
13958 Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
13959 to scroll across a wide formula. For really big formulas, you may
13960 even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
13963 @pindex calc-unformatted-language
13964 The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
13965 the use of operator notation in formulas. In this mode, the formula
13966 shown above would be displayed:
13969 sqrt(add(div(add(a, 1), b), pow(c, 2)))
13972 These four modes differ only in display format, not in the format
13973 expected for algebraic entry. The standard Calc operators work in
13974 all four modes, and unformatted notation works in any language mode
13975 (except that Mathematica mode expects square brackets instead of
13978 @node C FORTRAN Pascal, TeX Language Mode, Normal Language Modes, Language Modes
13979 @subsection C, FORTRAN, and Pascal Modes
13983 @pindex calc-c-language
13985 The @kbd{d C} (@code{calc-c-language}) command selects the conventions
13986 of the C language for display and entry of formulas. This differs from
13987 the normal language mode in a variety of (mostly minor) ways. In
13988 particular, C language operators and operator precedences are used in
13989 place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)}
13990 in C mode; a value raised to a power is written as a function call,
13993 In C mode, vectors and matrices use curly braces instead of brackets.
13994 Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
13995 rather than using the @samp{#} symbol. Array subscripting is
13996 translated into @code{subscr} calls, so that @samp{a[i]} in C
13997 mode is the same as @samp{a_i} in normal mode. Assignments
13998 turn into the @code{assign} function, which Calc normally displays
13999 using the @samp{:=} symbol.
14001 The variables @code{var-pi} and @code{var-e} would be displayed @samp{pi}
14002 and @samp{e} in normal mode, but in C mode they are displayed as
14003 @samp{M_PI} and @samp{M_E}, corresponding to the names of constants
14004 typically provided in the @file{<math.h>} header. Functions whose
14005 names are different in C are translated automatically for entry and
14006 display purposes. For example, entering @samp{asin(x)} will push the
14007 formula @samp{arcsin(x)} onto the stack; this formula will be displayed
14008 as @samp{asin(x)} as long as C mode is in effect.
14011 @pindex calc-pascal-language
14012 @cindex Pascal language
14013 The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
14014 conventions. Like C mode, Pascal mode interprets array brackets and uses
14015 a different table of operators. Hexadecimal numbers are entered and
14016 displayed with a preceding dollar sign. (Thus the regular meaning of
14017 @kbd{$2} during algebraic entry does not work in Pascal mode, though
14018 @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
14019 always.) No special provisions are made for other non-decimal numbers,
14020 vectors, and so on, since there is no universally accepted standard way
14021 of handling these in Pascal.
14024 @pindex calc-fortran-language
14025 @cindex FORTRAN language
14026 The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
14027 conventions. Various function names are transformed into FORTRAN
14028 equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be
14029 entered this way or using square brackets. Since FORTRAN uses round
14030 parentheses for both function calls and array subscripts, Calc displays
14031 both in the same way; @samp{a(i)} is interpreted as a function call
14032 upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
14033 Also, if the variable @code{a} has been declared to have type
14034 @code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
14035 subscript. (@xref{Declarations}.) Usually it doesn't matter, though;
14036 if you enter the subscript expression @samp{a(i)} and Calc interprets
14037 it as a function call, you'll never know the difference unless you
14038 switch to another language mode or replace @code{a} with an actual
14039 vector (or unless @code{a} happens to be the name of a built-in
14042 Underscores are allowed in variable and function names in all of these
14043 language modes. The underscore here is equivalent to the @samp{#} in
14044 normal mode, or to hyphens in the underlying Emacs Lisp variable names.
14046 FORTRAN and Pascal modes normally do not adjust the case of letters in
14047 formulas. Most built-in Calc names use lower-case letters. If you use a
14048 positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
14049 modes will use upper-case letters exclusively for display, and will
14050 convert to lower-case on input. With a negative prefix, these modes
14051 convert to lower-case for display and input.
14053 @node TeX Language Mode, Eqn Language Mode, C FORTRAN Pascal, Language Modes
14054 @subsection @TeX{} Language Mode
14058 @pindex calc-tex-language
14059 @cindex TeX language
14060 The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
14061 of ``math mode'' in the @TeX{} typesetting language, by Donald Knuth.
14062 Formulas are entered
14063 and displayed in @TeX{} notation, as in @samp{\sin\left( a \over b \right)}.
14064 Math formulas are usually enclosed by @samp{$ $} signs in @TeX{}; these
14065 should be omitted when interfacing with Calc. To Calc, the @samp{$} sign
14066 has the same meaning it always does in algebraic formulas (a reference to
14067 an existing entry on the stack).@refill
14069 Complex numbers are displayed as in @samp{3 + 4i}. Fractions and
14070 quotients are written using @code{\over};
14071 binomial coefficients are written with @code{\choose}.
14072 Interval forms are written with @code{\ldots}, and
14073 error forms are written with @code{\pm}.
14074 Absolute values are written as in @samp{|x + 1|}, and the floor and
14075 ceiling functions are written with @code{\lfloor}, @code{\rfloor}, etc.
14076 The words @code{\left} and @code{\right} are ignored when reading
14077 formulas in @TeX{} mode. Both @code{inf} and @code{uinf} are written
14078 as @code{\infty}; when read, @code{\infty} always translates to
14081 Function calls are written the usual way, with the function name followed
14082 by the arguments in parentheses. However, functions for which @TeX{} has
14083 special names (like @code{\sin}) will use curly braces instead of
14084 parentheses for very simple arguments. During input, curly braces and
14085 parentheses work equally well for grouping, but when the document is
14086 formatted the curly braces will be invisible. Thus the printed result is
14088 @cite{sin 2x} but @c{$\sin(2 + x)$}
14091 Function and variable names not treated specially by @TeX{} are simply
14092 written out as-is, which will cause them to come out in italic letters
14093 in the printed document. If you invoke @kbd{d T} with a positive numeric
14094 prefix argument, names of more than one character will instead be written
14095 @samp{\hbox@{@var{name}@}}. The @samp{\hbox@{ @}} notation is ignored
14096 during reading. If you use a negative prefix argument, such function
14097 names are written @samp{\@var{name}}, and function names that begin
14098 with @code{\} during reading have the @code{\} removed. (Note that
14099 in this mode, long variable names are still written with @code{\hbox}.
14100 However, you can always make an actual variable name like @code{\bar}
14101 in any @TeX{} mode.)
14103 During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
14104 by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and
14105 @code{\bmatrix}. The symbol @samp{&} is interpreted as a comma,
14106 and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
14107 During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
14108 format; you may need to edit this afterwards to change @code{\matrix}
14109 to @code{\pmatrix} or @code{\\} to @code{\cr}.
14111 Accents like @code{\tilde} and @code{\bar} translate into function
14112 calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline}
14113 sequence is treated as an accent. The @code{\vec} accent corresponds
14114 to the function name @code{Vec}, because @code{vec} is the name of
14115 a built-in Calc function. The following table shows the accents
14116 in Calc, @TeX{}, and @dfn{eqn} (described in the next section):
14120 @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes
14121 @let@calcindexersh=@calcindexernoshow
14186 dotdot \ddot dotdot
14192 under \underline under
14196 The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
14197 @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an
14198 alias for @code{\rightarrow}. However, if the @samp{=>} is the
14199 top-level expression being formatted, a slightly different notation
14200 is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto}
14201 word is ignored by Calc's input routines, and is undefined in @TeX{}.
14202 You will typically want to include one of the following definitions
14203 at the top of a @TeX{} file that uses @code{\evalto}:
14207 \def\evalto#1\to@{@}
14210 The first definition formats evaluates-to operators in the usual
14211 way. The second causes only the @var{b} part to appear in the
14212 printed document; the @var{a} part and the arrow are hidden.
14213 Another definition you may wish to use is @samp{\let\to=\Rightarrow}
14214 which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
14215 @xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
14217 The complete set of @TeX{} control sequences that are ignored during
14221 \hbox \mbox \text \left \right
14222 \, \> \: \; \! \quad \qquad \hfil \hfill
14223 \displaystyle \textstyle \dsize \tsize
14224 \scriptstyle \scriptscriptstyle \ssize \ssize
14225 \rm \bf \it \sl \roman \bold \italic \slanted
14226 \cal \mit \Cal \Bbb \frak \goth
14230 Note that, because these symbols are ignored, reading a @TeX{} formula
14231 into Calc and writing it back out may lose spacing and font information.
14233 Also, the ``discretionary multiplication sign'' @samp{\*} is read
14234 the same as @samp{*}.
14237 The @TeX{} version of this manual includes some printed examples at the
14238 end of this section.
14241 Here are some examples of how various Calc formulas are formatted in @TeX{}:
14246 \sin\left( {a^2 \over b_i} \right)
14251 $$ \sin\left( a^2 \over b_i \right) $$
14257 [(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
14258 [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
14263 $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
14269 [abs(a), abs(a / b), floor(a), ceil(a / b)]
14270 [|a|, \left| a \over b \right|,
14271 \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
14275 $$ [|a|, \left| a \over b \right|,
14276 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
14282 [sin(a), sin(2 a), sin(2 + a), sin(a / b)]
14283 [\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
14284 \sin\left( @{a \over b@} \right)]
14288 \turnoffactive\let\rm\goodrm
14289 $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
14293 First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
14294 @kbd{C-u - d T} (using the example definition
14295 @samp{\def\foo#1@{\tilde F(#1)@}}:
14299 [f(a), foo(bar), sin(pi)]
14300 [f(a), foo(bar), \sin{\pi}]
14301 [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
14302 [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
14307 $$ [f(a), foo(bar), \sin{\pi}] $$
14308 $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
14309 $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
14313 First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
14318 \evalto 2 + 3 \to 5
14328 First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
14332 [2 + 3 => 5, a / 2 => (b + c) / 2]
14333 [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
14338 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
14339 {\let\to\Rightarrow
14340 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
14344 Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
14348 [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
14349 \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14350 \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14355 $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14356 $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14361 @node Eqn Language Mode, Mathematica Language Mode, TeX Language Mode, Language Modes
14362 @subsection Eqn Language Mode
14366 @pindex calc-eqn-language
14367 @dfn{Eqn} is another popular formatter for math formulas. It is
14368 designed for use with the TROFF text formatter, and comes standard
14369 with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language})
14370 command selects @dfn{eqn} notation.
14372 The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
14373 a significant part in the parsing of the language. For example,
14374 @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
14375 @code{sqrt} operator. @dfn{Eqn} also understands more conventional
14376 grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are
14377 required only when the argument contains spaces.
14379 In Calc's @dfn{eqn} mode, however, curly braces are required to
14380 delimit arguments of operators like @code{sqrt}. The first of the
14381 above examples would treat only the @samp{x} as the argument of
14382 @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
14383 @samp{sin * x + 1}, because @code{sin} is not a special operator
14384 in the @dfn{eqn} language. If you always surround the argument
14385 with curly braces, Calc will never misunderstand.
14387 Calc also understands parentheses as grouping characters. Another
14388 peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
14389 words with spaces from any surrounding characters that aren't curly
14390 braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
14391 (The spaces around @code{sin} are important to make @dfn{eqn}
14392 recognize that @code{sin} should be typeset in a roman font, and
14393 the spaces around @code{x} and @code{y} are a good idea just in
14394 case the @dfn{eqn} document has defined special meanings for these
14397 Powers and subscripts are written with the @code{sub} and @code{sup}
14398 operators, respectively. Note that the caret symbol @samp{^} is
14399 treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
14400 symbol (these are used to introduce spaces of various widths into
14401 the typeset output of @dfn{eqn}).
14403 As in @TeX{} mode, Calc's formatter omits parentheses around the
14404 arguments of functions like @code{ln} and @code{sin} if they are
14405 ``simple-looking''; in this case Calc surrounds the argument with
14406 braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
14408 Font change codes (like @samp{roman @var{x}}) and positioning codes
14409 (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
14410 @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right},
14411 @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input
14412 are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
14413 @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
14414 of quotes in @dfn{eqn}, but it is good enough for most uses.
14416 Accent codes (@samp{@var{x} dot}) are handled by treating them as
14417 function calls (@samp{dot(@var{x})}) internally. @xref{TeX Language
14418 Mode}, for a table of these accent functions. The @code{prime} accent
14419 is treated specially if it occurs on a variable or function name:
14420 @samp{f prime prime @w{( x prime )}} is stored internally as
14421 @samp{f'@w{'}(x')}. For example, taking the derivative of @samp{f(2 x)}
14422 with @kbd{a d x} will produce @samp{2 f'(2 x)}, which @dfn{eqn} mode
14423 will display as @samp{2 f prime ( 2 x )}.
14425 Assignments are written with the @samp{<-} (left-arrow) symbol,
14426 and @code{evalto} operators are written with @samp{->} or
14427 @samp{evalto ... ->} (@pxref{TeX Language Mode}, for a discussion
14428 of this). The regular Calc symbols @samp{:=} and @samp{=>} are also
14429 recognized for these operators during reading.
14431 Vectors in @dfn{eqn} mode use regular Calc square brackets, but
14432 matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
14433 The words @code{lcol} and @code{rcol} are recognized as synonyms
14434 for @code{ccol} during input, and are generated instead of @code{ccol}
14435 if the matrix justification mode so specifies.
14437 @node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
14438 @subsection Mathematica Language Mode
14442 @pindex calc-mathematica-language
14443 @cindex Mathematica language
14444 The @kbd{d M} (@code{calc-mathematica-language}) command selects the
14445 conventions of Mathematica, a powerful and popular mathematical tool
14446 from Wolfram Research, Inc. Notable differences in Mathematica mode
14447 are that the names of built-in functions are capitalized, and function
14448 calls use square brackets instead of parentheses. Thus the Calc
14449 formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
14452 Vectors and matrices use curly braces in Mathematica. Complex numbers
14453 are written @samp{3 + 4 I}. The standard special constants in Calc are
14454 written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
14455 @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
14457 Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point
14458 numbers in scientific notation are written @samp{1.23*10.^3}.
14459 Subscripts use double square brackets: @samp{a[[i]]}.@refill
14461 @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
14462 @subsection Maple Language Mode
14466 @pindex calc-maple-language
14467 @cindex Maple language
14468 The @kbd{d W} (@code{calc-maple-language}) command selects the
14469 conventions of Maple, another mathematical tool from the University
14472 Maple's language is much like C. Underscores are allowed in symbol
14473 names; square brackets are used for subscripts; explicit @samp{*}s for
14474 multiplications are required. Use either @samp{^} or @samp{**} to
14477 Maple uses square brackets for lists and curly braces for sets. Calc
14478 interprets both notations as vectors, and displays vectors with square
14479 brackets. This means Maple sets will be converted to lists when they
14480 pass through Calc. As a special case, matrices are written as calls
14481 to the function @code{matrix}, given a list of lists as the argument,
14482 and can be read in this form or with all-capitals @code{MATRIX}.
14484 The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
14485 Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
14486 writes any kind of interval as @samp{2 .. 3}. This means you cannot
14487 see the difference between an open and a closed interval while in
14488 Maple display mode.
14490 Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
14491 are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
14492 @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
14493 Floating-point numbers are written @samp{1.23*10.^3}.
14495 Among things not currently handled by Calc's Maple mode are the
14496 various quote symbols, procedures and functional operators, and
14497 inert (@samp{&}) operators.
14499 @node Compositions, Syntax Tables, Maple Language Mode, Language Modes
14500 @subsection Compositions
14503 @cindex Compositions
14504 There are several @dfn{composition functions} which allow you to get
14505 displays in a variety of formats similar to those in Big language
14506 mode. Most of these functions do not evaluate to anything; they are
14507 placeholders which are left in symbolic form by Calc's evaluator but
14508 are recognized by Calc's display formatting routines.
14510 Two of these, @code{string} and @code{bstring}, are described elsewhere.
14511 @xref{Strings}. For example, @samp{string("ABC")} is displayed as
14512 @samp{ABC}. When viewed on the stack it will be indistinguishable from
14513 the variable @code{ABC}, but internally it will be stored as
14514 @samp{string([65, 66, 67])} and can still be manipulated this way; for
14515 example, the selection and vector commands @kbd{j 1 v v j u} would
14516 select the vector portion of this object and reverse the elements, then
14517 deselect to reveal a string whose characters had been reversed.
14519 The composition functions do the same thing in all language modes
14520 (although their components will of course be formatted in the current
14521 language mode). The one exception is Unformatted mode (@kbd{d U}),
14522 which does not give the composition functions any special treatment.
14523 The functions are discussed here because of their relationship to
14524 the language modes.
14527 * Composition Basics::
14528 * Horizontal Compositions::
14529 * Vertical Compositions::
14530 * Other Compositions::
14531 * Information about Compositions::
14532 * User-Defined Compositions::
14535 @node Composition Basics, Horizontal Compositions, Compositions, Compositions
14536 @subsubsection Composition Basics
14539 Compositions are generally formed by stacking formulas together
14540 horizontally or vertically in various ways. Those formulas are
14541 themselves compositions. @TeX{} users will find this analogous
14542 to @TeX{}'s ``boxes.'' Each multi-line composition has a
14543 @dfn{baseline}; horizontal compositions use the baselines to
14544 decide how formulas should be positioned relative to one another.
14545 For example, in the Big mode formula
14557 the second term of the sum is four lines tall and has line three as
14558 its baseline. Thus when the term is combined with 17, line three
14559 is placed on the same level as the baseline of 17.
14565 Another important composition concept is @dfn{precedence}. This is
14566 an integer that represents the binding strength of various operators.
14567 For example, @samp{*} has higher precedence (195) than @samp{+} (180),
14568 which means that @samp{(a * b) + c} will be formatted without the
14569 parentheses, but @samp{a * (b + c)} will keep the parentheses.
14571 The operator table used by normal and Big language modes has the
14572 following precedences:
14575 _ 1200 @r{(subscripts)}
14576 % 1100 @r{(as in n}%@r{)}
14577 - 1000 @r{(as in }-@r{n)}
14578 ! 1000 @r{(as in }!@r{n)}
14581 !! 210 @r{(as in n}!!@r{)}
14582 ! 210 @r{(as in n}!@r{)}
14584 * 195 @r{(or implicit multiplication)}
14586 + - 180 @r{(as in a}+@r{b)}
14588 < = 160 @r{(and other relations)}
14600 The general rule is that if an operator with precedence @cite{n}
14601 occurs as an argument to an operator with precedence @cite{m}, then
14602 the argument is enclosed in parentheses if @cite{n < m}. Top-level
14603 expressions and expressions which are function arguments, vector
14604 components, etc., are formatted with precedence zero (so that they
14605 normally never get additional parentheses).
14607 For binary left-associative operators like @samp{+}, the righthand
14608 argument is actually formatted with one-higher precedence than shown
14609 in the table. This makes sure @samp{(a + b) + c} omits the parentheses,
14610 but the unnatural form @samp{a + (b + c)} keeps its parentheses.
14611 Right-associative operators like @samp{^} format the lefthand argument
14612 with one-higher precedence.
14618 The @code{cprec} function formats an expression with an arbitrary
14619 precedence. For example, @samp{cprec(abc, 185)} will combine into
14620 sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because
14621 this @code{cprec} form has higher precedence than addition, but lower
14622 precedence than multiplication).
14628 A final composition issue is @dfn{line breaking}. Calc uses two
14629 different strategies for ``flat'' and ``non-flat'' compositions.
14630 A non-flat composition is anything that appears on multiple lines
14631 (not counting line breaking). Examples would be matrices and Big
14632 mode powers and quotients. Non-flat compositions are displayed
14633 exactly as specified. If they come out wider than the current
14634 window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
14637 Flat compositions, on the other hand, will be broken across several
14638 lines if they are too wide to fit the window. Certain points in a
14639 composition are noted internally as @dfn{break points}. Calc's
14640 general strategy is to fill each line as much as possible, then to
14641 move down to the next line starting at the first break point that
14642 didn't fit. However, the line breaker understands the hierarchical
14643 structure of formulas. It will not break an ``inner'' formula if
14644 it can use an earlier break point from an ``outer'' formula instead.
14645 For example, a vector of sums might be formatted as:
14649 [ a + b + c, d + e + f,
14650 g + h + i, j + k + l, m ]
14655 If the @samp{m} can fit, then so, it seems, could the @samp{g}.
14656 But Calc prefers to break at the comma since the comma is part
14657 of a ``more outer'' formula. Calc would break at a plus sign
14658 only if it had to, say, if the very first sum in the vector had
14659 itself been too large to fit.
14661 Of the composition functions described below, only @code{choriz}
14662 generates break points. The @code{bstring} function (@pxref{Strings})
14663 also generates breakable items: A break point is added after every
14664 space (or group of spaces) except for spaces at the very beginning or
14667 Composition functions themselves count as levels in the formula
14668 hierarchy, so a @code{choriz} that is a component of a larger
14669 @code{choriz} will be less likely to be broken. As a special case,
14670 if a @code{bstring} occurs as a component of a @code{choriz} or
14671 @code{choriz}-like object (such as a vector or a list of arguments
14672 in a function call), then the break points in that @code{bstring}
14673 will be on the same level as the break points of the surrounding
14676 @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
14677 @subsubsection Horizontal Compositions
14684 The @code{choriz} function takes a vector of objects and composes
14685 them horizontally. For example, @samp{choriz([17, a b/c, d])} formats
14686 as @w{@samp{17a b / cd}} in normal language mode, or as
14697 in Big language mode. This is actually one case of the general
14698 function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
14699 either or both of @var{sep} and @var{prec} may be omitted.
14700 @var{Prec} gives the @dfn{precedence} to use when formatting
14701 each of the components of @var{vec}. The default precedence is
14702 the precedence from the surrounding environment.
14704 @var{Sep} is a string (i.e., a vector of character codes as might
14705 be entered with @code{" "} notation) which should separate components
14706 of the composition. Also, if @var{sep} is given, the line breaker
14707 will allow lines to be broken after each occurrence of @var{sep}.
14708 If @var{sep} is omitted, the composition will not be breakable
14709 (unless any of its component compositions are breakable).
14711 For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
14712 formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz}
14713 to have precedence 180 ``outwards'' as well as ``inwards,''
14714 enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)}
14715 formats as @samp{2 (a + b c + (d = e))}.
14717 The baseline of a horizontal composition is the same as the
14718 baselines of the component compositions, which are all aligned.
14720 @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
14721 @subsubsection Vertical Compositions
14728 The @code{cvert} function makes a vertical composition. Each
14729 component of the vector is centered in a column. The baseline of
14730 the result is by default the top line of the resulting composition.
14731 For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
14732 formats in Big mode as
14747 There are several special composition functions that work only as
14748 components of a vertical composition. The @code{cbase} function
14749 controls the baseline of the vertical composition; the baseline
14750 will be the same as the baseline of whatever component is enclosed
14751 in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]),
14752 cvert([a^2 + 1, cbase(b^2)]))} displays as
14772 There are also @code{ctbase} and @code{cbbase} functions which
14773 make the baseline of the vertical composition equal to the top
14774 or bottom line (rather than the baseline) of that component.
14775 Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
14776 cvert([cbbase(a / b)])} gives
14788 There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
14789 function in a given vertical composition. These functions can also
14790 be written with no arguments: @samp{ctbase()} is a zero-height object
14791 which means the baseline is the top line of the following item, and
14792 @samp{cbbase()} means the baseline is the bottom line of the preceding
14799 The @code{crule} function builds a ``rule,'' or horizontal line,
14800 across a vertical composition. By itself @samp{crule()} uses @samp{-}
14801 characters to build the rule. You can specify any other character,
14802 e.g., @samp{crule("=")}. The argument must be a character code or
14803 vector of exactly one character code. It is repeated to match the
14804 width of the widest item in the stack. For example, a quotient
14805 with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
14824 Finally, the functions @code{clvert} and @code{crvert} act exactly
14825 like @code{cvert} except that the items are left- or right-justified
14826 in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
14837 Like @code{choriz}, the vertical compositions accept a second argument
14838 which gives the precedence to use when formatting the components.
14839 Vertical compositions do not support separator strings.
14841 @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
14842 @subsubsection Other Compositions
14849 The @code{csup} function builds a superscripted expression. For
14850 example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
14851 language mode. This is essentially a horizontal composition of
14852 @samp{a} and @samp{b}, where @samp{b} is shifted up so that its
14853 bottom line is one above the baseline.
14859 Likewise, the @code{csub} function builds a subscripted expression.
14860 This shifts @samp{b} down so that its top line is one below the
14861 bottom line of @samp{a} (note that this is not quite analogous to
14862 @code{csup}). Other arrangements can be obtained by using
14863 @code{choriz} and @code{cvert} directly.
14869 The @code{cflat} function formats its argument in ``flat'' mode,
14870 as obtained by @samp{d O}, if the current language mode is normal
14871 or Big. It has no effect in other language modes. For example,
14872 @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
14873 to improve its readability.
14879 The @code{cspace} function creates horizontal space. For example,
14880 @samp{cspace(4)} is effectively the same as @samp{string(" ")}.
14881 A second string (i.e., vector of characters) argument is repeated
14882 instead of the space character. For example, @samp{cspace(4, "ab")}
14883 looks like @samp{abababab}. If the second argument is not a string,
14884 it is formatted in the normal way and then several copies of that
14885 are composed together: @samp{cspace(4, a^2)} yields
14895 If the number argument is zero, this is a zero-width object.
14901 The @code{cvspace} function creates vertical space, or a vertical
14902 stack of copies of a certain string or formatted object. The
14903 baseline is the center line of the resulting stack. A numerical
14904 argument of zero will produce an object which contributes zero
14905 height if used in a vertical composition.
14915 There are also @code{ctspace} and @code{cbspace} functions which
14916 create vertical space with the baseline the same as the baseline
14917 of the top or bottom copy, respectively, of the second argument.
14918 Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
14935 @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
14936 @subsubsection Information about Compositions
14939 The functions in this section are actual functions; they compose their
14940 arguments according to the current language and other display modes,
14941 then return a certain measurement of the composition as an integer.
14947 The @code{cwidth} function measures the width, in characters, of a
14948 composition. For example, @samp{cwidth(a + b)} is 5, and
14949 @samp{cwidth(a / b)} is 5 in normal mode, 1 in Big mode, and 11 in
14950 @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve
14951 the composition functions described in this section.
14957 The @code{cheight} function measures the height of a composition.
14958 This is the total number of lines in the argument's printed form.
14968 The functions @code{cascent} and @code{cdescent} measure the amount
14969 of the height that is above (and including) the baseline, or below
14970 the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
14971 always equals @samp{cheight(@var{x})}. For a one-line formula like
14972 @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
14973 For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
14974 returns 1. The only formula for which @code{cascent} will return zero
14975 is @samp{cvspace(0)} or equivalents.
14977 @node User-Defined Compositions, , Information about Compositions, Compositions
14978 @subsubsection User-Defined Compositions
14982 @pindex calc-user-define-composition
14983 The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
14984 define the display format for any algebraic function. You provide a
14985 formula containing a certain number of argument variables on the stack.
14986 Any time Calc formats a call to the specified function in the current
14987 language mode and with that number of arguments, Calc effectively
14988 replaces the function call with that formula with the arguments
14991 Calc builds the default argument list by sorting all the variable names
14992 that appear in the formula into alphabetical order. You can edit this
14993 argument list before pressing @key{RET} if you wish. Any variables in
14994 the formula that do not appear in the argument list will be displayed
14995 literally; any arguments that do not appear in the formula will not
14996 affect the display at all.
14998 You can define formats for built-in functions, for functions you have
14999 defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
15000 which have no definitions but are being used as purely syntactic objects.
15001 You can define different formats for each language mode, and for each
15002 number of arguments, using a succession of @kbd{Z C} commands. When
15003 Calc formats a function call, it first searches for a format defined
15004 for the current language mode (and number of arguments); if there is
15005 none, it uses the format defined for the Normal language mode. If
15006 neither format exists, Calc uses its built-in standard format for that
15007 function (usually just @samp{@var{func}(@var{args})}).
15009 If you execute @kbd{Z C} with the number 0 on the stack instead of a
15010 formula, any defined formats for the function in the current language
15011 mode will be removed. The function will revert to its standard format.
15013 For example, the default format for the binomial coefficient function
15014 @samp{choose(n, m)} in the Big language mode is
15025 You might prefer the notation,
15035 To define this notation, first make sure you are in Big mode,
15036 then put the formula
15039 choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
15043 on the stack and type @kbd{Z C}. Answer the first prompt with
15044 @code{choose}. The second prompt will be the default argument list
15045 of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press
15046 @key{RET}. Now, try it out: For example, turn simplification
15047 off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
15048 as an algebraic entry.
15057 As another example, let's define the usual notation for Stirling
15058 numbers of the first kind, @samp{stir1(n, m)}. This is just like
15059 the regular format for binomial coefficients but with square brackets
15060 instead of parentheses.
15063 choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
15066 Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
15067 @samp{(n m)}, and type @key{RET}.
15069 The formula provided to @kbd{Z C} usually will involve composition
15070 functions, but it doesn't have to. Putting the formula @samp{a + b + c}
15071 onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
15072 the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
15073 This ``sum'' will act exactly like a real sum for all formatting
15074 purposes (it will be parenthesized the same, and so on). However
15075 it will be computationally unrelated to a sum. For example, the
15076 formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
15077 Operator precedences have caused the ``sum'' to be written in
15078 parentheses, but the arguments have not actually been summed.
15079 (Generally a display format like this would be undesirable, since
15080 it can easily be confused with a real sum.)
15082 The special function @code{eval} can be used inside a @kbd{Z C}
15083 composition formula to cause all or part of the formula to be
15084 evaluated at display time. For example, if the formula is
15085 @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
15086 as @samp{1 + 5}. Evaluation will use the default simplifications,
15087 regardless of the current simplification mode. There are also
15088 @code{evalsimp} and @code{evalextsimp} which simplify as if by
15089 @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions''
15090 operate only in the context of composition formulas (and also in
15091 rewrite rules, where they serve a similar purpose; @pxref{Rewrite
15092 Rules}). On the stack, a call to @code{eval} will be left in
15095 It is not a good idea to use @code{eval} except as a last resort.
15096 It can cause the display of formulas to be extremely slow. For
15097 example, while @samp{eval(a + b)} might seem quite fast and simple,
15098 there are several situations where it could be slow. For example,
15099 @samp{a} and/or @samp{b} could be polar complex numbers, in which
15100 case doing the sum requires trigonometry. Or, @samp{a} could be
15101 the factorial @samp{fact(100)} which is unevaluated because you
15102 have typed @kbd{m O}; @code{eval} will evaluate it anyway to
15103 produce a large, unwieldy integer.
15105 You can save your display formats permanently using the @kbd{Z P}
15106 command (@pxref{Creating User Keys}).
15108 @node Syntax Tables, , Compositions, Language Modes
15109 @subsection Syntax Tables
15112 @cindex Syntax tables
15113 @cindex Parsing formulas, customized
15114 Syntax tables do for input what compositions do for output: They
15115 allow you to teach custom notations to Calc's formula parser.
15116 Calc keeps a separate syntax table for each language mode.
15118 (Note that the Calc ``syntax tables'' discussed here are completely
15119 unrelated to the syntax tables described in the Emacs manual.)
15122 @pindex calc-edit-user-syntax
15123 The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
15124 syntax table for the current language mode. If you want your
15125 syntax to work in any language, define it in the normal language
15126 mode. Type @kbd{M-# M-#} to finish editing the syntax table, or
15127 @kbd{M-# x} to cancel the edit. The @kbd{m m} command saves all
15128 the syntax tables along with the other mode settings;
15129 @pxref{General Mode Commands}.
15132 * Syntax Table Basics::
15133 * Precedence in Syntax Tables::
15134 * Advanced Syntax Patterns::
15135 * Conditional Syntax Rules::
15138 @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
15139 @subsubsection Syntax Table Basics
15142 @dfn{Parsing} is the process of converting a raw string of characters,
15143 such as you would type in during algebraic entry, into a Calc formula.
15144 Calc's parser works in two stages. First, the input is broken down
15145 into @dfn{tokens}, such as words, numbers, and punctuation symbols
15146 like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is
15147 ignored (except when it serves to separate adjacent words). Next,
15148 the parser matches this string of tokens against various built-in
15149 syntactic patterns, such as ``an expression followed by @samp{+}
15150 followed by another expression'' or ``a name followed by @samp{(},
15151 zero or more expressions separated by commas, and @samp{)}.''
15153 A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
15154 which allow you to specify new patterns to define your own
15155 favorite input notations. Calc's parser always checks the syntax
15156 table for the current language mode, then the table for the normal
15157 language mode, before it uses its built-in rules to parse an
15158 algebraic formula you have entered. Each syntax rule should go on
15159 its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
15160 and a Calc formula with an optional @dfn{condition}. (Syntax rules
15161 resemble algebraic rewrite rules, but the notation for patterns is
15162 completely different.)
15164 A syntax pattern is a list of tokens, separated by spaces.
15165 Except for a few special symbols, tokens in syntax patterns are
15166 matched literally, from left to right. For example, the rule,
15173 would cause Calc to parse the formula @samp{4+foo()*5} as if it
15174 were @samp{4+(2+3)*5}. Notice that the parentheses were written
15175 as two separate tokens in the rule. As a result, the rule works
15176 for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written
15177 the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
15178 as a single, indivisible token, so that @w{@samp{foo( )}} would
15179 not be recognized by the rule. (It would be parsed as a regular
15180 zero-argument function call instead.) In fact, this rule would
15181 also make trouble for the rest of Calc's parser: An unrelated
15182 formula like @samp{bar()} would now be tokenized into @samp{bar ()}
15183 instead of @samp{bar ( )}, so that the standard parser for function
15184 calls would no longer recognize it!
15186 While it is possible to make a token with a mixture of letters
15187 and punctuation symbols, this is not recommended. It is better to
15188 break it into several tokens, as we did with @samp{foo()} above.
15190 The symbol @samp{#} in a syntax pattern matches any Calc expression.
15191 On the righthand side, the things that matched the @samp{#}s can
15192 be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
15193 matches the leftmost @samp{#} in the pattern). For example, these
15194 rules match a user-defined function, prefix operator, infix operator,
15195 and postfix operator, respectively:
15198 foo ( # ) := myfunc(#1)
15199 foo # := myprefix(#1)
15200 # foo # := myinfix(#1,#2)
15201 # foo := mypostfix(#1)
15204 Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
15205 will parse as @samp{mypostfix(2+3)}.
15207 It is important to write the first two rules in the order shown,
15208 because Calc tries rules in order from first to last. If the
15209 pattern @samp{foo #} came first, it would match anything that could
15210 match the @samp{foo ( # )} rule, since an expression in parentheses
15211 is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would
15212 never get to match anything. Likewise, the last two rules must be
15213 written in the order shown or else @samp{3 foo 4} will be parsed as
15214 @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these
15215 ambiguities is not to use the same symbol in more than one way at
15216 the same time! In case you're not convinced, try the following
15217 exercise: How will the above rules parse the input @samp{foo(3,4)},
15218 if at all? Work it out for yourself, then try it in Calc and see.)
15220 Calc is quite flexible about what sorts of patterns are allowed.
15221 The only rule is that every pattern must begin with a literal
15222 token (like @samp{foo} in the first two patterns above), or with
15223 a @samp{#} followed by a literal token (as in the last two
15224 patterns). After that, any mixture is allowed, although putting
15225 two @samp{#}s in a row will not be very useful since two
15226 expressions with nothing between them will be parsed as one
15227 expression that uses implicit multiplication.
15229 As a more practical example, Maple uses the notation
15230 @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
15231 recognize at present. To handle this syntax, we simply add the
15235 sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
15239 to the Maple mode syntax table. As another example, C mode can't
15240 read assignment operators like @samp{++} and @samp{*=}. We can
15241 define these operators quite easily:
15244 # *= # := muleq(#1,#2)
15245 # ++ := postinc(#1)
15250 To complete the job, we would use corresponding composition functions
15251 and @kbd{Z C} to cause these functions to display in their respective
15252 Maple and C notations. (Note that the C example ignores issues of
15253 operator precedence, which are discussed in the next section.)
15255 You can enclose any token in quotes to prevent its usual
15256 interpretation in syntax patterns:
15259 # ":=" # := becomes(#1,#2)
15262 Quotes also allow you to include spaces in a token, although once
15263 again it is generally better to use two tokens than one token with
15264 an embedded space. To include an actual quotation mark in a quoted
15265 token, precede it with a backslash. (This also works to include
15266 backslashes in tokens.)
15269 # "bad token" # "/\"\\" # := silly(#1,#2,#3)
15273 This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
15275 The token @kbd{#} has a predefined meaning in Calc's formula parser;
15276 it is not legal to use @samp{"#"} in a syntax rule. However, longer
15277 tokens that include the @samp{#} character are allowed. Also, while
15278 @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
15279 the syntax table will prevent those characters from working in their
15280 usual ways (referring to stack entries and quoting strings,
15283 Finally, the notation @samp{%%} anywhere in a syntax table causes
15284 the rest of the line to be ignored as a comment.
15286 @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
15287 @subsubsection Precedence
15290 Different operators are generally assigned different @dfn{precedences}.
15291 By default, an operator defined by a rule like
15294 # foo # := foo(#1,#2)
15298 will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
15299 will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the
15300 precedence of an operator, use the notation @samp{#/@var{p}} in
15301 place of @samp{#}, where @var{p} is an integer precedence level.
15302 For example, 185 lies between the precedences for @samp{+} and
15303 @samp{*}, so if we change this rule to
15306 #/185 foo #/186 := foo(#1,#2)
15310 then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
15311 Also, because we've given the righthand expression slightly higher
15312 precedence, our new operator will be left-associative:
15313 @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
15314 By raising the precedence of the lefthand expression instead, we
15315 can create a right-associative operator.
15317 @xref{Composition Basics}, for a table of precedences of the
15318 standard Calc operators. For the precedences of operators in other
15319 language modes, look in the Calc source file @file{calc-lang.el}.
15321 @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
15322 @subsubsection Advanced Syntax Patterns
15325 To match a function with a variable number of arguments, you could
15329 foo ( # ) := myfunc(#1)
15330 foo ( # , # ) := myfunc(#1,#2)
15331 foo ( # , # , # ) := myfunc(#1,#2,#3)
15335 but this isn't very elegant. To match variable numbers of items,
15336 Calc uses some notations inspired regular expressions and the
15337 ``extended BNF'' style used by some language designers.
15340 foo ( @{ # @}*, ) := apply(myfunc,#1)
15343 The token @samp{@{} introduces a repeated or optional portion.
15344 One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
15345 ends the portion. These will match zero or more, one or more,
15346 or zero or one copies of the enclosed pattern, respectively.
15347 In addition, @samp{@}*} and @samp{@}+} can be followed by a
15348 separator token (with no space in between, as shown above).
15349 Thus @samp{@{ # @}*,} matches nothing, or one expression, or
15350 several expressions separated by commas.
15352 A complete @samp{@{ ... @}} item matches as a vector of the
15353 items that matched inside it. For example, the above rule will
15354 match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
15355 The Calc @code{apply} function takes a function name and a vector
15356 of arguments and builds a call to the function with those
15357 arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
15359 If the body of a @samp{@{ ... @}} contains several @samp{#}s
15360 (or nested @samp{@{ ... @}} constructs), then the items will be
15361 strung together into the resulting vector. If the body
15362 does not contain anything but literal tokens, the result will
15363 always be an empty vector.
15366 foo ( @{ # , # @}+, ) := bar(#1)
15367 foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
15371 will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
15372 @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after
15373 some thought it's easy to see how this pair of rules will parse
15374 @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
15375 rule will only match an even number of arguments. The rule
15378 foo ( # @{ , # , # @}? ) := bar(#1,#2)
15382 will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
15383 @samp{foo(2)} as @samp{bar(2,[])}.
15385 The notation @samp{@{ ... @}?.} (note the trailing period) works
15386 just the same as regular @samp{@{ ... @}?}, except that it does not
15387 count as an argument; the following two rules are equivalent:
15390 foo ( # , @{ also @}? # ) := bar(#1,#3)
15391 foo ( # , @{ also @}?. # ) := bar(#1,#2)
15395 Note that in the first case the optional text counts as @samp{#2},
15396 which will always be an empty vector, but in the second case no
15397 empty vector is produced.
15399 Another variant is @samp{@{ ... @}?$}, which means the body is
15400 optional only at the end of the input formula. All built-in syntax
15401 rules in Calc use this for closing delimiters, so that during
15402 algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
15403 the closing parenthesis and bracket. Calc does this automatically
15404 for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
15405 rules, but you can use @samp{@{ ... @}?$} explicitly to get
15406 this effect with any token (such as @samp{"@}"} or @samp{end}).
15407 Like @samp{@{ ... @}?.}, this notation does not count as an
15408 argument. Conversely, you can use quotes, as in @samp{")"}, to
15409 prevent a closing-delimiter token from being automatically treated
15412 Calc's parser does not have full backtracking, which means some
15413 patterns will not work as you might expect:
15416 foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
15420 Here we are trying to make the first argument optional, so that
15421 @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc
15422 first tries to match @samp{2,} against the optional part of the
15423 pattern, finds a match, and so goes ahead to match the rest of the
15424 pattern. Later on it will fail to match the second comma, but it
15425 doesn't know how to go back and try the other alternative at that
15426 point. One way to get around this would be to use two rules:
15429 foo ( # , # , # ) := bar([#1],#2,#3)
15430 foo ( # , # ) := bar([],#1,#2)
15433 More precisely, when Calc wants to match an optional or repeated
15434 part of a pattern, it scans forward attempting to match that part.
15435 If it reaches the end of the optional part without failing, it
15436 ``finalizes'' its choice and proceeds. If it fails, though, it
15437 backs up and tries the other alternative. Thus Calc has ``partial''
15438 backtracking. A fully backtracking parser would go on to make sure
15439 the rest of the pattern matched before finalizing the choice.
15441 @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
15442 @subsubsection Conditional Syntax Rules
15445 It is possible to attach a @dfn{condition} to a syntax rule. For
15449 foo ( # ) := ifoo(#1) :: integer(#1)
15450 foo ( # ) := gfoo(#1)
15454 will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
15455 @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any
15456 number of conditions may be attached; all must be true for the
15457 rule to succeed. A condition is ``true'' if it evaluates to a
15458 nonzero number. @xref{Logical Operations}, for a list of Calc
15459 functions like @code{integer} that perform logical tests.
15461 The exact sequence of events is as follows: When Calc tries a
15462 rule, it first matches the pattern as usual. It then substitutes
15463 @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the
15464 conditions are simplified and evaluated in order from left to right,
15465 as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}).
15466 Each result is true if it is a nonzero number, or an expression
15467 that can be proven to be nonzero (@pxref{Declarations}). If the
15468 results of all conditions are true, the expression (such as
15469 @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
15470 result of the parse. If the result of any condition is false, Calc
15471 goes on to try the next rule in the syntax table.
15473 Syntax rules also support @code{let} conditions, which operate in
15474 exactly the same way as they do in algebraic rewrite rules.
15475 @xref{Other Features of Rewrite Rules}, for details. A @code{let}
15476 condition is always true, but as a side effect it defines a
15477 variable which can be used in later conditions, and also in the
15478 expression after the @samp{:=} sign:
15481 foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
15485 The @code{dnumint} function tests if a value is numerically an
15486 integer, i.e., either a true integer or an integer-valued float.
15487 This rule will parse @code{foo} with a half-integer argument,
15488 like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
15490 The lefthand side of a syntax rule @code{let} must be a simple
15491 variable, not the arbitrary pattern that is allowed in rewrite
15494 The @code{matches} function is also treated specially in syntax
15495 rule conditions (again, in the same way as in rewrite rules).
15496 @xref{Matching Commands}. If the matching pattern contains
15497 meta-variables, then those meta-variables may be used in later
15498 conditions and in the result expression. The arguments to
15499 @code{matches} are not evaluated in this situation.
15502 sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
15506 This is another way to implement the Maple mode @code{sum} notation.
15507 In this approach, we allow @samp{#2} to equal the whole expression
15508 @samp{i=1..10}. Then, we use @code{matches} to break it apart into
15509 its components. If the expression turns out not to match the pattern,
15510 the syntax rule will fail. Note that @kbd{Z S} always uses Calc's
15511 normal language mode for editing expressions in syntax rules, so we
15512 must use regular Calc notation for the interval @samp{[b..c]} that
15513 will correspond to the Maple mode interval @samp{1..10}.
15515 @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
15516 @section The @code{Modes} Variable
15520 @pindex calc-get-modes
15521 The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
15522 a vector of numbers that describes the various mode settings that
15523 are in effect. With a numeric prefix argument, it pushes only the
15524 @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard
15525 macros can use the @kbd{m g} command to modify their behavior based
15526 on the current mode settings.
15528 @cindex @code{Modes} variable
15530 The modes vector is also available in the special variable
15531 @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
15532 It will not work to store into this variable; in fact, if you do,
15533 @code{Modes} will cease to track the current modes. (The @kbd{m g}
15534 command will continue to work, however.)
15536 In general, each number in this vector is suitable as a numeric
15537 prefix argument to the associated mode-setting command. (Recall
15538 that the @kbd{~} key takes a number from the stack and gives it as
15539 a numeric prefix to the next command.)
15541 The elements of the modes vector are as follows:
15545 Current precision. Default is 12; associated command is @kbd{p}.
15548 Binary word size. Default is 32; associated command is @kbd{b w}.
15551 Stack size (not counting the value about to be pushed by @kbd{m g}).
15552 This is zero if @kbd{m g} is executed with an empty stack.
15555 Number radix. Default is 10; command is @kbd{d r}.
15558 Floating-point format. This is the number of digits, plus the
15559 constant 0 for normal notation, 10000 for scientific notation,
15560 20000 for engineering notation, or 30000 for fixed-point notation.
15561 These codes are acceptable as prefix arguments to the @kbd{d n}
15562 command, but note that this may lose information: For example,
15563 @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
15564 identical) effects if the current precision is 12, but they both
15565 produce a code of 10012, which will be treated by @kbd{d n} as
15566 @kbd{C-u 12 d s}. If the precision then changes, the float format
15567 will still be frozen at 12 significant figures.
15570 Angular mode. Default is 1 (degrees). Other values are 2 (radians)
15571 and 3 (HMS). The @kbd{m d} command accepts these prefixes.
15574 Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}.
15577 Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}.
15580 Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0.
15581 Command is @kbd{m p}.
15584 Matrix/scalar mode. Default value is @i{-1}. Value is 0 for scalar
15585 mode, @i{-2} for matrix mode, or @var{N} for @c{$N\times N$}
15586 @var{N}x@var{N} matrix mode. Command is @kbd{m v}.
15589 Simplification mode. Default is 1. Value is @i{-1} for off (@kbd{m O}),
15590 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
15591 or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes.
15594 Infinite mode. Default is @i{-1} (off). Value is 1 if the mode is on,
15595 or 0 if the mode is on with positive zeros. Command is @kbd{m i}.
15598 For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
15599 precision by two, leaving a copy of the old precision on the stack.
15600 Later, @kbd{~ p} will restore the original precision using that
15601 stack value. (This sequence might be especially useful inside a
15604 As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
15605 oldest (bottommost) stack entry.
15607 Yet another example: The HP-48 ``round'' command rounds a number
15608 to the current displayed precision. You could roughly emulate this
15609 in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This
15610 would not work for fixed-point mode, but it wouldn't be hard to
15611 do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
15612 programming commands. @xref{Conditionals in Macros}.)
15614 @node Calc Mode Line, , Modes Variable, Mode Settings
15615 @section The Calc Mode Line
15618 @cindex Mode line indicators
15619 This section is a summary of all symbols that can appear on the
15620 Calc mode line, the highlighted bar that appears under the Calc
15621 stack window (or under an editing window in Embedded Mode).
15623 The basic mode line format is:
15626 --%%-Calc: 12 Deg @var{other modes} (Calculator)
15629 The @samp{%%} is the Emacs symbol for ``read-only''; it shows that
15630 regular Emacs commands are not allowed to edit the stack buffer
15631 as if it were text.
15633 The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded Mode
15634 is enabled. The words after this describe the various Calc modes
15635 that are in effect.
15637 The first mode is always the current precision, an integer.
15638 The second mode is always the angular mode, either @code{Deg},
15639 @code{Rad}, or @code{Hms}.
15641 Here is a complete list of the remaining symbols that can appear
15646 Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
15649 Incomplete algebraic mode (@kbd{C-u m a}).
15652 Total algebraic mode (@kbd{m t}).
15655 Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
15658 Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
15660 @item Matrix@var{n}
15661 Dimensioned matrix mode (@kbd{C-u @var{n} m v}).
15664 Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
15667 Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
15670 Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
15673 Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
15676 Positive infinite mode (@kbd{C-u 0 m i}).
15679 Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
15682 Default simplifications for numeric arguments only (@kbd{m N}).
15684 @item BinSimp@var{w}
15685 Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
15688 Algebraic simplification mode (@kbd{m A}).
15691 Extended algebraic simplification mode (@kbd{m E}).
15694 Units simplification mode (@kbd{m U}).
15697 Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
15700 Current radix is 8 (@kbd{d 8}).
15703 Current radix is 16 (@kbd{d 6}).
15706 Current radix is @var{n} (@kbd{d r}).
15709 Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
15712 Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
15715 One-line normal language mode (@kbd{d O}).
15718 Unformatted language mode (@kbd{d U}).
15721 C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
15724 Pascal language mode (@kbd{d P}).
15727 FORTRAN language mode (@kbd{d F}).
15730 @TeX{} language mode (@kbd{d T}; @pxref{TeX Language Mode}).
15733 @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
15736 Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
15739 Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
15742 Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
15745 Fixed point mode with @var{n} digits after the point (@kbd{d f}).
15748 Scientific notation mode (@kbd{d s}).
15751 Scientific notation with @var{n} digits (@kbd{d s}).
15754 Engineering notation mode (@kbd{d e}).
15757 Engineering notation with @var{n} digits (@kbd{d e}).
15760 Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
15763 Right-justified display (@kbd{d >}).
15766 Right-justified display with width @var{n} (@kbd{d >}).
15769 Centered display (@kbd{d =}).
15771 @item Center@var{n}
15772 Centered display with center column @var{n} (@kbd{d =}).
15775 Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
15778 No line breaking (@kbd{d b}).
15781 Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
15784 Record modes in @file{~/.emacs} (@kbd{m R}; @pxref{General Mode Commands}).
15787 Record modes in Embedded buffer (@kbd{m R}).
15790 Record modes as editing-only in Embedded buffer (@kbd{m R}).
15793 Record modes as permanent-only in Embedded buffer (@kbd{m R}).
15796 Record modes as global in Embedded buffer (@kbd{m R}).
15799 Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
15803 GNUPLOT process is alive in background (@pxref{Graphics}).
15806 Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
15809 The stack display may not be up-to-date (@pxref{Display Modes}).
15812 ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
15815 ``Hyperbolic'' prefix was pressed (@kbd{H}).
15818 ``Keep-arguments'' prefix was pressed (@kbd{K}).
15821 Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
15824 In addition, the symbols @code{Active} and @code{~Active} can appear
15825 as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}.
15827 @node Arithmetic, Scientific Functions, Mode Settings, Top
15828 @chapter Arithmetic Functions
15831 This chapter describes the Calc commands for doing simple calculations
15832 on numbers, such as addition, absolute value, and square roots. These
15833 commands work by removing the top one or two values from the stack,
15834 performing the desired operation, and pushing the result back onto the
15835 stack. If the operation cannot be performed, the result pushed is a
15836 formula instead of a number, such as @samp{2/0} (because division by zero
15837 is illegal) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
15839 Most of the commands described here can be invoked by a single keystroke.
15840 Some of the more obscure ones are two-letter sequences beginning with
15841 the @kbd{f} (``functions'') prefix key.
15843 @xref{Prefix Arguments}, for a discussion of the effect of numeric
15844 prefix arguments on commands in this chapter which do not otherwise
15845 interpret a prefix argument.
15848 * Basic Arithmetic::
15849 * Integer Truncation::
15850 * Complex Number Functions::
15852 * Date Arithmetic::
15853 * Financial Functions::
15854 * Binary Functions::
15857 @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
15858 @section Basic Arithmetic
15867 The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may
15868 be any of the standard Calc data types. The resulting sum is pushed back
15871 If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
15872 the result is a vector or matrix sum. If one argument is a vector and the
15873 other a scalar (i.e., a non-vector), the scalar is added to each of the
15874 elements of the vector to form a new vector. If the scalar is not a
15875 number, the operation is left in symbolic form: Suppose you added @samp{x}
15876 to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or
15877 you may plan to substitute a 2-vector for @samp{x} in the future. Since
15878 the Calculator can't tell which interpretation you want, it makes the
15879 safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x}
15880 to every element of a vector.
15882 If either argument of @kbd{+} is a complex number, the result will in general
15883 be complex. If one argument is in rectangular form and the other polar,
15884 the current Polar Mode determines the form of the result. If Symbolic
15885 Mode is enabled, the sum may be left as a formula if the necessary
15886 conversions for polar addition are non-trivial.
15888 If both arguments of @kbd{+} are HMS forms, the forms are added according to
15889 the usual conventions of hours-minutes-seconds notation. If one argument
15890 is an HMS form and the other is a number, that number is converted from
15891 degrees or radians (depending on the current Angular Mode) to HMS format
15892 and then the two HMS forms are added.
15894 If one argument of @kbd{+} is a date form, the other can be either a
15895 real number, which advances the date by a certain number of days, or
15896 an HMS form, which advances the date by a certain amount of time.
15897 Subtracting two date forms yields the number of days between them.
15898 Adding two date forms is meaningless, but Calc interprets it as the
15899 subtraction of one date form and the negative of the other. (The
15900 negative of a date form can be understood by remembering that dates
15901 are stored as the number of days before or after Jan 1, 1 AD.)
15903 If both arguments of @kbd{+} are error forms, the result is an error form
15904 with an appropriately computed standard deviation. If one argument is an
15905 error form and the other is a number, the number is taken to have zero error.
15906 Error forms may have symbolic formulas as their mean and/or error parts;
15907 adding these will produce a symbolic error form result. However, adding an
15908 error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
15909 work, for the same reasons just mentioned for vectors. Instead you must
15910 write @samp{(a +/- b) + (c +/- 0)}.
15912 If both arguments of @kbd{+} are modulo forms with equal values of @cite{M},
15913 or if one argument is a modulo form and the other a plain number, the
15914 result is a modulo form which represents the sum, modulo @cite{M}, of
15917 If both arguments of @kbd{+} are intervals, the result is an interval
15918 which describes all possible sums of the possible input values. If
15919 one argument is a plain number, it is treated as the interval
15920 @w{@samp{[x ..@: x]}}.
15922 If one argument of @kbd{+} is an infinity and the other is not, the
15923 result is that same infinity. If both arguments are infinite and in
15924 the same direction, the result is the same infinity, but if they are
15925 infinite in different directions the result is @code{nan}.
15933 The @kbd{-} (@code{calc-minus}) command subtracts two values. The top
15934 number on the stack is subtracted from the one behind it, so that the
15935 computation @kbd{5 @key{RET} 2 -} produces 3, not @i{-3}. All options
15936 available for @kbd{+} are available for @kbd{-} as well.
15944 The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one
15945 argument is a vector and the other a scalar, the scalar is multiplied by
15946 the elements of the vector to produce a new vector. If both arguments
15947 are vectors, the interpretation depends on the dimensions of the
15948 vectors: If both arguments are matrices, a matrix multiplication is
15949 done. If one argument is a matrix and the other a plain vector, the
15950 vector is interpreted as a row vector or column vector, whichever is
15951 dimensionally correct. If both arguments are plain vectors, the result
15952 is a single scalar number which is the dot product of the two vectors.
15954 If one argument of @kbd{*} is an HMS form and the other a number, the
15955 HMS form is multiplied by that amount. It is an error to multiply two
15956 HMS forms together, or to attempt any multiplication involving date
15957 forms. Error forms, modulo forms, and intervals can be multiplied;
15958 see the comments for addition of those forms. When two error forms
15959 or intervals are multiplied they are considered to be statistically
15960 independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
15961 whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
15964 @pindex calc-divide
15969 The @kbd{/} (@code{calc-divide}) command divides two numbers. When
15970 dividing a scalar @cite{B} by a square matrix @cite{A}, the computation
15971 performed is @cite{B} times the inverse of @cite{A}. This also occurs
15972 if @cite{B} is itself a vector or matrix, in which case the effect is
15973 to solve the set of linear equations represented by @cite{B}. If @cite{B}
15974 is a matrix with the same number of rows as @cite{A}, or a plain vector
15975 (which is interpreted here as a column vector), then the equation
15976 @cite{A X = B} is solved for the vector or matrix @cite{X}. Otherwise,
15977 if @cite{B} is a non-square matrix with the same number of @emph{columns}
15978 as @cite{A}, the equation @cite{X A = B} is solved. If you wish a vector
15979 @cite{B} to be interpreted as a row vector to be solved as @cite{X A = B},
15980 make it into a one-row matrix with @kbd{C-u 1 v p} first. To force a
15981 left-handed solution with a square matrix @cite{B}, transpose @cite{A} and
15982 @cite{B} before dividing, then transpose the result.
15984 HMS forms can be divided by real numbers or by other HMS forms. Error
15985 forms can be divided in any combination of ways. Modulo forms where both
15986 values and the modulo are integers can be divided to get an integer modulo
15987 form result. Intervals can be divided; dividing by an interval that
15988 encompasses zero or has zero as a limit will result in an infinite
15997 The @kbd{^} (@code{calc-power}) command raises a number to a power. If
15998 the power is an integer, an exact result is computed using repeated
15999 multiplications. For non-integer powers, Calc uses Newton's method or
16000 logarithms and exponentials. Square matrices can be raised to integer
16001 powers. If either argument is an error (or interval or modulo) form,
16002 the result is also an error (or interval or modulo) form.
16006 If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
16007 computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5.
16008 (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
16017 The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
16018 to produce an integer result. It is equivalent to dividing with
16019 @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
16020 more convenient and efficient. Also, since it is an all-integer
16021 operation when the arguments are integers, it avoids problems that
16022 @kbd{/ F} would have with floating-point roundoff.
16030 The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
16031 operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
16032 for all real numbers @cite{a} and @cite{b} (except @cite{b=0}). For
16033 positive @cite{b}, the result will always be between 0 (inclusive) and
16034 @cite{b} (exclusive). Modulo does not work for HMS forms and error forms.
16035 If @cite{a} is a modulo form, its modulo is changed to @cite{b}, which
16036 must be positive real number.
16041 The @kbd{:} (@code{calc-fdiv}) command [@code{fdiv} function in a formula]
16042 divides the two integers on the top of the stack to produce a fractional
16043 result. This is a convenient shorthand for enabling Fraction Mode (with
16044 @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry
16045 the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
16046 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in
16047 this case, it would be much easier simply to enter the fraction directly
16048 as @kbd{8:6 @key{RET}}!)
16051 @pindex calc-change-sign
16052 The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
16053 of the stack. It works on numbers, vectors and matrices, HMS forms, date
16054 forms, error forms, intervals, and modulo forms.
16059 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
16060 value of a number. The result of @code{abs} is always a nonnegative
16061 real number: With a complex argument, it computes the complex magnitude.
16062 With a vector or matrix argument, it computes the Frobenius norm, i.e.,
16063 the square root of the sum of the squares of the absolute values of the
16064 elements. The absolute value of an error form is defined by replacing
16065 the mean part with its absolute value and leaving the error part the same.
16066 The absolute value of a modulo form is undefined. The absolute value of
16067 an interval is defined in the obvious way.
16070 @pindex calc-abssqr
16072 The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
16073 absolute value squared of a number, vector or matrix, or error form.
16078 The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
16079 argument is positive, @i{-1} if its argument is negative, or 0 if its
16080 argument is zero. In algebraic form, you can also write @samp{sign(a,x)}
16081 which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
16082 zero depending on the sign of @samp{a}.
16088 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
16089 reciprocal of a number, i.e., @cite{1 / x}. Operating on a square
16090 matrix, it computes the inverse of that matrix.
16095 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
16096 root of a number. For a negative real argument, the result will be a
16097 complex number whose form is determined by the current Polar Mode.
16102 The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
16103 root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)}
16104 is the length of the hypotenuse of a right triangle with sides @cite{a}
16105 and @cite{b}. If the arguments are complex numbers, their squared
16106 magnitudes are used.
16111 The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
16112 integer square root of an integer. This is the true square root of the
16113 number, rounded down to an integer. For example, @samp{isqrt(10)}
16114 produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact
16115 integer arithmetic throughout to avoid roundoff problems. If the input
16116 is a floating-point number or other non-integer value, this is exactly
16117 the same as @samp{floor(sqrt(x))}.
16125 The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
16126 [@code{max}] commands take the minimum or maximum of two real numbers,
16127 respectively. These commands also work on HMS forms, date forms,
16128 intervals, and infinities. (In algebraic expressions, these functions
16129 take any number of arguments and return the maximum or minimum among
16130 all the arguments.)@refill
16134 @pindex calc-mant-part
16136 @pindex calc-xpon-part
16138 The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
16139 the ``mantissa'' part @cite{m} of its floating-point argument; @kbd{f X}
16140 (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
16141 @cite{e}. The original number is equal to @c{$m \times 10^e$}
16143 where @cite{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
16144 @cite{m=e=0} if the original number is zero. For integers
16145 and fractions, @code{mant} returns the number unchanged and @code{xpon}
16146 returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be
16147 used to ``unpack'' a floating-point number; this produces an integer
16148 mantissa and exponent, with the constraint that the mantissa is not
16149 a multiple of ten (again except for the @cite{m=e=0} case).@refill
16152 @pindex calc-scale-float
16154 The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
16155 by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any
16156 real @samp{x}. The second argument must be an integer, but the first
16157 may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05}
16158 or @samp{1:20} depending on the current Fraction Mode.@refill
16162 @pindex calc-decrement
16163 @pindex calc-increment
16166 The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
16167 (@code{calc-increment}) [@code{incr}] functions decrease or increase
16168 a number by one unit. For integers, the effect is obvious. For
16169 floating-point numbers, the change is by one unit in the last place.
16170 For example, incrementing @samp{12.3456} when the current precision
16171 is 6 digits yields @samp{12.3457}. If the current precision had been
16172 8 digits, the result would have been @samp{12.345601}. Incrementing
16173 @samp{0.0} produces @c{$10^{-p}$}
16174 @cite{10^-p}, where @cite{p} is the current
16175 precision. These operations are defined only on integers and floats.
16176 With numeric prefix arguments, they change the number by @cite{n} units.
16178 Note that incrementing followed by decrementing, or vice-versa, will
16179 almost but not quite always cancel out. Suppose the precision is
16180 6 digits and the number @samp{9.99999} is on the stack. Incrementing
16181 will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
16182 One digit has been dropped. This is an unavoidable consequence of the
16183 way floating-point numbers work.
16185 Incrementing a date/time form adjusts it by a certain number of seconds.
16186 Incrementing a pure date form adjusts it by a certain number of days.
16188 @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
16189 @section Integer Truncation
16192 There are four commands for truncating a real number to an integer,
16193 differing mainly in their treatment of negative numbers. All of these
16194 commands have the property that if the argument is an integer, the result
16195 is the same integer. An integer-valued floating-point argument is converted
16198 If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
16199 expressed as an integer-valued floating-point number.
16201 @cindex Integer part of a number
16210 The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
16211 truncates a real number to the next lower integer, i.e., toward minus
16212 infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
16216 @pindex calc-ceiling
16223 The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
16224 command truncates toward positive infinity. Thus @kbd{3.6 I F} produces
16225 4, and @kbd{_3.6 I F} produces @i{-3}.@refill
16235 The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
16236 rounds to the nearest integer. When the fractional part is .5 exactly,
16237 this command rounds away from zero. (All other rounding in the
16238 Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4
16239 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @i{-4}.@refill
16249 The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
16250 command truncates toward zero. In other words, it ``chops off''
16251 everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and
16252 @kbd{_3.6 I R} produces @i{-3}.@refill
16254 These functions may not be applied meaningfully to error forms, but they
16255 do work for intervals. As a convenience, applying @code{floor} to a
16256 modulo form floors the value part of the form. Applied to a vector,
16257 these functions operate on all elements of the vector one by one.
16258 Applied to a date form, they operate on the internal numerical
16259 representation of dates, converting a date/time form into a pure date.
16277 There are two more rounding functions which can only be entered in
16278 algebraic notation. The @code{roundu} function is like @code{round}
16279 except that it rounds up, toward plus infinity, when the fractional
16280 part is .5. This distinction matters only for negative arguments.
16281 Also, @code{rounde} rounds to an even number in the case of a tie,
16282 rounding up or down as necessary. For example, @samp{rounde(3.5)} and
16283 @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
16284 The advantage of round-to-even is that the net error due to rounding
16285 after a long calculation tends to cancel out to zero. An important
16286 subtle point here is that the number being fed to @code{rounde} will
16287 already have been rounded to the current precision before @code{rounde}
16288 begins. For example, @samp{rounde(2.500001)} with a current precision
16289 of 6 will incorrectly, or at least surprisingly, yield 2 because the
16290 argument will first have been rounded down to @cite{2.5} (which
16291 @code{rounde} sees as an exact tie between 2 and 3).
16293 Each of these functions, when written in algebraic formulas, allows
16294 a second argument which specifies the number of digits after the
16295 decimal point to keep. For example, @samp{round(123.4567, 2)} will
16296 produce the answer 123.46, and @samp{round(123.4567, -1)} will
16297 produce 120 (i.e., the cutoff is one digit to the @emph{left} of
16298 the decimal point). A second argument of zero is equivalent to
16299 no second argument at all.
16301 @cindex Fractional part of a number
16302 To compute the fractional part of a number (i.e., the amount which, when
16303 added to `@t{floor(}@var{n}@t{)}', will produce @var{n}) just take @var{n}
16304 modulo 1 using the @code{%} command.@refill
16306 Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
16307 and @kbd{f Q} (integer square root) commands, which are analogous to
16308 @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
16309 arguments and return the result rounded down to an integer.
16311 @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
16312 @section Complex Number Functions
16318 The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
16319 complex conjugate of a number. For complex number @cite{a+bi}, the
16320 complex conjugate is @cite{a-bi}. If the argument is a real number,
16321 this command leaves it the same. If the argument is a vector or matrix,
16322 this command replaces each element by its complex conjugate.
16325 @pindex calc-argument
16327 The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
16328 ``argument'' or polar angle of a complex number. For a number in polar
16329 notation, this is simply the second component of the pair
16330 `@t{(}@var{r}@t{;}@c{$\theta$}
16332 The result is expressed according to the current angular mode and will
16333 be in the range @i{-180} degrees (exclusive) to @i{+180} degrees
16334 (inclusive), or the equivalent range in radians.@refill
16336 @pindex calc-imaginary
16337 The @code{calc-imaginary} command multiplies the number on the
16338 top of the stack by the imaginary number @cite{i = (0,1)}. This
16339 command is not normally bound to a key in Calc, but it is available
16340 on the @key{IMAG} button in Keypad Mode.
16345 The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
16346 by its real part. This command has no effect on real numbers. (As an
16347 added convenience, @code{re} applied to a modulo form extracts
16348 the value part.)@refill
16353 The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
16354 by its imaginary part; real numbers are converted to zero. With a vector
16355 or matrix argument, these functions operate element-wise.@refill
16360 @kindex v p (complex)
16362 The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
16363 the stack into a composite object such as a complex number. With
16364 a prefix argument of @i{-1}, it produces a rectangular complex number;
16365 with an argument of @i{-2}, it produces a polar complex number.
16366 (Also, @pxref{Building Vectors}.)
16371 @kindex v u (complex)
16372 @pindex calc-unpack
16373 The @kbd{v u} (@code{calc-unpack}) command takes the complex number
16374 (or other composite object) on the top of the stack and unpacks it
16375 into its separate components.
16377 @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
16378 @section Conversions
16381 The commands described in this section convert numbers from one form
16382 to another; they are two-key sequences beginning with the letter @kbd{c}.
16387 The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
16388 number on the top of the stack to floating-point form. For example,
16389 @cite{23} is converted to @cite{23.0}, @cite{3:2} is converted to
16390 @cite{1.5}, and @cite{2.3} is left the same. If the value is a composite
16391 object such as a complex number or vector, each of the components is
16392 converted to floating-point. If the value is a formula, all numbers
16393 in the formula are converted to floating-point. Note that depending
16394 on the current floating-point precision, conversion to floating-point
16395 format may lose information.@refill
16397 As a special exception, integers which appear as powers or subscripts
16398 are not floated by @kbd{c f}. If you really want to float a power,
16399 you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
16400 Because @kbd{c f} cannot examine the formula outside of the selection,
16401 it does not notice that the thing being floated is a power.
16402 @xref{Selecting Subformulas}.
16404 The normal @kbd{c f} command is ``pervasive'' in the sense that it
16405 applies to all numbers throughout the formula. The @code{pfloat}
16406 algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
16407 changes to @samp{a + 1.0} as soon as it is evaluated.
16411 With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
16412 only on the number or vector of numbers at the top level of its
16413 argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
16414 is left unevaluated because its argument is not a number.
16416 You should use @kbd{H c f} if you wish to guarantee that the final
16417 value, once all the variables have been assigned, is a float; you
16418 would use @kbd{c f} if you wish to do the conversion on the numbers
16419 that appear right now.
16422 @pindex calc-fraction
16424 The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
16425 floating-point number into a fractional approximation. By default, it
16426 produces a fraction whose decimal representation is the same as the
16427 input number, to within the current precision. You can also give a
16428 numeric prefix argument to specify a tolerance, either directly, or,
16429 if the prefix argument is zero, by using the number on top of the stack
16430 as the tolerance. If the tolerance is a positive integer, the fraction
16431 is correct to within that many significant figures. If the tolerance is
16432 a non-positive integer, it specifies how many digits fewer than the current
16433 precision to use. If the tolerance is a floating-point number, the
16434 fraction is correct to within that absolute amount.
16438 The @code{pfrac} function is pervasive, like @code{pfloat}.
16439 There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
16440 which is analogous to @kbd{H c f} discussed above.
16443 @pindex calc-to-degrees
16445 The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
16446 number into degrees form. The value on the top of the stack may be an
16447 HMS form (interpreted as degrees-minutes-seconds), or a real number which
16448 will be interpreted in radians regardless of the current angular mode.@refill
16451 @pindex calc-to-radians
16453 The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
16454 HMS form or angle in degrees into an angle in radians.
16457 @pindex calc-to-hms
16459 The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
16460 number, interpreted according to the current angular mode, to an HMS
16461 form describing the same angle. In algebraic notation, the @code{hms}
16462 function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
16463 (The three-argument version is independent of the current angular mode.)
16465 @pindex calc-from-hms
16466 The @code{calc-from-hms} command converts the HMS form on the top of the
16467 stack into a real number according to the current angular mode.
16474 The @kbd{c p} (@code{calc-polar}) command converts the complex number on
16475 the top of the stack from polar to rectangular form, or from rectangular
16476 to polar form, whichever is appropriate. Real numbers are left the same.
16477 This command is equivalent to the @code{rect} or @code{polar}
16478 functions in algebraic formulas, depending on the direction of
16479 conversion. (It uses @code{polar}, except that if the argument is
16480 already a polar complex number, it uses @code{rect} instead. The
16481 @kbd{I c p} command always uses @code{rect}.)@refill
16486 The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
16487 number on the top of the stack. Floating point numbers are re-rounded
16488 according to the current precision. Polar numbers whose angular
16489 components have strayed from the @i{-180} to @i{+180} degree range
16490 are normalized. (Note that results will be undesirable if the current
16491 angular mode is different from the one under which the number was
16492 produced!) Integers and fractions are generally unaffected by this
16493 operation. Vectors and formulas are cleaned by cleaning each component
16494 number (i.e., pervasively).@refill
16496 If the simplification mode is set below the default level, it is raised
16497 to the default level for the purposes of this command. Thus, @kbd{c c}
16498 applies the default simplifications even if their automatic application
16499 is disabled. @xref{Simplification Modes}.
16501 @cindex Roundoff errors, correcting
16502 A numeric prefix argument to @kbd{c c} sets the floating-point precision
16503 to that value for the duration of the command. A positive prefix (of at
16504 least 3) sets the precision to the specified value; a negative or zero
16505 prefix decreases the precision by the specified amount.
16508 @pindex calc-clean-num
16509 The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
16510 to @kbd{c c} with the corresponding negative prefix argument. If roundoff
16511 errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
16512 decimal place often conveniently does the trick.
16514 The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
16515 through @kbd{c 9} commands, also ``clip'' very small floating-point
16516 numbers to zero. If the exponent is less than or equal to the negative
16517 of the specified precision, the number is changed to 0.0. For example,
16518 if the current precision is 12, then @kbd{c 2} changes the vector
16519 @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
16520 Numbers this small generally arise from roundoff noise.
16522 If the numbers you are using really are legitimately this small,
16523 you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
16524 (The plain @kbd{c c} command rounds to the current precision but
16525 does not clip small numbers.)
16527 One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
16528 a prefix argument, is that integer-valued floats are converted to
16529 plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
16530 produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge
16531 numbers (@samp{1e100} is technically an integer-valued float, but
16532 you wouldn't want it automatically converted to a 100-digit integer).
16537 With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
16538 operate non-pervasively [@code{clean}].
16540 @node Date Arithmetic, Financial Functions, Conversions, Arithmetic
16541 @section Date Arithmetic
16544 @cindex Date arithmetic, additional functions
16545 The commands described in this section perform various conversions
16546 and calculations involving date forms (@pxref{Date Forms}). They
16547 use the @kbd{t} (for time/date) prefix key followed by shifted
16550 The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
16551 commands. In particular, adding a number to a date form advances the
16552 date form by a certain number of days; adding an HMS form to a date
16553 form advances the date by a certain amount of time; and subtracting two
16554 date forms produces a difference measured in days. The commands
16555 described here provide additional, more specialized operations on dates.
16557 Many of these commands accept a numeric prefix argument; if you give
16558 plain @kbd{C-u} as the prefix, these commands will instead take the
16559 additional argument from the top of the stack.
16562 * Date Conversions::
16568 @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
16569 @subsection Date Conversions
16575 The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
16576 date form into a number, measured in days since Jan 1, 1 AD. The
16577 result will be an integer if @var{date} is a pure date form, or a
16578 fraction or float if @var{date} is a date/time form. Or, if its
16579 argument is a number, it converts this number into a date form.
16581 With a numeric prefix argument, @kbd{t D} takes that many objects
16582 (up to six) from the top of the stack and interprets them in one
16583 of the following ways:
16585 The @samp{date(@var{year}, @var{month}, @var{day})} function
16586 builds a pure date form out of the specified year, month, and
16587 day, which must all be integers. @var{Year} is a year number,
16588 such as 1991 (@emph{not} the same as 91!). @var{Month} must be
16589 an integer in the range 1 to 12; @var{day} must be in the range
16590 1 to 31. If the specified month has fewer than 31 days and
16591 @var{day} is too large, the equivalent day in the following
16592 month will be used.
16594 The @samp{date(@var{month}, @var{day})} function builds a
16595 pure date form using the current year, as determined by the
16598 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
16599 function builds a date/time form using an @var{hms} form.
16601 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
16602 @var{minute}, @var{second})} function builds a date/time form.
16603 @var{hour} should be an integer in the range 0 to 23;
16604 @var{minute} should be an integer in the range 0 to 59;
16605 @var{second} should be any real number in the range @samp{[0 .. 60)}.
16606 The last two arguments default to zero if omitted.
16609 @pindex calc-julian
16611 @cindex Julian day counts, conversions
16612 The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
16613 a date form into a Julian day count, which is the number of days
16614 since noon on Jan 1, 4713 BC. A pure date is converted to an integer
16615 Julian count representing noon of that day. A date/time form is
16616 converted to an exact floating-point Julian count, adjusted to
16617 interpret the date form in the current time zone but the Julian
16618 day count in Greenwich Mean Time. A numeric prefix argument allows
16619 you to specify the time zone; @pxref{Time Zones}. Use a prefix of
16620 zero to suppress the time zone adjustment. Note that pure date forms
16621 are never time-zone adjusted.
16623 This command can also do the opposite conversion, from a Julian day
16624 count (either an integer day, or a floating-point day and time in
16625 the GMT zone), into a pure date form or a date/time form in the
16626 current or specified time zone.
16629 @pindex calc-unix-time
16631 @cindex Unix time format, conversions
16632 The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
16633 converts a date form into a Unix time value, which is the number of
16634 seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result
16635 will be an integer if the current precision is 12 or less; for higher
16636 precisions, the result may be a float with (@var{precision}@minus{}12)
16637 digits after the decimal. Just as for @kbd{t J}, the numeric time
16638 is interpreted in the GMT time zone and the date form is interpreted
16639 in the current or specified zone. Some systems use Unix-like
16640 numbering but with the local time zone; give a prefix of zero to
16641 suppress the adjustment if so.
16644 @pindex calc-convert-time-zones
16646 @cindex Time Zones, converting between
16647 The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
16648 command converts a date form from one time zone to another. You
16649 are prompted for each time zone name in turn; you can answer with
16650 any suitable Calc time zone expression (@pxref{Time Zones}).
16651 If you answer either prompt with a blank line, the local time
16652 zone is used for that prompt. You can also answer the first
16653 prompt with @kbd{$} to take the two time zone names from the
16654 stack (and the date to be converted from the third stack level).
16656 @node Date Functions, Business Days, Date Conversions, Date Arithmetic
16657 @subsection Date Functions
16663 The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
16664 current date and time on the stack as a date form. The time is
16665 reported in terms of the specified time zone; with no numeric prefix
16666 argument, @kbd{t N} reports for the current time zone.
16669 @pindex calc-date-part
16670 The @kbd{t P} (@code{calc-date-part}) command extracts one part
16671 of a date form. The prefix argument specifies the part; with no
16672 argument, this command prompts for a part code from 1 to 9.
16673 The various part codes are described in the following paragraphs.
16676 The @kbd{M-1 t P} [@code{year}] function extracts the year number
16677 from a date form as an integer, e.g., 1991. This and the
16678 following functions will also accept a real number for an
16679 argument, which is interpreted as a standard Calc day number.
16680 Note that this function will never return zero, since the year
16681 1 BC immediately precedes the year 1 AD.
16684 The @kbd{M-2 t P} [@code{month}] function extracts the month number
16685 from a date form as an integer in the range 1 to 12.
16688 The @kbd{M-3 t P} [@code{day}] function extracts the day number
16689 from a date form as an integer in the range 1 to 31.
16692 The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
16693 a date form as an integer in the range 0 (midnight) to 23. Note
16694 that 24-hour time is always used. This returns zero for a pure
16695 date form. This function (and the following two) also accept
16696 HMS forms as input.
16699 The @kbd{M-5 t P} [@code{minute}] function extracts the minute
16700 from a date form as an integer in the range 0 to 59.
16703 The @kbd{M-6 t P} [@code{second}] function extracts the second
16704 from a date form. If the current precision is 12 or less,
16705 the result is an integer in the range 0 to 59. For higher
16706 precisions, the result may instead be a floating-point number.
16709 The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
16710 number from a date form as an integer in the range 0 (Sunday)
16714 The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
16715 number from a date form as an integer in the range 1 (January 1)
16716 to 366 (December 31 of a leap year).
16719 The @kbd{M-9 t P} [@code{time}] function extracts the time portion
16720 of a date form as an HMS form. This returns @samp{0@@ 0' 0"}
16721 for a pure date form.
16724 @pindex calc-new-month
16726 The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
16727 computes a new date form that represents the first day of the month
16728 specified by the input date. The result is always a pure date
16729 form; only the year and month numbers of the input are retained.
16730 With a numeric prefix argument @var{n} in the range from 1 to 31,
16731 @kbd{t M} computes the @var{n}th day of the month. (If @var{n}
16732 is greater than the actual number of days in the month, or if
16733 @var{n} is zero, the last day of the month is used.)
16736 @pindex calc-new-year
16738 The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
16739 computes a new pure date form that represents the first day of
16740 the year specified by the input. The month, day, and time
16741 of the input date form are lost. With a numeric prefix argument
16742 @var{n} in the range from 1 to 366, @kbd{t Y} computes the
16743 @var{n}th day of the year (366 is treated as 365 in non-leap
16744 years). A prefix argument of 0 computes the last day of the
16745 year (December 31). A negative prefix argument from @i{-1} to
16746 @i{-12} computes the first day of the @var{n}th month of the year.
16749 @pindex calc-new-week
16751 The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
16752 computes a new pure date form that represents the Sunday on or before
16753 the input date. With a numeric prefix argument, it can be made to
16754 use any day of the week as the starting day; the argument must be in
16755 the range from 0 (Sunday) to 6 (Saturday). This function always
16756 subtracts between 0 and 6 days from the input date.
16758 Here's an example use of @code{newweek}: Find the date of the next
16759 Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
16760 will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
16761 will give you the following Wednesday. A further look at the definition
16762 of @code{newweek} shows that if the input date is itself a Wednesday,
16763 this formula will return the Wednesday one week in the future. An
16764 exercise for the reader is to modify this formula to yield the same day
16765 if the input is already a Wednesday. Another interesting exercise is
16766 to preserve the time-of-day portion of the input (@code{newweek} resets
16767 the time to midnight; hint:@: how can @code{newweek} be defined in terms
16768 of the @code{weekday} function?).
16774 The @samp{pwday(@var{date})} function (not on any key) computes the
16775 day-of-month number of the Sunday on or before @var{date}. With
16776 two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
16777 number of the Sunday on or before day number @var{day} of the month
16778 specified by @var{date}. The @var{day} must be in the range from
16779 7 to 31; if the day number is greater than the actual number of days
16780 in the month, the true number of days is used instead. Thus
16781 @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
16782 @samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
16783 With a third @var{weekday} argument, @code{pwday} can be made to look
16784 for any day of the week instead of Sunday.
16787 @pindex calc-inc-month
16789 The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
16790 increases a date form by one month, or by an arbitrary number of
16791 months specified by a numeric prefix argument. The time portion,
16792 if any, of the date form stays the same. The day also stays the
16793 same, except that if the new month has fewer days the day
16794 number may be reduced to lie in the valid range. For example,
16795 @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
16796 Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
16797 the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
16804 The @samp{incyear(@var{date}, @var{step})} function increases
16805 a date form by the specified number of years, which may be
16806 any positive or negative integer. Note that @samp{incyear(d, n)}
16807 is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
16808 simple equivalents in terms of day arithmetic because
16809 months and years have varying lengths. If the @var{step}
16810 argument is omitted, 1 year is assumed. There is no keyboard
16811 command for this function; use @kbd{C-u 12 t I} instead.
16813 There is no @code{newday} function at all because @kbd{F} [@code{floor}]
16814 serves this purpose. Similarly, instead of @code{incday} and
16815 @code{incweek} simply use @cite{d + n} or @cite{d + 7 n}.
16817 @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
16818 which can adjust a date/time form by a certain number of seconds.
16820 @node Business Days, Time Zones, Date Functions, Date Arithmetic
16821 @subsection Business Days
16824 Often time is measured in ``business days'' or ``working days,''
16825 where weekends and holidays are skipped. Calc's normal date
16826 arithmetic functions use calendar days, so that subtracting two
16827 consecutive Mondays will yield a difference of 7 days. By contrast,
16828 subtracting two consecutive Mondays would yield 5 business days
16829 (assuming two-day weekends and the absence of holidays).
16835 @pindex calc-business-days-plus
16836 @pindex calc-business-days-minus
16837 The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
16838 and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
16839 commands perform arithmetic using business days. For @kbd{t +},
16840 one argument must be a date form and the other must be a real
16841 number (positive or negative). If the number is not an integer,
16842 then a certain amount of time is added as well as a number of
16843 days; for example, adding 0.5 business days to a time in Friday
16844 evening will produce a time in Monday morning. It is also
16845 possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
16846 half a business day. For @kbd{t -}, the arguments are either a
16847 date form and a number or HMS form, or two date forms, in which
16848 case the result is the number of business days between the two
16851 @cindex @code{Holidays} variable
16853 By default, Calc considers any day that is not a Saturday or
16854 Sunday to be a business day. You can define any number of
16855 additional holidays by editing the variable @code{Holidays}.
16856 (There is an @w{@kbd{s H}} convenience command for editing this
16857 variable.) Initially, @code{Holidays} contains the vector
16858 @samp{[sat, sun]}. Entries in the @code{Holidays} vector may
16859 be any of the following kinds of objects:
16863 Date forms (pure dates, not date/time forms). These specify
16864 particular days which are to be treated as holidays.
16867 Intervals of date forms. These specify a range of days, all of
16868 which are holidays (e.g., Christmas week). @xref{Interval Forms}.
16871 Nested vectors of date forms. Each date form in the vector is
16872 considered to be a holiday.
16875 Any Calc formula which evaluates to one of the above three things.
16876 If the formula involves the variable @cite{y}, it stands for a
16877 yearly repeating holiday; @cite{y} will take on various year
16878 numbers like 1992. For example, @samp{date(y, 12, 25)} specifies
16879 Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
16880 Thanksgiving (which is held on the fourth Thursday of November).
16881 If the formula involves the variable @cite{m}, that variable
16882 takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is
16883 a holiday that takes place on the 15th of every month.
16886 A weekday name, such as @code{sat} or @code{sun}. This is really
16887 a variable whose name is a three-letter, lower-case day name.
16890 An interval of year numbers (integers). This specifies the span of
16891 years over which this holiday list is to be considered valid. Any
16892 business-day arithmetic that goes outside this range will result
16893 in an error message. Use this if you are including an explicit
16894 list of holidays, rather than a formula to generate them, and you
16895 want to make sure you don't accidentally go beyond the last point
16896 where the holidays you entered are complete. If there is no
16897 limiting interval in the @code{Holidays} vector, the default
16898 @samp{[1 .. 2737]} is used. (This is the absolute range of years
16899 for which Calc's business-day algorithms will operate.)
16902 An interval of HMS forms. This specifies the span of hours that
16903 are to be considered one business day. For example, if this
16904 range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
16905 the business day is only eight hours long, so that @kbd{1.5 t +}
16906 on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
16907 four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
16908 Likewise, @kbd{t -} will now express differences in time as
16909 fractions of an eight-hour day. Times before 9am will be treated
16910 as 9am by business date arithmetic, and times at or after 5pm will
16911 be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays},
16912 the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
16913 (Regardless of the type of bounds you specify, the interval is
16914 treated as inclusive on the low end and exclusive on the high end,
16915 so that the work day goes from 9am up to, but not including, 5pm.)
16918 If the @code{Holidays} vector is empty, then @kbd{t +} and
16919 @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
16920 then be no difference between business days and calendar days.
16922 Calc expands the intervals and formulas you give into a complete
16923 list of holidays for internal use. This is done mainly to make
16924 sure it can detect multiple holidays. (For example,
16925 @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
16926 Calc's algorithms take care to count it only once when figuring
16927 the number of holidays between two dates.)
16929 Since the complete list of holidays for all the years from 1 to
16930 2737 would be huge, Calc actually computes only the part of the
16931 list between the smallest and largest years that have been involved
16932 in business-day calculations so far. Normally, you won't have to
16933 worry about this. Keep in mind, however, that if you do one
16934 calculation for 1992, and another for 1792, even if both involve
16935 only a small range of years, Calc will still work out all the
16936 holidays that fall in that 200-year span.
16938 If you add a (positive) number of days to a date form that falls on a
16939 weekend or holiday, the date form is treated as if it were the most
16940 recent business day. (Thus adding one business day to a Friday,
16941 Saturday, or Sunday will all yield the following Monday.) If you
16942 subtract a number of days from a weekend or holiday, the date is
16943 effectively on the following business day. (So subtracting one business
16944 day from Saturday, Sunday, or Monday yields the preceding Friday.) The
16945 difference between two dates one or both of which fall on holidays
16946 equals the number of actual business days between them. These
16947 conventions are consistent in the sense that, if you add @var{n}
16948 business days to any date, the difference between the result and the
16949 original date will come out to @var{n} business days. (It can't be
16950 completely consistent though; a subtraction followed by an addition
16951 might come out a bit differently, since @kbd{t +} is incapable of
16952 producing a date that falls on a weekend or holiday.)
16958 There is a @code{holiday} function, not on any keys, that takes
16959 any date form and returns 1 if that date falls on a weekend or
16960 holiday, as defined in @code{Holidays}, or 0 if the date is a
16963 @node Time Zones, , Business Days, Date Arithmetic
16964 @subsection Time Zones
16968 @cindex Daylight savings time
16969 Time zones and daylight savings time are a complicated business.
16970 The conversions to and from Julian and Unix-style dates automatically
16971 compute the correct time zone and daylight savings adjustment to use,
16972 provided they can figure out this information. This section describes
16973 Calc's time zone adjustment algorithm in detail, in case you want to
16974 do conversions in different time zones or in case Calc's algorithms
16975 can't determine the right correction to use.
16977 Adjustments for time zones and daylight savings time are done by
16978 @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
16979 commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
16980 to exactly 30 days even though there is a daylight-savings
16981 transition in between. This is also true for Julian pure dates:
16982 @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian
16983 and Unix date/times will adjust for daylight savings time:
16984 @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
16985 evaluates to @samp{29.95834} (that's 29 days and 23 hours)
16986 because one hour was lost when daylight savings commenced on
16989 In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
16990 computes the actual number of 24-hour periods between two dates, whereas
16991 @samp{@var{date1} - @var{date2}} computes the number of calendar
16992 days between two dates without taking daylight savings into account.
16994 @pindex calc-time-zone
16999 The @code{calc-time-zone} [@code{tzone}] command converts the time
17000 zone specified by its numeric prefix argument into a number of
17001 seconds difference from Greenwich mean time (GMT). If the argument
17002 is a number, the result is simply that value multiplied by 3600.
17003 Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If
17004 Daylight Savings time is in effect, one hour should be subtracted from
17005 the normal difference.
17007 If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
17008 date arithmetic commands that include a time zone argument) takes the
17009 zone argument from the top of the stack. (In the case of @kbd{t J}
17010 and @kbd{t U}, the normal argument is then taken from the second-to-top
17011 stack position.) This allows you to give a non-integer time zone
17012 adjustment. The time-zone argument can also be an HMS form, or
17013 it can be a variable which is a time zone name in upper- or lower-case.
17014 For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
17015 (for Pacific standard and daylight savings times, respectively).
17017 North American and European time zone names are defined as follows;
17018 note that for each time zone there is one name for standard time,
17019 another for daylight savings time, and a third for ``generalized'' time
17020 in which the daylight savings adjustment is computed from context.
17024 YST PST MST CST EST AST NST GMT WET MET MEZ
17025 9 8 7 6 5 4 3.5 0 -1 -2 -2
17027 YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ
17028 8 7 6 5 4 3 2.5 -1 -2 -3 -3
17030 YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ
17031 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3
17035 @vindex math-tzone-names
17036 To define time zone names that do not appear in the above table,
17037 you must modify the Lisp variable @code{math-tzone-names}. This
17038 is a list of lists describing the different time zone names; its
17039 structure is best explained by an example. The three entries for
17040 Pacific Time look like this:
17044 ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard
17045 ( "PDT" 8 -1 ) ; adjustment, then daylight savings adjustment.
17046 ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone.
17050 @cindex @code{TimeZone} variable
17052 With no arguments, @code{calc-time-zone} or @samp{tzone()} obtains an
17053 argument from the Calc variable @code{TimeZone} if a value has been
17054 stored for that variable. If not, Calc runs the Unix @samp{date}
17055 command and looks for one of the above time zone names in the output;
17056 if this does not succeed, @samp{tzone()} leaves itself unevaluated.
17057 The time zone name in the @samp{date} output may be followed by a signed
17058 adjustment, e.g., @samp{GMT+5} or @samp{GMT+0500} which specifies a
17059 number of hours and minutes to be added to the base time zone.
17060 Calc stores the time zone it finds into @code{TimeZone} to speed
17061 later calls to @samp{tzone()}.
17063 The special time zone name @code{local} is equivalent to no argument,
17064 i.e., it uses the local time zone as obtained from the @code{date}
17067 If the time zone name found is one of the standard or daylight
17068 savings zone names from the above table, and Calc's internal
17069 daylight savings algorithm says that time and zone are consistent
17070 (e.g., @code{PDT} accompanies a date that Calc's algorithm would also
17071 consider to be daylight savings, or @code{PST} accompanies a date
17072 that Calc would consider to be standard time), then Calc substitutes
17073 the corresponding generalized time zone (like @code{PGT}).
17075 If your system does not have a suitable @samp{date} command, you
17076 may wish to put a @samp{(setq var-TimeZone ...)} in your Emacs
17077 initialization file to set the time zone. The easiest way to do
17078 this is to edit the @code{TimeZone} variable using Calc's @kbd{s T}
17079 command, then use the @kbd{s p} (@code{calc-permanent-variable})
17080 command to save the value of @code{TimeZone} permanently.
17082 The @kbd{t J} and @code{t U} commands with no numeric prefix
17083 arguments do the same thing as @samp{tzone()}. If the current
17084 time zone is a generalized time zone, e.g., @code{EGT}, Calc
17085 examines the date being converted to tell whether to use standard
17086 or daylight savings time. But if the current time zone is explicit,
17087 e.g., @code{EST} or @code{EDT}, then that adjustment is used exactly
17088 and Calc's daylight savings algorithm is not consulted.
17090 Some places don't follow the usual rules for daylight savings time.
17091 The state of Arizona, for example, does not observe daylight savings
17092 time. If you run Calc during the winter season in Arizona, the
17093 Unix @code{date} command will report @code{MST} time zone, which
17094 Calc will change to @code{MGT}. If you then convert a time that
17095 lies in the summer months, Calc will apply an incorrect daylight
17096 savings time adjustment. To avoid this, set your @code{TimeZone}
17097 variable explicitly to @code{MST} to force the use of standard,
17098 non-daylight-savings time.
17100 @vindex math-daylight-savings-hook
17101 @findex math-std-daylight-savings
17102 By default Calc always considers daylight savings time to begin at
17103 2 a.m.@: on the first Sunday of April, and to end at 2 a.m.@: on the
17104 last Sunday of October. This is the rule that has been in effect
17105 in North America since 1987. If you are in a country that uses
17106 different rules for computing daylight savings time, you have two
17107 choices: Write your own daylight savings hook, or control time
17108 zones explicitly by setting the @code{TimeZone} variable and/or
17109 always giving a time-zone argument for the conversion functions.
17111 The Lisp variable @code{math-daylight-savings-hook} holds the
17112 name of a function that is used to compute the daylight savings
17113 adjustment for a given date. The default is
17114 @code{math-std-daylight-savings}, which computes an adjustment
17115 (either 0 or @i{-1}) using the North American rules given above.
17117 The daylight savings hook function is called with four arguments:
17118 The date, as a floating-point number in standard Calc format;
17119 a six-element list of the date decomposed into year, month, day,
17120 hour, minute, and second, respectively; a string which contains
17121 the generalized time zone name in upper-case, e.g., @code{"WEGT"};
17122 and a special adjustment to be applied to the hour value when
17123 converting into a generalized time zone (see below).
17125 @findex math-prev-weekday-in-month
17126 The Lisp function @code{math-prev-weekday-in-month} is useful for
17127 daylight savings computations. This is an internal version of
17128 the user-level @code{pwday} function described in the previous
17129 section. It takes four arguments: The floating-point date value,
17130 the corresponding six-element date list, the day-of-month number,
17131 and the weekday number (0-6).
17133 The default daylight savings hook ignores the time zone name, but a
17134 more sophisticated hook could use different algorithms for different
17135 time zones. It would also be possible to use different algorithms
17136 depending on the year number, but the default hook always uses the
17137 algorithm for 1987 and later. Here is a listing of the default
17138 daylight savings hook:
17141 (defun math-std-daylight-savings (date dt zone bump)
17142 (cond ((< (nth 1 dt) 4) 0)
17144 (let ((sunday (math-prev-weekday-in-month date dt 7 0)))
17145 (cond ((< (nth 2 dt) sunday) 0)
17146 ((= (nth 2 dt) sunday)
17147 (if (>= (nth 3 dt) (+ 3 bump)) -1 0))
17149 ((< (nth 1 dt) 10) -1)
17151 (let ((sunday (math-prev-weekday-in-month date dt 31 0)))
17152 (cond ((< (nth 2 dt) sunday) -1)
17153 ((= (nth 2 dt) sunday)
17154 (if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
17161 The @code{bump} parameter is equal to zero when Calc is converting
17162 from a date form in a generalized time zone into a GMT date value.
17163 It is @i{-1} when Calc is converting in the other direction. The
17164 adjustments shown above ensure that the conversion behaves correctly
17165 and reasonably around the 2 a.m.@: transition in each direction.
17167 There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
17168 beginning of daylight savings time; converting a date/time form that
17169 falls in this hour results in a time value for the following hour,
17170 from 3 a.m.@: to 4 a.m. At the end of daylight savings time, the
17171 hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
17172 form that falls in in this hour results in a time value for the first
17173 manifestation of that time (@emph{not} the one that occurs one hour later).
17175 If @code{math-daylight-savings-hook} is @code{nil}, then the
17176 daylight savings adjustment is always taken to be zero.
17178 In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
17179 computes the time zone adjustment for a given zone name at a
17180 given date. The @var{date} is ignored unless @var{zone} is a
17181 generalized time zone. If @var{date} is a date form, the
17182 daylight savings computation is applied to it as it appears.
17183 If @var{date} is a numeric date value, it is adjusted for the
17184 daylight-savings version of @var{zone} before being given to
17185 the daylight savings hook. This odd-sounding rule ensures
17186 that the daylight-savings computation is always done in
17187 local time, not in the GMT time that a numeric @var{date}
17188 is typically represented in.
17194 The @samp{dsadj(@var{date}, @var{zone})} function computes the
17195 daylight savings adjustment that is appropriate for @var{date} in
17196 time zone @var{zone}. If @var{zone} is explicitly in or not in
17197 daylight savings time (e.g., @code{PDT} or @code{PST}) the
17198 @var{date} is ignored. If @var{zone} is a generalized time zone,
17199 the algorithms described above are used. If @var{zone} is omitted,
17200 the computation is done for the current time zone.
17202 @xref{Reporting Bugs}, for the address of Calc's author, if you
17203 should wish to contribute your improved versions of
17204 @code{math-tzone-names} and @code{math-daylight-savings-hook}
17205 to the Calc distribution.
17207 @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
17208 @section Financial Functions
17211 Calc's financial or business functions use the @kbd{b} prefix
17212 key followed by a shifted letter. (The @kbd{b} prefix followed by
17213 a lower-case letter is used for operations on binary numbers.)
17215 Note that the rate and the number of intervals given to these
17216 functions must be on the same time scale, e.g., both months or
17217 both years. Mixing an annual interest rate with a time expressed
17218 in months will give you very wrong answers!
17220 It is wise to compute these functions to a higher precision than
17221 you really need, just to make sure your answer is correct to the
17222 last penny; also, you may wish to check the definitions at the end
17223 of this section to make sure the functions have the meaning you expect.
17229 * Related Financial Functions::
17230 * Depreciation Functions::
17231 * Definitions of Financial Functions::
17234 @node Percentages, Future Value, Financial Functions, Financial Functions
17235 @subsection Percentages
17238 @pindex calc-percent
17241 The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
17242 say 5.4, and converts it to an equivalent actual number. For example,
17243 @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or
17244 @key{ESC} key combined with @kbd{%}.)
17246 Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
17247 You can enter @samp{5.4%} yourself during algebraic entry. The
17248 @samp{%} operator simply means, ``the preceding value divided by
17249 100.'' The @samp{%} operator has very high precedence, so that
17250 @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
17251 (The @samp{%} operator is just a postfix notation for the
17252 @code{percent} function, just like @samp{20!} is the notation for
17253 @samp{fact(20)}, or twenty-factorial.)
17255 The formula @samp{5.4%} would normally evaluate immediately to
17256 0.054, but the @kbd{M-%} command suppresses evaluation as it puts
17257 the formula onto the stack. However, the next Calc command that
17258 uses the formula @samp{5.4%} will evaluate it as its first step.
17259 The net effect is that you get to look at @samp{5.4%} on the stack,
17260 but Calc commands see it as @samp{0.054}, which is what they expect.
17262 In particular, @samp{5.4%} and @samp{0.054} are suitable values
17263 for the @var{rate} arguments of the various financial functions,
17264 but the number @samp{5.4} is probably @emph{not} suitable---it
17265 represents a rate of 540 percent!
17267 The key sequence @kbd{M-% *} effectively means ``percent-of.''
17268 For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
17269 68 (and also 68% of 25, which comes out to the same thing).
17272 @pindex calc-convert-percent
17273 The @kbd{c %} (@code{calc-convert-percent}) command converts the
17274 value on the top of the stack from numeric to percentage form.
17275 For example, if 0.08 is on the stack, @kbd{c %} converts it to
17276 @samp{8%}. The quantity is the same, it's just represented
17277 differently. (Contrast this with @kbd{M-%}, which would convert
17278 this number to @samp{0.08%}.) The @kbd{=} key is a convenient way
17279 to convert a formula like @samp{8%} back to numeric form, 0.08.
17281 To compute what percentage one quantity is of another quantity,
17282 use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
17286 @pindex calc-percent-change
17288 The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
17289 calculates the percentage change from one number to another.
17290 For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
17291 since 50 is 25% larger than 40. A negative result represents a
17292 decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
17293 20% smaller than 50. (The answers are different in magnitude
17294 because, in the first case, we're increasing by 25% of 40, but
17295 in the second case, we're decreasing by 20% of 50.) The effect
17296 of @kbd{40 @key{RET} 50 b %} is to compute @cite{(50-40)/40}, converting
17297 the answer to percentage form as if by @kbd{c %}.
17299 @node Future Value, Present Value, Percentages, Financial Functions
17300 @subsection Future Value
17304 @pindex calc-fin-fv
17306 The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
17307 the future value of an investment. It takes three arguments
17308 from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}.
17309 If you give payments of @var{payment} every year for @var{n}
17310 years, and the money you have paid earns interest at @var{rate} per
17311 year, then this function tells you what your investment would be
17312 worth at the end of the period. (The actual interval doesn't
17313 have to be years, as long as @var{n} and @var{rate} are expressed
17314 in terms of the same intervals.) This function assumes payments
17315 occur at the @emph{end} of each interval.
17319 The @kbd{I b F} [@code{fvb}] command does the same computation,
17320 but assuming your payments are at the beginning of each interval.
17321 Suppose you plan to deposit $1000 per year in a savings account
17322 earning 5.4% interest, starting right now. How much will be
17323 in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}.
17324 Thus you will have earned $870 worth of interest over the years.
17325 Using the stack, this calculation would have been
17326 @kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed
17327 as a number between 0 and 1, @emph{not} as a percentage.
17331 The @kbd{H b F} [@code{fvl}] command computes the future value
17332 of an initial lump sum investment. Suppose you could deposit
17333 those five thousand dollars in the bank right now; how much would
17334 they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}.
17336 The algebraic functions @code{fv} and @code{fvb} accept an optional
17337 fourth argument, which is used as an initial lump sum in the sense
17338 of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n},
17339 @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
17340 + fvl(@var{rate}, @var{n}, @var{initial})}.@refill
17342 To illustrate the relationships between these functions, we could
17343 do the @code{fvb} calculation ``by hand'' using @code{fvl}. The
17344 final balance will be the sum of the contributions of our five
17345 deposits at various times. The first deposit earns interest for
17346 five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second
17347 deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) =
17348 1234.13}. And so on down to the last deposit, which earns one
17349 year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of
17350 these five values is, sure enough, $5870.73, just as was computed
17351 by @code{fvb} directly.
17353 What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments
17354 are now at the ends of the periods. The end of one year is the same
17355 as the beginning of the next, so what this really means is that we've
17356 lost the payment at year zero (which contributed $1300.78), but we're
17357 now counting the payment at year five (which, since it didn't have
17358 a chance to earn interest, counts as $1000). Indeed, @cite{5569.96 =
17359 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
17361 @node Present Value, Related Financial Functions, Future Value, Financial Functions
17362 @subsection Present Value
17366 @pindex calc-fin-pv
17368 The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
17369 the present value of an investment. Like @code{fv}, it takes
17370 three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}.
17371 It computes the present value of a series of regular payments.
17372 Suppose you have the chance to make an investment that will
17373 pay $2000 per year over the next four years; as you receive
17374 these payments you can put them in the bank at 9% interest.
17375 You want to know whether it is better to make the investment, or
17376 to keep the money in the bank where it earns 9% interest right
17377 from the start. The calculation @code{pv(9%, 4, 2000)} gives the
17378 result 6479.44. If your initial investment must be less than this,
17379 say, $6000, then the investment is worthwhile. But if you had to
17380 put up $7000, then it would be better just to leave it in the bank.
17382 Here is the interpretation of the result of @code{pv}: You are
17383 trying to compare the return from the investment you are
17384 considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
17385 the return from leaving the money in the bank, which is
17386 @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
17387 you would have to put up in advance. The @code{pv} function
17388 finds the break-even point, @cite{x = 6479.44}, at which
17389 @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is
17390 the largest amount you should be willing to invest.
17394 The @kbd{I b P} [@code{pvb}] command solves the same problem,
17395 but with payments occurring at the beginning of each interval.
17396 It has the same relationship to @code{fvb} as @code{pv} has
17397 to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59},
17398 a larger number than @code{pv} produced because we get to start
17399 earning interest on the return from our investment sooner.
17403 The @kbd{H b P} [@code{pvl}] command computes the present value of
17404 an investment that will pay off in one lump sum at the end of the
17405 period. For example, if we get our $8000 all at the end of the
17406 four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much
17407 less than @code{pv} reported, because we don't earn any interest
17408 on the return from this investment. Note that @code{pvl} and
17409 @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}.
17411 You can give an optional fourth lump-sum argument to @code{pv}
17412 and @code{pvb}; this is handled in exactly the same way as the
17413 fourth argument for @code{fv} and @code{fvb}.
17416 @pindex calc-fin-npv
17418 The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
17419 the net present value of a series of irregular investments.
17420 The first argument is the interest rate. The second argument is
17421 a vector which represents the expected return from the investment
17422 at the end of each interval. For example, if the rate represents
17423 a yearly interest rate, then the vector elements are the return
17424 from the first year, second year, and so on.
17426 Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
17427 Obviously this function is more interesting when the payments are
17430 The @code{npv} function can actually have two or more arguments.
17431 Multiple arguments are interpreted in the same way as for the
17432 vector statistical functions like @code{vsum}.
17433 @xref{Single-Variable Statistics}. Basically, if there are several
17434 payment arguments, each either a vector or a plain number, all these
17435 values are collected left-to-right into the complete list of payments.
17436 A numeric prefix argument on the @kbd{b N} command says how many
17437 payment values or vectors to take from the stack.@refill
17441 The @kbd{I b N} [@code{npvb}] command computes the net present
17442 value where payments occur at the beginning of each interval
17443 rather than at the end.
17445 @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
17446 @subsection Related Financial Functions
17449 The functions in this section are basically inverses of the
17450 present value functions with respect to the various arguments.
17453 @pindex calc-fin-pmt
17455 The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
17456 the amount of periodic payment necessary to amortize a loan.
17457 Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
17458 value of @var{payment} such that @code{pv(@var{rate}, @var{n},
17459 @var{payment}) = @var{amount}}.@refill
17463 The @kbd{I b M} [@code{pmtb}] command does the same computation
17464 but using @code{pvb} instead of @code{pv}. Like @code{pv} and
17465 @code{pvb}, these functions can also take a fourth argument which
17466 represents an initial lump-sum investment.
17469 The @kbd{H b M} key just invokes the @code{fvl} function, which is
17470 the inverse of @code{pvl}. There is no explicit @code{pmtl} function.
17473 @pindex calc-fin-nper
17475 The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
17476 the number of regular payments necessary to amortize a loan.
17477 Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
17478 the value of @var{n} such that @code{pv(@var{rate}, @var{n},
17479 @var{payment}) = @var{amount}}. If @var{payment} is too small
17480 ever to amortize a loan for @var{amount} at interest rate @var{rate},
17481 the @code{nper} function is left in symbolic form.@refill
17485 The @kbd{I b #} [@code{nperb}] command does the same computation
17486 but using @code{pvb} instead of @code{pv}. You can give a fourth
17487 lump-sum argument to these functions, but the computation will be
17488 rather slow in the four-argument case.@refill
17492 The @kbd{H b #} [@code{nperl}] command does the same computation
17493 using @code{pvl}. By exchanging @var{payment} and @var{amount} you
17494 can also get the solution for @code{fvl}. For example,
17495 @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
17496 bank account earning 8%, it will take nine years to grow to $2000.@refill
17499 @pindex calc-fin-rate
17501 The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
17502 the rate of return on an investment. This is also an inverse of @code{pv}:
17503 @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
17504 @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
17505 @var{amount}}. The result is expressed as a formula like @samp{6.3%}.@refill
17511 The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
17512 commands solve the analogous equations with @code{pvb} or @code{pvl}
17513 in place of @code{pv}. Also, @code{rate} and @code{rateb} can
17514 accept an optional fourth argument just like @code{pv} and @code{pvb}.
17515 To redo the above example from a different perspective,
17516 @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
17517 interest rate of 8% in order to double your account in nine years.@refill
17520 @pindex calc-fin-irr
17522 The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
17523 analogous function to @code{rate} but for net present value.
17524 Its argument is a vector of payments. Thus @code{irr(@var{payments})}
17525 computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
17526 this rate is known as the @dfn{internal rate of return}.
17530 The @kbd{I b I} [@code{irrb}] command computes the internal rate of
17531 return assuming payments occur at the beginning of each period.
17533 @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
17534 @subsection Depreciation Functions
17537 The functions in this section calculate @dfn{depreciation}, which is
17538 the amount of value that a possession loses over time. These functions
17539 are characterized by three parameters: @var{cost}, the original cost
17540 of the asset; @var{salvage}, the value the asset will have at the end
17541 of its expected ``useful life''; and @var{life}, the number of years
17542 (or other periods) of the expected useful life.
17544 There are several methods for calculating depreciation that differ in
17545 the way they spread the depreciation over the lifetime of the asset.
17548 @pindex calc-fin-sln
17550 The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
17551 ``straight-line'' depreciation. In this method, the asset depreciates
17552 by the same amount every year (or period). For example,
17553 @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000
17554 initially and will be worth $2000 after five years; it loses $2000
17558 @pindex calc-fin-syd
17560 The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
17561 accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation
17562 is higher during the early years of the asset's life. Since the
17563 depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
17564 parameter which specifies which year is requested, from 1 to @var{life}.
17565 If @var{period} is outside this range, the @code{syd} function will
17569 @pindex calc-fin-ddb
17571 The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
17572 accelerated depreciation using the double-declining balance method.
17573 It also takes a fourth @var{period} parameter.
17575 For symmetry, the @code{sln} function will accept a @var{period}
17576 parameter as well, although it will ignore its value except that the
17577 return value will as usual be zero if @var{period} is out of range.
17579 For example, pushing the vector @cite{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
17580 and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
17581 ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
17582 the three depreciation methods:
17586 [ [ 2000, 3333, 4800 ]
17587 [ 2000, 2667, 2880 ]
17588 [ 2000, 2000, 1728 ]
17589 [ 2000, 1333, 592 ]
17595 (Values have been rounded to nearest integers in this figure.)
17596 We see that @code{sln} depreciates by the same amount each year,
17597 @kbd{syd} depreciates more at the beginning and less at the end,
17598 and @kbd{ddb} weights the depreciation even more toward the beginning.
17600 Summing columns with @kbd{V R : +} yields @cite{[10000, 10000, 10000]};
17601 the total depreciation in any method is (by definition) the
17602 difference between the cost and the salvage value.
17604 @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
17605 @subsection Definitions
17608 For your reference, here are the actual formulas used to compute
17609 Calc's financial functions.
17611 Calc will not evaluate a financial function unless the @var{rate} or
17612 @var{n} argument is known. However, @var{payment} or @var{amount} can
17613 be a variable. Calc expands these functions according to the
17614 formulas below for symbolic arguments only when you use the @kbd{a "}
17615 (@code{calc-expand-formula}) command, or when taking derivatives or
17616 integrals or solving equations involving the functions.
17619 These formulas are shown using the conventions of ``Big'' display
17620 mode (@kbd{d B}); for example, the formula for @code{fv} written
17621 linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
17626 fv(rate, n, pmt) = pmt * ---------------
17630 ((1 + rate) - 1) (1 + rate)
17631 fvb(rate, n, pmt) = pmt * ----------------------------
17635 fvl(rate, n, pmt) = pmt * (1 + rate)
17639 pv(rate, n, pmt) = pmt * ----------------
17643 (1 - (1 + rate) ) (1 + rate)
17644 pvb(rate, n, pmt) = pmt * -----------------------------
17648 pvl(rate, n, pmt) = pmt * (1 + rate)
17651 npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate)
17654 npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate)
17657 (amt - x * (1 + rate) ) * rate
17658 pmt(rate, n, amt, x) = -------------------------------
17663 (amt - x * (1 + rate) ) * rate
17664 pmtb(rate, n, amt, x) = -------------------------------
17666 (1 - (1 + rate) ) (1 + rate)
17669 nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate)
17673 nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
17677 nperl(rate, pmt, amt) = - log(---, 1 + rate)
17682 ratel(n, pmt, amt) = ------ - 1
17687 sln(cost, salv, life) = -----------
17690 (cost - salv) * (life - per + 1)
17691 syd(cost, salv, life, per) = --------------------------------
17692 life * (life + 1) / 2
17695 ddb(cost, salv, life, per) = --------, book = cost - depreciation so far
17701 $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
17702 $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
17703 $$ \code{fvl}(r, n, p) = p (1 + r)^n $$
17704 $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
17705 $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
17706 $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
17707 $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
17708 $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
17709 $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
17710 $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
17711 (1 - (1 + r)^{-n}) (1 + r) } $$
17712 $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
17713 $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
17714 $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
17715 $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
17716 $$ \code{sln}(c, s, l) = { c - s \over l } $$
17717 $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
17718 $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
17722 In @code{pmt} and @code{pmtb}, @cite{x=0} if omitted.
17724 These functions accept any numeric objects, including error forms,
17725 intervals, and even (though not very usefully) complex numbers. The
17726 above formulas specify exactly the behavior of these functions with
17727 all sorts of inputs.
17729 Note that if the first argument to the @code{log} in @code{nper} is
17730 negative, @code{nper} leaves itself in symbolic form rather than
17731 returning a (financially meaningless) complex number.
17733 @samp{rate(num, pmt, amt)} solves the equation
17734 @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
17735 (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
17736 for an initial guess. The @code{rateb} function is the same except
17737 that it uses @code{pvb}. Note that @code{ratel} can be solved
17738 directly; its formula is shown in the above list.
17740 Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
17743 If you give a fourth argument to @code{nper} or @code{nperb}, Calc
17744 will also use @kbd{H a R} to solve the equation using an initial
17745 guess interval of @samp{[0 .. 100]}.
17747 A fourth argument to @code{fv} simply sums the two components
17748 calculated from the above formulas for @code{fv} and @code{fvl}.
17749 The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
17751 The @kbd{ddb} function is computed iteratively; the ``book'' value
17752 starts out equal to @var{cost}, and decreases according to the above
17753 formula for the specified number of periods. If the book value
17754 would decrease below @var{salvage}, it only decreases to @var{salvage}
17755 and the depreciation is zero for all subsequent periods. The @code{ddb}
17756 function returns the amount the book value decreased in the specified
17759 The Calc financial function names were borrowed mostly from Microsoft
17760 Excel and Borland's Quattro. The @code{ratel} function corresponds to
17761 @samp{@@CGR} in Borland's Reflex. The @code{nper} and @code{nperl}
17762 functions correspond to @samp{@@TERM} and @samp{@@CTERM} in Quattro,
17763 respectively. Beware that the Calc functions may take their arguments
17764 in a different order than the corresponding functions in your favorite
17767 @node Binary Functions, , Financial Functions, Arithmetic
17768 @section Binary Number Functions
17771 The commands in this chapter all use two-letter sequences beginning with
17772 the @kbd{b} prefix.
17774 @cindex Binary numbers
17775 The ``binary'' operations actually work regardless of the currently
17776 displayed radix, although their results make the most sense in a radix
17777 like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
17778 commands, respectively). You may also wish to enable display of leading
17779 zeros with @kbd{d z}. @xref{Radix Modes}.
17781 @cindex Word size for binary operations
17782 The Calculator maintains a current @dfn{word size} @cite{w}, an
17783 arbitrary positive or negative integer. For a positive word size, all
17784 of the binary operations described here operate modulo @cite{2^w}. In
17785 particular, negative arguments are converted to positive integers modulo
17786 @cite{2^w} by all binary functions.@refill
17788 If the word size is negative, binary operations produce 2's complement
17789 integers from @c{$-2^{-w-1}$}
17790 @cite{-(2^(-w-1))} to @c{$2^{-w-1}-1$}
17791 @cite{2^(-w-1)-1} inclusive. Either
17792 mode accepts inputs in any range; the sign of @cite{w} affects only
17793 the results produced.
17798 The @kbd{b c} (@code{calc-clip})
17799 [@code{clip}] command can be used to clip a number by reducing it modulo
17800 @cite{2^w}. The commands described in this chapter automatically clip
17801 their results to the current word size. Note that other operations like
17802 addition do not use the current word size, since integer addition
17803 generally is not ``binary.'' (However, @pxref{Simplification Modes},
17804 @code{calc-bin-simplify-mode}.) For example, with a word size of 8
17805 bits @kbd{b c} converts a number to the range 0 to 255; with a word
17806 size of @i{-8} @kbd{b c} converts to the range @i{-128} to 127.@refill
17809 @pindex calc-word-size
17810 The default word size is 32 bits. All operations except the shifts and
17811 rotates allow you to specify a different word size for that one
17812 operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the
17813 top of stack to the range 0 to 255 regardless of the current word size.
17814 To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
17815 This command displays a prompt with the current word size; press @key{RET}
17816 immediately to keep this word size, or type a new word size at the prompt.
17818 When the binary operations are written in symbolic form, they take an
17819 optional second (or third) word-size parameter. When a formula like
17820 @samp{and(a,b)} is finally evaluated, the word size current at that time
17821 will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
17822 @i{-8} will always be used. A symbolic binary function will be left
17823 in symbolic form unless the all of its argument(s) are integers or
17824 integer-valued floats.
17826 If either or both arguments are modulo forms for which @cite{M} is a
17827 power of two, that power of two is taken as the word size unless a
17828 numeric prefix argument overrides it. The current word size is never
17829 consulted when modulo-power-of-two forms are involved.
17834 The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
17835 AND of the two numbers on the top of the stack. In other words, for each
17836 of the @cite{w} binary digits of the two numbers (pairwise), the corresponding
17837 bit of the result is 1 if and only if both input bits are 1:
17838 @samp{and(2#1100, 2#1010) = 2#1000}.
17843 The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
17844 inclusive OR of two numbers. A bit is 1 if either of the input bits, or
17845 both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}.
17850 The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
17851 exclusive OR of two numbers. A bit is 1 if exactly one of the input bits
17852 is 1: @samp{xor(2#1100, 2#1010) = 2#0110}.
17857 The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
17858 difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
17859 so that @samp{diff(2#1100, 2#1010) = 2#0100}.
17864 The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
17865 NOT of a number. A bit is 1 if the input bit is 0 and vice-versa.
17868 @pindex calc-lshift-binary
17870 The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
17871 number left by one bit, or by the number of bits specified in the numeric
17872 prefix argument. A negative prefix argument performs a logical right shift,
17873 in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)}
17874 is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
17875 Bits shifted ``off the end,'' according to the current word size, are lost.
17891 The @kbd{H b l} command also does a left shift, but it takes two arguments
17892 from the stack (the value to shift, and, at top-of-stack, the number of
17893 bits to shift). This version interprets the prefix argument just like
17894 the regular binary operations, i.e., as a word size. The Hyperbolic flag
17895 has a similar effect on the rest of the binary shift and rotate commands.
17898 @pindex calc-rshift-binary
17900 The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
17901 number right by one bit, or by the number of bits specified in the numeric
17902 prefix argument: @samp{rsh(a,n) = lsh(a,-n)}.
17905 @pindex calc-lshift-arith
17907 The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
17908 number left. It is analogous to @code{lsh}, except that if the shift
17909 is rightward (the prefix argument is negative), an arithmetic shift
17910 is performed as described below.
17913 @pindex calc-rshift-arith
17915 The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
17916 an ``arithmetic'' shift to the right, in which the leftmost bit (according
17917 to the current word size) is duplicated rather than shifting in zeros.
17918 This corresponds to dividing by a power of two where the input is interpreted
17919 as a signed, twos-complement number. (The distinction between the @samp{rsh}
17920 and @samp{rash} operations is totally independent from whether the word
17921 size is positive or negative.) With a negative prefix argument, this
17922 performs a standard left shift.
17925 @pindex calc-rotate-binary
17927 The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
17928 number one bit to the left. The leftmost bit (according to the current
17929 word size) is dropped off the left and shifted in on the right. With a
17930 numeric prefix argument, the number is rotated that many bits to the left
17933 @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
17934 pack and unpack binary integers into sets. (For example, @kbd{b u}
17935 unpacks the number @samp{2#11001} to the set of bit-numbers
17936 @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1''
17937 bits in a binary integer.
17939 Another interesting use of the set representation of binary integers
17940 is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to
17941 unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
17942 with 31 minus that bit-number; type @kbd{b p} to pack the set back
17943 into a binary integer.
17945 @node Scientific Functions, Matrix Functions, Arithmetic, Top
17946 @chapter Scientific Functions
17949 The functions described here perform trigonometric and other transcendental
17950 calculations. They generally produce floating-point answers correct to the
17951 full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
17952 flag keys must be used to get some of these functions from the keyboard.
17956 @cindex @code{pi} variable
17959 @cindex @code{e} variable
17962 @cindex @code{gamma} variable
17964 @cindex Gamma constant, Euler's
17965 @cindex Euler's gamma constant
17967 @cindex @code{phi} variable
17968 @cindex Phi, golden ratio
17969 @cindex Golden ratio
17970 One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
17971 the value of @c{$\pi$}
17972 @cite{pi} (at the current precision) onto the stack. With the
17973 Hyperbolic flag, it pushes the value @cite{e}, the base of natural logarithms.
17974 With the Inverse flag, it pushes Euler's constant @c{$\gamma$}
17975 @cite{gamma} (about 0.5772). With both Inverse and Hyperbolic, it
17976 pushes the ``golden ratio'' @c{$\phi$}
17977 @cite{phi} (about 1.618). (At present, Euler's constant is not available
17978 to unlimited precision; Calc knows only the first 100 digits.)
17979 In Symbolic mode, these commands push the
17980 actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
17981 respectively, instead of their values; @pxref{Symbolic Mode}.@refill
17991 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
17992 @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command
17993 computes the square of the argument.
17995 @xref{Prefix Arguments}, for a discussion of the effect of numeric
17996 prefix arguments on commands in this chapter which do not otherwise
17997 interpret a prefix argument.
18000 * Logarithmic Functions::
18001 * Trigonometric and Hyperbolic Functions::
18002 * Advanced Math Functions::
18005 * Combinatorial Functions::
18006 * Probability Distribution Functions::
18009 @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
18010 @section Logarithmic Functions
18020 The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
18021 logarithm of the real or complex number on the top of the stack. With
18022 the Inverse flag it computes the exponential function instead, although
18023 this is redundant with the @kbd{E} command.
18032 The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
18033 exponential, i.e., @cite{e} raised to the power of the number on the stack.
18034 The meanings of the Inverse and Hyperbolic flags follow from those for
18035 the @code{calc-ln} command.
18050 The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
18051 (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}],
18052 it raises ten to a given power.) Note that the common logarithm of a
18053 complex number is computed by taking the natural logarithm and dividing
18062 The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
18063 to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since
18064 @c{$2^{10} = 1024$}
18065 @cite{2^10 = 1024}. In certain cases like @samp{log(3,9)}, the result
18066 will be either @cite{1:2} or @cite{0.5} depending on the current Fraction
18067 Mode setting. With the Inverse flag [@code{alog}], this command is
18068 similar to @kbd{^} except that the order of the arguments is reversed.
18073 The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
18074 integer logarithm of a number to any base. The number and the base must
18075 themselves be positive integers. This is the true logarithm, rounded
18076 down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @cite{x} in the
18077 range from 1000 to 9999. If both arguments are positive integers, exact
18078 integer arithmetic is used; otherwise, this is equivalent to
18079 @samp{floor(log(x,b))}.
18084 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
18086 @cite{exp(x)-1}, but using an algorithm that produces a more accurate
18087 answer when the result is close to zero, i.e., when @c{$e^x$}
18088 @cite{exp(x)} is close
18094 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
18096 @cite{ln(x+1)}, producing a more accurate answer when @cite{x} is close
18099 @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
18100 @section Trigonometric/Hyperbolic Functions
18106 The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
18107 of an angle or complex number. If the input is an HMS form, it is interpreted
18108 as degrees-minutes-seconds; otherwise, the input is interpreted according
18109 to the current angular mode. It is best to use Radians mode when operating
18110 on complex numbers.@refill
18112 Calc's ``units'' mechanism includes angular units like @code{deg},
18113 @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated
18114 all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
18115 simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
18116 of the current angular mode. @xref{Basic Operations on Units}.
18118 Also, the symbolic variable @code{pi} is not ordinarily recognized in
18119 arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
18120 the @kbd{a s} (@code{calc-simplify}) command recognizes many such
18121 formulas when the current angular mode is radians @emph{and} symbolic
18122 mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
18123 @xref{Symbolic Mode}. Beware, this simplification occurs even if you
18124 have stored a different value in the variable @samp{pi}; this is one
18125 reason why changing built-in variables is a bad idea. Arguments of
18126 the form @cite{x} plus a multiple of @c{$\pi/2$}
18127 @cite{pi/2} are also simplified.
18128 Calc includes similar formulas for @code{cos} and @code{tan}.@refill
18130 The @kbd{a s} command knows all angles which are integer multiples of
18132 @cite{pi/12}, @c{$\pi/10$}
18133 @cite{pi/10}, or @c{$\pi/8$}
18134 @cite{pi/8} radians. In degrees mode,
18135 analogous simplifications occur for integer multiples of 15 or 18
18136 degrees, and for arguments plus multiples of 90 degrees.
18139 @pindex calc-arcsin
18141 With the Inverse flag, @code{calc-sin} computes an arcsine. This is also
18142 available as the @code{calc-arcsin} command or @code{arcsin} algebraic
18143 function. The returned argument is converted to degrees, radians, or HMS
18144 notation depending on the current angular mode.
18150 @pindex calc-arcsinh
18152 With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
18153 sine, also available as @code{calc-sinh} [@code{sinh}]. With the
18154 Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
18155 (@code{calc-arcsinh}) [@code{arcsinh}].
18164 @pindex calc-arccos
18182 @pindex calc-arccosh
18200 @pindex calc-arctan
18218 @pindex calc-arctanh
18223 The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
18224 of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
18225 computes the tangent, along with all the various inverse and hyperbolic
18226 variants of these functions.
18229 @pindex calc-arctan2
18231 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
18232 numbers from the stack and computes the arc tangent of their ratio. The
18233 result is in the full range from @i{-180} (exclusive) to @i{+180}
18234 (inclusive) degrees, or the analogous range in radians. A similar
18235 result would be obtained with @kbd{/} followed by @kbd{I T}, but the
18236 value would only be in the range from @i{-90} to @i{+90} degrees
18237 since the division loses information about the signs of the two
18238 components, and an error might result from an explicit division by zero
18239 which @code{arctan2} would avoid. By (arbitrary) definition,
18240 @samp{arctan2(0,0)=0}.
18242 @pindex calc-sincos
18254 The @code{calc-sincos} [@code{sincos}] command computes the sine and
18255 cosine of a number, returning them as a vector of the form
18256 @samp{[@var{cos}, @var{sin}]}.
18257 With the Inverse flag [@code{arcsincos}], this command takes a two-element
18258 vector as an argument and computes @code{arctan2} of the elements.
18259 (This command does not accept the Hyperbolic flag.)@refill
18261 @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
18262 @section Advanced Mathematical Functions
18265 Calc can compute a variety of less common functions that arise in
18266 various branches of mathematics. All of the functions described in
18267 this section allow arbitrary complex arguments and, except as noted,
18268 will work to arbitrarily large precisions. They can not at present
18269 handle error forms or intervals as arguments.
18271 NOTE: These functions are still experimental. In particular, their
18272 accuracy is not guaranteed in all domains. It is advisable to set the
18273 current precision comfortably higher than you actually need when
18274 using these functions. Also, these functions may be impractically
18275 slow for some values of the arguments.
18280 The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
18281 gamma function. For positive integer arguments, this is related to the
18282 factorial function: @samp{gamma(n+1) = fact(n)}. For general complex
18283 arguments the gamma function can be defined by the following definite
18284 integral: @c{$\Gamma(a) = \int_0^\infty t^{a-1} e^t dt$}
18285 @cite{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
18286 (The actual implementation uses far more efficient computational methods.)
18302 @pindex calc-inc-gamma
18315 The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
18316 the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by
18317 the integral, @c{$P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)$}
18318 @cite{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
18319 This implies that @samp{gammaP(a,inf) = 1} for any @cite{a} (see the
18320 definition of the normal gamma function).
18322 Several other varieties of incomplete gamma function are defined.
18323 The complement of @cite{P(a,x)}, called @cite{Q(a,x) = 1-P(a,x)} by
18324 some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
18325 You can think of this as taking the other half of the integral, from
18326 @cite{x} to infinity.
18329 The functions corresponding to the integrals that define @cite{P(a,x)}
18330 and @cite{Q(a,x)} but without the normalizing @cite{1/gamma(a)}
18331 factor are called @cite{g(a,x)} and @cite{G(a,x)}, respectively
18332 (where @cite{g} and @cite{G} represent the lower- and upper-case Greek
18333 letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}]
18334 and @kbd{H I f G} [@code{gammaG}] commands.
18338 The functions corresponding to the integrals that define $P(a,x)$
18339 and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
18340 factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
18341 You can obtain these using the \kbd{H f G} [\code{gammag}] and
18342 \kbd{I H f G} [\code{gammaG}] commands.
18348 The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
18349 Euler beta function, which is defined in terms of the gamma function as
18350 @c{$B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)$}
18351 @cite{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)}, or by
18352 @c{$B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt$}
18353 @cite{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
18357 @pindex calc-inc-beta
18360 The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
18361 the incomplete beta function @cite{I(x,a,b)}. It is defined by
18362 @c{$I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)$}
18363 @cite{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
18364 Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
18365 un-normalized version [@code{betaB}].
18372 The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
18373 error function @c{$\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt$}
18374 @cite{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
18375 The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
18376 is the corresponding integral from @samp{x} to infinity; the sum
18377 @c{$\hbox{erf}(x) + \hbox{erfc}(x) = 1$}
18378 @cite{erf(x) + erfc(x) = 1}.
18382 @pindex calc-bessel-J
18383 @pindex calc-bessel-Y
18386 The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
18387 (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
18388 functions of the first and second kinds, respectively.
18389 In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
18390 @cite{n} is often an integer, but is not required to be one.
18391 Calc's implementation of the Bessel functions currently limits the
18392 precision to 8 digits, and may not be exact even to that precision.
18393 Use with care!@refill
18395 @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
18396 @section Branch Cuts and Principal Values
18399 @cindex Branch cuts
18400 @cindex Principal values
18401 All of the logarithmic, trigonometric, and other scientific functions are
18402 defined for complex numbers as well as for reals.
18403 This section describes the values
18404 returned in cases where the general result is a family of possible values.
18405 Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
18406 second edition, in these matters. This section will describe each
18407 function briefly; for a more detailed discussion (including some nifty
18408 diagrams), consult Steele's book.
18410 Note that the branch cuts for @code{arctan} and @code{arctanh} were
18411 changed between the first and second editions of Steele. Versions of
18412 Calc starting with 2.00 follow the second edition.
18414 The new branch cuts exactly match those of the HP-28/48 calculators.
18415 They also match those of Mathematica 1.2, except that Mathematica's
18416 @code{arctan} cut is always in the right half of the complex plane,
18417 and its @code{arctanh} cut is always in the top half of the plane.
18418 Calc's cuts are continuous with quadrants I and III for @code{arctan},
18419 or II and IV for @code{arctanh}.
18421 Note: The current implementations of these functions with complex arguments
18422 are designed with proper behavior around the branch cuts in mind, @emph{not}
18423 efficiency or accuracy. You may need to increase the floating precision
18424 and wait a while to get suitable answers from them.
18426 For @samp{sqrt(a+bi)}: When @cite{a<0} and @cite{b} is small but positive
18427 or zero, the result is close to the @cite{+i} axis. For @cite{b} small and
18428 negative, the result is close to the @cite{-i} axis. The result always lies
18429 in the right half of the complex plane.
18431 For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}.
18432 The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
18433 Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
18434 negative real axis.
18436 The following table describes these branch cuts in another way.
18437 If the real and imaginary parts of @cite{z} are as shown, then
18438 the real and imaginary parts of @cite{f(z)} will be as shown.
18439 Here @code{eps} stands for a small positive value; each
18440 occurrence of @code{eps} may stand for a different small value.
18444 ----------------------------------------
18447 -, +eps +eps, + +eps, +
18448 -, -eps +eps, - +eps, -
18451 For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}.
18452 One interesting consequence of this is that @samp{(-8)^1:3} does
18453 not evaluate to @i{-2} as you might expect, but to the complex
18454 number @cite{(1., 1.732)}. Both of these are valid cube roots
18455 of @i{-8} (as is @cite{(1., -1.732)}); Calc chooses a perhaps
18456 less-obvious root for the sake of mathematical consistency.
18458 For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
18459 The branch cuts are on the real axis, less than @i{-1} and greater than 1.
18461 For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
18462 or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on
18463 the real axis, less than @i{-1} and greater than 1.
18465 For @samp{arctan(z)}: This is defined by
18466 @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the
18467 imaginary axis, below @cite{-i} and above @cite{i}.
18469 For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}.
18470 The branch cuts are on the imaginary axis, below @cite{-i} and
18473 For @samp{arccosh(z)}: This is defined by
18474 @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the
18475 real axis less than 1.
18477 For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
18478 The branch cuts are on the real axis, less than @i{-1} and greater than 1.
18480 The following tables for @code{arcsin}, @code{arccos}, and
18481 @code{arctan} assume the current angular mode is radians. The
18482 hyperbolic functions operate independently of the angular mode.
18485 z arcsin(z) arccos(z)
18486 -------------------------------------------------------
18487 (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0
18488 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps
18489 (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps
18490 <-1, 0 -pi/2, + pi, -
18491 <-1, +eps -pi/2 + eps, + pi - eps, -
18492 <-1, -eps -pi/2 + eps, - pi - eps, +
18494 >1, +eps pi/2 - eps, + +eps, -
18495 >1, -eps pi/2 - eps, - +eps, +
18499 z arccosh(z) arctanh(z)
18500 -----------------------------------------------------
18501 (-1..1), 0 0, (0..pi) any, 0
18502 (-1..1), +eps +eps, (0..pi) any, +eps
18503 (-1..1), -eps +eps, (-pi..0) any, -eps
18504 <-1, 0 +, pi -, pi/2
18505 <-1, +eps +, pi - eps -, pi/2 - eps
18506 <-1, -eps +, -pi + eps -, -pi/2 + eps
18507 >1, 0 +, 0 +, -pi/2
18508 >1, +eps +, +eps +, pi/2 - eps
18509 >1, -eps +, -eps +, -pi/2 + eps
18513 z arcsinh(z) arctan(z)
18514 -----------------------------------------------------
18515 0, (-1..1) 0, (-pi/2..pi/2) 0, any
18516 0, <-1 -, -pi/2 -pi/2, -
18517 +eps, <-1 +, -pi/2 + eps pi/2 - eps, -
18518 -eps, <-1 -, -pi/2 + eps -pi/2 + eps, -
18519 0, >1 +, pi/2 pi/2, +
18520 +eps, >1 +, pi/2 - eps pi/2 - eps, +
18521 -eps, >1 -, pi/2 - eps -pi/2 + eps, +
18524 Finally, the following identities help to illustrate the relationship
18525 between the complex trigonometric and hyperbolic functions. They
18526 are valid everywhere, including on the branch cuts.
18529 sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z)
18530 cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z)
18531 tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z)
18532 sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)
18535 The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
18536 for general complex arguments, but their branch cuts and principal values
18537 are not rigorously specified at present.
18539 @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
18540 @section Random Numbers
18544 @pindex calc-random
18546 The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
18547 random numbers of various sorts.
18549 Given a positive numeric prefix argument @cite{M}, it produces a random
18550 integer @cite{N} in the range @c{$0 \le N < M$}
18551 @cite{0 <= N < M}. Each of the @cite{M}
18552 values appears with equal probability.@refill
18554 With no numeric prefix argument, the @kbd{k r} command takes its argument
18555 from the stack instead. Once again, if this is a positive integer @cite{M}
18556 the result is a random integer less than @cite{M}. However, note that
18557 while numeric prefix arguments are limited to six digits or so, an @cite{M}
18558 taken from the stack can be arbitrarily large. If @cite{M} is negative,
18559 the result is a random integer in the range @c{$M < N \le 0$}
18562 If the value on the stack is a floating-point number @cite{M}, the result
18563 is a random floating-point number @cite{N} in the range @c{$0 \le N < M$}
18565 or @c{$M < N \le 0$}
18566 @cite{M < N <= 0}, according to the sign of @cite{M}.
18568 If @cite{M} is zero, the result is a Gaussian-distributed random real
18569 number; the distribution has a mean of zero and a standard deviation
18570 of one. The algorithm used generates random numbers in pairs; thus,
18571 every other call to this function will be especially fast.
18573 If @cite{M} is an error form @c{$m$ @code{+/-} $\sigma$}
18574 @samp{m +/- s} where @var{m}
18576 @var{s} are both real numbers, the result uses a Gaussian
18577 distribution with mean @var{m} and standard deviation @c{$\sigma$}
18580 If @cite{M} is an interval form, the lower and upper bounds specify the
18581 acceptable limits of the random numbers. If both bounds are integers,
18582 the result is a random integer in the specified range. If either bound
18583 is floating-point, the result is a random real number in the specified
18584 range. If the interval is open at either end, the result will be sure
18585 not to equal that end value. (This makes a big difference for integer
18586 intervals, but for floating-point intervals it's relatively minor:
18587 with a precision of 6, @samp{random([1.0..2.0))} will return any of one
18588 million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
18589 additionally return 2.00000, but the probability of this happening is
18592 If @cite{M} is a vector, the result is one element taken at random from
18593 the vector. All elements of the vector are given equal probabilities.
18596 The sequence of numbers produced by @kbd{k r} is completely random by
18597 default, i.e., the sequence is seeded each time you start Calc using
18598 the current time and other information. You can get a reproducible
18599 sequence by storing a particular ``seed value'' in the Calc variable
18600 @code{RandSeed}. Any integer will do for a seed; integers of from 1
18601 to 12 digits are good. If you later store a different integer into
18602 @code{RandSeed}, Calc will switch to a different pseudo-random
18603 sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
18604 from the current time. If you store the same integer that you used
18605 before back into @code{RandSeed}, you will get the exact same sequence
18606 of random numbers as before.
18608 @pindex calc-rrandom
18609 The @code{calc-rrandom} command (not on any key) produces a random real
18610 number between zero and one. It is equivalent to @samp{random(1.0)}.
18613 @pindex calc-random-again
18614 The @kbd{k a} (@code{calc-random-again}) command produces another random
18615 number, re-using the most recent value of @cite{M}. With a numeric
18616 prefix argument @var{n}, it produces @var{n} more random numbers using
18617 that value of @cite{M}.
18620 @pindex calc-shuffle
18622 The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
18623 random values with no duplicates. The value on the top of the stack
18624 specifies the set from which the random values are drawn, and may be any
18625 of the @cite{M} formats described above. The numeric prefix argument
18626 gives the length of the desired list. (If you do not provide a numeric
18627 prefix argument, the length of the list is taken from the top of the
18628 stack, and @cite{M} from second-to-top.)
18630 If @cite{M} is a floating-point number, zero, or an error form (so
18631 that the random values are being drawn from the set of real numbers)
18632 there is little practical difference between using @kbd{k h} and using
18633 @kbd{k r} several times. But if the set of possible values consists
18634 of just a few integers, or the elements of a vector, then there is
18635 a very real chance that multiple @kbd{k r}'s will produce the same
18636 number more than once. The @kbd{k h} command produces a vector whose
18637 elements are always distinct. (Actually, there is a slight exception:
18638 If @cite{M} is a vector, no given vector element will be drawn more
18639 than once, but if several elements of @cite{M} are equal, they may
18640 each make it into the result vector.)
18642 One use of @kbd{k h} is to rearrange a list at random. This happens
18643 if the prefix argument is equal to the number of values in the list:
18644 @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
18645 @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument
18646 @var{n} is negative it is replaced by the size of the set represented
18647 by @cite{M}. Naturally, this is allowed only when @cite{M} specifies
18648 a small discrete set of possibilities.
18650 To do the equivalent of @kbd{k h} but with duplications allowed,
18651 given @cite{M} on the stack and with @var{n} just entered as a numeric
18652 prefix, use @kbd{v b} to build a vector of copies of @cite{M}, then use
18653 @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
18654 elements of this vector. @xref{Matrix Functions}.
18657 * Random Number Generator:: (Complete description of Calc's algorithm)
18660 @node Random Number Generator, , Random Numbers, Random Numbers
18661 @subsection Random Number Generator
18663 Calc's random number generator uses several methods to ensure that
18664 the numbers it produces are highly random. Knuth's @emph{Art of
18665 Computer Programming}, Volume II, contains a thorough description
18666 of the theory of random number generators and their measurement and
18669 If @code{RandSeed} has no stored value, Calc calls Emacs' built-in
18670 @code{random} function to get a stream of random numbers, which it
18671 then treats in various ways to avoid problems inherent in the simple
18672 random number generators that many systems use to implement @code{random}.
18674 When Calc's random number generator is first invoked, it ``seeds''
18675 the low-level random sequence using the time of day, so that the
18676 random number sequence will be different every time you use Calc.
18678 Since Emacs Lisp doesn't specify the range of values that will be
18679 returned by its @code{random} function, Calc exercises the function
18680 several times to estimate the range. When Calc subsequently uses
18681 the @code{random} function, it takes only 10 bits of the result
18682 near the most-significant end. (It avoids at least the bottom
18683 four bits, preferably more, and also tries to avoid the top two
18684 bits.) This strategy works well with the linear congruential
18685 generators that are typically used to implement @code{random}.
18687 If @code{RandSeed} contains an integer, Calc uses this integer to
18688 seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
18689 computing @c{$X_{n-55} - X_{n-24}$}
18690 @cite{X_n-55 - X_n-24}). This method expands the seed
18691 value into a large table which is maintained internally; the variable
18692 @code{RandSeed} is changed from, e.g., 42 to the vector @cite{[42]}
18693 to indicate that the seed has been absorbed into this table. When
18694 @code{RandSeed} contains a vector, @kbd{k r} and related commands
18695 continue to use the same internal table as last time. There is no
18696 way to extract the complete state of the random number generator
18697 so that you can restart it from any point; you can only restart it
18698 from the same initial seed value. A simple way to restart from the
18699 same seed is to type @kbd{s r RandSeed} to get the seed vector,
18700 @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
18701 to reseed the generator with that number.
18703 Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
18704 of Knuth. It fills a table with 13 random 10-bit numbers. Then,
18705 to generate a new random number, it uses the previous number to
18706 index into the table, picks the value it finds there as the new
18707 random number, then replaces that table entry with a new value
18708 obtained from a call to the base random number generator (either
18709 the additive congruential generator or the @code{random} function
18710 supplied by the system). If there are any flaws in the base
18711 generator, shuffling will tend to even them out. But if the system
18712 provides an excellent @code{random} function, shuffling will not
18713 damage its randomness.
18715 To create a random integer of a certain number of digits, Calc
18716 builds the integer three decimal digits at a time. For each group
18717 of three digits, Calc calls its 10-bit shuffling random number generator
18718 (which returns a value from 0 to 1023); if the random value is 1000
18719 or more, Calc throws it out and tries again until it gets a suitable
18722 To create a random floating-point number with precision @var{p}, Calc
18723 simply creates a random @var{p}-digit integer and multiplies by
18725 @cite{10^-p}. The resulting random numbers should be very clean, but note
18726 that relatively small numbers will have few significant random digits.
18727 In other words, with a precision of 12, you will occasionally get
18728 numbers on the order of @c{$10^{-9}$}
18729 @cite{10^-9} or @c{$10^{-10}$}
18730 @cite{10^-10}, but those numbers
18731 will only have two or three random digits since they correspond to small
18732 integers times @c{$10^{-12}$}
18735 To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
18736 counts the digits in @var{m}, creates a random integer with three
18737 additional digits, then reduces modulo @var{m}. Unless @var{m} is a
18738 power of ten the resulting values will be very slightly biased toward
18739 the lower numbers, but this bias will be less than 0.1%. (For example,
18740 if @var{m} is 42, Calc will reduce a random integer less than 100000
18741 modulo 42 to get a result less than 42. It is easy to show that the
18742 numbers 40 and 41 will be only 2380/2381 as likely to result from this
18743 modulo operation as numbers 39 and below.) If @var{m} is a power of
18744 ten, however, the numbers should be completely unbiased.
18746 The Gaussian random numbers generated by @samp{random(0.0)} use the
18747 ``polar'' method described in Knuth section 3.4.1C. This method
18748 generates a pair of Gaussian random numbers at a time, so only every
18749 other call to @samp{random(0.0)} will require significant calculations.
18751 @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
18752 @section Combinatorial Functions
18755 Commands relating to combinatorics and number theory begin with the
18756 @kbd{k} key prefix.
18761 The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
18762 Greatest Common Divisor of two integers. It also accepts fractions;
18763 the GCD of two fractions is defined by taking the GCD of the
18764 numerators, and the LCM of the denominators. This definition is
18765 consistent with the idea that @samp{a / gcd(a,x)} should yield an
18766 integer for any @samp{a} and @samp{x}. For other types of arguments,
18767 the operation is left in symbolic form.@refill
18772 The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
18773 Least Common Multiple of two integers or fractions. The product of
18774 the LCM and GCD of two numbers is equal to the product of the
18778 @pindex calc-extended-gcd
18780 The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
18781 the GCD of two integers @cite{x} and @cite{y} and returns a vector
18782 @cite{[g, a, b]} where @c{$g = \gcd(x,y) = a x + b y$}
18783 @cite{g = gcd(x,y) = a x + b y}.
18786 @pindex calc-factorial
18792 The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
18793 factorial of the number at the top of the stack. If the number is an
18794 integer, the result is an exact integer. If the number is an
18795 integer-valued float, the result is a floating-point approximation. If
18796 the number is a non-integral real number, the generalized factorial is used,
18797 as defined by the Euler Gamma function. Please note that computation of
18798 large factorials can be slow; using floating-point format will help
18799 since fewer digits must be maintained. The same is true of many of
18800 the commands in this section.@refill
18803 @pindex calc-double-factorial
18809 The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
18810 computes the ``double factorial'' of an integer. For an even integer,
18811 this is the product of even integers from 2 to @cite{N}. For an odd
18812 integer, this is the product of odd integers from 3 to @cite{N}. If
18813 the argument is an integer-valued float, the result is a floating-point
18814 approximation. This function is undefined for negative even integers.
18815 The notation @cite{N!!} is also recognized for double factorials.@refill
18818 @pindex calc-choose
18820 The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
18821 binomial coefficient @cite{N}-choose-@cite{M}, where @cite{M} is the number
18822 on the top of the stack and @cite{N} is second-to-top. If both arguments
18823 are integers, the result is an exact integer. Otherwise, the result is a
18824 floating-point approximation. The binomial coefficient is defined for all
18825 real numbers by @c{$N! \over M! (N-M)!\,$}
18826 @cite{N! / M! (N-M)!}.
18832 The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
18833 number-of-permutations function @cite{N! / (N-M)!}.
18836 The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
18837 number-of-perm\-utations function $N! \over (N-M)!\,$.
18842 @pindex calc-bernoulli-number
18844 The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
18845 computes a given Bernoulli number. The value at the top of the stack
18846 is a nonnegative integer @cite{n} that specifies which Bernoulli number
18847 is desired. The @kbd{H k b} command computes a Bernoulli polynomial,
18848 taking @cite{n} from the second-to-top position and @cite{x} from the
18849 top of the stack. If @cite{x} is a variable or formula the result is
18850 a polynomial in @cite{x}; if @cite{x} is a number the result is a number.
18854 @pindex calc-euler-number
18856 The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
18857 computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
18858 Bernoulli and Euler numbers occur in the Taylor expansions of several
18863 @pindex calc-stirling-number
18866 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
18867 computes a Stirling number of the first kind@c{ $n \brack m$}
18868 @asis{}, given two integers
18869 @cite{n} and @cite{m} on the stack. The @kbd{H k s} [@code{stir2}]
18870 command computes a Stirling number of the second kind@c{ $n \brace m$}
18872 the number of @cite{m}-cycle permutations of @cite{n} objects, and
18873 the number of ways to partition @cite{n} objects into @cite{m}
18874 non-empty sets, respectively.
18877 @pindex calc-prime-test
18879 The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
18880 the top of the stack is prime. For integers less than eight million, the
18881 answer is always exact and reasonably fast. For larger integers, a
18882 probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
18883 The number is first checked against small prime factors (up to 13). Then,
18884 any number of iterations of the algorithm are performed. Each step either
18885 discovers that the number is non-prime, or substantially increases the
18886 certainty that the number is prime. After a few steps, the chance that
18887 a number was mistakenly described as prime will be less than one percent.
18888 (Indeed, this is a worst-case estimate of the probability; in practice
18889 even a single iteration is quite reliable.) After the @kbd{k p} command,
18890 the number will be reported as definitely prime or non-prime if possible,
18891 or otherwise ``probably'' prime with a certain probability of error.
18897 The normal @kbd{k p} command performs one iteration of the primality
18898 test. Pressing @kbd{k p} repeatedly for the same integer will perform
18899 additional iterations. Also, @kbd{k p} with a numeric prefix performs
18900 the specified number of iterations. There is also an algebraic function
18901 @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @cite{n}
18902 is (probably) prime and 0 if not.
18905 @pindex calc-prime-factors
18907 The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
18908 attempts to decompose an integer into its prime factors. For numbers up
18909 to 25 million, the answer is exact although it may take some time. The
18910 result is a vector of the prime factors in increasing order. For larger
18911 inputs, prime factors above 5000 may not be found, in which case the
18912 last number in the vector will be an unfactored integer greater than 25
18913 million (with a warning message). For negative integers, the first
18914 element of the list will be @i{-1}. For inputs @i{-1}, @i{0}, and
18915 @i{1}, the result is a list of the same number.
18918 @pindex calc-next-prime
18920 @mindex nextpr@idots
18923 The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
18924 the next prime above a given number. Essentially, it searches by calling
18925 @code{calc-prime-test} on successive integers until it finds one that
18926 passes the test. This is quite fast for integers less than eight million,
18927 but once the probabilistic test comes into play the search may be rather
18928 slow. Ordinarily this command stops for any prime that passes one iteration
18929 of the primality test. With a numeric prefix argument, a number must pass
18930 the specified number of iterations before the search stops. (This only
18931 matters when searching above eight million.) You can always use additional
18932 @kbd{k p} commands to increase your certainty that the number is indeed
18936 @pindex calc-prev-prime
18938 @mindex prevpr@idots
18941 The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
18942 analogously finds the next prime less than a given number.
18945 @pindex calc-totient
18947 The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
18948 Euler ``totient'' function@c{ $\phi(n)$}
18949 @asis{}, the number of integers less than @cite{n} which
18950 are relatively prime to @cite{n}.
18953 @pindex calc-moebius
18955 The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
18957 @asis{Moebius ``mu''} function. If the input number is a product of @cite{k}
18958 distinct factors, this is @cite{(-1)^k}. If the input number has any
18959 duplicate factors (i.e., can be divided by the same prime more than once),
18960 the result is zero.
18962 @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
18963 @section Probability Distribution Functions
18966 The functions in this section compute various probability distributions.
18967 For continuous distributions, this is the integral of the probability
18968 density function from @cite{x} to infinity. (These are the ``upper
18969 tail'' distribution functions; there are also corresponding ``lower
18970 tail'' functions which integrate from minus infinity to @cite{x}.)
18971 For discrete distributions, the upper tail function gives the sum
18972 from @cite{x} to infinity; the lower tail function gives the sum
18973 from minus infinity up to, but not including,@w{ }@cite{x}.
18975 To integrate from @cite{x} to @cite{y}, just use the distribution
18976 function twice and subtract. For example, the probability that a
18977 Gaussian random variable with mean 2 and standard deviation 1 will
18978 lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
18979 (``the probability that it is greater than 2.5, but not greater than 2.8''),
18980 or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
18987 The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
18988 binomial distribution. Push the parameters @var{n}, @var{p}, and
18989 then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
18990 probability that an event will occur @var{x} or more times out
18991 of @var{n} trials, if its probability of occurring in any given
18992 trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is
18993 the probability that the event will occur fewer than @var{x} times.
18995 The other probability distribution functions similarly take the
18996 form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
18997 and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
18998 @var{x}. The arguments to the algebraic functions are the value of
18999 the random variable first, then whatever other parameters define the
19000 distribution. Note these are among the few Calc functions where the
19001 order of the arguments in algebraic form differs from the order of
19002 arguments as found on the stack. (The random variable comes last on
19003 the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
19004 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
19005 recover the original arguments but substitute a new value for @cite{x}.)
19018 The @samp{utpc(x,v)} function uses the chi-square distribution with
19020 @cite{v} degrees of freedom. It is the probability that a model is
19021 correct if its chi-square statistic is @cite{x}.
19034 The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
19035 various statistical tests. The parameters @c{$\nu_1$}
19036 @cite{v1} and @c{$\nu_2$}
19038 are the degrees of freedom in the numerator and denominator,
19039 respectively, used in computing the statistic @cite{F}.
19052 The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
19053 with mean @cite{m} and standard deviation @c{$\sigma$}
19054 @cite{s}. It is the
19055 probability that such a normal-distributed random variable would
19069 The @samp{utpp(n,x)} function uses a Poisson distribution with
19070 mean @cite{x}. It is the probability that @cite{n} or more such
19071 Poisson random events will occur.
19084 The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
19086 @cite{v} degrees of freedom. It is the probability that a
19087 t-distributed random variable will be greater than @cite{t}.
19088 (Note: This computes the distribution function @c{$A(t|\nu)$}
19090 where @c{$A(0|\nu) = 1$}
19091 @cite{A(0|v) = 1} and @c{$A(\infty|\nu) \to 0$}
19092 @cite{A(inf|v) -> 0}. The
19093 @code{UTPT} operation on the HP-48 uses a different definition
19094 which returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.)
19096 While Calc does not provide inverses of the probability distribution
19097 functions, the @kbd{a R} command can be used to solve for the inverse.
19098 Since the distribution functions are monotonic, @kbd{a R} is guaranteed
19099 to be able to find a solution given any initial guess.
19100 @xref{Numerical Solutions}.
19102 @node Matrix Functions, Algebra, Scientific Functions, Top
19103 @chapter Vector/Matrix Functions
19106 Many of the commands described here begin with the @kbd{v} prefix.
19107 (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
19108 The commands usually apply to both plain vectors and matrices; some
19109 apply only to matrices or only to square matrices. If the argument
19110 has the wrong dimensions the operation is left in symbolic form.
19112 Vectors are entered and displayed using @samp{[a,b,c]} notation.
19113 Matrices are vectors of which all elements are vectors of equal length.
19114 (Though none of the standard Calc commands use this concept, a
19115 three-dimensional matrix or rank-3 tensor could be defined as a
19116 vector of matrices, and so on.)
19119 * Packing and Unpacking::
19120 * Building Vectors::
19121 * Extracting Elements::
19122 * Manipulating Vectors::
19123 * Vector and Matrix Arithmetic::
19125 * Statistical Operations::
19126 * Reducing and Mapping::
19127 * Vector and Matrix Formats::
19130 @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
19131 @section Packing and Unpacking
19134 Calc's ``pack'' and ``unpack'' commands collect stack entries to build
19135 composite objects such as vectors and complex numbers. They are
19136 described in this chapter because they are most often used to build
19141 The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
19142 elements from the stack into a matrix, complex number, HMS form, error
19143 form, etc. It uses a numeric prefix argument to specify the kind of
19144 object to be built; this argument is referred to as the ``packing mode.''
19145 If the packing mode is a nonnegative integer, a vector of that
19146 length is created. For example, @kbd{C-u 5 v p} will pop the top
19147 five stack elements and push back a single vector of those five
19148 elements. (@kbd{C-u 0 v p} simply creates an empty vector.)
19150 The same effect can be had by pressing @kbd{[} to push an incomplete
19151 vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
19152 the incomplete object up past a certain number of elements, and
19153 then pressing @kbd{]} to complete the vector.
19155 Negative packing modes create other kinds of composite objects:
19159 Two values are collected to build a complex number. For example,
19160 @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
19161 @cite{(5, 7)}. The result is always a rectangular complex
19162 number. The two input values must both be real numbers,
19163 i.e., integers, fractions, or floats. If they are not, Calc
19164 will instead build a formula like @samp{a + (0, 1) b}. (The
19165 other packing modes also create a symbolic answer if the
19166 components are not suitable.)
19169 Two values are collected to build a polar complex number.
19170 The first is the magnitude; the second is the phase expressed
19171 in either degrees or radians according to the current angular
19175 Three values are collected into an HMS form. The first
19176 two values (hours and minutes) must be integers or
19177 integer-valued floats. The third value may be any real
19181 Two values are collected into an error form. The inputs
19182 may be real numbers or formulas.
19185 Two values are collected into a modulo form. The inputs
19186 must be real numbers.
19189 Two values are collected into the interval @samp{[a .. b]}.
19190 The inputs may be real numbers, HMS or date forms, or formulas.
19193 Two values are collected into the interval @samp{[a .. b)}.
19196 Two values are collected into the interval @samp{(a .. b]}.
19199 Two values are collected into the interval @samp{(a .. b)}.
19202 Two integer values are collected into a fraction.
19205 Two values are collected into a floating-point number.
19206 The first is the mantissa; the second, which must be an
19207 integer, is the exponent. The result is the mantissa
19208 times ten to the power of the exponent.
19211 This is treated the same as @i{-11} by the @kbd{v p} command.
19212 When unpacking, @i{-12} specifies that a floating-point mantissa
19216 A real number is converted into a date form.
19219 Three numbers (year, month, day) are packed into a pure date form.
19222 Six numbers are packed into a date/time form.
19225 With any of the two-input negative packing modes, either or both
19226 of the inputs may be vectors. If both are vectors of the same
19227 length, the result is another vector made by packing corresponding
19228 elements of the input vectors. If one input is a vector and the
19229 other is a plain number, the number is packed along with each vector
19230 element to produce a new vector. For example, @kbd{C-u -4 v p}
19231 could be used to convert a vector of numbers and a vector of errors
19232 into a single vector of error forms; @kbd{C-u -5 v p} could convert
19233 a vector of numbers and a single number @var{M} into a vector of
19234 numbers modulo @var{M}.
19236 If you don't give a prefix argument to @kbd{v p}, it takes
19237 the packing mode from the top of the stack. The elements to
19238 be packed then begin at stack level 2. Thus
19239 @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
19240 enter the error form @samp{1 +/- 2}.
19242 If the packing mode taken from the stack is a vector, the result is a
19243 matrix with the dimensions specified by the elements of the vector,
19244 which must each be integers. For example, if the packing mode is
19245 @samp{[2, 3]}, then six numbers will be taken from the stack and
19246 returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
19248 If any elements of the vector are negative, other kinds of
19249 packing are done at that level as described above. For
19250 example, @samp{[2, 3, -4]} takes 12 objects and creates a
19252 @asis{2x3} matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
19253 Also, @samp{[-4, -10]} will convert four integers into an
19254 error form consisting of two fractions: @samp{a:b +/- c:d}.
19260 There is an equivalent algebraic function,
19261 @samp{pack(@var{mode}, @var{items})} where @var{mode} is a
19262 packing mode (an integer or a vector of integers) and @var{items}
19263 is a vector of objects to be packed (re-packed, really) according
19264 to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
19265 yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is
19266 left in symbolic form if the packing mode is illegal, or if the
19267 number of data items does not match the number of items required
19271 @pindex calc-unpack
19272 The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
19273 number, HMS form, or other composite object on the top of the stack and
19274 ``unpacks'' it, pushing each of its elements onto the stack as separate
19275 objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value
19276 at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
19277 each of the arguments of the top-level operator onto the stack.
19279 You can optionally give a numeric prefix argument to @kbd{v u}
19280 to specify an explicit (un)packing mode. If the packing mode is
19281 negative and the input is actually a vector or matrix, the result
19282 will be two or more similar vectors or matrices of the elements.
19283 For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
19284 the result of @kbd{C-u -4 v u} will be the two vectors
19285 @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
19287 Note that the prefix argument can have an effect even when the input is
19288 not a vector. For example, if the input is the number @i{-5}, then
19289 @kbd{c-u -1 v u} yields @i{-5} and 0 (the components of @i{-5}
19290 when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
19291 and 180 (assuming degrees mode); and @kbd{C-u -10 v u} yields @i{-5}
19292 and 1 (the numerator and denominator of @i{-5}, viewed as a rational
19293 number). Plain @kbd{v u} with this input would complain that the input
19294 is not a composite object.
19296 Unpacking mode @i{-11} converts a float into an integer mantissa and
19297 an integer exponent, where the mantissa is not divisible by 10
19298 (except that 0.0 is represented by a mantissa and exponent of 0).
19299 Unpacking mode @i{-12} converts a float into a floating-point mantissa
19300 and integer exponent, where the mantissa (for non-zero numbers)
19301 is guaranteed to lie in the range [1 .. 10). In both cases,
19302 the mantissa is shifted left or right (and the exponent adjusted
19303 to compensate) in order to satisfy these constraints.
19305 Positive unpacking modes are treated differently than for @kbd{v p}.
19306 A mode of 1 is much like plain @kbd{v u} with no prefix argument,
19307 except that in addition to the components of the input object,
19308 a suitable packing mode to re-pack the object is also pushed.
19309 Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
19312 A mode of 2 unpacks two levels of the object; the resulting
19313 re-packing mode will be a vector of length 2. This might be used
19314 to unpack a matrix, say, or a vector of error forms. Higher
19315 unpacking modes unpack the input even more deeply.
19321 There are two algebraic functions analogous to @kbd{v u}.
19322 The @samp{unpack(@var{mode}, @var{item})} function unpacks the
19323 @var{item} using the given @var{mode}, returning the result as
19324 a vector of components. Here the @var{mode} must be an
19325 integer, not a vector. For example, @samp{unpack(-4, a +/- b)}
19326 returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
19332 The @code{unpackt} function is like @code{unpack} but instead
19333 of returning a simple vector of items, it returns a vector of
19334 two things: The mode, and the vector of items. For example,
19335 @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
19336 and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
19337 The identity for re-building the original object is
19338 @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The
19339 @code{apply} function builds a function call given the function
19340 name and a vector of arguments.)
19342 @cindex Numerator of a fraction, extracting
19343 Subscript notation is a useful way to extract a particular part
19344 of an object. For example, to get the numerator of a rational
19345 number, you can use @samp{unpack(-10, @var{x})_1}.
19347 @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
19348 @section Building Vectors
19351 Vectors and matrices can be added,
19352 subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.@refill
19355 @pindex calc-concat
19360 The @kbd{|} (@code{calc-concat}) command ``concatenates'' two vectors
19361 into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
19362 will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments
19363 are matrices, the rows of the first matrix are concatenated with the
19364 rows of the second. (In other words, two matrices are just two vectors
19365 of row-vectors as far as @kbd{|} is concerned.)
19367 If either argument to @kbd{|} is a scalar (a non-vector), it is treated
19368 like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |}
19369 produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a
19370 matrix and the other is a plain vector, the vector is treated as a
19375 The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
19376 two vectors without any special cases. Both inputs must be vectors.
19377 Whether or not they are matrices is not taken into account. If either
19378 argument is a scalar, the @code{append} function is left in symbolic form.
19379 See also @code{cons} and @code{rcons} below.
19383 The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
19384 two stack arguments in the opposite order. Thus @kbd{I |} is equivalent
19385 to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
19390 The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
19391 square matrix. The optional numeric prefix gives the number of rows
19392 and columns in the matrix. If the value at the top of the stack is a
19393 vector, the elements of the vector are used as the diagonal elements; the
19394 prefix, if specified, must match the size of the vector. If the value on
19395 the stack is a scalar, it is used for each element on the diagonal, and
19396 the prefix argument is required.
19398 To build a constant square matrix, e.g., a @c{$3\times3$}
19399 @asis{3x3} matrix filled with ones,
19400 use @kbd{0 M-3 v d 1 +}, i.e., build a zero matrix first and then add a
19401 constant value to that matrix. (Another alternative would be to use
19402 @kbd{v b} and @kbd{v a}; see below.)
19407 The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
19408 matrix of the specified size. It is a convenient form of @kbd{v d}
19409 where the diagonal element is always one. If no prefix argument is given,
19410 this command prompts for one.
19412 In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
19413 except that @cite{a} is required to be a scalar (non-vector) quantity.
19414 If @cite{n} is omitted, @samp{idn(a)} represents @cite{a} times an
19415 identity matrix of unknown size. Calc can operate algebraically on
19416 such generic identity matrices, and if one is combined with a matrix
19417 whose size is known, it is converted automatically to an identity
19418 matrix of a suitable matching size. The @kbd{v i} command with an
19419 argument of zero creates a generic identity matrix, @samp{idn(1)}.
19420 Note that in dimensioned matrix mode (@pxref{Matrix Mode}), generic
19421 identity matrices are immediately expanded to the current default
19427 The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
19428 of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
19429 prefix argument. If you do not provide a prefix argument, you will be
19430 prompted to enter a suitable number. If @var{n} is negative, the result
19431 is a vector of negative integers from @var{n} to @i{-1}.
19433 With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
19434 three values from the stack: @var{n}, @var{start}, and @var{incr} (with
19435 @var{incr} at top-of-stack). Counting starts at @var{start} and increases
19436 by @var{incr} for successive vector elements. If @var{start} or @var{n}
19437 is in floating-point format, the resulting vector elements will also be
19438 floats. Note that @var{start} and @var{incr} may in fact be any kind
19439 of numbers or formulas.
19441 When @var{start} and @var{incr} are specified, a negative @var{n} has a
19442 different interpretation: It causes a geometric instead of arithmetic
19443 sequence to be generated. For example, @samp{index(-3, a, b)} produces
19444 @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form,
19445 @samp{index(@var{n}, @var{start})}, the default value for @var{incr}
19446 is one for positive @var{n} or two for negative @var{n}.
19449 @pindex calc-build-vector
19451 The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
19452 vector of @var{n} copies of the value on the top of the stack, where @var{n}
19453 is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)}
19454 can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
19455 (Interactively, just use @kbd{v b} twice: once to build a row, then again
19456 to build a matrix of copies of that row.)
19464 The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
19465 element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
19466 function returns the vector with its first element removed. In both
19467 cases, the argument must be a non-empty vector.
19472 The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
19473 and a vector @var{t} from the stack, and produces the vector whose head is
19474 @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except
19475 if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
19476 whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
19496 Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
19497 @code{rtail}, @code{rcons}] in which case @var{t} instead represents
19498 the @emph{last} single element of the vector, with @var{h}
19499 representing the remainder of the vector. Thus the vector
19500 @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
19501 Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
19502 @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
19504 @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
19505 @section Extracting Vector Elements
19511 The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
19512 the matrix on the top of the stack, or one element of the plain vector on
19513 the top of the stack. The row or element is specified by the numeric
19514 prefix argument; the default is to prompt for the row or element number.
19515 The matrix or vector is replaced by the specified row or element in the
19516 form of a vector or scalar, respectively.
19518 @cindex Permutations, applying
19519 With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
19520 the element or row from the top of the stack, and the vector or matrix
19521 from the second-to-top position. If the index is itself a vector of
19522 integers, the result is a vector of the corresponding elements of the
19523 input vector, or a matrix of the corresponding rows of the input matrix.
19524 This command can be used to obtain any permutation of a vector.
19526 With @kbd{C-u}, if the index is an interval form with integer components,
19527 it is interpreted as a range of indices and the corresponding subvector or
19528 submatrix is returned.
19530 @cindex Subscript notation
19532 @pindex calc-subscript
19535 Subscript notation in algebraic formulas (@samp{a_b}) stands for the
19536 Calc function @code{subscr}, which is synonymous with @code{mrow}.
19537 Thus, @samp{[x, y, z]_k} produces @cite{x}, @cite{y}, or @cite{z} if
19538 @cite{k} is one, two, or three, respectively. A double subscript
19539 (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
19540 access the element at row @cite{i}, column @cite{j} of a matrix.
19541 The @kbd{a _} (@code{calc-subscript}) command creates a subscript
19542 formula @samp{a_b} out of two stack entries. (It is on the @kbd{a}
19543 ``algebra'' prefix because subscripted variables are often used
19544 purely as an algebraic notation.)
19547 Given a negative prefix argument, @kbd{v r} instead deletes one row or
19548 element from the matrix or vector on the top of the stack. Thus
19549 @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
19550 replaces the matrix with the same matrix with its second row removed.
19551 In algebraic form this function is called @code{mrrow}.
19554 Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
19555 of a square matrix in the form of a vector. In algebraic form this
19556 function is called @code{getdiag}.
19562 The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
19563 the analogous operation on columns of a matrix. Given a plain vector
19564 it extracts (or removes) one element, just like @kbd{v r}. If the
19565 index in @kbd{C-u v c} is an interval or vector and the argument is a
19566 matrix, the result is a submatrix with only the specified columns
19567 retained (and possibly permuted in the case of a vector index).@refill
19569 To extract a matrix element at a given row and column, use @kbd{v r} to
19570 extract the row as a vector, then @kbd{v c} to extract the column element
19571 from that vector. In algebraic formulas, it is often more convenient to
19572 use subscript notation: @samp{m_i_j} gives row @cite{i}, column @cite{j}
19573 of matrix @cite{m}.
19576 @pindex calc-subvector
19578 The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
19579 a subvector of a vector. The arguments are the vector, the starting
19580 index, and the ending index, with the ending index in the top-of-stack
19581 position. The starting index indicates the first element of the vector
19582 to take. The ending index indicates the first element @emph{past} the
19583 range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
19584 the subvector @samp{[b, c]}. You could get the same result using
19585 @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
19587 If either the start or the end index is zero or negative, it is
19588 interpreted as relative to the end of the vector. Thus
19589 @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In
19590 the algebraic form, the end index can be omitted in which case it
19591 is taken as zero, i.e., elements from the starting element to the
19592 end of the vector are used. The infinity symbol, @code{inf}, also
19593 has this effect when used as the ending index.
19597 With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
19598 from a vector. The arguments are interpreted the same as for the
19599 normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
19600 produces @samp{[a, d, e]}. It is always true that @code{subvec} and
19601 @code{rsubvec} return complementary parts of the input vector.
19603 @xref{Selecting Subformulas}, for an alternative way to operate on
19604 vectors one element at a time.
19606 @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
19607 @section Manipulating Vectors
19611 @pindex calc-vlength
19613 The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
19614 length of a vector. The length of a non-vector is considered to be zero.
19615 Note that matrices are just vectors of vectors for the purposes of this
19620 With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
19621 of the dimensions of a vector, matrix, or higher-order object. For
19622 example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
19623 its argument is a @c{$2\times3$}
19627 @pindex calc-vector-find
19629 The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
19630 along a vector for the first element equal to a given target. The target
19631 is on the top of the stack; the vector is in the second-to-top position.
19632 If a match is found, the result is the index of the matching element.
19633 Otherwise, the result is zero. The numeric prefix argument, if given,
19634 allows you to select any starting index for the search.
19637 @pindex calc-arrange-vector
19639 @cindex Arranging a matrix
19640 @cindex Reshaping a matrix
19641 @cindex Flattening a matrix
19642 The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
19643 rearranges a vector to have a certain number of columns and rows. The
19644 numeric prefix argument specifies the number of columns; if you do not
19645 provide an argument, you will be prompted for the number of columns.
19646 The vector or matrix on the top of the stack is @dfn{flattened} into a
19647 plain vector. If the number of columns is nonzero, this vector is
19648 then formed into a matrix by taking successive groups of @var{n} elements.
19649 If the number of columns does not evenly divide the number of elements
19650 in the vector, the last row will be short and the result will not be
19651 suitable for use as a matrix. For example, with the matrix
19652 @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
19653 @samp{[[1, 2, 3, 4]]} (a @c{$1\times4$}
19654 @asis{1x4} matrix), @kbd{v a 1} produces
19655 @samp{[[1], [2], [3], [4]]} (a @c{$4\times1$}
19656 @asis{4x1} matrix), @kbd{v a 2} produces
19657 @samp{[[1, 2], [3, 4]]} (the original @c{$2\times2$}
19658 @asis{2x2} matrix), @w{@kbd{v a 3}} produces
19659 @samp{[[1, 2, 3], [4]]} (not a matrix), and @kbd{v a 0} produces
19660 the flattened list @samp{[1, 2, @w{3, 4}]}.
19662 @cindex Sorting data
19668 The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
19669 a vector into increasing order. Real numbers, real infinities, and
19670 constant interval forms come first in this ordering; next come other
19671 kinds of numbers, then variables (in alphabetical order), then finally
19672 come formulas and other kinds of objects; these are sorted according
19673 to a kind of lexicographic ordering with the useful property that
19674 one vector is less or greater than another if the first corresponding
19675 unequal elements are less or greater, respectively. Since quoted strings
19676 are stored by Calc internally as vectors of ASCII character codes
19677 (@pxref{Strings}), this means vectors of strings are also sorted into
19678 alphabetical order by this command.
19680 The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
19682 @cindex Permutation, inverse of
19683 @cindex Inverse of permutation
19684 @cindex Index tables
19685 @cindex Rank tables
19691 The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
19692 produces an index table or permutation vector which, if applied to the
19693 input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
19694 A permutation vector is just a vector of integers from 1 to @var{n}, where
19695 each integer occurs exactly once. One application of this is to sort a
19696 matrix of data rows using one column as the sort key; extract that column,
19697 grade it with @kbd{V G}, then use the result to reorder the original matrix
19698 with @kbd{C-u v r}. Another interesting property of the @code{V G} command
19699 is that, if the input is itself a permutation vector, the result will
19700 be the inverse of the permutation. The inverse of an index table is
19701 a rank table, whose @var{k}th element says where the @var{k}th original
19702 vector element will rest when the vector is sorted. To get a rank
19703 table, just use @kbd{V G V G}.
19705 With the Inverse flag, @kbd{I V G} produces an index table that would
19706 sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G}
19707 use a ``stable'' sorting algorithm, i.e., any two elements which are equal
19708 will not be moved out of their original order. Generally there is no way
19709 to tell with @kbd{V S}, since two elements which are equal look the same,
19710 but with @kbd{V G} this can be an important issue. In the matrix-of-rows
19711 example, suppose you have names and telephone numbers as two columns and
19712 you wish to sort by phone number primarily, and by name when the numbers
19713 are equal. You can sort the data matrix by names first, and then again
19714 by phone numbers. Because the sort is stable, any two rows with equal
19715 phone numbers will remain sorted by name even after the second sort.
19719 @pindex calc-histogram
19721 @mindex histo@idots
19724 The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
19725 histogram of a vector of numbers. Vector elements are assumed to be
19726 integers or real numbers in the range [0..@var{n}) for some ``number of
19727 bins'' @var{n}, which is the numeric prefix argument given to the
19728 command. The result is a vector of @var{n} counts of how many times
19729 each value appeared in the original vector. Non-integers in the input
19730 are rounded down to integers. Any vector elements outside the specified
19731 range are ignored. (You can tell if elements have been ignored by noting
19732 that the counts in the result vector don't add up to the length of the
19736 With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
19737 The second-to-top vector is the list of numbers as before. The top
19738 vector is an equal-sized list of ``weights'' to attach to the elements
19739 of the data vector. For example, if the first data element is 4.2 and
19740 the first weight is 10, then 10 will be added to bin 4 of the result
19741 vector. Without the hyperbolic flag, every element has a weight of one.
19744 @pindex calc-transpose
19746 The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
19747 the transpose of the matrix at the top of the stack. If the argument
19748 is a plain vector, it is treated as a row vector and transposed into
19749 a one-column matrix.
19752 @pindex calc-reverse-vector
19754 The @kbd{v v} (@code{calc-reverse-vector}) [@code{vec}] command reverses
19755 a vector end-for-end. Given a matrix, it reverses the order of the rows.
19756 (To reverse the columns instead, just use @kbd{v t v v v t}. The same
19757 principle can be used to apply other vector commands to the columns of
19761 @pindex calc-mask-vector
19763 The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
19764 one vector as a mask to extract elements of another vector. The mask
19765 is in the second-to-top position; the target vector is on the top of
19766 the stack. These vectors must have the same length. The result is
19767 the same as the target vector, but with all elements which correspond
19768 to zeros in the mask vector deleted. Thus, for example,
19769 @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
19770 @xref{Logical Operations}.
19773 @pindex calc-expand-vector
19775 The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
19776 expands a vector according to another mask vector. The result is a
19777 vector the same length as the mask, but with nonzero elements replaced
19778 by successive elements from the target vector. The length of the target
19779 vector is normally the number of nonzero elements in the mask. If the
19780 target vector is longer, its last few elements are lost. If the target
19781 vector is shorter, the last few nonzero mask elements are left
19782 unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
19783 produces @samp{[a, 0, b, 0, 7]}.
19786 With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
19787 top of the stack; the mask and target vectors come from the third and
19788 second elements of the stack. This filler is used where the mask is
19789 zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
19790 @samp{[a, z, c, z, 7]}. If the filler value is itself a vector,
19791 then successive values are taken from it, so that the effect is to
19792 interleave two vectors according to the mask:
19793 @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
19794 @samp{[a, x, b, 7, y, 0]}.
19796 Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
19797 with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
19798 You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
19799 operation across the two vectors. @xref{Logical Operations}. Note that
19800 the @code{? :} operation also discussed there allows other types of
19801 masking using vectors.
19803 @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
19804 @section Vector and Matrix Arithmetic
19807 Basic arithmetic operations like addition and multiplication are defined
19808 for vectors and matrices as well as for numbers. Division of matrices, in
19809 the sense of multiplying by the inverse, is supported. (Division by a
19810 matrix actually uses LU-decomposition for greater accuracy and speed.)
19811 @xref{Basic Arithmetic}.
19813 The following functions are applied element-wise if their arguments are
19814 vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
19815 @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
19816 @code{float}, @code{frac}. @xref{Function Index}.@refill
19819 @pindex calc-conj-transpose
19821 The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
19822 the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
19827 @kindex A (vectors)
19828 @pindex calc-abs (vectors)
19832 @tindex abs (vectors)
19833 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
19834 Frobenius norm of a vector or matrix argument. This is the square
19835 root of the sum of the squares of the absolute values of the
19836 elements of the vector or matrix. If the vector is interpreted as
19837 a point in two- or three-dimensional space, this is the distance
19838 from that point to the origin.@refill
19843 The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes
19844 the row norm, or infinity-norm, of a vector or matrix. For a plain
19845 vector, this is the maximum of the absolute values of the elements.
19846 For a matrix, this is the maximum of the row-absolute-value-sums,
19847 i.e., of the sums of the absolute values of the elements along the
19853 The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
19854 the column norm, or one-norm, of a vector or matrix. For a plain
19855 vector, this is the sum of the absolute values of the elements.
19856 For a matrix, this is the maximum of the column-absolute-value-sums.
19857 General @cite{k}-norms for @cite{k} other than one or infinity are
19863 The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
19864 right-handed cross product of two vectors, each of which must have
19865 exactly three elements.
19870 @kindex & (matrices)
19871 @pindex calc-inv (matrices)
19875 @tindex inv (matrices)
19876 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
19877 inverse of a square matrix. If the matrix is singular, the inverse
19878 operation is left in symbolic form. Matrix inverses are recorded so
19879 that once an inverse (or determinant) of a particular matrix has been
19880 computed, the inverse and determinant of the matrix can be recomputed
19881 quickly in the future.
19883 If the argument to @kbd{&} is a plain number @cite{x}, this
19884 command simply computes @cite{1/x}. This is okay, because the
19885 @samp{/} operator also does a matrix inversion when dividing one
19891 The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
19892 determinant of a square matrix.
19897 The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
19898 LU decomposition of a matrix. The result is a list of three matrices
19899 which, when multiplied together left-to-right, form the original matrix.
19900 The first is a permutation matrix that arises from pivoting in the
19901 algorithm, the second is lower-triangular with ones on the diagonal,
19902 and the third is upper-triangular.
19905 @pindex calc-mtrace
19907 The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
19908 trace of a square matrix. This is defined as the sum of the diagonal
19909 elements of the matrix.
19911 @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
19912 @section Set Operations using Vectors
19915 @cindex Sets, as vectors
19916 Calc includes several commands which interpret vectors as @dfn{sets} of
19917 objects. A set is a collection of objects; any given object can appear
19918 only once in the set. Calc stores sets as vectors of objects in
19919 sorted order. Objects in a Calc set can be any of the usual things,
19920 such as numbers, variables, or formulas. Two set elements are considered
19921 equal if they are identical, except that numerically equal numbers like
19922 the integer 4 and the float 4.0 are considered equal even though they
19923 are not ``identical.'' Variables are treated like plain symbols without
19924 attached values by the set operations; subtracting the set @samp{[b]}
19925 from @samp{[a, b]} always yields the set @samp{[a]} even though if
19926 the variables @samp{a} and @samp{b} both equaled 17, you might
19927 expect the answer @samp{[]}.
19929 If a set contains interval forms, then it is assumed to be a set of
19930 real numbers. In this case, all set operations require the elements
19931 of the set to be only things that are allowed in intervals: Real
19932 numbers, plus and minus infinity, HMS forms, and date forms. If
19933 there are variables or other non-real objects present in a real set,
19934 all set operations on it will be left in unevaluated form.
19936 If the input to a set operation is a plain number or interval form
19937 @var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
19938 The result is always a vector, except that if the set consists of a
19939 single interval, the interval itself is returned instead.
19941 @xref{Logical Operations}, for the @code{in} function which tests if
19942 a certain value is a member of a given set. To test if the set @cite{A}
19943 is a subset of the set @cite{B}, use @samp{vdiff(A, B) = []}.
19946 @pindex calc-remove-duplicates
19948 The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
19949 converts an arbitrary vector into set notation. It works by sorting
19950 the vector as if by @kbd{V S}, then removing duplicates. (For example,
19951 @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
19952 reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as
19953 necessary. You rarely need to use @kbd{V +} explicitly, since all the
19954 other set-based commands apply @kbd{V +} to their inputs before using
19958 @pindex calc-set-union
19960 The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
19961 the union of two sets. An object is in the union of two sets if and
19962 only if it is in either (or both) of the input sets. (You could
19963 accomplish the same thing by concatenating the sets with @kbd{|},
19964 then using @kbd{V +}.)
19967 @pindex calc-set-intersect
19969 The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
19970 the intersection of two sets. An object is in the intersection if
19971 and only if it is in both of the input sets. Thus if the input
19972 sets are disjoint, i.e., if they share no common elements, the result
19973 will be the empty vector @samp{[]}. Note that the characters @kbd{V}
19974 and @kbd{^} were chosen to be close to the conventional mathematical
19975 notation for set union@c{ ($A \cup B$)}
19976 @asis{} and intersection@c{ ($A \cap B$)}
19980 @pindex calc-set-difference
19982 The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
19983 the difference between two sets. An object is in the difference
19984 @cite{A - B} if and only if it is in @cite{A} but not in @cite{B}.
19985 Thus subtracting @samp{[y,z]} from a set will remove the elements
19986 @samp{y} and @samp{z} if they are present. You can also think of this
19987 as a general @dfn{set complement} operator; if @cite{A} is the set of
19988 all possible values, then @cite{A - B} is the ``complement'' of @cite{B}.
19989 Obviously this is only practical if the set of all possible values in
19990 your problem is small enough to list in a Calc vector (or simple
19991 enough to express in a few intervals).
19994 @pindex calc-set-xor
19996 The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
19997 the ``exclusive-or,'' or ``symmetric difference'' of two sets.
19998 An object is in the symmetric difference of two sets if and only
19999 if it is in one, but @emph{not} both, of the sets. Objects that
20000 occur in both sets ``cancel out.''
20003 @pindex calc-set-complement
20005 The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
20006 computes the complement of a set with respect to the real numbers.
20007 Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
20008 For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
20009 @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
20012 @pindex calc-set-floor
20014 The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
20015 reinterprets a set as a set of integers. Any non-integer values,
20016 and intervals that do not enclose any integers, are removed. Open
20017 intervals are converted to equivalent closed intervals. Successive
20018 integers are converted into intervals of integers. For example, the
20019 complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
20020 the complement with respect to the set of integers you could type
20021 @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
20024 @pindex calc-set-enumerate
20026 The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
20027 converts a set of integers into an explicit vector. Intervals in
20028 the set are expanded out to lists of all integers encompassed by
20029 the intervals. This only works for finite sets (i.e., sets which
20030 do not involve @samp{-inf} or @samp{inf}).
20033 @pindex calc-set-span
20035 The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
20036 set of reals into an interval form that encompasses all its elements.
20037 The lower limit will be the smallest element in the set; the upper
20038 limit will be the largest element. For an empty set, @samp{vspan([])}
20039 returns the empty interval @w{@samp{[0 .. 0)}}.
20042 @pindex calc-set-cardinality
20044 The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
20045 the number of integers in a set. The result is the length of the vector
20046 that would be produced by @kbd{V E}, although the computation is much
20047 more efficient than actually producing that vector.
20049 @cindex Sets, as binary numbers
20050 Another representation for sets that may be more appropriate in some
20051 cases is binary numbers. If you are dealing with sets of integers
20052 in the range 0 to 49, you can use a 50-bit binary number where a
20053 particular bit is 1 if the corresponding element is in the set.
20054 @xref{Binary Functions}, for a list of commands that operate on
20055 binary numbers. Note that many of the above set operations have
20056 direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}),
20057 @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
20058 @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
20059 respectively. You can use whatever representation for sets is most
20064 @pindex calc-pack-bits
20065 @pindex calc-unpack-bits
20068 The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
20069 converts an integer that represents a set in binary into a set
20070 in vector/interval notation. For example, @samp{vunpack(67)}
20071 returns @samp{[[0 .. 1], 6]}. If the input is negative, the set
20072 it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
20073 Use @kbd{V E} afterwards to expand intervals to individual
20074 values if you wish. Note that this command uses the @kbd{b}
20075 (binary) prefix key.
20077 The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
20078 converts the other way, from a vector or interval representing
20079 a set of nonnegative integers into a binary integer describing
20080 the same set. The set may include positive infinity, but must
20081 not include any negative numbers. The input is interpreted as a
20082 set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware
20083 that a simple input like @samp{[100]} can result in a huge integer
20084 representation (@c{$2^{100}$}
20085 @cite{2^100}, a 31-digit integer, in this case).
20087 @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
20088 @section Statistical Operations on Vectors
20091 @cindex Statistical functions
20092 The commands in this section take vectors as arguments and compute
20093 various statistical measures on the data stored in the vectors. The
20094 references used in the definitions of these functions are Bevington's
20095 @emph{Data Reduction and Error Analysis for the Physical Sciences},
20096 and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
20099 The statistical commands use the @kbd{u} prefix key followed by
20100 a shifted letter or other character.
20102 @xref{Manipulating Vectors}, for a description of @kbd{V H}
20103 (@code{calc-histogram}).
20105 @xref{Curve Fitting}, for the @kbd{a F} command for doing
20106 least-squares fits to statistical data.
20108 @xref{Probability Distribution Functions}, for several common
20109 probability distribution functions.
20112 * Single-Variable Statistics::
20113 * Paired-Sample Statistics::
20116 @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
20117 @subsection Single-Variable Statistics
20120 These functions do various statistical computations on single
20121 vectors. Given a numeric prefix argument, they actually pop
20122 @var{n} objects from the stack and combine them into a data
20123 vector. Each object may be either a number or a vector; if a
20124 vector, any sub-vectors inside it are ``flattened'' as if by
20125 @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object
20126 is popped, which (in order to be useful) is usually a vector.
20128 If an argument is a variable name, and the value stored in that
20129 variable is a vector, then the stored vector is used. This method
20130 has the advantage that if your data vector is large, you can avoid
20131 the slow process of manipulating it directly on the stack.
20133 These functions are left in symbolic form if any of their arguments
20134 are not numbers or vectors, e.g., if an argument is a formula, or
20135 a non-vector variable. However, formulas embedded within vector
20136 arguments are accepted; the result is a symbolic representation
20137 of the computation, based on the assumption that the formula does
20138 not itself represent a vector. All varieties of numbers such as
20139 error forms and interval forms are acceptable.
20141 Some of the functions in this section also accept a single error form
20142 or interval as an argument. They then describe a property of the
20143 normal or uniform (respectively) statistical distribution described
20144 by the argument. The arguments are interpreted in the same way as
20145 the @var{M} argument of the random number function @kbd{k r}. In
20146 particular, an interval with integer limits is considered an integer
20147 distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
20148 An interval with at least one floating-point limit is a continuous
20149 distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as
20150 @samp{[2.0 .. 5.0]}!
20153 @pindex calc-vector-count
20155 The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
20156 computes the number of data values represented by the inputs.
20157 For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
20158 If the argument is a single vector with no sub-vectors, this
20159 simply computes the length of the vector.
20163 @pindex calc-vector-sum
20164 @pindex calc-vector-prod
20167 @cindex Summations (statistical)
20168 The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
20169 computes the sum of the data values. The @kbd{u *}
20170 (@code{calc-vector-prod}) [@code{vprod}] command computes the
20171 product of the data values. If the input is a single flat vector,
20172 these are the same as @kbd{V R +} and @kbd{V R *}
20173 (@pxref{Reducing and Mapping}).@refill
20177 @pindex calc-vector-max
20178 @pindex calc-vector-min
20181 The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
20182 computes the maximum of the data values, and the @kbd{u N}
20183 (@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
20184 If the argument is an interval, this finds the minimum or maximum
20185 value in the interval. (Note that @samp{vmax([2..6)) = 5} as
20186 described above.) If the argument is an error form, this returns
20187 plus or minus infinity.
20190 @pindex calc-vector-mean
20192 @cindex Mean of data values
20193 The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
20194 computes the average (arithmetic mean) of the data values.
20195 If the inputs are error forms @c{$x$ @code{+/-} $\sigma$}
20196 @samp{x +/- s}, this is the weighted
20197 mean of the @cite{x} values with weights @c{$1 / \sigma^2$}
20201 $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
20202 \displaystyle \sum { 1 \over \sigma_i^2 } } $$
20204 If the inputs are not error forms, this is simply the sum of the
20205 values divided by the count of the values.@refill
20207 Note that a plain number can be considered an error form with
20208 error @c{$\sigma = 0$}
20209 @cite{s = 0}. If the input to @kbd{u M} is a mixture of
20210 plain numbers and error forms, the result is the mean of the
20211 plain numbers, ignoring all values with non-zero errors. (By the
20212 above definitions it's clear that a plain number effectively
20213 has an infinite weight, next to which an error form with a finite
20214 weight is completely negligible.)
20216 This function also works for distributions (error forms or
20217 intervals). The mean of an error form `@var{a} @t{+/-} @var{b}' is simply
20218 @cite{a}. The mean of an interval is the mean of the minimum
20219 and maximum values of the interval.
20222 @pindex calc-vector-mean-error
20224 The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
20225 command computes the mean of the data points expressed as an
20226 error form. This includes the estimated error associated with
20227 the mean. If the inputs are error forms, the error is the square
20228 root of the reciprocal of the sum of the reciprocals of the squares
20229 of the input errors. (I.e., the variance is the reciprocal of the
20230 sum of the reciprocals of the variances.)
20233 $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
20235 If the inputs are plain
20236 numbers, the error is equal to the standard deviation of the values
20237 divided by the square root of the number of values. (This works
20238 out to be equivalent to calculating the standard deviation and
20239 then assuming each value's error is equal to this standard
20243 $$ \sigma_\mu^2 = {\sigma^2 \over N} $$
20247 @pindex calc-vector-median
20249 @cindex Median of data values
20250 The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
20251 command computes the median of the data values. The values are
20252 first sorted into numerical order; the median is the middle
20253 value after sorting. (If the number of data values is even,
20254 the median is taken to be the average of the two middle values.)
20255 The median function is different from the other functions in
20256 this section in that the arguments must all be real numbers;
20257 variables are not accepted even when nested inside vectors.
20258 (Otherwise it is not possible to sort the data values.) If
20259 any of the input values are error forms, their error parts are
20262 The median function also accepts distributions. For both normal
20263 (error form) and uniform (interval) distributions, the median is
20264 the same as the mean.
20267 @pindex calc-vector-harmonic-mean
20269 @cindex Harmonic mean
20270 The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
20271 command computes the harmonic mean of the data values. This is
20272 defined as the reciprocal of the arithmetic mean of the reciprocals
20276 $$ { N \over \displaystyle \sum {1 \over x_i} } $$
20280 @pindex calc-vector-geometric-mean
20282 @cindex Geometric mean
20283 The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
20284 command computes the geometric mean of the data values. This
20285 is the @var{n}th root of the product of the values. This is also
20286 equal to the @code{exp} of the arithmetic mean of the logarithms
20287 of the data values.
20290 $$ \exp \left ( \sum { \ln x_i } \right ) =
20291 \left ( \prod { x_i } \right)^{1 / N} $$
20296 The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
20297 mean'' of two numbers taken from the stack. This is computed by
20298 replacing the two numbers with their arithmetic mean and geometric
20299 mean, then repeating until the two values converge.
20302 $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
20305 @cindex Root-mean-square
20306 Another commonly used mean, the RMS (root-mean-square), can be computed
20307 for a vector of numbers simply by using the @kbd{A} command.
20310 @pindex calc-vector-sdev
20312 @cindex Standard deviation
20313 @cindex Sample statistics
20314 The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
20315 computes the standard deviation@c{ $\sigma$}
20316 @asis{} of the data values. If the
20317 values are error forms, the errors are used as weights just
20318 as for @kbd{u M}. This is the @emph{sample} standard deviation,
20319 whose value is the square root of the sum of the squares of the
20320 differences between the values and the mean of the @cite{N} values,
20321 divided by @cite{N-1}.
20324 $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
20327 This function also applies to distributions. The standard deviation
20328 of a single error form is simply the error part. The standard deviation
20329 of a continuous interval happens to equal the difference between the
20330 limits, divided by @c{$\sqrt{12}$}
20331 @cite{sqrt(12)}. The standard deviation of an
20332 integer interval is the same as the standard deviation of a vector
20336 @pindex calc-vector-pop-sdev
20338 @cindex Population statistics
20339 The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
20340 command computes the @emph{population} standard deviation.
20341 It is defined by the same formula as above but dividing
20342 by @cite{N} instead of by @cite{N-1}. The population standard
20343 deviation is used when the input represents the entire set of
20344 data values in the distribution; the sample standard deviation
20345 is used when the input represents a sample of the set of all
20346 data values, so that the mean computed from the input is itself
20347 only an estimate of the true mean.
20350 $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
20353 For error forms and continuous intervals, @code{vpsdev} works
20354 exactly like @code{vsdev}. For integer intervals, it computes the
20355 population standard deviation of the equivalent vector of integers.
20359 @pindex calc-vector-variance
20360 @pindex calc-vector-pop-variance
20363 @cindex Variance of data values
20364 The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
20365 @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
20366 commands compute the variance of the data values. The variance
20367 is the square@c{ $\sigma^2$}
20368 @asis{} of the standard deviation, i.e., the sum of the
20369 squares of the deviations of the data values from the mean.
20370 (This definition also applies when the argument is a distribution.)
20376 The @code{vflat} algebraic function returns a vector of its
20377 arguments, interpreted in the same way as the other functions
20378 in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)}
20379 returns @samp{[1, 2, 3, 4, 5]}.
20381 @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
20382 @subsection Paired-Sample Statistics
20385 The functions in this section take two arguments, which must be
20386 vectors of equal size. The vectors are each flattened in the same
20387 way as by the single-variable statistical functions. Given a numeric
20388 prefix argument of 1, these functions instead take one object from
20389 the stack, which must be an @c{$N\times2$}
20390 @asis{Nx2} matrix of data values. Once
20391 again, variable names can be used in place of actual vectors and
20395 @pindex calc-vector-covariance
20398 The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
20399 computes the sample covariance of two vectors. The covariance
20400 of vectors @var{x} and @var{y} is the sum of the products of the
20401 differences between the elements of @var{x} and the mean of @var{x}
20402 times the differences between the corresponding elements of @var{y}
20403 and the mean of @var{y}, all divided by @cite{N-1}. Note that
20404 the variance of a vector is just the covariance of the vector
20405 with itself. Once again, if the inputs are error forms the
20406 errors are used as weight factors. If both @var{x} and @var{y}
20407 are composed of error forms, the error for a given data point
20408 is taken as the square root of the sum of the squares of the two
20412 $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
20413 $$ \sigma_{x\!y}^2 =
20414 {\displaystyle {1 \over N-1}
20415 \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
20416 \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
20421 @pindex calc-vector-pop-covariance
20423 The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
20424 command computes the population covariance, which is the same as the
20425 sample covariance computed by @kbd{u C} except dividing by @cite{N}
20426 instead of @cite{N-1}.
20429 @pindex calc-vector-correlation
20431 @cindex Correlation coefficient
20432 @cindex Linear correlation
20433 The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
20434 command computes the linear correlation coefficient of two vectors.
20435 This is defined by the covariance of the vectors divided by the
20436 product of their standard deviations. (There is no difference
20437 between sample or population statistics here.)
20440 $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
20443 @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
20444 @section Reducing and Mapping Vectors
20447 The commands in this section allow for more general operations on the
20448 elements of vectors.
20453 The simplest of these operations is @kbd{V A} (@code{calc-apply})
20454 [@code{apply}], which applies a given operator to the elements of a vector.
20455 For example, applying the hypothetical function @code{f} to the vector
20456 @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
20457 Applying the @code{+} function to the vector @samp{[a, b]} gives
20458 @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an
20459 error, since the @code{+} function expects exactly two arguments.
20461 While @kbd{V A} is useful in some cases, you will usually find that either
20462 @kbd{V R} or @kbd{V M}, described below, is closer to what you want.
20465 * Specifying Operators::
20468 * Nesting and Fixed Points::
20469 * Generalized Products::
20472 @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
20473 @subsection Specifying Operators
20476 Commands in this section (like @kbd{V A}) prompt you to press the key
20477 corresponding to the desired operator. Press @kbd{?} for a partial
20478 list of the available operators. Generally, an operator is any key or
20479 sequence of keys that would normally take one or more arguments from
20480 the stack and replace them with a result. For example, @kbd{V A H C}
20481 uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh}
20482 expects one argument, @kbd{V A H C} requires a vector with a single
20483 element as its argument.)
20485 You can press @kbd{x} at the operator prompt to select any algebraic
20486 function by name to use as the operator. This includes functions you
20487 have defined yourself using the @kbd{Z F} command. (@xref{Algebraic
20488 Definitions}.) If you give a name for which no function has been
20489 defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
20490 Calc will prompt for the number of arguments the function takes if it
20491 can't figure it out on its own (say, because you named a function that
20492 is currently undefined). It is also possible to type a digit key before
20493 the function name to specify the number of arguments, e.g.,
20494 @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
20495 looks like it ought to have only two. This technique may be necessary
20496 if the function allows a variable number of arguments. For example,
20497 the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
20498 if you want to map with the three-argument version, you will have to
20499 type @kbd{V M 3 v e}.
20501 It is also possible to apply any formula to a vector by treating that
20502 formula as a function. When prompted for the operator to use, press
20503 @kbd{'} (the apostrophe) and type your formula as an algebraic entry.
20504 You will then be prompted for the argument list, which defaults to a
20505 list of all variables that appear in the formula, sorted into alphabetic
20506 order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
20507 The default argument list would be @samp{(x y)}, which means that if
20508 this function is applied to the arguments @samp{[3, 10]} the result will
20509 be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this
20510 way often, you might consider defining it as a function with @kbd{Z F}.)
20512 Another way to specify the arguments to the formula you enter is with
20513 @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$}
20514 has the same effect as the previous example. The argument list is
20515 automatically taken to be @samp{($$ $)}. (The order of the arguments
20516 may seem backwards, but it is analogous to the way normal algebraic
20517 entry interacts with the stack.)
20519 If you press @kbd{$} at the operator prompt, the effect is similar to
20520 the apostrophe except that the relevant formula is taken from top-of-stack
20521 instead. The actual vector arguments of the @kbd{V A $} or related command
20522 then start at the second-to-top stack position. You will still be
20523 prompted for an argument list.
20525 @cindex Nameless functions
20526 @cindex Generic functions
20527 A function can be written without a name using the notation @samp{<#1 - #2>},
20528 which means ``a function of two arguments that computes the first
20529 argument minus the second argument.'' The symbols @samp{#1} and @samp{#2}
20530 are placeholders for the arguments. You can use any names for these
20531 placeholders if you wish, by including an argument list followed by a
20532 colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
20533 Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
20534 to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
20535 Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both
20536 cases, Calc also writes the nameless function to the Trail so that you
20537 can get it back later if you wish.
20539 If there is only one argument, you can write @samp{#} in place of @samp{#1}.
20540 (Note that @samp{< >} notation is also used for date forms. Calc tells
20541 that @samp{<@var{stuff}>} is a nameless function by the presence of
20542 @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
20543 begins with a list of variables followed by a colon.)
20545 You can type a nameless function directly to @kbd{V A '}, or put one on
20546 the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an
20547 argument list in this case, since the nameless function specifies the
20548 argument list as well as the function itself. In @kbd{V A '}, you can
20549 omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
20550 so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
20551 which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
20553 @cindex Lambda expressions
20558 The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
20559 (The word @code{lambda} derives from Lisp notation and the theory of
20560 functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
20561 ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called
20562 @code{lambda}; the whole point is that the @code{lambda} expression is
20563 used in its symbolic form, not evaluated for an answer until it is applied
20564 to specific arguments by a command like @kbd{V A} or @kbd{V M}.
20566 (Actually, @code{lambda} does have one special property: Its arguments
20567 are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
20568 will not simplify the @samp{2/3} until the nameless function is actually
20597 As usual, commands like @kbd{V A} have algebraic function name equivalents.
20598 For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
20599 @samp{apply(gcd, v)}. The first argument specifies the operator name,
20600 and is either a variable whose name is the same as the function name,
20601 or a nameless function like @samp{<#^3+1>}. Operators that are normally
20602 written as algebraic symbols have the names @code{add}, @code{sub},
20603 @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
20604 @code{vconcat}.@refill
20610 The @code{call} function builds a function call out of several arguments:
20611 @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
20612 in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call},
20613 like the other functions described here, may be either a variable naming a
20614 function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
20617 (Experts will notice that it's not quite proper to use a variable to name
20618 a function, since the name @code{gcd} corresponds to the Lisp variable
20619 @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc
20620 automatically makes this translation, so you don't have to worry
20623 @node Mapping, Reducing, Specifying Operators, Reducing and Mapping
20624 @subsection Mapping
20630 The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
20631 operator elementwise to one or more vectors. For example, mapping
20632 @code{A} [@code{abs}] produces a vector of the absolute values of the
20633 elements in the input vector. Mapping @code{+} pops two vectors from
20634 the stack, which must be of equal length, and produces a vector of the
20635 pairwise sums of the elements. If either argument is a non-vector, it
20636 is duplicated for each element of the other vector. For example,
20637 @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
20638 With the 2 listed first, it would have computed a vector of powers of
20639 two. Mapping a user-defined function pops as many arguments from the
20640 stack as the function requires. If you give an undefined name, you will
20641 be prompted for the number of arguments to use.@refill
20643 If any argument to @kbd{V M} is a matrix, the operator is normally mapped
20644 across all elements of the matrix. For example, given the matrix
20645 @cite{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
20646 produce another @c{$3\times2$}
20647 @asis{3x2} matrix, @cite{[[1, 2, 3], [4, 5, 6]]}.
20650 The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
20651 operator prompt) maps by rows instead. For example, @kbd{V M _ A} views
20652 the above matrix as a vector of two 3-element row vectors. It produces
20653 a new vector which contains the absolute values of those row vectors,
20654 namely @cite{[3.74, 8.77]}. (Recall, the absolute value of a vector is
20655 defined as the square root of the sum of the squares of the elements.)
20656 Some operators accept vectors and return new vectors; for example,
20657 @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
20658 of the matrix to get a new matrix, @cite{[[3, -2, 1], [-6, 5, -4]]}.
20660 Sometimes a vector of vectors (representing, say, strings, sets, or lists)
20661 happens to look like a matrix. If so, remember to use @kbd{V M _} if you
20662 want to map a function across the whole strings or sets rather than across
20663 their individual elements.
20666 The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it
20667 transposes the input matrix, maps by rows, and then, if the result is a
20668 matrix, transposes again. For example, @kbd{V M : A} takes the absolute
20669 values of the three columns of the matrix, treating each as a 2-vector,
20670 and @kbd{V M : v v} reverses the columns to get the matrix
20671 @cite{[[-4, 5, -6], [1, -2, 3]]}.
20673 (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
20674 and column-like appearances, and were not already taken by useful
20675 operators. Also, they appear shifted on most keyboards so they are easy
20676 to type after @kbd{V M}.)
20678 The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
20679 not matrices (so if none of the arguments are matrices, they have no
20680 effect at all). If some of the arguments are matrices and others are
20681 plain numbers, the plain numbers are held constant for all rows of the
20682 matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
20683 a vector takes a dot product of the vector with itself).
20685 If some of the arguments are vectors with the same lengths as the
20686 rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
20687 arguments, those vectors are also held constant for every row or
20690 Sometimes it is useful to specify another mapping command as the operator
20691 to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +}
20692 to each row of the input matrix, which in turn adds the two values on that
20693 row. If you give another vector-operator command as the operator for
20694 @kbd{V M}, it automatically uses map-by-rows mode if you don't specify
20695 otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If
20696 you really want to map-by-elements another mapping command, you can use
20697 a triple-nested mapping command: @kbd{V M V M V A +} means to map
20698 @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
20699 mapped over the elements of each row.)
20703 Previous versions of Calc had ``map across'' and ``map down'' modes
20704 that are now considered obsolete; the old ``map across'' is now simply
20705 @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic
20706 functions @code{mapa} and @code{mapd} are still supported, though.
20707 Note also that, while the old mapping modes were persistent (once you
20708 set the mode, it would apply to later mapping commands until you reset
20709 it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
20710 mapping command. The default @kbd{V M} always means map-by-elements.
20712 @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
20713 @kbd{V M} but for equations and inequalities instead of vectors.
20714 @xref{Storing Variables}, for the @kbd{s m} command which modifies a
20715 variable's stored value using a @kbd{V M}-like operator.
20717 @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
20718 @subsection Reducing
20722 @pindex calc-reduce
20724 The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
20725 binary operator across all the elements of a vector. A binary operator is
20726 a function such as @code{+} or @code{max} which takes two arguments. For
20727 example, reducing @code{+} over a vector computes the sum of the elements
20728 of the vector. Reducing @code{-} computes the first element minus each of
20729 the remaining elements. Reducing @code{max} computes the maximum element
20730 and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
20731 produces @samp{f(f(f(a, b), c), d)}.
20735 The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
20736 that works from right to left through the vector. For example, plain
20737 @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
20738 but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
20739 or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently
20740 in power series expansions.
20744 The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
20745 accumulation operation. Here Calc does the corresponding reduction
20746 operation, but instead of producing only the final result, it produces
20747 a vector of all the intermediate results. Accumulating @code{+} over
20748 the vector @samp{[a, b, c, d]} produces the vector
20749 @samp{[a, a + b, a + b + c, a + b + c + d]}.
20753 The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
20754 For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
20755 vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
20761 As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For
20762 example, given the matrix @cite{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
20763 compute @cite{a + b + c + d + e + f}. You can type @kbd{V R _} or
20764 @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}]
20765 command reduces ``across'' the matrix; it reduces each row of the matrix
20766 as a vector, then collects the results. Thus @kbd{V R _ +} of this
20767 matrix would produce @cite{[a + b + c, d + e + f]}. Similarly, @kbd{V R :}
20768 [@code{reduced}] reduces down; @kbd{V R : +} would produce @cite{[a + d,
20773 There is a third ``by rows'' mode for reduction that is occasionally
20774 useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
20775 the rows of the matrix themselves. Thus @kbd{V R = +} on the above
20776 matrix would get the same result as @kbd{V R : +}, since adding two
20777 row vectors is equivalent to adding their elements. But @kbd{V R = *}
20778 would multiply the two rows (to get a single number, their dot product),
20779 while @kbd{V R : *} would produce a vector of the products of the columns.
20781 These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
20782 but they are not currently supported with @kbd{V U} or @kbd{I V U}.
20786 The obsolete reduce-by-columns function, @code{reducec}, is still
20787 supported but there is no way to get it through the @kbd{V R} command.
20789 The commands @kbd{M-# :} and @kbd{M-# _} are equivalent to typing
20790 @kbd{M-# r} to grab a rectangle of data into Calc, and then typing
20791 @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
20792 rows of the matrix. @xref{Grabbing From Buffers}.
20794 @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
20795 @subsection Nesting and Fixed Points
20800 The @kbd{H V R} [@code{nest}] command applies a function to a given
20801 argument repeatedly. It takes two values, @samp{a} and @samp{n}, from
20802 the stack, where @samp{n} must be an integer. It then applies the
20803 function nested @samp{n} times; if the function is @samp{f} and @samp{n}
20804 is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be
20805 negative if Calc knows an inverse for the function @samp{f}; for
20806 example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
20810 The @kbd{H V U} [@code{anest}] command is an accumulating version of
20811 @code{nest}: It returns a vector of @samp{n+1} values, e.g.,
20812 @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and
20813 @samp{F} is the inverse of @samp{f}, then the result is of the
20814 form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
20818 @cindex Fixed points
20819 The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
20820 that it takes only an @samp{a} value from the stack; the function is
20821 applied until it reaches a ``fixed point,'' i.e., until the result
20826 The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
20827 The first element of the return vector will be the initial value @samp{a};
20828 the last element will be the final result that would have been returned
20831 For example, 0.739085 is a fixed point of the cosine function (in radians):
20832 @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say,
20833 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating
20834 version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553,
20835 0.65329, ...]}. With a precision of six, this command will take 36 steps
20836 to converge to 0.739085.)
20838 Newton's method for finding roots is a classic example of iteration
20839 to a fixed point. To find the square root of five starting with an
20840 initial guess, Newton's method would look for a fixed point of the
20841 function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack
20842 and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
20843 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root})
20844 command to find a root of the equation @samp{x^2 = 5}.
20846 These examples used numbers for @samp{a} values. Calc keeps applying
20847 the function until two successive results are equal to within the
20848 current precision. For complex numbers, both the real parts and the
20849 imaginary parts must be equal to within the current precision. If
20850 @samp{a} is a formula (say, a variable name), then the function is
20851 applied until two successive results are exactly the same formula.
20852 It is up to you to ensure that the function will eventually converge;
20853 if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
20855 The algebraic @code{fixp} function takes two optional arguments, @samp{n}
20856 and @samp{tol}. The first is the maximum number of steps to be allowed,
20857 and must be either an integer or the symbol @samp{inf} (infinity, the
20858 default). The second is a convergence tolerance. If a tolerance is
20859 specified, all results during the calculation must be numbers, not
20860 formulas, and the iteration stops when the magnitude of the difference
20861 between two successive results is less than or equal to the tolerance.
20862 (This implies that a tolerance of zero iterates until the results are
20865 Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
20866 computes the square root of @samp{A} given the initial guess @samp{B},
20867 stopping when the result is correct within the specified tolerance, or
20868 when 20 steps have been taken, whichever is sooner.
20870 @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
20871 @subsection Generalized Products
20874 @pindex calc-outer-product
20876 The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
20877 a given binary operator to all possible pairs of elements from two
20878 vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]}
20879 and @samp{[x, y, z]} on the stack produces a multiplication table:
20880 @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of
20881 the result matrix is obtained by applying the operator to element @var{r}
20882 of the lefthand vector and element @var{c} of the righthand vector.
20885 @pindex calc-inner-product
20887 The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
20888 the generalized inner product of two vectors or matrices, given a
20889 ``multiplicative'' operator and an ``additive'' operator. These can each
20890 actually be any binary operators; if they are @samp{*} and @samp{+},
20891 respectively, the result is a standard matrix multiplication. Element
20892 @var{r},@var{c} of the result matrix is obtained by mapping the
20893 multiplicative operator across row @var{r} of the lefthand matrix and
20894 column @var{c} of the righthand matrix, and then reducing with the additive
20895 operator. Just as for the standard @kbd{*} command, this can also do a
20896 vector-matrix or matrix-vector inner product, or a vector-vector
20897 generalized dot product.
20899 Since @kbd{V I} requires two operators, it prompts twice. In each case,
20900 you can use any of the usual methods for entering the operator. If you
20901 use @kbd{$} twice to take both operator formulas from the stack, the
20902 first (multiplicative) operator is taken from the top of the stack
20903 and the second (additive) operator is taken from second-to-top.
20905 @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
20906 @section Vector and Matrix Display Formats
20909 Commands for controlling vector and matrix display use the @kbd{v} prefix
20910 instead of the usual @kbd{d} prefix. But they are display modes; in
20911 particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
20912 in the same way (@pxref{Display Modes}). Matrix display is also
20913 influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
20914 @pxref{Normal Language Modes}.
20917 @pindex calc-matrix-left-justify
20919 @pindex calc-matrix-center-justify
20921 @pindex calc-matrix-right-justify
20922 The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
20923 (@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
20924 (@code{calc-matrix-center-justify}) control whether matrix elements
20925 are justified to the left, right, or center of their columns.@refill
20928 @pindex calc-vector-brackets
20930 @pindex calc-vector-braces
20932 @pindex calc-vector-parens
20933 The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
20934 brackets that surround vectors and matrices displayed in the stack on
20935 and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
20936 (@code{calc-vector-parens}) commands use curly braces or parentheses,
20937 respectively, instead of square brackets. For example, @kbd{v @{} might
20938 be used in preparation for yanking a matrix into a buffer running
20939 Mathematica. (In fact, the Mathematica language mode uses this mode;
20940 @pxref{Mathematica Language Mode}.) Note that, regardless of the
20941 display mode, either brackets or braces may be used to enter vectors,
20942 and parentheses may never be used for this purpose.@refill
20945 @pindex calc-matrix-brackets
20946 The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
20947 ``big'' style display of matrices. It prompts for a string of code
20948 letters; currently implemented letters are @code{R}, which enables
20949 brackets on each row of the matrix; @code{O}, which enables outer
20950 brackets in opposite corners of the matrix; and @code{C}, which
20951 enables commas or semicolons at the ends of all rows but the last.
20952 The default format is @samp{RO}. (Before Calc 2.00, the format
20953 was fixed at @samp{ROC}.) Here are some example matrices:
20957 [ [ 123, 0, 0 ] [ [ 123, 0, 0 ],
20958 [ 0, 123, 0 ] [ 0, 123, 0 ],
20959 [ 0, 0, 123 ] ] [ 0, 0, 123 ] ]
20968 [ 123, 0, 0 [ 123, 0, 0 ;
20969 0, 123, 0 0, 123, 0 ;
20970 0, 0, 123 ] 0, 0, 123 ]
20979 [ 123, 0, 0 ] 123, 0, 0
20980 [ 0, 123, 0 ] 0, 123, 0
20981 [ 0, 0, 123 ] 0, 0, 123
20988 Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
20989 @samp{OC} are all recognized as matrices during reading, while
20990 the others are useful for display only.
20993 @pindex calc-vector-commas
20994 The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
20995 off in vector and matrix display.@refill
20997 In vectors of length one, and in all vectors when commas have been
20998 turned off, Calc adds extra parentheses around formulas that might
20999 otherwise be ambiguous. For example, @samp{[a b]} could be a vector
21000 of the one formula @samp{a b}, or it could be a vector of two
21001 variables with commas turned off. Calc will display the former
21002 case as @samp{[(a b)]}. You can disable these extra parentheses
21003 (to make the output less cluttered at the expense of allowing some
21004 ambiguity) by adding the letter @code{P} to the control string you
21005 give to @kbd{v ]} (as described above).
21008 @pindex calc-full-vectors
21009 The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
21010 display of long vectors on and off. In this mode, vectors of six
21011 or more elements, or matrices of six or more rows or columns, will
21012 be displayed in an abbreviated form that displays only the first
21013 three elements and the last element: @samp{[a, b, c, ..., z]}.
21014 When very large vectors are involved this will substantially
21015 improve Calc's display speed.
21018 @pindex calc-full-trail-vectors
21019 The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
21020 similar mode for recording vectors in the Trail. If you turn on
21021 this mode, vectors of six or more elements and matrices of six or
21022 more rows or columns will be abbreviated when they are put in the
21023 Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be
21024 unable to recover those vectors. If you are working with very
21025 large vectors, this mode will improve the speed of all operations
21026 that involve the trail.
21029 @pindex calc-break-vectors
21030 The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
21031 vector display on and off. Normally, matrices are displayed with one
21032 row per line but all other types of vectors are displayed in a single
21033 line. This mode causes all vectors, whether matrices or not, to be
21034 displayed with a single element per line. Sub-vectors within the
21035 vectors will still use the normal linear form.
21037 @node Algebra, Units, Matrix Functions, Top
21041 This section covers the Calc features that help you work with
21042 algebraic formulas. First, the general sub-formula selection
21043 mechanism is described; this works in conjunction with any Calc
21044 commands. Then, commands for specific algebraic operations are
21045 described. Finally, the flexible @dfn{rewrite rule} mechanism
21048 The algebraic commands use the @kbd{a} key prefix; selection
21049 commands use the @kbd{j} (for ``just a letter that wasn't used
21050 for anything else'') prefix.
21052 @xref{Editing Stack Entries}, to see how to manipulate formulas
21053 using regular Emacs editing commands.@refill
21055 When doing algebraic work, you may find several of the Calculator's
21056 modes to be helpful, including algebraic-simplification mode (@kbd{m A})
21057 or no-simplification mode (@kbd{m O}),
21058 algebraic-entry mode (@kbd{m a}), fraction mode (@kbd{m f}), and
21059 symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions
21060 of these modes. You may also wish to select ``big'' display mode (@kbd{d B}).
21061 @xref{Normal Language Modes}.@refill
21064 * Selecting Subformulas::
21065 * Algebraic Manipulation::
21066 * Simplifying Formulas::
21069 * Solving Equations::
21070 * Numerical Solutions::
21073 * Logical Operations::
21077 @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
21078 @section Selecting Sub-Formulas
21082 @cindex Sub-formulas
21083 @cindex Parts of formulas
21084 When working with an algebraic formula it is often necessary to
21085 manipulate a portion of the formula rather than the formula as a
21086 whole. Calc allows you to ``select'' a portion of any formula on
21087 the stack. Commands which would normally operate on that stack
21088 entry will now operate only on the sub-formula, leaving the
21089 surrounding part of the stack entry alone.
21091 One common non-algebraic use for selection involves vectors. To work
21092 on one element of a vector in-place, simply select that element as a
21093 ``sub-formula'' of the vector.
21096 * Making Selections::
21097 * Changing Selections::
21098 * Displaying Selections::
21099 * Operating on Selections::
21100 * Rearranging with Selections::
21103 @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
21104 @subsection Making Selections
21108 @pindex calc-select-here
21109 To select a sub-formula, move the Emacs cursor to any character in that
21110 sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will
21111 highlight the smallest portion of the formula that contains that
21112 character. By default the sub-formula is highlighted by blanking out
21113 all of the rest of the formula with dots. Selection works in any
21114 display mode but is perhaps easiest in ``big'' (@kbd{d B}) mode.
21115 Suppose you enter the following formula:
21127 (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the
21128 cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
21141 Every character not part of the sub-formula @samp{b} has been changed
21142 to a dot. The @samp{*} next to the line number is to remind you that
21143 the formula has a portion of it selected. (In this case, it's very
21144 obvious, but it might not always be. If Embedded Mode is enabled,
21145 the word @samp{Sel} also appears in the mode line because the stack
21146 may not be visible. @pxref{Embedded Mode}.)
21148 If you had instead placed the cursor on the parenthesis immediately to
21149 the right of the @samp{b}, the selection would have been:
21161 The portion selected is always large enough to be considered a complete
21162 formula all by itself, so selecting the parenthesis selects the whole
21163 formula that it encloses. Putting the cursor on the @samp{+} sign
21164 would have had the same effect.
21166 (Strictly speaking, the Emacs cursor is really the manifestation of
21167 the Emacs ``point,'' which is a position @emph{between} two characters
21168 in the buffer. So purists would say that Calc selects the smallest
21169 sub-formula which contains the character to the right of ``point.'')
21171 If you supply a numeric prefix argument @var{n}, the selection is
21172 expanded to the @var{n}th enclosing sub-formula. Thus, positioning
21173 the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
21174 @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
21177 If the cursor is not on any part of the formula, or if you give a
21178 numeric prefix that is too large, the entire formula is selected.
21180 If the cursor is on the @samp{.} line that marks the top of the stack
21181 (i.e., its normal ``rest position''), this command selects the entire
21182 formula at stack level 1. Most selection commands similarly operate
21183 on the formula at the top of the stack if you haven't positioned the
21184 cursor on any stack entry.
21187 @pindex calc-select-additional
21188 The @kbd{j a} (@code{calc-select-additional}) command enlarges the
21189 current selection to encompass the cursor. To select the smallest
21190 sub-formula defined by two different points, move to the first and
21191 press @kbd{j s}, then move to the other and press @kbd{j a}. This
21192 is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
21193 select the two ends of a region of text during normal Emacs editing.
21196 @pindex calc-select-once
21197 The @kbd{j o} (@code{calc-select-once}) command selects a formula in
21198 exactly the same way as @kbd{j s}, except that the selection will
21199 last only as long as the next command that uses it. For example,
21200 @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
21203 (A somewhat more precise definition: The @kbd{j o} command sets a flag
21204 such that the next command involving selected stack entries will clear
21205 the selections on those stack entries afterwards. All other selection
21206 commands except @kbd{j a} and @kbd{j O} clear this flag.)
21210 @pindex calc-select-here-maybe
21211 @pindex calc-select-once-maybe
21212 The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
21213 (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
21214 and @kbd{j o}, respectively, except that if the formula already
21215 has a selection they have no effect. This is analogous to the
21216 behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
21217 @pxref{Selections with Rewrite Rules}) and is mainly intended to be
21218 used in keyboard macros that implement your own selection-oriented
21221 Selection of sub-formulas normally treats associative terms like
21222 @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
21223 If you place the cursor anywhere inside @samp{a + b - c + d} except
21224 on one of the variable names and use @kbd{j s}, you will select the
21225 entire four-term sum.
21228 @pindex calc-break-selections
21229 The @kbd{j b} (@code{calc-break-selections}) command controls a mode
21230 in which the ``deep structure'' of these associative formulas shows
21231 through. Calc actually stores the above formulas as @samp{((a + b) - c) + d}
21232 and @samp{x * (y * z)}. (Note that for certain obscure reasons, Calc
21233 treats multiplication as right-associative.) Once you have enabled
21234 @kbd{j b} mode, selecting with the cursor on the @samp{-} sign would
21235 only select the @samp{a + b - c} portion, which makes sense when the
21236 deep structure of the sum is considered. There is no way to select
21237 the @samp{b - c + d} portion; although this might initially look
21238 like just as legitimate a sub-formula as @samp{a + b - c}, the deep
21239 structure shows that it isn't. The @kbd{d U} command can be used
21240 to view the deep structure of any formula (@pxref{Normal Language Modes}).
21242 When @kbd{j b} mode has not been enabled, the deep structure is
21243 generally hidden by the selection commands---what you see is what
21247 @pindex calc-unselect
21248 The @kbd{j u} (@code{calc-unselect}) command unselects the formula
21249 that the cursor is on. If there was no selection in the formula,
21250 this command has no effect. With a numeric prefix argument, it
21251 unselects the @var{n}th stack element rather than using the cursor
21255 @pindex calc-clear-selections
21256 The @kbd{j c} (@code{calc-clear-selections}) command unselects all
21259 @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
21260 @subsection Changing Selections
21264 @pindex calc-select-more
21265 Once you have selected a sub-formula, you can expand it using the
21266 @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is
21267 selected, pressing @w{@kbd{j m}} repeatedly works as follows:
21272 (a + b) . . . (a + b) + V c (a + b) + V c
21273 1* ............... 1* ............... 1* ---------------
21274 . . . . . . . . 2 x + 1
21279 In the last example, the entire formula is selected. This is roughly
21280 the same as having no selection at all, but because there are subtle
21281 differences the @samp{*} character is still there on the line number.
21283 With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
21284 times (or until the entire formula is selected). Note that @kbd{j s}
21285 with argument @var{n} is equivalent to plain @kbd{j s} followed by
21286 @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there
21287 is no current selection, it is equivalent to @w{@kbd{j s}}.
21289 Even though @kbd{j m} does not explicitly use the location of the
21290 cursor within the formula, it nevertheless uses the cursor to determine
21291 which stack element to operate on. As usual, @kbd{j m} when the cursor
21292 is not on any stack element operates on the top stack element.
21295 @pindex calc-select-less
21296 The @kbd{j l} (@code{calc-select-less}) command reduces the current
21297 selection around the cursor position. That is, it selects the
21298 immediate sub-formula of the current selection which contains the
21299 cursor, the opposite of @kbd{j m}. If the cursor is not inside the
21300 current selection, the command de-selects the formula.
21303 @pindex calc-select-part
21304 The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
21305 select the @var{n}th sub-formula of the current selection. They are
21306 like @kbd{j l} (@code{calc-select-less}) except they use counting
21307 rather than the cursor position to decide which sub-formula to select.
21308 For example, if the current selection is @kbd{a + b + c} or
21309 @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
21310 @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
21311 these cases, @kbd{j 4} through @kbd{j 9} would be errors.
21313 If there is no current selection, @kbd{j 1} through @kbd{j 9} select
21314 the @var{n}th top-level sub-formula. (In other words, they act as if
21315 the entire stack entry were selected first.) To select the @var{n}th
21316 sub-formula where @var{n} is greater than nine, you must instead invoke
21317 @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.@refill
21321 @pindex calc-select-next
21322 @pindex calc-select-previous
21323 The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
21324 (@code{calc-select-previous}) commands change the current selection
21325 to the next or previous sub-formula at the same level. For example,
21326 if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
21327 selects @samp{c}. Further @kbd{j n} commands would be in error because,
21328 even though there is something to the right of @samp{c} (namely, @samp{x}),
21329 it is not at the same level; in this case, it is not a term of the
21330 same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select
21331 the whole product @samp{a*b*c} as a term of the sum) followed by
21332 @w{@kbd{j n}} would successfully select the @samp{x}.
21334 Similarly, @kbd{j p} moves the selection from the @samp{b} in this
21335 sample formula to the @samp{a}. Both commands accept numeric prefix
21336 arguments to move several steps at a time.
21338 It is interesting to compare Calc's selection commands with the
21339 Emacs Info system's commands for navigating through hierarchically
21340 organized documentation. Calc's @kbd{j n} command is completely
21341 analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to
21342 @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
21343 (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
21344 The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
21345 @kbd{j l}; in each case, you can jump directly to a sub-component
21346 of the hierarchy simply by pointing to it with the cursor.
21348 @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
21349 @subsection Displaying Selections
21353 @pindex calc-show-selections
21354 The @kbd{j d} (@code{calc-show-selections}) command controls how
21355 selected sub-formulas are displayed. One of the alternatives is
21356 illustrated in the above examples; if we press @kbd{j d} we switch
21357 to the other style in which the selected portion itself is obscured
21363 (a + b) . . . ## # ## + V c
21364 1* ............... 1* ---------------
21369 @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
21370 @subsection Operating on Selections
21373 Once a selection is made, all Calc commands that manipulate items
21374 on the stack will operate on the selected portions of the items
21375 instead. (Note that several stack elements may have selections
21376 at once, though there can be only one selection at a time in any
21377 given stack element.)
21380 @pindex calc-enable-selections
21381 The @kbd{j e} (@code{calc-enable-selections}) command disables the
21382 effect that selections have on Calc commands. The current selections
21383 still exist, but Calc commands operate on whole stack elements anyway.
21384 This mode can be identified by the fact that the @samp{*} markers on
21385 the line numbers are gone, even though selections are visible. To
21386 reactivate the selections, press @kbd{j e} again.
21388 To extract a sub-formula as a new formula, simply select the
21389 sub-formula and press @key{RET}. This normally duplicates the top
21390 stack element; here it duplicates only the selected portion of that
21393 To replace a sub-formula with something different, you can enter the
21394 new value onto the stack and press @key{TAB}. This normally exchanges
21395 the top two stack elements; here it swaps the value you entered into
21396 the selected portion of the formula, returning the old selected
21397 portion to the top of the stack.
21402 (a + b) . . . 17 x y . . . 17 x y + V c
21403 2* ............... 2* ............. 2: -------------
21404 . . . . . . . . 2 x + 1
21407 1: 17 x y 1: (a + b) 1: (a + b)
21411 In this example we select a sub-formula of our original example,
21412 enter a new formula, @key{TAB} it into place, then deselect to see
21413 the complete, edited formula.
21415 If you want to swap whole formulas around even though they contain
21416 selections, just use @kbd{j e} before and after.
21419 @pindex calc-enter-selection
21420 The @kbd{j '} (@code{calc-enter-selection}) command is another way
21421 to replace a selected sub-formula. This command does an algebraic
21422 entry just like the regular @kbd{'} key. When you press @key{RET},
21423 the formula you type replaces the original selection. You can use
21424 the @samp{$} symbol in the formula to refer to the original
21425 selection. If there is no selection in the formula under the cursor,
21426 the cursor is used to make a temporary selection for the purposes of
21427 the command. Thus, to change a term of a formula, all you have to
21428 do is move the Emacs cursor to that term and press @kbd{j '}.
21431 @pindex calc-edit-selection
21432 The @kbd{j `} (@code{calc-edit-selection}) command is a similar
21433 analogue of the @kbd{`} (@code{calc-edit}) command. It edits the
21434 selected sub-formula in a separate buffer. If there is no
21435 selection, it edits the sub-formula indicated by the cursor.
21437 To delete a sub-formula, press @key{DEL}. This generally replaces
21438 the sub-formula with the constant zero, but in a few suitable contexts
21439 it uses the constant one instead. The @key{DEL} key automatically
21440 deselects and re-simplifies the entire formula afterwards. Thus:
21445 17 x y + # # 17 x y 17 # y 17 y
21446 1* ------------- 1: ------- 1* ------- 1: -------
21447 2 x + 1 2 x + 1 2 x + 1 2 x + 1
21451 In this example, we first delete the @samp{sqrt(c)} term; Calc
21452 accomplishes this by replacing @samp{sqrt(c)} with zero and
21453 resimplifying. We then delete the @kbd{x} in the numerator;
21454 since this is part of a product, Calc replaces it with @samp{1}
21457 If you select an element of a vector and press @key{DEL}, that
21458 element is deleted from the vector. If you delete one side of
21459 an equation or inequality, only the opposite side remains.
21461 @kindex j @key{DEL}
21462 @pindex calc-del-selection
21463 The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
21464 @key{DEL} but with the auto-selecting behavior of @kbd{j '} and
21465 @kbd{j `}. It deletes the selected portion of the formula
21466 indicated by the cursor, or, in the absence of a selection, it
21467 deletes the sub-formula indicated by the cursor position.
21469 @kindex j @key{RET}
21470 @pindex calc-grab-selection
21471 (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
21474 Normal arithmetic operations also apply to sub-formulas. Here we
21475 select the denominator, press @kbd{5 -} to subtract five from the
21476 denominator, press @kbd{n} to negate the denominator, then
21477 press @kbd{Q} to take the square root.
21481 .. . .. . .. . .. .
21482 1* ....... 1* ....... 1* ....... 1* ..........
21483 2 x + 1 2 x - 4 4 - 2 x _________
21488 Certain types of operations on selections are not allowed. For
21489 example, for an arithmetic function like @kbd{-} no more than one of
21490 the arguments may be a selected sub-formula. (As the above example
21491 shows, the result of the subtraction is spliced back into the argument
21492 which had the selection; if there were more than one selection involved,
21493 this would not be well-defined.) If you try to subtract two selections,
21494 the command will abort with an error message.
21496 Operations on sub-formulas sometimes leave the formula as a whole
21497 in an ``un-natural'' state. Consider negating the @samp{2 x} term
21498 of our sample formula by selecting it and pressing @kbd{n}
21499 (@code{calc-change-sign}).@refill
21504 1* .......... 1* ...........
21505 ......... ..........
21506 . . . 2 x . . . -2 x
21510 Unselecting the sub-formula reveals that the minus sign, which would
21511 normally have cancelled out with the subtraction automatically, has
21512 not been able to do so because the subtraction was not part of the
21513 selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
21514 any other mathematical operation on the whole formula will cause it
21520 1: ----------- 1: ----------
21521 __________ _________
21522 V 4 - -2 x V 4 + 2 x
21526 @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
21527 @subsection Rearranging Formulas using Selections
21531 @pindex calc-commute-right
21532 The @kbd{j R} (@code{calc-commute-right}) command moves the selected
21533 sub-formula to the right in its surrounding formula. Generally the
21534 selection is one term of a sum or product; the sum or product is
21535 rearranged according to the commutative laws of algebra.
21537 As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
21538 if there is no selection in the current formula. All commands described
21539 in this section share this property. In this example, we place the
21540 cursor on the @samp{a} and type @kbd{j R}, then repeat.
21543 1: a + b - c 1: b + a - c 1: b - c + a
21547 Note that in the final step above, the @samp{a} is switched with
21548 the @samp{c} but the signs are adjusted accordingly. When moving
21549 terms of sums and products, @kbd{j R} will never change the
21550 mathematical meaning of the formula.
21552 The selected term may also be an element of a vector or an argument
21553 of a function. The term is exchanged with the one to its right.
21554 In this case, the ``meaning'' of the vector or function may of
21555 course be drastically changed.
21558 1: [a, b, c] 1: [b, a, c] 1: [b, c, a]
21560 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a)
21564 @pindex calc-commute-left
21565 The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
21566 except that it swaps the selected term with the one to its left.
21568 With numeric prefix arguments, these commands move the selected
21569 term several steps at a time. It is an error to try to move a
21570 term left or right past the end of its enclosing formula.
21571 With numeric prefix arguments of zero, these commands move the
21572 selected term as far as possible in the given direction.
21575 @pindex calc-sel-distribute
21576 The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
21577 sum or product into the surrounding formula using the distributive
21578 law. For example, in @samp{a * (b - c)} with the @samp{b - c}
21579 selected, the result is @samp{a b - a c}. This also distributes
21580 products or quotients into surrounding powers, and can also do
21581 transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
21582 where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
21583 to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
21585 For multiple-term sums or products, @kbd{j D} takes off one term
21586 at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
21587 with the @samp{c - d} selected so that you can type @kbd{j D}
21588 repeatedly to expand completely. The @kbd{j D} command allows a
21589 numeric prefix argument which specifies the maximum number of
21590 times to expand at once; the default is one time only.
21592 @vindex DistribRules
21593 The @kbd{j D} command is implemented using rewrite rules.
21594 @xref{Selections with Rewrite Rules}. The rules are stored in
21595 the Calc variable @code{DistribRules}. A convenient way to view
21596 these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
21597 displays and edits the stored value of a variable. Press @kbd{M-# M-#}
21598 to return from editing mode; be careful not to make any actual changes
21599 or else you will affect the behavior of future @kbd{j D} commands!
21601 To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
21602 as described above. You can then use the @kbd{s p} command to save
21603 this variable's value permanently for future Calc sessions.
21604 @xref{Operations on Variables}.
21607 @pindex calc-sel-merge
21609 The @kbd{j M} (@code{calc-sel-merge}) command is the complement
21610 of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
21611 @samp{a c} selected, the result is @samp{a * (b - c)}. Once
21612 again, @kbd{j M} can also merge calls to functions like @code{exp}
21613 and @code{ln}; examine the variable @code{MergeRules} to see all
21614 the relevant rules.
21617 @pindex calc-sel-commute
21618 @vindex CommuteRules
21619 The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
21620 of the selected sum, product, or equation. It always behaves as
21621 if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
21622 treated as the nested sums @samp{(a + b) + c} by this command.
21623 If you put the cursor on the first @samp{+}, the result is
21624 @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
21625 result is @samp{c + (a + b)} (which the default simplifications
21626 will rearrange to @samp{(c + a) + b}). The relevant rules are stored
21627 in the variable @code{CommuteRules}.
21629 You may need to turn default simplifications off (with the @kbd{m O}
21630 command) in order to get the full benefit of @kbd{j C}. For example,
21631 commuting @samp{a - b} produces @samp{-b + a}, but the default
21632 simplifications will ``simplify'' this right back to @samp{a - b} if
21633 you don't turn them off. The same is true of some of the other
21634 manipulations described in this section.
21637 @pindex calc-sel-negate
21638 @vindex NegateRules
21639 The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
21640 term with the negative of that term, then adjusts the surrounding
21641 formula in order to preserve the meaning. For example, given
21642 @samp{exp(a - b)} where @samp{a - b} is selected, the result is
21643 @samp{1 / exp(b - a)}. By contrast, selecting a term and using the
21644 regular @kbd{n} (@code{calc-change-sign}) command negates the
21645 term without adjusting the surroundings, thus changing the meaning
21646 of the formula as a whole. The rules variable is @code{NegateRules}.
21649 @pindex calc-sel-invert
21650 @vindex InvertRules
21651 The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
21652 except it takes the reciprocal of the selected term. For example,
21653 given @samp{a - ln(b)} with @samp{b} selected, the result is
21654 @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}.
21657 @pindex calc-sel-jump-equals
21659 The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
21660 selected term from one side of an equation to the other. Given
21661 @samp{a + b = c + d} with @samp{c} selected, the result is
21662 @samp{a + b - c = d}. This command also works if the selected
21663 term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The
21664 relevant rules variable is @code{JumpRules}.
21668 @pindex calc-sel-isolate
21669 The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
21670 selected term on its side of an equation. It uses the @kbd{a S}
21671 (@code{calc-solve-for}) command to solve the equation, and the
21672 Hyperbolic flag affects it in the same way. @xref{Solving Equations}.
21673 When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
21674 It understands more rules of algebra, and works for inequalities
21675 as well as equations.
21679 @pindex calc-sel-mult-both-sides
21680 @pindex calc-sel-div-both-sides
21681 The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
21682 formula using algebraic entry, then multiplies both sides of the
21683 selected quotient or equation by that formula. It simplifies each
21684 side with @kbd{a s} (@code{calc-simplify}) before re-forming the
21685 quotient or equation. You can suppress this simplification by
21686 providing any numeric prefix argument. There is also a @kbd{j /}
21687 (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
21688 dividing instead of multiplying by the factor you enter.
21690 As a special feature, if the numerator of the quotient is 1, then
21691 the denominator is expanded at the top level using the distributive
21692 law (i.e., using the @kbd{C-u -1 a x} command). Suppose the
21693 formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish
21694 to eliminate the square root in the denominator by multiplying both
21695 sides by @samp{sqrt(a) - 1}. Calc's default simplifications would
21696 change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)}
21697 right back to the original form by cancellation; Calc expands the
21698 denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent
21699 this. (You would now want to use an @kbd{a x} command to expand
21700 the rest of the way, whereupon the denominator would cancel out to
21701 the desired form, @samp{a - 1}.) When the numerator is not 1, this
21702 initial expansion is not necessary because Calc's default
21703 simplifications will not notice the potential cancellation.
21705 If the selection is an inequality, @kbd{j *} and @kbd{j /} will
21706 accept any factor, but will warn unless they can prove the factor
21707 is either positive or negative. (In the latter case the direction
21708 of the inequality will be switched appropriately.) @xref{Declarations},
21709 for ways to inform Calc that a given variable is positive or
21710 negative. If Calc can't tell for sure what the sign of the factor
21711 will be, it will assume it is positive and display a warning
21714 For selections that are not quotients, equations, or inequalities,
21715 these commands pull out a multiplicative factor: They divide (or
21716 multiply) by the entered formula, simplify, then multiply (or divide)
21717 back by the formula.
21721 @pindex calc-sel-add-both-sides
21722 @pindex calc-sel-sub-both-sides
21723 The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
21724 (@code{calc-sel-sub-both-sides}) commands analogously add to or
21725 subtract from both sides of an equation or inequality. For other
21726 types of selections, they extract an additive factor. A numeric
21727 prefix argument suppresses simplification of the intermediate
21731 @pindex calc-sel-unpack
21732 The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
21733 selected function call with its argument. For example, given
21734 @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
21735 is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you
21736 wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
21737 now to take the cosine of the selected part.)
21740 @pindex calc-sel-evaluate
21741 The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
21742 normal default simplifications on the selected sub-formula.
21743 These are the simplifications that are normally done automatically
21744 on all results, but which may have been partially inhibited by
21745 previous selection-related operations, or turned off altogether
21746 by the @kbd{m O} command. This command is just an auto-selecting
21747 version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
21749 With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
21750 the @kbd{a s} (@code{calc-simplify}) command to the selected
21751 sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
21752 applies the @kbd{a e} (@code{calc-simplify-extended}) command.
21753 @xref{Simplifying Formulas}. With a negative prefix argument
21754 it simplifies at the top level only, just as with @kbd{a v}.
21755 Here the ``top'' level refers to the top level of the selected
21759 @pindex calc-sel-expand-formula
21760 The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
21761 (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
21763 You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
21764 to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}.
21766 @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
21767 @section Algebraic Manipulation
21770 The commands in this section perform general-purpose algebraic
21771 manipulations. They work on the whole formula at the top of the
21772 stack (unless, of course, you have made a selection in that
21775 Many algebra commands prompt for a variable name or formula. If you
21776 answer the prompt with a blank line, the variable or formula is taken
21777 from top-of-stack, and the normal argument for the command is taken
21778 from the second-to-top stack level.
21781 @pindex calc-alg-evaluate
21782 The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
21783 default simplifications on a formula; for example, @samp{a - -b} is
21784 changed to @samp{a + b}. These simplifications are normally done
21785 automatically on all Calc results, so this command is useful only if
21786 you have turned default simplifications off with an @kbd{m O}
21787 command. @xref{Simplification Modes}.
21789 It is often more convenient to type @kbd{=}, which is like @kbd{a v}
21790 but which also substitutes stored values for variables in the formula.
21791 Use @kbd{a v} if you want the variables to ignore their stored values.
21793 If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
21794 as if in algebraic simplification mode. This is equivalent to typing
21795 @kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix
21796 of 3 or more, it uses extended simplification mode (@kbd{a e}).
21798 If you give a negative prefix argument @i{-1}, @i{-2}, or @i{-3},
21799 it simplifies in the corresponding mode but only works on the top-level
21800 function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will
21801 simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
21802 @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector
21803 @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
21804 in no-simplify mode. Using @kbd{a v} will evaluate this all the way to
21805 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
21806 (@xref{Reducing and Mapping}.)
21810 The @kbd{=} command corresponds to the @code{evalv} function, and
21811 the related @kbd{N} command, which is like @kbd{=} but temporarily
21812 disables symbolic (@kbd{m s}) mode during the evaluation, corresponds
21813 to the @code{evalvn} function. (These commands interpret their prefix
21814 arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
21815 the number of stack elements to evaluate at once, and @kbd{N} treats
21816 it as a temporary different working precision.)
21818 The @code{evalvn} function can take an alternate working precision
21819 as an optional second argument. This argument can be either an
21820 integer, to set the precision absolutely, or a vector containing
21821 a single integer, to adjust the precision relative to the current
21822 precision. Note that @code{evalvn} with a larger than current
21823 precision will do the calculation at this higher precision, but the
21824 result will as usual be rounded back down to the current precision
21825 afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision
21826 of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
21827 will return @samp{9.26535897932e-5} (computing a 25-digit result which
21828 is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
21829 will return @samp{9.2654e-5}.
21832 @pindex calc-expand-formula
21833 The @kbd{a "} (@code{calc-expand-formula}) command expands functions
21834 into their defining formulas wherever possible. For example,
21835 @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions,
21836 like @code{sin} and @code{gcd}, are not defined by simple formulas
21837 and so are unaffected by this command. One important class of
21838 functions which @emph{can} be expanded is the user-defined functions
21839 created by the @kbd{Z F} command. @xref{Algebraic Definitions}.
21840 Other functions which @kbd{a "} can expand include the probability
21841 distribution functions, most of the financial functions, and the
21842 hyperbolic and inverse hyperbolic functions. A numeric prefix argument
21843 affects @kbd{a "} in the same way as it does @kbd{a v}: A positive
21844 argument expands all functions in the formula and then simplifies in
21845 various ways; a negative argument expands and simplifies only the
21846 top-level function call.
21849 @pindex calc-map-equation
21851 The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
21852 a given function or operator to one or more equations. It is analogous
21853 to @kbd{V M}, which operates on vectors instead of equations.
21854 @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes
21855 @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
21856 @samp{x = y+1} and @cite{6} on the stack produces @samp{x+6 = y+7}.
21857 With two equations on the stack, @kbd{a M +} would add the lefthand
21858 sides together and the righthand sides together to get the two
21859 respective sides of a new equation.
21861 Mapping also works on inequalities. Mapping two similar inequalities
21862 produces another inequality of the same type. Mapping an inequality
21863 with an equation produces an inequality of the same type. Mapping a
21864 @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
21865 If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
21866 are mapped, the direction of the second inequality is reversed to
21867 match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
21868 reverses the latter to get @samp{2 < a}, which then allows the
21869 combination @samp{a + 2 < b + a}, which the @kbd{a s} command can
21870 then simplify to get @samp{2 < b}.
21872 Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
21873 or invert an inequality will reverse the direction of the inequality.
21874 Other adjustments to inequalities are @emph{not} done automatically;
21875 @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
21876 though this is not true for all values of the variables.
21880 With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
21881 mapping operation without reversing the direction of any inequalities.
21882 Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
21883 (This change is mathematically incorrect, but perhaps you were
21884 fixing an inequality which was already incorrect.)
21888 With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
21889 the direction of the inequality. You might use @kbd{I a M C} to
21890 change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
21891 working with small positive angles.
21894 @pindex calc-substitute
21896 The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
21898 of some variable or sub-expression of an expression with a new
21899 sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)}
21900 in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
21901 @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
21902 Note that this is a purely structural substitution; the lone @samp{x} and
21903 the @samp{sin(2 x)} stayed the same because they did not look like
21904 @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for
21905 doing substitutions.@refill
21907 The @kbd{a b} command normally prompts for two formulas, the old
21908 one and the new one. If you enter a blank line for the first
21909 prompt, all three arguments are taken from the stack (new, then old,
21910 then target expression). If you type an old formula but then enter a
21911 blank line for the new one, the new formula is taken from top-of-stack
21912 and the target from second-to-top. If you answer both prompts, the
21913 target is taken from top-of-stack as usual.
21915 Note that @kbd{a b} has no understanding of commutativity or
21916 associativity. The pattern @samp{x+y} will not match the formula
21917 @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
21918 because the @samp{+} operator is left-associative, so the ``deep
21919 structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U}
21920 (@code{calc-unformatted-language}) mode to see the true structure of
21921 a formula. The rewrite rule mechanism, discussed later, does not have
21924 As an algebraic function, @code{subst} takes three arguments:
21925 Target expression, old, new. Note that @code{subst} is always
21926 evaluated immediately, even if its arguments are variables, so if
21927 you wish to put a call to @code{subst} onto the stack you must
21928 turn the default simplifications off first (with @kbd{m O}).
21930 @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
21931 @section Simplifying Formulas
21935 @pindex calc-simplify
21937 The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies
21938 various algebraic rules to simplify a formula. This includes rules which
21939 are not part of the default simplifications because they may be too slow
21940 to apply all the time, or may not be desirable all of the time. For
21941 example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a}
21942 to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are
21943 simplified to @samp{x}.
21945 The sections below describe all the various kinds of algebraic
21946 simplifications Calc provides in full detail. None of Calc's
21947 simplification commands are designed to pull rabbits out of hats;
21948 they simply apply certain specific rules to put formulas into
21949 less redundant or more pleasing forms. Serious algebra in Calc
21950 must be done manually, usually with a combination of selections
21951 and rewrite rules. @xref{Rearranging with Selections}.
21952 @xref{Rewrite Rules}.
21954 @xref{Simplification Modes}, for commands to control what level of
21955 simplification occurs automatically. Normally only the ``default
21956 simplifications'' occur.
21959 * Default Simplifications::
21960 * Algebraic Simplifications::
21961 * Unsafe Simplifications::
21962 * Simplification of Units::
21965 @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
21966 @subsection Default Simplifications
21969 @cindex Default simplifications
21970 This section describes the ``default simplifications,'' those which are
21971 normally applied to all results. For example, if you enter the variable
21972 @cite{x} on the stack twice and push @kbd{+}, Calc's default
21973 simplifications automatically change @cite{x + x} to @cite{2 x}.
21975 The @kbd{m O} command turns off the default simplifications, so that
21976 @cite{x + x} will remain in this form unless you give an explicit
21977 ``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic
21978 Manipulation}. The @kbd{m D} command turns the default simplifications
21981 The most basic default simplification is the evaluation of functions.
21982 For example, @cite{2 + 3} is evaluated to @cite{5}, and @cite{@t{sqrt}(9)}
21983 is evaluated to @cite{3}. Evaluation does not occur if the arguments
21984 to a function are somehow of the wrong type (@cite{@t{tan}([2,3,4])},
21985 range (@cite{@t{tan}(90)}), or number (@cite{@t{tan}(3,5)}), or if the
21986 function name is not recognized (@cite{@t{f}(5)}), or if ``symbolic''
21987 mode (@pxref{Symbolic Mode}) prevents evaluation (@cite{@t{sqrt}(2)}).
21989 Calc simplifies (evaluates) the arguments to a function before it
21990 simplifies the function itself. Thus @cite{@t{sqrt}(5+4)} is
21991 simplified to @cite{@t{sqrt}(9)} before the @code{sqrt} function
21992 itself is applied. There are very few exceptions to this rule:
21993 @code{quote}, @code{lambda}, and @code{condition} (the @code{::}
21994 operator) do not evaluate their arguments, @code{if} (the @code{? :}
21995 operator) does not evaluate all of its arguments, and @code{evalto}
21996 does not evaluate its lefthand argument.
21998 Most commands apply the default simplifications to all arguments they
21999 take from the stack, perform a particular operation, then simplify
22000 the result before pushing it back on the stack. In the common special
22001 case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}],
22002 the arguments are simply popped from the stack and collected into a
22003 suitable function call, which is then simplified (the arguments being
22004 simplified first as part of the process, as described above).
22006 The default simplifications are too numerous to describe completely
22007 here, but this section will describe the ones that apply to the
22008 major arithmetic operators. This list will be rather technical in
22009 nature, and will probably be interesting to you only if you are
22010 a serious user of Calc's algebra facilities.
22016 As well as the simplifications described here, if you have stored
22017 any rewrite rules in the variable @code{EvalRules} then these rules
22018 will also be applied before any built-in default simplifications.
22019 @xref{Automatic Rewrites}, for details.
22025 And now, on with the default simplifications:
22027 Arithmetic operators like @kbd{+} and @kbd{*} always take two
22028 arguments in Calc's internal form. Sums and products of three or
22029 more terms are arranged by the associative law of algebra into
22030 a left-associative form for sums, @cite{((a + b) + c) + d}, and
22031 a right-associative form for products, @cite{a * (b * (c * d))}.
22032 Formulas like @cite{(a + b) + (c + d)} are rearranged to
22033 left-associative form, though this rarely matters since Calc's
22034 algebra commands are designed to hide the inner structure of
22035 sums and products as much as possible. Sums and products in
22036 their proper associative form will be written without parentheses
22037 in the examples below.
22039 Sums and products are @emph{not} rearranged according to the
22040 commutative law (@cite{a + b} to @cite{b + a}) except in a few
22041 special cases described below. Some algebra programs always
22042 rearrange terms into a canonical order, which enables them to
22043 see that @cite{a b + b a} can be simplified to @cite{2 a b}.
22044 Calc assumes you have put the terms into the order you want
22045 and generally leaves that order alone, with the consequence
22046 that formulas like the above will only be simplified if you
22047 explicitly give the @kbd{a s} command. @xref{Algebraic
22050 Differences @cite{a - b} are treated like sums @cite{a + (-b)}
22051 for purposes of simplification; one of the default simplifications
22052 is to rewrite @cite{a + (-b)} or @cite{(-b) + a}, where @cite{-b}
22053 represents a ``negative-looking'' term, into @cite{a - b} form.
22054 ``Negative-looking'' means negative numbers, negated formulas like
22055 @cite{-x}, and products or quotients in which either term is
22058 Other simplifications involving negation are @cite{-(-x)} to @cite{x};
22059 @cite{-(a b)} or @cite{-(a/b)} where either @cite{a} or @cite{b} is
22060 negative-looking, simplified by negating that term, or else where
22061 @cite{a} or @cite{b} is any number, by negating that number;
22062 @cite{-(a + b)} to @cite{-a - b}, and @cite{-(b - a)} to @cite{a - b}.
22063 (This, and rewriting @cite{(-b) + a} to @cite{a - b}, are the only
22064 cases where the order of terms in a sum is changed by the default
22067 The distributive law is used to simplify sums in some cases:
22068 @cite{a x + b x} to @cite{(a + b) x}, where @cite{a} represents
22069 a number or an implicit 1 or @i{-1} (as in @cite{x} or @cite{-x})
22070 and similarly for @cite{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or
22071 @kbd{j M} commands to merge sums with non-numeric coefficients
22072 using the distributive law.
22074 The distributive law is only used for sums of two terms, or
22075 for adjacent terms in a larger sum. Thus @cite{a + b + b + c}
22076 is simplified to @cite{a + 2 b + c}, but @cite{a + b + c + b}
22077 is not simplified. The reason is that comparing all terms of a
22078 sum with one another would require time proportional to the
22079 square of the number of terms; Calc relegates potentially slow
22080 operations like this to commands that have to be invoked
22081 explicitly, like @kbd{a s}.
22083 Finally, @cite{a + 0} and @cite{0 + a} are simplified to @cite{a}.
22084 A consequence of the above rules is that @cite{0 - a} is simplified
22091 The products @cite{1 a} and @cite{a 1} are simplified to @cite{a};
22092 @cite{(-1) a} and @cite{a (-1)} are simplified to @cite{-a};
22093 @cite{0 a} and @cite{a 0} are simplified to @cite{0}, except that
22094 in matrix mode where @cite{a} is not provably scalar the result
22095 is the generic zero matrix @samp{idn(0)}, and that if @cite{a} is
22096 infinite the result is @samp{nan}.
22098 Also, @cite{(-a) b} and @cite{a (-b)} are simplified to @cite{-(a b)},
22099 where this occurs for negated formulas but not for regular negative
22102 Products are commuted only to move numbers to the front:
22103 @cite{a b 2} is commuted to @cite{2 a b}.
22105 The product @cite{a (b + c)} is distributed over the sum only if
22106 @cite{a} and at least one of @cite{b} and @cite{c} are numbers:
22107 @cite{2 (x + 3)} goes to @cite{2 x + 6}. The formula
22108 @cite{(-a) (b - c)}, where @cite{-a} is a negative number, is
22109 rewritten to @cite{a (c - b)}.
22111 The distributive law of products and powers is used for adjacent
22112 terms of the product: @cite{x^a x^b} goes to @c{$x^{a+b}$}
22114 where @cite{a} is a number, or an implicit 1 (as in @cite{x}),
22115 or the implicit one-half of @cite{@t{sqrt}(x)}, and similarly for
22116 @cite{b}. The result is written using @samp{sqrt} or @samp{1/sqrt}
22117 if the sum of the powers is @cite{1/2} or @cite{-1/2}, respectively.
22118 If the sum of the powers is zero, the product is simplified to
22119 @cite{1} or to @samp{idn(1)} if matrix mode is enabled.
22121 The product of a negative power times anything but another negative
22122 power is changed to use division: @c{$x^{-2} y$}
22123 @cite{x^(-2) y} goes to @cite{y / x^2} unless matrix mode is
22124 in effect and neither @cite{x} nor @cite{y} are scalar (in which
22125 case it is considered unsafe to rearrange the order of the terms).
22127 Finally, @cite{a (b/c)} is rewritten to @cite{(a b)/c}, and also
22128 @cite{(a/b) c} is changed to @cite{(a c)/b} unless in matrix mode.
22134 Simplifications for quotients are analogous to those for products.
22135 The quotient @cite{0 / x} is simplified to @cite{0}, with the same
22136 exceptions that were noted for @cite{0 x}. Likewise, @cite{x / 1}
22137 and @cite{x / (-1)} are simplified to @cite{x} and @cite{-x},
22140 The quotient @cite{x / 0} is left unsimplified or changed to an
22141 infinite quantity, as directed by the current infinite mode.
22142 @xref{Infinite Mode}.
22144 The expression @c{$a / b^{-c}$}
22145 @cite{a / b^(-c)} is changed to @cite{a b^c},
22146 where @cite{-c} is any negative-looking power. Also, @cite{1 / b^c}
22147 is changed to @c{$b^{-c}$}
22148 @cite{b^(-c)} for any power @cite{c}.
22150 Also, @cite{(-a) / b} and @cite{a / (-b)} go to @cite{-(a/b)};
22151 @cite{(a/b) / c} goes to @cite{a / (b c)}; and @cite{a / (b/c)}
22152 goes to @cite{(a c) / b} unless matrix mode prevents this
22153 rearrangement. Similarly, @cite{a / (b:c)} is simplified to
22154 @cite{(c:b) a} for any fraction @cite{b:c}.
22156 The distributive law is applied to @cite{(a + b) / c} only if
22157 @cite{c} and at least one of @cite{a} and @cite{b} are numbers.
22158 Quotients of powers and square roots are distributed just as
22159 described for multiplication.
22161 Quotients of products cancel only in the leading terms of the
22162 numerator and denominator. In other words, @cite{a x b / a y b}
22163 is cancelled to @cite{x b / y b} but not to @cite{x / y}. Once
22164 again this is because full cancellation can be slow; use @kbd{a s}
22165 to cancel all terms of the quotient.
22167 Quotients of negative-looking values are simplified according
22168 to @cite{(-a) / (-b)} to @cite{a / b}, @cite{(-a) / (b - c)}
22169 to @cite{a / (c - b)}, and @cite{(a - b) / (-c)} to @cite{(b - a) / c}.
22175 The formula @cite{x^0} is simplified to @cite{1}, or to @samp{idn(1)}
22176 in matrix mode. The formula @cite{0^x} is simplified to @cite{0}
22177 unless @cite{x} is a negative number or complex number, in which
22178 case the result is an infinity or an unsimplified formula according
22179 to the current infinite mode. Note that @cite{0^0} is an
22180 indeterminate form, as evidenced by the fact that the simplifications
22181 for @cite{x^0} and @cite{0^x} conflict when @cite{x=0}.
22183 Powers of products or quotients @cite{(a b)^c}, @cite{(a/b)^c}
22184 are distributed to @cite{a^c b^c}, @cite{a^c / b^c} only if @cite{c}
22185 is an integer, or if either @cite{a} or @cite{b} are nonnegative
22186 real numbers. Powers of powers @cite{(a^b)^c} are simplified to
22188 @cite{a^(b c)} only when @cite{c} is an integer and @cite{b c} also
22189 evaluates to an integer. Without these restrictions these simplifications
22190 would not be safe because of problems with principal values.
22191 (In other words, @c{$((-3)^{1/2})^2$}
22192 @cite{((-3)^1:2)^2} is safe to simplify, but
22193 @c{$((-3)^2)^{1/2}$}
22194 @cite{((-3)^2)^1:2} is not.) @xref{Declarations}, for ways to inform
22195 Calc that your variables satisfy these requirements.
22197 As a special case of this rule, @cite{@t{sqrt}(x)^n} is simplified to
22199 @cite{x^(n/2)} only for even integers @cite{n}.
22201 If @cite{a} is known to be real, @cite{b} is an even integer, and
22202 @cite{c} is a half- or quarter-integer, then @cite{(a^b)^c} is
22203 simplified to @c{$@t{abs}(a^{b c})$}
22204 @cite{@t{abs}(a^(b c))}.
22206 Also, @cite{(-a)^b} is simplified to @cite{a^b} if @cite{b} is an
22207 even integer, or to @cite{-(a^b)} if @cite{b} is an odd integer,
22208 for any negative-looking expression @cite{-a}.
22210 Square roots @cite{@t{sqrt}(x)} generally act like one-half powers
22212 @cite{x^1:2} for the purposes of the above-listed simplifications.
22214 Also, note that @c{$1 / x^{1:2}$}
22215 @cite{1 / x^1:2} is changed to @c{$x^{-1:2}$}
22217 but @cite{1 / @t{sqrt}(x)} is left alone.
22223 Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
22224 following rules: @cite{@t{idn}(a) + b} to @cite{a + b} if @cite{b}
22225 is provably scalar, or expanded out if @cite{b} is a matrix;
22226 @cite{@t{idn}(a) + @t{idn}(b)} to @cite{@t{idn}(a + b)};
22227 @cite{-@t{idn}(a)} to @cite{@t{idn}(-a)}; @cite{a @t{idn}(b)} to
22228 @cite{@t{idn}(a b)} if @cite{a} is provably scalar, or to @cite{a b}
22229 if @cite{a} is provably non-scalar; @cite{@t{idn}(a) @t{idn}(b)}
22230 to @cite{@t{idn}(a b)}; analogous simplifications for quotients
22231 involving @code{idn}; and @cite{@t{idn}(a)^n} to @cite{@t{idn}(a^n)}
22232 where @cite{n} is an integer.
22238 The @code{floor} function and other integer truncation functions
22239 vanish if the argument is provably integer-valued, so that
22240 @cite{@t{floor}(@t{round}(x))} simplifies to @cite{@t{round}(x)}.
22241 Also, combinations of @code{float}, @code{floor} and its friends,
22242 and @code{ffloor} and its friends, are simplified in appropriate
22243 ways. @xref{Integer Truncation}.
22245 The expression @cite{@t{abs}(-x)} changes to @cite{@t{abs}(x)}.
22246 The expression @cite{@t{abs}(@t{abs}(x))} changes to @cite{@t{abs}(x)};
22247 in fact, @cite{@t{abs}(x)} changes to @cite{x} or @cite{-x} if @cite{x}
22248 is provably nonnegative or nonpositive (@pxref{Declarations}).
22250 While most functions do not recognize the variable @code{i} as an
22251 imaginary number, the @code{arg} function does handle the two cases
22252 @cite{@t{arg}(@t{i})} and @cite{@t{arg}(-@t{i})} just for convenience.
22254 The expression @cite{@t{conj}(@t{conj}(x))} simplifies to @cite{x}.
22255 Various other expressions involving @code{conj}, @code{re}, and
22256 @code{im} are simplified, especially if some of the arguments are
22257 provably real or involve the constant @code{i}. For example,
22258 @cite{@t{conj}(a + b i)} is changed to @cite{@t{conj}(a) - @t{conj}(b) i},
22259 or to @cite{a - b i} if @cite{a} and @cite{b} are known to be real.
22261 Functions like @code{sin} and @code{arctan} generally don't have
22262 any default simplifications beyond simply evaluating the functions
22263 for suitable numeric arguments and infinity. The @kbd{a s} command
22264 described in the next section does provide some simplifications for
22265 these functions, though.
22267 One important simplification that does occur is that @cite{@t{ln}(@t{e})}
22268 is simplified to 1, and @cite{@t{ln}(@t{e}^x)} is simplified to @cite{x}
22269 for any @cite{x}. This occurs even if you have stored a different
22270 value in the Calc variable @samp{e}; but this would be a bad idea
22271 in any case if you were also using natural logarithms!
22273 Among the logical functions, @t{(@var{a} <= @var{b})} changes to
22274 @t{@var{a} > @var{b}} and so on. Equations and inequalities where both sides
22275 are either negative-looking or zero are simplified by negating both sides
22276 and reversing the inequality. While it might seem reasonable to simplify
22277 @cite{!!x} to @cite{x}, this would not be valid in general because
22278 @cite{!!2} is 1, not 2.
22280 Most other Calc functions have few if any default simplifications
22281 defined, aside of course from evaluation when the arguments are
22284 @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas
22285 @subsection Algebraic Simplifications
22288 @cindex Algebraic simplifications
22289 The @kbd{a s} command makes simplifications that may be too slow to
22290 do all the time, or that may not be desirable all of the time.
22291 If you find these simplifications are worthwhile, you can type
22292 @kbd{m A} to have Calc apply them automatically.
22294 This section describes all simplifications that are performed by
22295 the @kbd{a s} command. Note that these occur in addition to the
22296 default simplifications; even if the default simplifications have
22297 been turned off by an @kbd{m O} command, @kbd{a s} will turn them
22298 back on temporarily while it simplifies the formula.
22300 There is a variable, @code{AlgSimpRules}, in which you can put rewrites
22301 to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules},
22302 but without the special restrictions. Basically, the simplifier does
22303 @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
22304 expression being simplified, then it traverses the expression applying
22305 the built-in rules described below. If the result is different from
22306 the original expression, the process repeats with the default
22307 simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
22308 then the built-in simplifications, and so on.
22314 Sums are simplified in two ways. Constant terms are commuted to the
22315 end of the sum, so that @cite{a + 2 + b} changes to @cite{a + b + 2}.
22316 The only exception is that a constant will not be commuted away
22317 from the first position of a difference, i.e., @cite{2 - x} is not
22318 commuted to @cite{-x + 2}.
22320 Also, terms of sums are combined by the distributive law, as in
22321 @cite{x + y + 2 x} to @cite{y + 3 x}. This always occurs for
22322 adjacent terms, but @kbd{a s} compares all pairs of terms including
22329 Products are sorted into a canonical order using the commutative
22330 law. For example, @cite{b c a} is commuted to @cite{a b c}.
22331 This allows easier comparison of products; for example, the default
22332 simplifications will not change @cite{x y + y x} to @cite{2 x y},
22333 but @kbd{a s} will; it first rewrites the sum to @cite{x y + x y},
22334 and then the default simplifications are able to recognize a sum
22335 of identical terms.
22337 The canonical ordering used to sort terms of products has the
22338 property that real-valued numbers, interval forms and infinities
22339 come first, and are sorted into increasing order. The @kbd{V S}
22340 command uses the same ordering when sorting a vector.
22342 Sorting of terms of products is inhibited when matrix mode is
22343 turned on; in this case, Calc will never exchange the order of
22344 two terms unless it knows at least one of the terms is a scalar.
22346 Products of powers are distributed by comparing all pairs of
22347 terms, using the same method that the default simplifications
22348 use for adjacent terms of products.
22350 Even though sums are not sorted, the commutative law is still
22351 taken into account when terms of a product are being compared.
22352 Thus @cite{(x + y) (y + x)} will be simplified to @cite{(x + y)^2}.
22353 A subtle point is that @cite{(x - y) (y - x)} will @emph{not}
22354 be simplified to @cite{-(x - y)^2}; Calc does not notice that
22355 one term can be written as a constant times the other, even if
22356 that constant is @i{-1}.
22358 A fraction times any expression, @cite{(a:b) x}, is changed to
22359 a quotient involving integers: @cite{a x / b}. This is not
22360 done for floating-point numbers like @cite{0.5}, however. This
22361 is one reason why you may find it convenient to turn Fraction mode
22362 on while doing algebra; @pxref{Fraction Mode}.
22368 Quotients are simplified by comparing all terms in the numerator
22369 with all terms in the denominator for possible cancellation using
22370 the distributive law. For example, @cite{a x^2 b / c x^3 d} will
22371 cancel @cite{x^2} from both sides to get @cite{a b / c x d}.
22372 (The terms in the denominator will then be rearranged to @cite{c d x}
22373 as described above.) If there is any common integer or fractional
22374 factor in the numerator and denominator, it is cancelled out;
22375 for example, @cite{(4 x + 6) / 8 x} simplifies to @cite{(2 x + 3) / 4 x}.
22377 Non-constant common factors are not found even by @kbd{a s}. To
22378 cancel the factor @cite{a} in @cite{(a x + a) / a^2} you could first
22379 use @kbd{j M} on the product @cite{a x} to Merge the numerator to
22380 @cite{a (1+x)}, which can then be simplified successfully.
22386 Integer powers of the variable @code{i} are simplified according
22387 to the identity @cite{i^2 = -1}. If you store a new value other
22388 than the complex number @cite{(0,1)} in @code{i}, this simplification
22389 will no longer occur. This is done by @kbd{a s} instead of by default
22390 in case someone (unwisely) uses the name @code{i} for a variable
22391 unrelated to complex numbers; it would be unfortunate if Calc
22392 quietly and automatically changed this formula for reasons the
22393 user might not have been thinking of.
22395 Square roots of integer or rational arguments are simplified in
22396 several ways. (Note that these will be left unevaluated only in
22397 Symbolic mode.) First, square integer or rational factors are
22398 pulled out so that @cite{@t{sqrt}(8)} is rewritten as
22399 @c{$2\,\t{sqrt}(2)$}
22400 @cite{2 sqrt(2)}. Conceptually speaking this implies factoring
22401 the argument into primes and moving pairs of primes out of the
22402 square root, but for reasons of efficiency Calc only looks for
22405 Square roots in the denominator of a quotient are moved to the
22406 numerator: @cite{1 / @t{sqrt}(3)} changes to @cite{@t{sqrt}(3) / 3}.
22407 The same effect occurs for the square root of a fraction:
22408 @cite{@t{sqrt}(2:3)} changes to @cite{@t{sqrt}(6) / 3}.
22414 The @code{%} (modulo) operator is simplified in several ways
22415 when the modulus @cite{M} is a positive real number. First, if
22416 the argument is of the form @cite{x + n} for some real number
22417 @cite{n}, then @cite{n} is itself reduced modulo @cite{M}. For
22418 example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
22420 If the argument is multiplied by a constant, and this constant
22421 has a common integer divisor with the modulus, then this factor is
22422 cancelled out. For example, @samp{12 x % 15} is changed to
22423 @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
22424 is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
22425 not seem ``simpler,'' they allow Calc to discover useful information
22426 about modulo forms in the presence of declarations.
22428 If the modulus is 1, then Calc can use @code{int} declarations to
22429 evaluate the expression. For example, the idiom @samp{x % 2} is
22430 often used to check whether a number is odd or even. As described
22431 above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
22432 @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
22433 can simplify these to 0 and 1 (respectively) if @code{n} has been
22434 declared to be an integer.
22440 Trigonometric functions are simplified in several ways. First,
22441 @cite{@t{sin}(@t{arcsin}(x))} is simplified to @cite{x}, and
22442 similarly for @code{cos} and @code{tan}. If the argument to
22443 @code{sin} is negative-looking, it is simplified to @cite{-@t{sin}(x)},
22444 and similarly for @code{cos} and @code{tan}. Finally, certain
22445 special values of the argument are recognized;
22446 @pxref{Trigonometric and Hyperbolic Functions}.
22448 Trigonometric functions of inverses of different trigonometric
22449 functions can also be simplified, as in @cite{@t{sin}(@t{arccos}(x))}
22450 to @cite{@t{sqrt}(1 - x^2)}.
22452 Hyperbolic functions of their inverses and of negative-looking
22453 arguments are also handled, as are exponentials of inverse
22454 hyperbolic functions.
22456 No simplifications for inverse trigonometric and hyperbolic
22457 functions are known, except for negative arguments of @code{arcsin},
22458 @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that
22459 @cite{@t{arcsin}(@t{sin}(x))} can @emph{not} safely change to
22460 @cite{x}, since this only correct within an integer multiple
22462 @cite{2 pi} radians or 360 degrees. However,
22463 @cite{@t{arcsinh}(@t{sinh}(x))} is simplified to @cite{x} if
22464 @cite{x} is known to be real.
22466 Several simplifications that apply to logarithms and exponentials
22467 are that @cite{@t{exp}(@t{ln}(x))}, @c{$@t{e}^{\ln(x)}$}
22468 @cite{e^@t{ln}(x)}, and
22469 @c{$10^{{\rm log10}(x)}$}
22470 @cite{10^@t{log10}(x)} all reduce to @cite{x}.
22471 Also, @cite{@t{ln}(@t{exp}(x))}, etc., can reduce to @cite{x} if
22472 @cite{x} is provably real. The form @cite{@t{exp}(x)^y} is simplified
22473 to @cite{@t{exp}(x y)}. If @cite{x} is a suitable multiple of @c{$\pi i$}
22475 (as described above for the trigonometric functions), then @cite{@t{exp}(x)}
22476 or @cite{e^x} will be expanded. Finally, @cite{@t{ln}(x)} is simplified
22477 to a form involving @code{pi} and @code{i} where @cite{x} is provably
22478 negative, positive imaginary, or negative imaginary.
22480 The error functions @code{erf} and @code{erfc} are simplified when
22481 their arguments are negative-looking or are calls to the @code{conj}
22488 Equations and inequalities are simplified by cancelling factors
22489 of products, quotients, or sums on both sides. Inequalities
22490 change sign if a negative multiplicative factor is cancelled.
22491 Non-constant multiplicative factors as in @cite{a b = a c} are
22492 cancelled from equations only if they are provably nonzero (generally
22493 because they were declared so; @pxref{Declarations}). Factors
22494 are cancelled from inequalities only if they are nonzero and their
22497 Simplification also replaces an equation or inequality with
22498 1 or 0 (``true'' or ``false'') if it can through the use of
22499 declarations. If @cite{x} is declared to be an integer greater
22500 than 5, then @cite{x < 3}, @cite{x = 3}, and @cite{x = 7.5} are
22501 all simplified to 0, but @cite{x > 3} is simplified to 1.
22502 By a similar analysis, @cite{abs(x) >= 0} is simplified to 1,
22503 as is @cite{x^2 >= 0} if @cite{x} is known to be real.
22505 @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
22506 @subsection ``Unsafe'' Simplifications
22509 @cindex Unsafe simplifications
22510 @cindex Extended simplification
22512 @pindex calc-simplify-extended
22514 @mindex esimpl@idots
22517 The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command
22519 except that it applies some additional simplifications which are not
22520 ``safe'' in all cases. Use this only if you know the values in your
22521 formula lie in the restricted ranges for which these simplifications
22522 are valid. The symbolic integrator uses @kbd{a e};
22523 one effect of this is that the integrator's results must be used with
22524 caution. Where an integral table will often attach conditions like
22525 ``for positive @cite{a} only,'' Calc (like most other symbolic
22526 integration programs) will simply produce an unqualified result.@refill
22528 Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
22529 to type @kbd{C-u -3 a v}, which does extended simplification only
22530 on the top level of the formula without affecting the sub-formulas.
22531 In fact, @kbd{C-u -3 j v} allows you to target extended simplification
22532 to any specific part of a formula.
22534 The variable @code{ExtSimpRules} contains rewrites to be applied by
22535 the @kbd{a e} command. These are applied in addition to
22536 @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules}
22537 step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
22539 Following is a complete list of ``unsafe'' simplifications performed
22546 Inverse trigonometric or hyperbolic functions, called with their
22547 corresponding non-inverse functions as arguments, are simplified
22548 by @kbd{a e}. For example, @cite{@t{arcsin}(@t{sin}(x))} changes
22549 to @cite{x}. Also, @cite{@t{arcsin}(@t{cos}(x))} and
22550 @cite{@t{arccos}(@t{sin}(x))} both change to @cite{@t{pi}/2 - x}.
22551 These simplifications are unsafe because they are valid only for
22552 values of @cite{x} in a certain range; outside that range, values
22553 are folded down to the 360-degree range that the inverse trigonometric
22554 functions always produce.
22556 Powers of powers @cite{(x^a)^b} are simplified to @c{$x^{a b}$}
22558 for all @cite{a} and @cite{b}. These results will be valid only
22559 in a restricted range of @cite{x}; for example, in @c{$(x^2)^{1:2}$}
22561 the powers cancel to get @cite{x}, which is valid for positive values
22562 of @cite{x} but not for negative or complex values.
22564 Similarly, @cite{@t{sqrt}(x^a)} and @cite{@t{sqrt}(x)^a} are both
22565 simplified (possibly unsafely) to @c{$x^{a/2}$}
22568 Forms like @cite{@t{sqrt}(1 - @t{sin}(x)^2)} are simplified to, e.g.,
22569 @cite{@t{cos}(x)}. Calc has identities of this sort for @code{sin},
22570 @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
22572 Arguments of square roots are partially factored to look for
22573 squared terms that can be extracted. For example,
22574 @cite{@t{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to @cite{a b @t{sqrt}(a+b)}.
22576 The simplifications of @cite{@t{ln}(@t{exp}(x))}, @cite{@t{ln}(@t{e}^x)},
22577 and @cite{@t{log10}(10^x)} to @cite{x} are also unsafe because
22578 of problems with principal values (although these simplifications
22579 are safe if @cite{x} is known to be real).
22581 Common factors are cancelled from products on both sides of an
22582 equation, even if those factors may be zero: @cite{a x / b x}
22583 to @cite{a / b}. Such factors are never cancelled from
22584 inequalities: Even @kbd{a e} is not bold enough to reduce
22585 @cite{a x < b x} to @cite{a < b} (or @cite{a > b}, depending
22586 on whether you believe @cite{x} is positive or negative).
22587 The @kbd{a M /} command can be used to divide a factor out of
22588 both sides of an inequality.
22590 @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
22591 @subsection Simplification of Units
22594 The simplifications described in this section are applied by the
22595 @kbd{u s} (@code{calc-simplify-units}) command. These are in addition
22596 to the regular @kbd{a s} (but not @kbd{a e}) simplifications described
22597 earlier. @xref{Basic Operations on Units}.
22599 The variable @code{UnitSimpRules} contains rewrites to be applied by
22600 the @kbd{u s} command. These are applied in addition to @code{EvalRules}
22601 and @code{AlgSimpRules}.
22603 Scalar mode is automatically put into effect when simplifying units.
22604 @xref{Matrix Mode}.
22606 Sums @cite{a + b} involving units are simplified by extracting the
22607 units of @cite{a} as if by the @kbd{u x} command (call the result
22608 @cite{u_a}), then simplifying the expression @cite{b / u_a}
22609 using @kbd{u b} and @kbd{u s}. If the result has units then the sum
22610 is inconsistent and is left alone. Otherwise, it is rewritten
22611 in terms of the units @cite{u_a}.
22613 If units auto-ranging mode is enabled, products or quotients in
22614 which the first argument is a number which is out of range for the
22615 leading unit are modified accordingly.
22617 When cancelling and combining units in products and quotients,
22618 Calc accounts for unit names that differ only in the prefix letter.
22619 For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
22620 However, compatible but different units like @code{ft} and @code{in}
22621 are not combined in this way.
22623 Quotients @cite{a / b} are simplified in three additional ways. First,
22624 if @cite{b} is a number or a product beginning with a number, Calc
22625 computes the reciprocal of this number and moves it to the numerator.
22627 Second, for each pair of unit names from the numerator and denominator
22628 of a quotient, if the units are compatible (e.g., they are both
22629 units of area) then they are replaced by the ratio between those
22630 units. For example, in @samp{3 s in N / kg cm} the units
22631 @samp{in / cm} will be replaced by @cite{2.54}.
22633 Third, if the units in the quotient exactly cancel out, so that
22634 a @kbd{u b} command on the quotient would produce a dimensionless
22635 number for an answer, then the quotient simplifies to that number.
22637 For powers and square roots, the ``unsafe'' simplifications
22638 @cite{(a b)^c} to @cite{a^c b^c}, @cite{(a/b)^c} to @cite{a^c / b^c},
22639 and @cite{(a^b)^c} to @c{$a^{b c}$}
22640 @cite{a^(b c)} are done if the powers are
22641 real numbers. (These are safe in the context of units because
22642 all numbers involved can reasonably be assumed to be real.)
22644 Also, if a unit name is raised to a fractional power, and the
22645 base units in that unit name all occur to powers which are a
22646 multiple of the denominator of the power, then the unit name
22647 is expanded out into its base units, which can then be simplified
22648 according to the previous paragraph. For example, @samp{acre^1.5}
22649 is simplified by noting that @cite{1.5 = 3:2}, that @samp{acre}
22650 is defined in terms of @samp{m^2}, and that the 2 in the power of
22651 @code{m} is a multiple of 2 in @cite{3:2}. Thus, @code{acre^1.5} is
22652 replaced by approximately @c{$(4046 m^2)^{1.5}$}
22653 @cite{(4046 m^2)^1.5}, which is then
22654 changed to @c{$4046^{1.5} \, (m^2)^{1.5}$}
22655 @cite{4046^1.5 (m^2)^1.5}, then to @cite{257440 m^3}.
22657 The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
22658 as well as @code{floor} and the other integer truncation functions,
22659 applied to unit names or products or quotients involving units, are
22660 simplified. For example, @samp{round(1.6 in)} is changed to
22661 @samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
22662 and the righthand term simplifies to @code{in}.
22664 The functions @code{sin}, @code{cos}, and @code{tan} with arguments
22665 that have angular units like @code{rad} or @code{arcmin} are
22666 simplified by converting to base units (radians), then evaluating
22667 with the angular mode temporarily set to radians.
22669 @node Polynomials, Calculus, Simplifying Formulas, Algebra
22670 @section Polynomials
22672 A @dfn{polynomial} is a sum of terms which are coefficients times
22673 various powers of a ``base'' variable. For example, @cite{2 x^2 + 3 x - 4}
22674 is a polynomial in @cite{x}. Some formulas can be considered
22675 polynomials in several different variables: @cite{1 + 2 x + 3 y + 4 x y^2}
22676 is a polynomial in both @cite{x} and @cite{y}. Polynomial coefficients
22677 are often numbers, but they may in general be any formulas not
22678 involving the base variable.
22681 @pindex calc-factor
22683 The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
22684 polynomial into a product of terms. For example, the polynomial
22685 @cite{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another
22686 example, @cite{a c + b d + b c + a d} is factored into the product
22687 @cite{(a + b) (c + d)}.
22689 Calc currently has three algorithms for factoring. Formulas which are
22690 linear in several variables, such as the second example above, are
22691 merged according to the distributive law. Formulas which are
22692 polynomials in a single variable, with constant integer or fractional
22693 coefficients, are factored into irreducible linear and/or quadratic
22694 terms. The first example above factors into three linear terms
22695 (@cite{x}, @cite{x+1}, and @cite{x+1} again). Finally, formulas
22696 which do not fit the above criteria are handled by the algebraic
22699 Calc's polynomial factorization algorithm works by using the general
22700 root-finding command (@w{@kbd{a P}}) to solve for the roots of the
22701 polynomial. It then looks for roots which are rational numbers
22702 or complex-conjugate pairs, and converts these into linear and
22703 quadratic terms, respectively. Because it uses floating-point
22704 arithmetic, it may be unable to find terms that involve large
22705 integers (whose number of digits approaches the current precision).
22706 Also, irreducible factors of degree higher than quadratic are not
22707 found, and polynomials in more than one variable are not treated.
22708 (A more robust factorization algorithm may be included in a future
22711 @vindex FactorRules
22723 The rewrite-based factorization method uses rules stored in the variable
22724 @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the
22725 operation of rewrite rules. The default @code{FactorRules} are able
22726 to factor quadratic forms symbolically into two linear terms,
22727 @cite{(a x + b) (c x + d)}. You can edit these rules to include other
22728 cases if you wish. To use the rules, Calc builds the formula
22729 @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
22730 base variable and @code{a}, @code{b}, etc., are polynomial coefficients
22731 (which may be numbers or formulas). The constant term is written first,
22732 i.e., in the @code{a} position. When the rules complete, they should have
22733 changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
22734 where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
22735 Calc then multiplies these terms together to get the complete
22736 factored form of the polynomial. If the rules do not change the
22737 @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
22738 polynomial alone on the assumption that it is unfactorable. (Note that
22739 the function names @code{thecoefs} and @code{thefactors} are used only
22740 as placeholders; there are no actual Calc functions by those names.)
22744 The @kbd{H a f} [@code{factors}] command also factors a polynomial,
22745 but it returns a list of factors instead of an expression which is the
22746 product of the factors. Each factor is represented by a sub-vector
22747 of the factor, and the power with which it appears. For example,
22748 @cite{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @cite{(x + 7) x^2 (x - 3)^2}
22749 in @kbd{a f}, or to @cite{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
22750 If there is an overall numeric factor, it always comes first in the list.
22751 The functions @code{factor} and @code{factors} allow a second argument
22752 when written in algebraic form; @samp{factor(x,v)} factors @cite{x} with
22753 respect to the specific variable @cite{v}. The default is to factor with
22754 respect to all the variables that appear in @cite{x}.
22757 @pindex calc-collect
22759 The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
22761 polynomial in a given variable, ordered in decreasing powers of that
22762 variable. For example, given @cite{1 + 2 x + 3 y + 4 x y^2} on
22763 the stack, @kbd{a c x} would produce @cite{(2 + 4 y^2) x + (1 + 3 y)},
22764 and @kbd{a c y} would produce @cite{(4 x) y^2 + 3 y + (1 + 2 x)}.
22765 The polynomial will be expanded out using the distributive law as
22766 necessary: Collecting @cite{x} in @cite{(x - 1)^3} produces
22767 @cite{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @cite{x} will
22770 The ``variable'' you specify at the prompt can actually be any
22771 expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
22772 by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears
22773 in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
22774 treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
22777 @pindex calc-expand
22779 The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
22780 expression by applying the distributive law everywhere. It applies to
22781 products, quotients, and powers involving sums. By default, it fully
22782 distributes all parts of the expression. With a numeric prefix argument,
22783 the distributive law is applied only the specified number of times, then
22784 the partially expanded expression is left on the stack.
22786 The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use
22787 @kbd{a x} if you want to expand all products of sums in your formula.
22788 Use @kbd{j D} if you want to expand a particular specified term of
22789 the formula. There is an exactly analogous correspondence between
22790 @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands
22791 also know many other kinds of expansions, such as
22792 @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
22795 Calc's automatic simplifications will sometimes reverse a partial
22796 expansion. For example, the first step in expanding @cite{(x+1)^3} is
22797 to write @cite{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries
22798 to put this formula onto the stack, though, Calc will automatically
22799 simplify it back to @cite{(x+1)^3} form. The solution is to turn
22800 simplification off first (@pxref{Simplification Modes}), or to run
22801 @kbd{a x} without a numeric prefix argument so that it expands all
22802 the way in one step.
22807 The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
22808 rational function by partial fractions. A rational function is the
22809 quotient of two polynomials; @code{apart} pulls this apart into a
22810 sum of rational functions with simple denominators. In algebraic
22811 notation, the @code{apart} function allows a second argument that
22812 specifies which variable to use as the ``base''; by default, Calc
22813 chooses the base variable automatically.
22816 @pindex calc-normalize-rat
22818 The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
22819 attempts to arrange a formula into a quotient of two polynomials.
22820 For example, given @cite{1 + (a + b/c) / d}, the result would be
22821 @cite{(b + a c + c d) / c d}. The quotient is reduced, so that
22822 @kbd{a n} will simplify @cite{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
22823 out the common factor @cite{x + 1}, yielding @cite{(x + 1) / (x - 1)}.
22826 @pindex calc-poly-div
22828 The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
22829 two polynomials @cite{u} and @cite{v}, yielding a new polynomial
22830 @cite{q}. If several variables occur in the inputs, the inputs are
22831 considered multivariate polynomials. (Calc divides by the variable
22832 with the largest power in @cite{u} first, or, in the case of equal
22833 powers, chooses the variables in alphabetical order.) For example,
22834 dividing @cite{x^2 + 3 x + 2} by @cite{x + 2} yields @cite{x + 1}.
22835 The remainder from the division, if any, is reported at the bottom
22836 of the screen and is also placed in the Trail along with the quotient.
22838 Using @code{pdiv} in algebraic notation, you can specify the particular
22839 variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
22840 If @code{pdiv} is given only two arguments (as is always the case with
22841 the @kbd{a \} command), then it does a multivariate division as outlined
22845 @pindex calc-poly-rem
22847 The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
22848 two polynomials and keeps the remainder @cite{r}. The quotient
22849 @cite{q} is discarded. For any formulas @cite{a} and @cite{b}, the
22850 results of @kbd{a \} and @kbd{a %} satisfy @cite{a = q b + r}.
22851 (This is analogous to plain @kbd{\} and @kbd{%}, which compute the
22852 integer quotient and remainder from dividing two numbers.)
22856 @pindex calc-poly-div-rem
22859 The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
22860 divides two polynomials and reports both the quotient and the
22861 remainder as a vector @cite{[q, r]}. The @kbd{H a /} [@code{pdivide}]
22862 command divides two polynomials and constructs the formula
22863 @cite{q + r/b} on the stack. (Naturally if the remainder is zero,
22864 this will immediately simplify to @cite{q}.)
22867 @pindex calc-poly-gcd
22869 The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
22870 the greatest common divisor of two polynomials. (The GCD actually
22871 is unique only to within a constant multiplier; Calc attempts to
22872 choose a GCD which will be unsurprising.) For example, the @kbd{a n}
22873 command uses @kbd{a g} to take the GCD of the numerator and denominator
22874 of a quotient, then divides each by the result using @kbd{a \}. (The
22875 definition of GCD ensures that this division can take place without
22876 leaving a remainder.)
22878 While the polynomials used in operations like @kbd{a /} and @kbd{a g}
22879 often have integer coefficients, this is not required. Calc can also
22880 deal with polynomials over the rationals or floating-point reals.
22881 Polynomials with modulo-form coefficients are also useful in many
22882 applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
22883 automatically transforms this into a polynomial over the field of
22884 integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
22886 Congratulations and thanks go to Ove Ewerlid
22887 (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
22888 polynomial routines used in the above commands.
22890 @xref{Decomposing Polynomials}, for several useful functions for
22891 extracting the individual coefficients of a polynomial.
22893 @node Calculus, Solving Equations, Polynomials, Algebra
22897 The following calculus commands do not automatically simplify their
22898 inputs or outputs using @code{calc-simplify}. You may find it helps
22899 to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help
22900 to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
22904 * Differentiation::
22906 * Customizing the Integrator::
22907 * Numerical Integration::
22911 @node Differentiation, Integration, Calculus, Calculus
22912 @subsection Differentiation
22917 @pindex calc-derivative
22920 The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
22921 the derivative of the expression on the top of the stack with respect to
22922 some variable, which it will prompt you to enter. Normally, variables
22923 in the formula other than the specified differentiation variable are
22924 considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With
22925 the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
22926 instead, in which derivatives of variables are not reduced to zero
22927 unless those variables are known to be ``constant,'' i.e., independent
22928 of any other variables. (The built-in special variables like @code{pi}
22929 are considered constant, as are variables that have been declared
22930 @code{const}; @pxref{Declarations}.)
22932 With a numeric prefix argument @var{n}, this command computes the
22933 @var{n}th derivative.
22935 When working with trigonometric functions, it is best to switch to
22936 radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)}
22937 in degrees is @samp{(pi/180) cos(x)}, probably not the expected
22940 If you use the @code{deriv} function directly in an algebraic formula,
22941 you can write @samp{deriv(f,x,x0)} which represents the derivative
22942 of @cite{f} with respect to @cite{x}, evaluated at the point @c{$x=x_0$}
22945 If the formula being differentiated contains functions which Calc does
22946 not know, the derivatives of those functions are produced by adding
22947 primes (apostrophe characters). For example, @samp{deriv(f(2x), x)}
22948 produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
22949 derivative of @code{f}.
22951 For functions you have defined with the @kbd{Z F} command, Calc expands
22952 the functions according to their defining formulas unless you have
22953 also defined @code{f'} suitably. For example, suppose we define
22954 @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate
22955 the formula @samp{sinc(2 x)}, the formula will be expanded to
22956 @samp{sin(2 x) / (2 x)} and differentiated. However, if we also
22957 define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
22958 result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}.
22960 For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
22961 to the first argument is written @samp{f'(x,y,z)}; derivatives with
22962 respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
22963 Various higher-order derivatives can be formed in the obvious way, e.g.,
22964 @samp{f'@var{}'(x)} (the second derivative of @code{f}) or
22965 @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
22966 argument once).@refill
22968 @node Integration, Customizing the Integrator, Differentiation, Calculus
22969 @subsection Integration
22973 @pindex calc-integral
22975 The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
22976 indefinite integral of the expression on the top of the stack with
22977 respect to a variable. The integrator is not guaranteed to work for
22978 all integrable functions, but it is able to integrate several large
22979 classes of formulas. In particular, any polynomial or rational function
22980 (a polynomial divided by a polynomial) is acceptable. (Rational functions
22981 don't have to be in explicit quotient form, however; @c{$x/(1+x^{-2})$}
22983 is not strictly a quotient of polynomials, but it is equivalent to
22984 @cite{x^3/(x^2+1)}, which is.) Also, square roots of terms involving
22985 @cite{x} and @cite{x^2} may appear in rational functions being
22986 integrated. Finally, rational functions involving trigonometric or
22987 hyperbolic functions can be integrated.
22990 If you use the @code{integ} function directly in an algebraic formula,
22991 you can also write @samp{integ(f,x,v)} which expresses the resulting
22992 indefinite integral in terms of variable @code{v} instead of @code{x}.
22993 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
22994 integral from @code{a} to @code{b}.
22997 If you use the @code{integ} function directly in an algebraic formula,
22998 you can also write @samp{integ(f,x,v)} which expresses the resulting
22999 indefinite integral in terms of variable @code{v} instead of @code{x}.
23000 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23001 integral $\int_a^b f(x) \, dx$.
23004 Please note that the current implementation of Calc's integrator sometimes
23005 produces results that are significantly more complex than they need to
23006 be. For example, the integral Calc finds for @c{$1/(x+\sqrt{x^2+1})$}
23007 @cite{1/(x+sqrt(x^2+1))}
23008 is several times more complicated than the answer Mathematica
23009 returns for the same input, although the two forms are numerically
23010 equivalent. Also, any indefinite integral should be considered to have
23011 an arbitrary constant of integration added to it, although Calc does not
23012 write an explicit constant of integration in its result. For example,
23013 Calc's solution for @c{$1/(1+\tan x)$}
23014 @cite{1/(1+tan(x))} differs from the solution given
23015 in the @emph{CRC Math Tables} by a constant factor of @c{$\pi i / 2$}
23017 due to a different choice of constant of integration.
23019 The Calculator remembers all the integrals it has done. If conditions
23020 change in a way that would invalidate the old integrals, say, a switch
23021 from degrees to radians mode, then they will be thrown out. If you
23022 suspect this is not happening when it should, use the
23023 @code{calc-flush-caches} command; @pxref{Caches}.
23026 Calc normally will pursue integration by substitution or integration by
23027 parts up to 3 nested times before abandoning an approach as fruitless.
23028 If the integrator is taking too long, you can lower this limit by storing
23029 a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I}
23030 command is a convenient way to edit @code{IntegLimit}.) If this variable
23031 has no stored value or does not contain a nonnegative integer, a limit
23032 of 3 is used. The lower this limit is, the greater the chance that Calc
23033 will be unable to integrate a function it could otherwise handle. Raising
23034 this limit allows the Calculator to solve more integrals, though the time
23035 it takes may grow exponentially. You can monitor the integrator's actions
23036 by creating an Emacs buffer called @code{*Trace*}. If such a buffer
23037 exists, the @kbd{a i} command will write a log of its actions there.
23039 If you want to manipulate integrals in a purely symbolic way, you can
23040 set the integration nesting limit to 0 to prevent all but fast
23041 table-lookup solutions of integrals. You might then wish to define
23042 rewrite rules for integration by parts, various kinds of substitutions,
23043 and so on. @xref{Rewrite Rules}.
23045 @node Customizing the Integrator, Numerical Integration, Integration, Calculus
23046 @subsection Customizing the Integrator
23050 Calc has two built-in rewrite rules called @code{IntegRules} and
23051 @code{IntegAfterRules} which you can edit to define new integration
23052 methods. @xref{Rewrite Rules}. At each step of the integration process,
23053 Calc wraps the current integrand in a call to the fictitious function
23054 @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
23055 integrand and @var{var} is the integration variable. If your rules
23056 rewrite this to be a plain formula (not a call to @code{integtry}), then
23057 Calc will use this formula as the integral of @var{expr}. For example,
23058 the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
23059 integrate a function @code{mysin} that acts like the sine function.
23060 Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
23061 will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has
23062 automatically made various transformations on the integral to allow it
23063 to use your rule; integral tables generally give rules for
23064 @samp{mysin(a x + b)}, but you don't need to use this much generality
23065 in your @code{IntegRules}.
23067 @cindex Exponential integral Ei(x)
23072 As a more serious example, the expression @samp{exp(x)/x} cannot be
23073 integrated in terms of the standard functions, so the ``exponential
23074 integral'' function @c{${\rm Ei}(x)$}
23075 @cite{Ei(x)} was invented to describe it.
23076 We can get Calc to do this integral in terms of a made-up @code{Ei}
23077 function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
23078 to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack
23079 and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will
23080 work with Calc's various built-in integration methods (such as
23081 integration by substitution) to solve a variety of other problems
23082 involving @code{Ei}: For example, now Calc will also be able to
23083 integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
23084 and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
23086 Your rule may do further integration by calling @code{integ}. For
23087 example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
23088 to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
23089 Note that @code{integ} was called with only one argument. This notation
23090 is allowed only within @code{IntegRules}; it means ``integrate this
23091 with respect to the same integration variable.'' If Calc is unable
23092 to integrate @code{u}, the integration that invoked @code{IntegRules}
23093 also fails. Thus integrating @samp{twice(f(x))} fails, returning the
23094 unevaluated integral @samp{integ(twice(f(x)), x)}. It is still legal
23095 to call @code{integ} with two or more arguments, however; in this case,
23096 if @code{u} is not integrable, @code{twice} itself will still be
23097 integrated: If the above rule is changed to @samp{... := twice(integ(u,x))},
23098 then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
23100 If a rule instead produces the formula @samp{integsubst(@var{sexpr},
23101 @var{svar})}, either replacing the top-level @code{integtry} call or
23102 nested anywhere inside the expression, then Calc will apply the
23103 substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
23104 integrate the original @var{expr}. For example, the rule
23105 @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
23106 a square root in the integrand, it should attempt the substitution
23107 @samp{u = sqrt(x)}. (This particular rule is unnecessary because
23108 Calc always tries ``obvious'' substitutions where @var{sexpr} actually
23109 appears in the integrand.) The variable @var{svar} may be the same
23110 as the @var{var} that appeared in the call to @code{integtry}, but
23113 When integrating according to an @code{integsubst}, Calc uses the
23114 equation solver to find the inverse of @var{sexpr} (if the integrand
23115 refers to @var{var} anywhere except in subexpressions that exactly
23116 match @var{sexpr}). It uses the differentiator to find the derivative
23117 of @var{sexpr} and/or its inverse (it has two methods that use one
23118 derivative or the other). You can also specify these items by adding
23119 extra arguments to the @code{integsubst} your rules construct; the
23120 general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
23121 @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
23122 written as a function of @var{svar}), and @var{sprime} is the
23123 derivative of @var{sexpr} with respect to @var{svar}. If you don't
23124 specify these things, and Calc is not able to work them out on its
23125 own with the information it knows, then your substitution rule will
23126 work only in very specific, simple cases.
23128 Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
23129 in other words, Calc stops rewriting as soon as any rule in your rule
23130 set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
23131 example above would keep on adding layers of @code{integsubst} calls
23134 @vindex IntegSimpRules
23135 Another set of rules, stored in @code{IntegSimpRules}, are applied
23136 every time the integrator uses @kbd{a s} to simplify an intermediate
23137 result. For example, putting the rule @samp{twice(x) := 2 x} into
23138 @code{IntegSimpRules} would tell Calc to convert the @code{twice}
23139 function into a form it knows whenever integration is attempted.
23141 One more way to influence the integrator is to define a function with
23142 the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's
23143 integrator automatically expands such functions according to their
23144 defining formulas, even if you originally asked for the function to
23145 be left unevaluated for symbolic arguments. (Certain other Calc
23146 systems, such as the differentiator and the equation solver, also
23149 @vindex IntegAfterRules
23150 Sometimes Calc is able to find a solution to your integral, but it
23151 expresses the result in a way that is unnecessarily complicated. If
23152 this happens, you can either use @code{integsubst} as described
23153 above to try to hint at a more direct path to the desired result, or
23154 you can use @code{IntegAfterRules}. This is an extra rule set that
23155 runs after the main integrator returns its result; basically, Calc does
23156 an @kbd{a r IntegAfterRules} on the result before showing it to you.
23157 (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that
23158 to further simplify the result.) For example, Calc's integrator
23159 sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
23160 the default @code{IntegAfterRules} rewrite this into the more readable
23161 form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules},
23162 @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
23163 of times until no further changes are possible. Rewriting by
23164 @code{IntegAfterRules} occurs only after the main integrator has
23165 finished, not at every step as for @code{IntegRules} and
23166 @code{IntegSimpRules}.
23168 @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
23169 @subsection Numerical Integration
23173 @pindex calc-num-integral
23175 If you want a purely numerical answer to an integration problem, you can
23176 use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This
23177 command prompts for an integration variable, a lower limit, and an
23178 upper limit. Except for the integration variable, all other variables
23179 that appear in the integrand formula must have stored values. (A stored
23180 value, if any, for the integration variable itself is ignored.)
23182 Numerical integration works by evaluating your formula at many points in
23183 the specified interval. Calc uses an ``open Romberg'' method; this means
23184 that it does not evaluate the formula actually at the endpoints (so that
23185 it is safe to integrate @samp{sin(x)/x} from zero, for example). Also,
23186 the Romberg method works especially well when the function being
23187 integrated is fairly smooth. If the function is not smooth, Calc will
23188 have to evaluate it at quite a few points before it can accurately
23189 determine the value of the integral.
23191 Integration is much faster when the current precision is small. It is
23192 best to set the precision to the smallest acceptable number of digits
23193 before you use @kbd{a I}. If Calc appears to be taking too long, press
23194 @kbd{C-g} to halt it and try a lower precision. If Calc still appears
23195 to need hundreds of evaluations, check to make sure your function is
23196 well-behaved in the specified interval.
23198 It is possible for the lower integration limit to be @samp{-inf} (minus
23199 infinity). Likewise, the upper limit may be plus infinity. Calc
23200 internally transforms the integral into an equivalent one with finite
23201 limits. However, integration to or across singularities is not supported:
23202 The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
23203 by Calc's symbolic integrator, for example), but @kbd{a I} will fail
23204 because the integrand goes to infinity at one of the endpoints.
23206 @node Taylor Series, , Numerical Integration, Calculus
23207 @subsection Taylor Series
23211 @pindex calc-taylor
23213 The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
23214 power series expansion or Taylor series of a function. You specify the
23215 variable and the desired number of terms. You may give an expression of
23216 the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
23217 of just a variable to produce a Taylor expansion about the point @var{a}.
23218 You may specify the number of terms with a numeric prefix argument;
23219 otherwise the command will prompt you for the number of terms. Note that
23220 many series expansions have coefficients of zero for some terms, so you
23221 may appear to get fewer terms than you asked for.@refill
23223 If the @kbd{a i} command is unable to find a symbolic integral for a
23224 function, you can get an approximation by integrating the function's
23227 @node Solving Equations, Numerical Solutions, Calculus, Algebra
23228 @section Solving Equations
23232 @pindex calc-solve-for
23234 @cindex Equations, solving
23235 @cindex Solving equations
23236 The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
23237 an equation to solve for a specific variable. An equation is an
23238 expression of the form @cite{L = R}. For example, the command @kbd{a S x}
23239 will rearrange @cite{y = 3x + 6} to the form, @cite{x = y/3 - 2}. If the
23240 input is not an equation, it is treated like an equation of the
23243 This command also works for inequalities, as in @cite{y < 3x + 6}.
23244 Some inequalities cannot be solved where the analogous equation could
23245 be; for example, solving @c{$a < b \, c$}
23246 @cite{a < b c} for @cite{b} is impossible
23247 without knowing the sign of @cite{c}. In this case, @kbd{a S} will
23248 produce the result @c{$b \mathbin{\hbox{\code{!=}}} a/c$}
23249 @cite{b != a/c} (using the not-equal-to operator)
23250 to signify that the direction of the inequality is now unknown. The
23251 inequality @c{$a \le b \, c$}
23252 @cite{a <= b c} is not even partially solved.
23253 @xref{Declarations}, for a way to tell Calc that the signs of the
23254 variables in a formula are in fact known.
23256 Two useful commands for working with the result of @kbd{a S} are
23257 @kbd{a .} (@pxref{Logical Operations}), which converts @cite{x = y/3 - 2}
23258 to @cite{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
23259 another formula with @cite{x} set equal to @cite{y/3 - 2}.
23262 * Multiple Solutions::
23263 * Solving Systems of Equations::
23264 * Decomposing Polynomials::
23267 @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
23268 @subsection Multiple Solutions
23273 Some equations have more than one solution. The Hyperbolic flag
23274 (@code{H a S}) [@code{fsolve}] tells the solver to report the fully
23275 general family of solutions. It will invent variables @code{n1},
23276 @code{n2}, @dots{}, which represent independent arbitrary integers, and
23277 @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
23278 signs (either @i{+1} or @i{-1}). If you don't use the Hyperbolic
23279 flag, Calc will use zero in place of all arbitrary integers, and plus
23280 one in place of all arbitrary signs. Note that variables like @code{n1}
23281 and @code{s1} are not given any special interpretation in Calc except by
23282 the equation solver itself. As usual, you can use the @w{@kbd{s l}}
23283 (@code{calc-let}) command to obtain solutions for various actual values
23284 of these variables.
23286 For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
23287 get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
23288 equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to
23289 think about it is that the square-root operation is really a
23290 two-valued function; since every Calc function must return a
23291 single result, @code{sqrt} chooses to return the positive result.
23292 Then @kbd{H a S} doctors this result using @code{s1} to indicate
23293 the full set of possible values of the mathematical square-root.
23295 There is a similar phenomenon going the other direction: Suppose
23296 we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides
23297 to get @samp{y = x^2}. This is correct, except that it introduces
23298 some dubious solutions. Consider solving @samp{sqrt(y) = -3}:
23299 Calc will report @cite{y = 9} as a valid solution, which is true
23300 in the mathematical sense of square-root, but false (there is no
23301 solution) for the actual Calc positive-valued @code{sqrt}. This
23302 happens for both @kbd{a S} and @kbd{H a S}.
23304 @cindex @code{GenCount} variable
23314 If you store a positive integer in the Calc variable @code{GenCount},
23315 then Calc will generate formulas of the form @samp{as(@var{n})} for
23316 arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
23317 where @var{n} represents successive values taken by incrementing
23318 @code{GenCount} by one. While the normal arbitrary sign and
23319 integer symbols start over at @code{s1} and @code{n1} with each
23320 new Calc command, the @code{GenCount} approach will give each
23321 arbitrary value a name that is unique throughout the entire Calc
23322 session. Also, the arbitrary values are function calls instead
23323 of variables, which is advantageous in some cases. For example,
23324 you can make a rewrite rule that recognizes all arbitrary signs
23325 using a pattern like @samp{as(n)}. The @kbd{s l} command only works
23326 on variables, but you can use the @kbd{a b} (@code{calc-substitute})
23327 command to substitute actual values for function calls like @samp{as(3)}.
23329 The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
23330 way to create or edit this variable. Press @kbd{M-# M-#} to finish.
23332 If you have not stored a value in @code{GenCount}, or if the value
23333 in that variable is not a positive integer, the regular
23334 @code{s1}/@code{n1} notation is used.
23340 With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
23341 on top of the stack as a function of the specified variable and solves
23342 to find the inverse function, written in terms of the same variable.
23343 For example, @kbd{I a S x} inverts @cite{2x + 6} to @cite{x/2 - 3}.
23344 You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
23345 fully general inverse, as described above.
23348 @pindex calc-poly-roots
23350 Some equations, specifically polynomials, have a known, finite number
23351 of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
23352 command uses @kbd{H a S} to solve an equation in general form, then, for
23353 all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
23354 variables like @code{n1} for which @code{n1} only usefully varies over
23355 a finite range, it expands these variables out to all their possible
23356 values. The results are collected into a vector, which is returned.
23357 For example, @samp{roots(x^4 = 1, x)} returns the four solutions
23358 @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree
23359 polynomial will always have @var{n} roots on the complex plane.
23360 (If you have given a @code{real} declaration for the solution
23361 variable, then only the real-valued solutions, if any, will be
23362 reported; @pxref{Declarations}.)
23364 Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
23365 symbolic solutions if the polynomial has symbolic coefficients. Also
23366 note that Calc's solver is not able to get exact symbolic solutions
23367 to all polynomials. Polynomials containing powers up to @cite{x^4}
23368 can always be solved exactly; polynomials of higher degree sometimes
23369 can be: @cite{x^6 + x^3 + 1} is converted to @cite{(x^3)^2 + (x^3) + 1},
23370 which can be solved for @cite{x^3} using the quadratic equation, and then
23371 for @cite{x} by taking cube roots. But in many cases, like
23372 @cite{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
23373 into a form it can solve. The @kbd{a P} command can still deliver a
23374 list of numerical roots, however, provided that symbolic mode (@kbd{m s})
23375 is not turned on. (If you work with symbolic mode on, recall that the
23376 @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
23377 formula on the stack with symbolic mode temporarily off.) Naturally,
23378 @kbd{a P} can only provide numerical roots if the polynomial coefficients
23379 are all numbers (real or complex).
23381 @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
23382 @subsection Solving Systems of Equations
23385 @cindex Systems of equations, symbolic
23386 You can also use the commands described above to solve systems of
23387 simultaneous equations. Just create a vector of equations, then
23388 specify a vector of variables for which to solve. (You can omit
23389 the surrounding brackets when entering the vector of variables
23392 For example, putting @samp{[x + y = a, x - y = b]} on the stack
23393 and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
23394 @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will
23395 have the same length as the variables vector, and the variables
23396 will be listed in the same order there. Note that the solutions
23397 are not always simplified as far as possible; the solution for
23398 @cite{x} here could be improved by an application of the @kbd{a n}
23401 Calc's algorithm works by trying to eliminate one variable at a
23402 time by solving one of the equations for that variable and then
23403 substituting into the other equations. Calc will try all the
23404 possibilities, but you can speed things up by noting that Calc
23405 first tries to eliminate the first variable with the first
23406 equation, then the second variable with the second equation,
23407 and so on. It also helps to put the simpler (e.g., more linear)
23408 equations toward the front of the list. Calc's algorithm will
23409 solve any system of linear equations, and also many kinds of
23416 Normally there will be as many variables as equations. If you
23417 give fewer variables than equations (an ``over-determined'' system
23418 of equations), Calc will find a partial solution. For example,
23419 typing @kbd{a S y @key{RET}} with the above system of equations
23420 would produce @samp{[y = a - x]}. There are now several ways to
23421 express this solution in terms of the original variables; Calc uses
23422 the first one that it finds. You can control the choice by adding
23423 variable specifiers of the form @samp{elim(@var{v})} to the
23424 variables list. This says that @var{v} should be eliminated from
23425 the equations; the variable will not appear at all in the solution.
23426 For example, typing @kbd{a S y,elim(x)} would yield
23427 @samp{[y = a - (b+a)/2]}.
23429 If the variables list contains only @code{elim} specifiers,
23430 Calc simply eliminates those variables from the equations
23431 and then returns the resulting set of equations. For example,
23432 @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable
23433 eliminated will reduce the number of equations in the system
23436 Again, @kbd{a S} gives you one solution to the system of
23437 equations. If there are several solutions, you can use @kbd{H a S}
23438 to get a general family of solutions, or, if there is a finite
23439 number of solutions, you can use @kbd{a P} to get a list. (In
23440 the latter case, the result will take the form of a matrix where
23441 the rows are different solutions and the columns correspond to the
23442 variables you requested.)
23444 Another way to deal with certain kinds of overdetermined systems of
23445 equations is the @kbd{a F} command, which does least-squares fitting
23446 to satisfy the equations. @xref{Curve Fitting}.
23448 @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
23449 @subsection Decomposing Polynomials
23456 The @code{poly} function takes a polynomial and a variable as
23457 arguments, and returns a vector of polynomial coefficients (constant
23458 coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns
23459 @cite{[0, 2, 0, 1]}. If the input is not a polynomial in @cite{x},
23460 the call to @code{poly} is left in symbolic form. If the input does
23461 not involve the variable @cite{x}, the input is returned in a list
23462 of length one, representing a polynomial with only a constant
23463 coefficient. The call @samp{poly(x, x)} returns the vector @cite{[0, 1]}.
23464 The last element of the returned vector is guaranteed to be nonzero;
23465 note that @samp{poly(0, x)} returns the empty vector @cite{[]}.
23466 Note also that @cite{x} may actually be any formula; for example,
23467 @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @cite{[3, -1, 1]}.
23469 @cindex Coefficients of polynomial
23470 @cindex Degree of polynomial
23471 To get the @cite{x^k} coefficient of polynomial @cite{p}, use
23472 @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @cite{p},
23473 use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)}
23474 returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
23475 gives the @cite{x^2} coefficient of this polynomial, 6.
23481 One important feature of the solver is its ability to recognize
23482 formulas which are ``essentially'' polynomials. This ability is
23483 made available to the user through the @code{gpoly} function, which
23484 is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}.
23485 If @var{expr} is a polynomial in some term which includes @var{var}, then
23486 this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
23487 where @var{x} is the term that depends on @var{var}, @var{c} is a
23488 vector of polynomial coefficients (like the one returned by @code{poly}),
23489 and @var{a} is a multiplier which is usually 1. Basically,
23490 @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
23491 @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is
23492 guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
23493 (i.e., the trivial decomposition @var{expr} = @var{x} is not
23494 considered a polynomial). One side effect is that @samp{gpoly(x, x)}
23495 and @samp{gpoly(6, x)}, both of which might be expected to recognize
23496 their arguments as polynomials, will not because the decomposition
23497 is considered trivial.
23499 For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
23500 since the expanded form of this polynomial is @cite{4 - 4 x + x^2}.
23502 The term @var{x} may itself be a polynomial in @var{var}. This is
23503 done to reduce the size of the @var{c} vector. For example,
23504 @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
23505 since a quadratic polynomial in @cite{x^2} is easier to solve than
23506 a quartic polynomial in @cite{x}.
23508 A few more examples of the kinds of polynomials @code{gpoly} can
23512 sin(x) - 1 [sin(x), [-1, 1], 1]
23513 x + 1/x - 1 [x, [1, -1, 1], 1/x]
23514 x + 1/x [x^2, [1, 1], 1/x]
23515 x^3 + 2 x [x^2, [2, 1], x]
23516 x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2]
23517 x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1]
23518 (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x]
23521 The @code{poly} and @code{gpoly} functions accept a third integer argument
23522 which specifies the largest degree of polynomial that is acceptable.
23523 If this is @cite{n}, then only @var{c} vectors of length @cite{n+1}
23524 or less will be returned. Otherwise, the @code{poly} or @code{gpoly}
23525 call will remain in symbolic form. For example, the equation solver
23526 can handle quartics and smaller polynomials, so it calls
23527 @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
23528 can be treated by its linear, quadratic, cubic, or quartic formulas.
23534 The @code{pdeg} function computes the degree of a polynomial;
23535 @samp{pdeg(p,x)} is the highest power of @code{x} that appears in
23536 @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is
23537 much more efficient. If @code{p} is constant with respect to @code{x},
23538 then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x}
23539 (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
23540 It is possible to omit the second argument @code{x}, in which case
23541 @samp{pdeg(p)} returns the highest total degree of any term of the
23542 polynomial, counting all variables that appear in @code{p}. Note
23543 that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
23544 the degree of the constant zero is considered to be @code{-inf}
23551 The @code{plead} function finds the leading term of a polynomial.
23552 Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
23553 though again more efficient. In particular, @samp{plead((2x+1)^10, x)}
23554 returns 1024 without expanding out the list of coefficients. The
23555 value of @code{plead(p,x)} will be zero only if @cite{p = 0}.
23561 The @code{pcont} function finds the @dfn{content} of a polynomial. This
23562 is the greatest common divisor of all the coefficients of the polynomial.
23563 With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
23564 to get a list of coefficients, then uses @code{pgcd} (the polynomial
23565 GCD function) to combine these into an answer. For example,
23566 @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is
23567 basically the ``biggest'' polynomial that can be divided into @code{p}
23568 exactly. The sign of the content is the same as the sign of the leading
23571 With only one argument, @samp{pcont(p)} computes the numerical
23572 content of the polynomial, i.e., the @code{gcd} of the numerical
23573 coefficients of all the terms in the formula. Note that @code{gcd}
23574 is defined on rational numbers as well as integers; it computes
23575 the @code{gcd} of the numerators and the @code{lcm} of the
23576 denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
23577 Dividing the polynomial by this number will clear all the
23578 denominators, as well as dividing by any common content in the
23579 numerators. The numerical content of a polynomial is negative only
23580 if all the coefficients in the polynomial are negative.
23586 The @code{pprim} function finds the @dfn{primitive part} of a
23587 polynomial, which is simply the polynomial divided (using @code{pdiv}
23588 if necessary) by its content. If the input polynomial has rational
23589 coefficients, the result will have integer coefficients in simplest
23592 @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
23593 @section Numerical Solutions
23596 Not all equations can be solved symbolically. The commands in this
23597 section use numerical algorithms that can find a solution to a specific
23598 instance of an equation to any desired accuracy. Note that the
23599 numerical commands are slower than their algebraic cousins; it is a
23600 good idea to try @kbd{a S} before resorting to these commands.
23602 (@xref{Curve Fitting}, for some other, more specialized, operations
23603 on numerical data.)
23608 * Numerical Systems of Equations::
23611 @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
23612 @subsection Root Finding
23616 @pindex calc-find-root
23618 @cindex Newton's method
23619 @cindex Roots of equations
23620 @cindex Numerical root-finding
23621 The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
23622 numerical solution (or @dfn{root}) of an equation. (This command treats
23623 inequalities the same as equations. If the input is any other kind
23624 of formula, it is interpreted as an equation of the form @cite{X = 0}.)
23626 The @kbd{a R} command requires an initial guess on the top of the
23627 stack, and a formula in the second-to-top position. It prompts for a
23628 solution variable, which must appear in the formula. All other variables
23629 that appear in the formula must have assigned values, i.e., when
23630 a value is assigned to the solution variable and the formula is
23631 evaluated with @kbd{=}, it should evaluate to a number. Any assigned
23632 value for the solution variable itself is ignored and unaffected by
23635 When the command completes, the initial guess is replaced on the stack
23636 by a vector of two numbers: The value of the solution variable that
23637 solves the equation, and the difference between the lefthand and
23638 righthand sides of the equation at that value. Ordinarily, the second
23639 number will be zero or very nearly zero. (Note that Calc uses a
23640 slightly higher precision while finding the root, and thus the second
23641 number may be slightly different from the value you would compute from
23642 the equation yourself.)
23644 The @kbd{v h} (@code{calc-head}) command is a handy way to extract
23645 the first element of the result vector, discarding the error term.
23647 The initial guess can be a real number, in which case Calc searches
23648 for a real solution near that number, or a complex number, in which
23649 case Calc searches the whole complex plane near that number for a
23650 solution, or it can be an interval form which restricts the search
23651 to real numbers inside that interval.
23653 Calc tries to use @kbd{a d} to take the derivative of the equation.
23654 If this succeeds, it uses Newton's method. If the equation is not
23655 differentiable Calc uses a bisection method. (If Newton's method
23656 appears to be going astray, Calc switches over to bisection if it
23657 can, or otherwise gives up. In this case it may help to try again
23658 with a slightly different initial guess.) If the initial guess is a
23659 complex number, the function must be differentiable.
23661 If the formula (or the difference between the sides of an equation)
23662 is negative at one end of the interval you specify and positive at
23663 the other end, the root finder is guaranteed to find a root.
23664 Otherwise, Calc subdivides the interval into small parts looking for
23665 positive and negative values to bracket the root. When your guess is
23666 an interval, Calc will not look outside that interval for a root.
23670 The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
23671 that if the initial guess is an interval for which the function has
23672 the same sign at both ends, then rather than subdividing the interval
23673 Calc attempts to widen it to enclose a root. Use this mode if
23674 you are not sure if the function has a root in your interval.
23676 If the function is not differentiable, and you give a simple number
23677 instead of an interval as your initial guess, Calc uses this widening
23678 process even if you did not type the Hyperbolic flag. (If the function
23679 @emph{is} differentiable, Calc uses Newton's method which does not
23680 require a bounding interval in order to work.)
23682 If Calc leaves the @code{root} or @code{wroot} function in symbolic
23683 form on the stack, it will normally display an explanation for why
23684 no root was found. If you miss this explanation, press @kbd{w}
23685 (@code{calc-why}) to get it back.
23687 @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
23688 @subsection Minimization
23695 @pindex calc-find-minimum
23696 @pindex calc-find-maximum
23699 @cindex Minimization, numerical
23700 The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
23701 finds a minimum value for a formula. It is very similar in operation
23702 to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial
23703 guess on the stack, and are prompted for the name of a variable. The guess
23704 may be either a number near the desired minimum, or an interval enclosing
23705 the desired minimum. The function returns a vector containing the
23706 value of the variable which minimizes the formula's value, along
23707 with the minimum value itself.
23709 Note that this command looks for a @emph{local} minimum. Many functions
23710 have more than one minimum; some, like @c{$x \sin x$}
23711 @cite{x sin(x)}, have infinitely
23712 many. In fact, there is no easy way to define the ``global'' minimum
23714 @cite{x sin(x)} but Calc can still locate any particular local minimum
23715 for you. Calc basically goes downhill from the initial guess until it
23716 finds a point at which the function's value is greater both to the left
23717 and to the right. Calc does not use derivatives when minimizing a function.
23719 If your initial guess is an interval and it looks like the minimum
23720 occurs at one or the other endpoint of the interval, Calc will return
23721 that endpoint only if that endpoint is closed; thus, minimizing @cite{17 x}
23722 over @cite{[2..3]} will return @cite{[2, 38]}, but minimizing over
23723 @cite{(2..3]} would report no minimum found. In general, you should
23724 use closed intervals to find literally the minimum value in that
23725 range of @cite{x}, or open intervals to find the local minimum, if
23726 any, that happens to lie in that range.
23728 Most functions are smooth and flat near their minimum values. Because
23729 of this flatness, if the current precision is, say, 12 digits, the
23730 variable can only be determined meaningfully to about six digits. Thus
23731 you should set the precision to twice as many digits as you need in your
23742 The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
23743 expands the guess interval to enclose a minimum rather than requiring
23744 that the minimum lie inside the interval you supply.
23746 The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
23747 @kbd{H a X} [@code{wmaximize}] commands effectively minimize the
23748 negative of the formula you supply.
23750 The formula must evaluate to a real number at all points inside the
23751 interval (or near the initial guess if the guess is a number). If
23752 the initial guess is a complex number the variable will be minimized
23753 over the complex numbers; if it is real or an interval it will
23754 be minimized over the reals.
23756 @node Numerical Systems of Equations, , Minimization, Numerical Solutions
23757 @subsection Systems of Equations
23760 @cindex Systems of equations, numerical
23761 The @kbd{a R} command can also solve systems of equations. In this
23762 case, the equation should instead be a vector of equations, the
23763 guess should instead be a vector of numbers (intervals are not
23764 supported), and the variable should be a vector of variables. You
23765 can omit the brackets while entering the list of variables. Each
23766 equation must be differentiable by each variable for this mode to
23767 work. The result will be a vector of two vectors: The variable
23768 values that solved the system of equations, and the differences
23769 between the sides of the equations with those variable values.
23770 There must be the same number of equations as variables. Since
23771 only plain numbers are allowed as guesses, the Hyperbolic flag has
23772 no effect when solving a system of equations.
23774 It is also possible to minimize over many variables with @kbd{a N}
23775 (or maximize with @kbd{a X}). Once again the variable name should
23776 be replaced by a vector of variables, and the initial guess should
23777 be an equal-sized vector of initial guesses. But, unlike the case of
23778 multidimensional @kbd{a R}, the formula being minimized should
23779 still be a single formula, @emph{not} a vector. Beware that
23780 multidimensional minimization is currently @emph{very} slow.
23782 @node Curve Fitting, Summations, Numerical Solutions, Algebra
23783 @section Curve Fitting
23786 The @kbd{a F} command fits a set of data to a @dfn{model formula},
23787 such as @cite{y = m x + b} where @cite{m} and @cite{b} are parameters
23788 to be determined. For a typical set of measured data there will be
23789 no single @cite{m} and @cite{b} that exactly fit the data; in this
23790 case, Calc chooses values of the parameters that provide the closest
23795 * Polynomial and Multilinear Fits::
23796 * Error Estimates for Fits::
23797 * Standard Nonlinear Models::
23798 * Curve Fitting Details::
23802 @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
23803 @subsection Linear Fits
23807 @pindex calc-curve-fit
23809 @cindex Linear regression
23810 @cindex Least-squares fits
23811 The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
23812 to fit a set of data (@cite{x} and @cite{y} vectors of numbers) to a
23813 straight line, polynomial, or other function of @cite{x}. For the
23814 moment we will consider only the case of fitting to a line, and we
23815 will ignore the issue of whether or not the model was in fact a good
23818 In a standard linear least-squares fit, we have a set of @cite{(x,y)}
23819 data points that we wish to fit to the model @cite{y = m x + b}
23820 by adjusting the parameters @cite{m} and @cite{b} to make the @cite{y}
23821 values calculated from the formula be as close as possible to the actual
23822 @cite{y} values in the data set. (In a polynomial fit, the model is
23823 instead, say, @cite{y = a x^3 + b x^2 + c x + d}. In a multilinear fit,
23824 we have data points of the form @cite{(x_1,x_2,x_3,y)} and our model is
23825 @cite{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.)
23827 In the model formula, variables like @cite{x} and @cite{x_2} are called
23828 the @dfn{independent variables}, and @cite{y} is the @dfn{dependent
23829 variable}. Variables like @cite{m}, @cite{a}, and @cite{b} are called
23830 the @dfn{parameters} of the model.
23832 The @kbd{a F} command takes the data set to be fitted from the stack.
23833 By default, it expects the data in the form of a matrix. For example,
23834 for a linear or polynomial fit, this would be a @c{$2\times N$}
23835 @asis{2xN} matrix where
23836 the first row is a list of @cite{x} values and the second row has the
23837 corresponding @cite{y} values. For the multilinear fit shown above,
23838 the matrix would have four rows (@cite{x_1}, @cite{x_2}, @cite{x_3}, and
23839 @cite{y}, respectively).
23841 If you happen to have an @c{$N\times2$}
23842 @asis{Nx2} matrix instead of a @c{$2\times N$}
23844 just press @kbd{v t} first to transpose the matrix.
23846 After you type @kbd{a F}, Calc prompts you to select a model. For a
23847 linear fit, press the digit @kbd{1}.
23849 Calc then prompts for you to name the variables. By default it chooses
23850 high letters like @cite{x} and @cite{y} for independent variables and
23851 low letters like @cite{a} and @cite{b} for parameters. (The dependent
23852 variable doesn't need a name.) The two kinds of variables are separated
23853 by a semicolon. Since you generally care more about the names of the
23854 independent variables than of the parameters, Calc also allows you to
23855 name only those and let the parameters use default names.
23857 For example, suppose the data matrix
23862 [ [ 1, 2, 3, 4, 5 ]
23863 [ 5, 7, 9, 11, 13 ] ]
23871 $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr
23872 5 & 7 & 9 & 11 & 13 }
23878 is on the stack and we wish to do a simple linear fit. Type
23879 @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
23880 the default names. The result will be the formula @cite{3 + 2 x}
23881 on the stack. Calc has created the model expression @kbd{a + b x},
23882 then found the optimal values of @cite{a} and @cite{b} to fit the
23883 data. (In this case, it was able to find an exact fit.) Calc then
23884 substituted those values for @cite{a} and @cite{b} in the model
23887 The @kbd{a F} command puts two entries in the trail. One is, as
23888 always, a copy of the result that went to the stack; the other is
23889 a vector of the actual parameter values, written as equations:
23890 @cite{[a = 3, b = 2]}, in case you'd rather read them in a list
23891 than pick them out of the formula. (You can type @kbd{t y}
23892 to move this vector to the stack; see @ref{Trail Commands}.
23894 Specifying a different independent variable name will affect the
23895 resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
23896 Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
23897 the equations that go into the trail.
23903 To see what happens when the fit is not exact, we could change
23904 the number 13 in the data matrix to 14 and try the fit again.
23911 Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
23912 a reasonably close match to the y-values in the data.
23915 [4.8, 7., 9.2, 11.4, 13.6]
23918 Since there is no line which passes through all the @var{n} data points,
23919 Calc has chosen a line that best approximates the data points using
23920 the method of least squares. The idea is to define the @dfn{chi-square}
23925 chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
23931 $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
23936 which is clearly zero if @cite{a + b x} exactly fits all data points,
23937 and increases as various @cite{a + b x_i} values fail to match the
23938 corresponding @cite{y_i} values. There are several reasons why the
23939 summand is squared, one of them being to ensure that @c{$\chi^2 \ge 0$}
23941 Least-squares fitting simply chooses the values of @cite{a} and @cite{b}
23942 for which the error @c{$\chi^2$}
23943 @cite{chi^2} is as small as possible.
23945 Other kinds of models do the same thing but with a different model
23946 formula in place of @cite{a + b x_i}.
23952 A numeric prefix argument causes the @kbd{a F} command to take the
23953 data in some other form than one big matrix. A positive argument @var{n}
23954 will take @var{N} items from the stack, corresponding to the @var{n} rows
23955 of a data matrix. In the linear case, @var{n} must be 2 since there
23956 is always one independent variable and one dependent variable.
23958 A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
23959 items from the stack, an @var{n}-row matrix of @cite{x} values, and a
23960 vector of @cite{y} values. If there is only one independent variable,
23961 the @cite{x} values can be either a one-row matrix or a plain vector,
23962 in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
23964 @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
23965 @subsection Polynomial and Multilinear Fits
23968 To fit the data to higher-order polynomials, just type one of the
23969 digits @kbd{2} through @kbd{9} when prompted for a model. For example,
23970 we could fit the original data matrix from the previous section
23971 (with 13, not 14) to a parabola instead of a line by typing
23972 @kbd{a F 2 @key{RET}}.
23975 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
23978 Note that since the constant and linear terms are enough to fit the
23979 data exactly, it's no surprise that Calc chose a tiny contribution
23980 for @cite{x^2}. (The fact that it's not exactly zero is due only
23981 to roundoff error. Since our data are exact integers, we could get
23982 an exact answer by typing @kbd{m f} first to get fraction mode.
23983 Then the @cite{x^2} term would vanish altogether. Usually, though,
23984 the data being fitted will be approximate floats so fraction mode
23987 Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
23988 gives a much larger @cite{x^2} contribution, as Calc bends the
23989 line slightly to improve the fit.
23992 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
23995 An important result from the theory of polynomial fitting is that it
23996 is always possible to fit @var{n} data points exactly using a polynomial
23997 of degree @i{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
23998 Using the modified (14) data matrix, a model number of 4 gives
23999 a polynomial that exactly matches all five data points:
24002 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
24005 The actual coefficients we get with a precision of 12, like
24006 @cite{0.0416666663588}, clearly suffer from loss of precision.
24007 It is a good idea to increase the working precision to several
24008 digits beyond what you need when you do a fitting operation.
24009 Or, if your data are exact, use fraction mode to get exact
24012 You can type @kbd{i} instead of a digit at the model prompt to fit
24013 the data exactly to a polynomial. This just counts the number of
24014 columns of the data matrix to choose the degree of the polynomial
24017 Fitting data ``exactly'' to high-degree polynomials is not always
24018 a good idea, though. High-degree polynomials have a tendency to
24019 wiggle uncontrollably in between the fitting data points. Also,
24020 if the exact-fit polynomial is going to be used to interpolate or
24021 extrapolate the data, it is numerically better to use the @kbd{a p}
24022 command described below. @xref{Interpolation}.
24028 Another generalization of the linear model is to assume the
24029 @cite{y} values are a sum of linear contributions from several
24030 @cite{x} values. This is a @dfn{multilinear} fit, and it is also
24031 selected by the @kbd{1} digit key. (Calc decides whether the fit
24032 is linear or multilinear by counting the rows in the data matrix.)
24034 Given the data matrix,
24038 [ [ 1, 2, 3, 4, 5 ]
24040 [ 14.5, 15, 18.5, 22.5, 24 ] ]
24045 the command @kbd{a F 1 @key{RET}} will call the first row @cite{x} and the
24046 second row @cite{y}, and will fit the values in the third row to the
24047 model @cite{a + b x + c y}.
24053 Calc can do multilinear fits with any number of independent variables
24054 (i.e., with any number of data rows).
24060 Yet another variation is @dfn{homogeneous} linear models, in which
24061 the constant term is known to be zero. In the linear case, this
24062 means the model formula is simply @cite{a x}; in the multilinear
24063 case, the model might be @cite{a x + b y + c z}; and in the polynomial
24064 case, the model could be @cite{a x + b x^2 + c x^3}. You can get
24065 a homogeneous linear or multilinear model by pressing the letter
24066 @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
24068 It is certainly possible to have other constrained linear models,
24069 like @cite{2.3 + a x} or @cite{a - 4 x}. While there is no single
24070 key to select models like these, a later section shows how to enter
24071 any desired model by hand. In the first case, for example, you
24072 would enter @kbd{a F ' 2.3 + a x}.
24074 Another class of models that will work but must be entered by hand
24075 are multinomial fits, e.g., @cite{a + b x + c y + d x^2 + e y^2 + f x y}.
24077 @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
24078 @subsection Error Estimates for Fits
24083 With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
24084 fitting operation as @kbd{a F}, but reports the coefficients as error
24085 forms instead of plain numbers. Fitting our two data matrices (first
24086 with 13, then with 14) to a line with @kbd{H a F} gives the results,
24090 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
24093 In the first case the estimated errors are zero because the linear
24094 fit is perfect. In the second case, the errors are nonzero but
24095 moderately small, because the data are still very close to linear.
24097 It is also possible for the @emph{input} to a fitting operation to
24098 contain error forms. The data values must either all include errors
24099 or all be plain numbers. Error forms can go anywhere but generally
24100 go on the numbers in the last row of the data matrix. If the last
24101 row contains error forms
24102 `@var{y_i}@w{ @t{+/-} }@c{$\sigma_i$}
24103 @var{sigma_i}', then the @c{$\chi^2$}
24109 chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
24115 $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
24120 so that data points with larger error estimates contribute less to
24121 the fitting operation.
24123 If there are error forms on other rows of the data matrix, all the
24124 errors for a given data point are combined; the square root of the
24125 sum of the squares of the errors forms the @c{$\sigma_i$}
24126 @cite{sigma_i} used for
24129 Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
24130 matrix, although if you are concerned about error analysis you will
24131 probably use @kbd{H a F} so that the output also contains error
24134 If the input contains error forms but all the @c{$\sigma_i$}
24135 @cite{sigma_i} values are
24136 the same, it is easy to see that the resulting fitted model will be
24137 the same as if the input did not have error forms at all (@c{$\chi^2$}
24139 is simply scaled uniformly by @c{$1 / \sigma^2$}
24140 @cite{1 / sigma^2}, which doesn't affect
24141 where it has a minimum). But there @emph{will} be a difference
24142 in the estimated errors of the coefficients reported by @kbd{H a F}.
24144 Consult any text on statistical modeling of data for a discussion
24145 of where these error estimates come from and how they should be
24154 With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
24155 information. The result is a vector of six items:
24159 The model formula with error forms for its coefficients or
24160 parameters. This is the result that @kbd{H a F} would have
24164 A vector of ``raw'' parameter values for the model. These are the
24165 polynomial coefficients or other parameters as plain numbers, in the
24166 same order as the parameters appeared in the final prompt of the
24167 @kbd{I a F} command. For polynomials of degree @cite{d}, this vector
24168 will have length @cite{M = d+1} with the constant term first.
24171 The covariance matrix @cite{C} computed from the fit. This is
24172 an @var{m}x@var{m} symmetric matrix; the diagonal elements
24174 @cite{C_j_j} are the variances @c{$\sigma_j^2$}
24175 @cite{sigma_j^2} of the parameters.
24176 The other elements are covariances @c{$\sigma_{ij}^2$}
24177 @cite{sigma_i_j^2} that describe the
24178 correlation between pairs of parameters. (A related set of
24179 numbers, the @dfn{linear correlation coefficients} @c{$r_{ij}$}
24181 are defined as @c{$\sigma_{ij}^2 / \sigma_i \, \sigma_j$}
24182 @cite{sigma_i_j^2 / sigma_i sigma_j}.)
24185 A vector of @cite{M} ``parameter filter'' functions whose
24186 meanings are described below. If no filters are necessary this
24187 will instead be an empty vector; this is always the case for the
24188 polynomial and multilinear fits described so far.
24191 The value of @c{$\chi^2$}
24192 @cite{chi^2} for the fit, calculated by the formulas
24193 shown above. This gives a measure of the quality of the fit;
24194 statisticians consider @c{$\chi^2 \approx N - M$}
24195 @cite{chi^2 = N - M} to indicate a moderately good fit
24196 (where again @cite{N} is the number of data points and @cite{M}
24197 is the number of parameters).
24200 A measure of goodness of fit expressed as a probability @cite{Q}.
24201 This is computed from the @code{utpc} probability distribution
24202 function using @c{$\chi^2$}
24203 @cite{chi^2} with @cite{N - M} degrees of freedom. A
24204 value of 0.5 implies a good fit; some texts recommend that often
24205 @cite{Q = 0.1} or even 0.001 can signify an acceptable fit. In
24206 particular, @c{$\chi^2$}
24207 @cite{chi^2} statistics assume the errors in your inputs
24208 follow a normal (Gaussian) distribution; if they don't, you may
24209 have to accept smaller values of @cite{Q}.
24211 The @cite{Q} value is computed only if the input included error
24212 estimates. Otherwise, Calc will report the symbol @code{nan}
24213 for @cite{Q}. The reason is that in this case the @c{$\chi^2$}
24215 value has effectively been used to estimate the original errors
24216 in the input, and thus there is no redundant information left
24217 over to use for a confidence test.
24220 @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
24221 @subsection Standard Nonlinear Models
24224 The @kbd{a F} command also accepts other kinds of models besides
24225 lines and polynomials. Some common models have quick single-key
24226 abbreviations; others must be entered by hand as algebraic formulas.
24228 Here is a complete list of the standard models recognized by @kbd{a F}:
24232 Linear or multilinear. @i{a + b x + c y + d z}.
24234 Polynomials. @i{a + b x + c x^2 + d x^3}.
24236 Exponential. @i{a} @t{exp}@i{(b x)} @t{exp}@i{(c y)}.
24238 Base-10 exponential. @i{a} @t{10^}@i{(b x)} @t{10^}@i{(c y)}.
24240 Exponential (alternate notation). @t{exp}@i{(a + b x + c y)}.
24242 Base-10 exponential (alternate). @t{10^}@i{(a + b x + c y)}.
24244 Logarithmic. @i{a + b} @t{ln}@i{(x) + c} @t{ln}@i{(y)}.
24246 Base-10 logarithmic. @i{a + b} @t{log10}@i{(x) + c} @t{log10}@i{(y)}.
24248 General exponential. @i{a b^x c^y}.
24250 Power law. @i{a x^b y^c}.
24252 Quadratic. @i{a + b (x-c)^2 + d (x-e)^2}.
24254 Gaussian. @c{${a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)$}
24255 @i{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
24258 All of these models are used in the usual way; just press the appropriate
24259 letter at the model prompt, and choose variable names if you wish. The
24260 result will be a formula as shown in the above table, with the best-fit
24261 values of the parameters substituted. (You may find it easier to read
24262 the parameter values from the vector that is placed in the trail.)
24264 All models except Gaussian and polynomials can generalize as shown to any
24265 number of independent variables. Also, all the built-in models have an
24266 additive or multiplicative parameter shown as @cite{a} in the above table
24267 which can be replaced by zero or one, as appropriate, by typing @kbd{h}
24268 before the model key.
24270 Note that many of these models are essentially equivalent, but express
24271 the parameters slightly differently. For example, @cite{a b^x} and
24272 the other two exponential models are all algebraic rearrangements of
24273 each other. Also, the ``quadratic'' model is just a degree-2 polynomial
24274 with the parameters expressed differently. Use whichever form best
24275 matches the problem.
24277 The HP-28/48 calculators support four different models for curve
24278 fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
24279 These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
24280 @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case,
24281 @cite{a} is what the HP-48 identifies as the ``intercept,'' and
24282 @cite{b} is what it calls the ``slope.''
24288 If the model you want doesn't appear on this list, press @kbd{'}
24289 (the apostrophe key) at the model prompt to enter any algebraic
24290 formula, such as @kbd{m x - b}, as the model. (Not all models
24291 will work, though---see the next section for details.)
24293 The model can also be an equation like @cite{y = m x + b}.
24294 In this case, Calc thinks of all the rows of the data matrix on
24295 equal terms; this model effectively has two parameters
24296 (@cite{m} and @cite{b}) and two independent variables (@cite{x}
24297 and @cite{y}), with no ``dependent'' variables. Model equations
24298 do not need to take this @cite{y =} form. For example, the
24299 implicit line equation @cite{a x + b y = 1} works fine as a
24302 When you enter a model, Calc makes an alphabetical list of all
24303 the variables that appear in the model. These are used for the
24304 default parameters, independent variables, and dependent variable
24305 (in that order). If you enter a plain formula (not an equation),
24306 Calc assumes the dependent variable does not appear in the formula
24307 and thus does not need a name.
24309 For example, if the model formula has the variables @cite{a,mu,sigma,t,x},
24310 and the data matrix has three rows (meaning two independent variables),
24311 Calc will use @cite{a,mu,sigma} as the default parameters, and the
24312 data rows will be named @cite{t} and @cite{x}, respectively. If you
24313 enter an equation instead of a plain formula, Calc will use @cite{a,mu}
24314 as the parameters, and @cite{sigma,t,x} as the three independent
24317 You can, of course, override these choices by entering something
24318 different at the prompt. If you leave some variables out of the list,
24319 those variables must have stored values and those stored values will
24320 be used as constants in the model. (Stored values for the parameters
24321 and independent variables are ignored by the @kbd{a F} command.)
24322 If you list only independent variables, all the remaining variables
24323 in the model formula will become parameters.
24325 If there are @kbd{$} signs in the model you type, they will stand
24326 for parameters and all other variables (in alphabetical order)
24327 will be independent. Use @kbd{$} for one parameter, @kbd{$$} for
24328 another, and so on. Thus @kbd{$ x + $$} is another way to describe
24331 If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
24332 Calc will take the model formula from the stack. (The data must then
24333 appear at the second stack level.) The same conventions are used to
24334 choose which variables in the formula are independent by default and
24335 which are parameters.
24337 Models taken from the stack can also be expressed as vectors of
24338 two or three elements, @cite{[@var{model}, @var{vars}]} or
24339 @cite{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars}
24340 and @var{params} may be either a variable or a vector of variables.
24341 (If @var{params} is omitted, all variables in @var{model} except
24342 those listed as @var{vars} are parameters.)@refill
24344 When you enter a model manually with @kbd{'}, Calc puts a 3-vector
24345 describing the model in the trail so you can get it back if you wish.
24353 Finally, you can store a model in one of the Calc variables
24354 @code{Model1} or @code{Model2}, then use this model by typing
24355 @kbd{a F u} or @kbd{a F U} (respectively). The value stored in
24356 the variable can be any of the formats that @kbd{a F $} would
24357 accept for a model on the stack.
24363 Calc uses the principal values of inverse functions like @code{ln}
24364 and @code{arcsin} when doing fits. For example, when you enter
24365 the model @samp{y = sin(a t + b)} Calc actually uses the easier
24366 form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always
24367 returns results in the range from @i{-90} to 90 degrees (or the
24368 equivalent range in radians). Suppose you had data that you
24369 believed to represent roughly three oscillations of a sine wave,
24370 so that the argument of the sine might go from zero to @c{$3\times360$}
24372 The above model would appear to be a good way to determine the
24373 true frequency and phase of the sine wave, but in practice it
24374 would fail utterly. The righthand side of the actual model
24375 @samp{arcsin(y) = a t + b} will grow smoothly with @cite{t}, but
24376 the lefthand side will bounce back and forth between @i{-90} and 90.
24377 No values of @cite{a} and @cite{b} can make the two sides match,
24378 even approximately.
24380 There is no good solution to this problem at present. You could
24381 restrict your data to small enough ranges so that the above problem
24382 doesn't occur (i.e., not straddling any peaks in the sine wave).
24383 Or, in this case, you could use a totally different method such as
24384 Fourier analysis, which is beyond the scope of the @kbd{a F} command.
24385 (Unfortunately, Calc does not currently have any facilities for
24386 taking Fourier and related transforms.)
24388 @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
24389 @subsection Curve Fitting Details
24392 Calc's internal least-squares fitter can only handle multilinear
24393 models. More precisely, it can handle any model of the form
24394 @cite{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @cite{a,b,c}
24395 are the parameters and @cite{x,y,z} are the independent variables
24396 (of course there can be any number of each, not just three).
24398 In a simple multilinear or polynomial fit, it is easy to see how
24399 to convert the model into this form. For example, if the model
24400 is @cite{a + b x + c x^2}, then @cite{f(x) = 1}, @cite{g(x) = x},
24401 and @cite{h(x) = x^2} are suitable functions.
24403 For other models, Calc uses a variety of algebraic manipulations
24404 to try to put the problem into the form
24407 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)
24411 where @cite{Y,A,B,C,F,G,H} are arbitrary functions. It computes
24412 @cite{Y}, @cite{F}, @cite{G}, and @cite{H} for all the data points,
24413 does a standard linear fit to find the values of @cite{A}, @cite{B},
24414 and @cite{C}, then uses the equation solver to solve for @cite{a,b,c}
24415 in terms of @cite{A,B,C}.
24417 A remarkable number of models can be cast into this general form.
24418 We'll look at two examples here to see how it works. The power-law
24419 model @cite{y = a x^b} with two independent variables and two parameters
24420 can be rewritten as follows:
24425 y = exp(ln(a) + b ln(x))
24426 ln(y) = ln(a) + b ln(x)
24430 which matches the desired form with @c{$Y = \ln(y)$}
24431 @cite{Y = ln(y)}, @c{$A = \ln(a)$}
24433 @cite{F = 1}, @cite{B = b}, and @c{$G = \ln(x)$}
24434 @cite{G = ln(x)}. Calc thus computes
24435 the logarithms of your @cite{y} and @cite{x} values, does a linear fit
24436 for @cite{A} and @cite{B}, then solves to get @c{$a = \exp(A)$}
24437 @cite{a = exp(A)} and
24440 Another interesting example is the ``quadratic'' model, which can
24441 be handled by expanding according to the distributive law.
24444 y = a + b*(x - c)^2
24445 y = a + b c^2 - 2 b c x + b x^2
24449 which matches with @cite{Y = y}, @cite{A = a + b c^2}, @cite{F = 1},
24450 @cite{B = -2 b c}, @cite{G = x} (the @i{-2} factor could just as easily
24451 have been put into @cite{G} instead of @cite{B}), @cite{C = b}, and
24454 The Gaussian model looks quite complicated, but a closer examination
24455 shows that it's actually similar to the quadratic model but with an
24456 exponential that can be brought to the top and moved into @cite{Y}.
24458 An example of a model that cannot be put into general linear
24459 form is a Gaussian with a constant background added on, i.e.,
24460 @cite{d} + the regular Gaussian formula. If you have a model like
24461 this, your best bet is to replace enough of your parameters with
24462 constants to make the model linearizable, then adjust the constants
24463 manually by doing a series of fits. You can compare the fits by
24464 graphing them, by examining the goodness-of-fit measures returned by
24465 @kbd{I a F}, or by some other method suitable to your application.
24466 Note that some models can be linearized in several ways. The
24467 Gaussian-plus-@var{d} model can be linearized by setting @cite{d}
24468 (the background) to a constant, or by setting @cite{b} (the standard
24469 deviation) and @cite{c} (the mean) to constants.
24471 To fit a model with constants substituted for some parameters, just
24472 store suitable values in those parameter variables, then omit them
24473 from the list of parameters when you answer the variables prompt.
24479 A last desperate step would be to use the general-purpose
24480 @code{minimize} function rather than @code{fit}. After all, both
24481 functions solve the problem of minimizing an expression (the @c{$\chi^2$}
24483 sum) by adjusting certain parameters in the expression. The @kbd{a F}
24484 command is able to use a vastly more efficient algorithm due to its
24485 special knowledge about linear chi-square sums, but the @kbd{a N}
24486 command can do the same thing by brute force.
24488 A compromise would be to pick out a few parameters without which the
24489 fit is linearizable, and use @code{minimize} on a call to @code{fit}
24490 which efficiently takes care of the rest of the parameters. The thing
24491 to be minimized would be the value of @c{$\chi^2$}
24492 @cite{chi^2} returned as
24493 the fifth result of the @code{xfit} function:
24496 minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
24500 where @code{gaus} represents the Gaussian model with background,
24501 @code{data} represents the data matrix, and @code{guess} represents
24502 the initial guess for @cite{d} that @code{minimize} requires.
24503 This operation will only be, shall we say, extraordinarily slow
24504 rather than astronomically slow (as would be the case if @code{minimize}
24505 were used by itself to solve the problem).
24511 The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
24512 nonlinear models are used. The second item in the result is the
24513 vector of ``raw'' parameters @cite{A}, @cite{B}, @cite{C}. The
24514 covariance matrix is written in terms of those raw parameters.
24515 The fifth item is a vector of @dfn{filter} expressions. This
24516 is the empty vector @samp{[]} if the raw parameters were the same
24517 as the requested parameters, i.e., if @cite{A = a}, @cite{B = b},
24518 and so on (which is always true if the model is already linear
24519 in the parameters as written, e.g., for polynomial fits). If the
24520 parameters had to be rearranged, the fifth item is instead a vector
24521 of one formula per parameter in the original model. The raw
24522 parameters are expressed in these ``filter'' formulas as
24523 @samp{fitdummy(1)} for @cite{A}, @samp{fitdummy(2)} for @cite{B},
24526 When Calc needs to modify the model to return the result, it replaces
24527 @samp{fitdummy(1)} in all the filters with the first item in the raw
24528 parameters list, and so on for the other raw parameters, then
24529 evaluates the resulting filter formulas to get the actual parameter
24530 values to be substituted into the original model. In the case of
24531 @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
24532 Calc uses the square roots of the diagonal entries of the covariance
24533 matrix as error values for the raw parameters, then lets Calc's
24534 standard error-form arithmetic take it from there.
24536 If you use @kbd{I a F} with a nonlinear model, be sure to remember
24537 that the covariance matrix is in terms of the raw parameters,
24538 @emph{not} the actual requested parameters. It's up to you to
24539 figure out how to interpret the covariances in the presence of
24540 nontrivial filter functions.
24542 Things are also complicated when the input contains error forms.
24543 Suppose there are three independent and dependent variables, @cite{x},
24544 @cite{y}, and @cite{z}, one or more of which are error forms in the
24545 data. Calc combines all the error values by taking the square root
24546 of the sum of the squares of the errors. It then changes @cite{x}
24547 and @cite{y} to be plain numbers, and makes @cite{z} into an error
24548 form with this combined error. The @cite{Y(x,y,z)} part of the
24549 linearized model is evaluated, and the result should be an error
24550 form. The error part of that result is used for @c{$\sigma_i$}
24552 the data point. If for some reason @cite{Y(x,y,z)} does not return
24553 an error form, the combined error from @cite{z} is used directly
24555 @cite{sigma_i}. Finally, @cite{z} is also stripped of its error
24556 for use in computing @cite{F(x,y,z)}, @cite{G(x,y,z)} and so on;
24557 the righthand side of the linearized model is computed in regular
24558 arithmetic with no error forms.
24560 (While these rules may seem complicated, they are designed to do
24561 the most reasonable thing in the typical case that @cite{Y(x,y,z)}
24562 depends only on the dependent variable @cite{z}, and in fact is
24563 often simply equal to @cite{z}. For common cases like polynomials
24564 and multilinear models, the combined error is simply used as the
24566 @cite{sigma} for the data point with no further ado.)
24573 It may be the case that the model you wish to use is linearizable,
24574 but Calc's built-in rules are unable to figure it out. Calc uses
24575 its algebraic rewrite mechanism to linearize a model. The rewrite
24576 rules are kept in the variable @code{FitRules}. You can edit this
24577 variable using the @kbd{s e FitRules} command; in fact, there is
24578 a special @kbd{s F} command just for editing @code{FitRules}.
24579 @xref{Operations on Variables}.
24581 @xref{Rewrite Rules}, for a discussion of rewrite rules.
24615 Calc uses @code{FitRules} as follows. First, it converts the model
24616 to an equation if necessary and encloses the model equation in a
24617 call to the function @code{fitmodel} (which is not actually a defined
24618 function in Calc; it is only used as a placeholder by the rewrite rules).
24619 Parameter variables are renamed to function calls @samp{fitparam(1)},
24620 @samp{fitparam(2)}, and so on, and independent variables are renamed
24621 to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable
24622 is the highest-numbered @code{fitvar}. For example, the power law
24623 model @cite{a x^b} is converted to @cite{y = a x^b}, then to
24627 fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
24631 Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
24632 (The zero prefix means that rewriting should continue until no further
24633 changes are possible.)
24635 When rewriting is complete, the @code{fitmodel} call should have
24636 been replaced by a @code{fitsystem} call that looks like this:
24639 fitsystem(@var{Y}, @var{FGH}, @var{abc})
24643 where @var{Y} is a formula that describes the function @cite{Y(x,y,z)},
24644 @var{FGH} is the vector of formulas @cite{[F(x,y,z), G(x,y,z), H(x,y,z)]},
24645 and @var{abc} is the vector of parameter filters which refer to the
24646 raw parameters as @samp{fitdummy(1)} for @cite{A}, @samp{fitdummy(2)}
24647 for @cite{B}, etc. While the number of raw parameters (the length of
24648 the @var{FGH} vector) is usually the same as the number of original
24649 parameters (the length of the @var{abc} vector), this is not required.
24651 The power law model eventually boils down to
24655 fitsystem(ln(fitvar(2)),
24656 [1, ln(fitvar(1))],
24657 [exp(fitdummy(1)), fitdummy(2)])
24661 The actual implementation of @code{FitRules} is complicated; it
24662 proceeds in four phases. First, common rearrangements are done
24663 to try to bring linear terms together and to isolate functions like
24664 @code{exp} and @code{ln} either all the way ``out'' (so that they
24665 can be put into @var{Y}) or all the way ``in'' (so that they can
24666 be put into @var{abc} or @var{FGH}). In particular, all
24667 non-constant powers are converted to logs-and-exponentials form,
24668 and the distributive law is used to expand products of sums.
24669 Quotients are rewritten to use the @samp{fitinv} function, where
24670 @samp{fitinv(x)} represents @cite{1/x} while the @code{FitRules}
24671 are operating. (The use of @code{fitinv} makes recognition of
24672 linear-looking forms easier.) If you modify @code{FitRules}, you
24673 will probably only need to modify the rules for this phase.
24675 Phase two, whose rules can actually also apply during phases one
24676 and three, first rewrites @code{fitmodel} to a two-argument
24677 form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
24678 initially zero and @var{model} has been changed from @cite{a=b}
24679 to @cite{a-b} form. It then tries to peel off invertible functions
24680 from the outside of @var{model} and put them into @var{Y} instead,
24681 calling the equation solver to invert the functions. Finally, when
24682 this is no longer possible, the @code{fitmodel} is changed to a
24683 four-argument @code{fitsystem}, where the fourth argument is
24684 @var{model} and the @var{FGH} and @var{abc} vectors are initially
24685 empty. (The last vector is really @var{ABC}, corresponding to
24686 raw parameters, for now.)
24688 Phase three converts a sum of items in the @var{model} to a sum
24689 of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
24690 terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
24691 is all factors that do not involve any variables, @var{b} is all
24692 factors that involve only parameters, and @var{c} is the factors
24693 that involve only independent variables. (If this decomposition
24694 is not possible, the rule set will not complete and Calc will
24695 complain that the model is too complex.) Then @code{fitpart}s
24696 with equal @var{b} or @var{c} components are merged back together
24697 using the distributive law in order to minimize the number of
24698 raw parameters needed.
24700 Phase four moves the @code{fitpart} terms into the @var{FGH} and
24701 @var{ABC} vectors. Also, some of the algebraic expansions that
24702 were done in phase 1 are undone now to make the formulas more
24703 computationally efficient. Finally, it calls the solver one more
24704 time to convert the @var{ABC} vector to an @var{abc} vector, and
24705 removes the fourth @var{model} argument (which by now will be zero)
24706 to obtain the three-argument @code{fitsystem} that the linear
24707 least-squares solver wants to see.
24713 @mindex hasfit@idots
24715 @tindex hasfitparams
24723 Two functions which are useful in connection with @code{FitRules}
24724 are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
24725 whether @cite{x} refers to any parameters or independent variables,
24726 respectively. Specifically, these functions return ``true'' if the
24727 argument contains any @code{fitparam} (or @code{fitvar}) function
24728 calls, and ``false'' otherwise. (Recall that ``true'' means a
24729 nonzero number, and ``false'' means zero. The actual nonzero number
24730 returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
24731 or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
24737 The @code{fit} function in algebraic notation normally takes four
24738 arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
24739 where @var{model} is the model formula as it would be typed after
24740 @kbd{a F '}, @var{vars} is the independent variable or a vector of
24741 independent variables, @var{params} likewise gives the parameter(s),
24742 and @var{data} is the data matrix. Note that the length of @var{vars}
24743 must be equal to the number of rows in @var{data} if @var{model} is
24744 an equation, or one less than the number of rows if @var{model} is
24745 a plain formula. (Actually, a name for the dependent variable is
24746 allowed but will be ignored in the plain-formula case.)
24748 If @var{params} is omitted, the parameters are all variables in
24749 @var{model} except those that appear in @var{vars}. If @var{vars}
24750 is also omitted, Calc sorts all the variables that appear in
24751 @var{model} alphabetically and uses the higher ones for @var{vars}
24752 and the lower ones for @var{params}.
24754 Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
24755 where @var{modelvec} is a 2- or 3-vector describing the model
24756 and variables, as discussed previously.
24758 If Calc is unable to do the fit, the @code{fit} function is left
24759 in symbolic form, ordinarily with an explanatory message. The
24760 message will be ``Model expression is too complex'' if the
24761 linearizer was unable to put the model into the required form.
24763 The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
24764 (for @kbd{I a F}) functions are completely analogous.
24766 @node Interpolation, , Curve Fitting Details, Curve Fitting
24767 @subsection Polynomial Interpolation
24770 @pindex calc-poly-interp
24772 The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
24773 a polynomial interpolation at a particular @cite{x} value. It takes
24774 two arguments from the stack: A data matrix of the sort used by
24775 @kbd{a F}, and a single number which represents the desired @cite{x}
24776 value. Calc effectively does an exact polynomial fit as if by @kbd{a F i},
24777 then substitutes the @cite{x} value into the result in order to get an
24778 approximate @cite{y} value based on the fit. (Calc does not actually
24779 use @kbd{a F i}, however; it uses a direct method which is both more
24780 efficient and more numerically stable.)
24782 The result of @kbd{a p} is actually a vector of two values: The @cite{y}
24783 value approximation, and an error measure @cite{dy} that reflects Calc's
24784 estimation of the probable error of the approximation at that value of
24785 @cite{x}. If the input @cite{x} is equal to any of the @cite{x} values
24786 in the data matrix, the output @cite{y} will be the corresponding @cite{y}
24787 value from the matrix, and the output @cite{dy} will be exactly zero.
24789 A prefix argument of 2 causes @kbd{a p} to take separate x- and
24790 y-vectors from the stack instead of one data matrix.
24792 If @cite{x} is a vector of numbers, @kbd{a p} will return a matrix of
24793 interpolated results for each of those @cite{x} values. (The matrix will
24794 have two columns, the @cite{y} values and the @cite{dy} values.)
24795 If @cite{x} is a formula instead of a number, the @code{polint} function
24796 remains in symbolic form; use the @kbd{a "} command to expand it out to
24797 a formula that describes the fit in symbolic terms.
24799 In all cases, the @kbd{a p} command leaves the data vectors or matrix
24800 on the stack. Only the @cite{x} value is replaced by the result.
24804 The @kbd{H a p} [@code{ratint}] command does a rational function
24805 interpolation. It is used exactly like @kbd{a p}, except that it
24806 uses as its model the quotient of two polynomials. If there are
24807 @cite{N} data points, the numerator and denominator polynomials will
24808 each have degree @cite{N/2} (if @cite{N} is odd, the denominator will
24809 have degree one higher than the numerator).
24811 Rational approximations have the advantage that they can accurately
24812 describe functions that have poles (points at which the function's value
24813 goes to infinity, so that the denominator polynomial of the approximation
24814 goes to zero). If @cite{x} corresponds to a pole of the fitted rational
24815 function, then the result will be a division by zero. If Infinite mode
24816 is enabled, the result will be @samp{[uinf, uinf]}.
24818 There is no way to get the actual coefficients of the rational function
24819 used by @kbd{H a p}. (The algorithm never generates these coefficients
24820 explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
24821 capabilities to fit.)
24823 @node Summations, Logical Operations, Curve Fitting, Algebra
24824 @section Summations
24827 @cindex Summation of a series
24829 @pindex calc-summation
24831 The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
24832 the sum of a formula over a certain range of index values. The formula
24833 is taken from the top of the stack; the command prompts for the
24834 name of the summation index variable, the lower limit of the
24835 sum (any formula), and the upper limit of the sum. If you
24836 enter a blank line at any of these prompts, that prompt and
24837 any later ones are answered by reading additional elements from
24838 the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
24839 produces the result 55.
24842 $$ \sum_{k=1}^5 k^2 = 55 $$
24845 The choice of index variable is arbitrary, but it's best not to
24846 use a variable with a stored value. In particular, while
24847 @code{i} is often a favorite index variable, it should be avoided
24848 in Calc because @code{i} has the imaginary constant @cite{(0, 1)}
24849 as a value. If you pressed @kbd{=} on a sum over @code{i}, it would
24850 be changed to a nonsensical sum over the ``variable'' @cite{(0, 1)}!
24851 If you really want to use @code{i} as an index variable, use
24852 @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
24853 (@xref{Storing Variables}.)
24855 A numeric prefix argument steps the index by that amount rather
24856 than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
24857 yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix
24858 argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
24859 step value, in which case you can enter any formula or enter
24860 a blank line to take the step value from the stack. With the
24861 @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
24862 the stack: The formula, the variable, the lower limit, the
24863 upper limit, and (at the top of the stack), the step value.
24865 Calc knows how to do certain sums in closed form. For example,
24866 @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular,
24867 this is possible if the formula being summed is polynomial or
24868 exponential in the index variable. Sums of logarithms are
24869 transformed into logarithms of products. Sums of trigonometric
24870 and hyperbolic functions are transformed to sums of exponentials
24871 and then done in closed form. Also, of course, sums in which the
24872 lower and upper limits are both numbers can always be evaluated
24873 just by grinding them out, although Calc will use closed forms
24874 whenever it can for the sake of efficiency.
24876 The notation for sums in algebraic formulas is
24877 @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
24878 If @var{step} is omitted, it defaults to one. If @var{high} is
24879 omitted, @var{low} is actually the upper limit and the lower limit
24880 is one. If @var{low} is also omitted, the limits are @samp{-inf}
24881 and @samp{inf}, respectively.
24883 Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)}
24884 returns @cite{1}. This is done by evaluating the sum in closed
24885 form (to @samp{1. - 0.5^n} in this case), then evaluating this
24886 formula with @code{n} set to @code{inf}. Calc's usual rules
24887 for ``infinite'' arithmetic can find the answer from there. If
24888 infinite arithmetic yields a @samp{nan}, or if the sum cannot be
24889 solved in closed form, Calc leaves the @code{sum} function in
24890 symbolic form. @xref{Infinities}.
24892 As a special feature, if the limits are infinite (or omitted, as
24893 described above) but the formula includes vectors subscripted by
24894 expressions that involve the iteration variable, Calc narrows
24895 the limits to include only the range of integers which result in
24896 legal subscripts for the vector. For example, the sum
24897 @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
24899 The limits of a sum do not need to be integers. For example,
24900 @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
24901 Calc computes the number of iterations using the formula
24902 @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
24903 after simplification as if by @kbd{a s}, evaluate to an integer.
24905 If the number of iterations according to the above formula does
24906 not come out to an integer, the sum is illegal and will be left
24907 in symbolic form. However, closed forms are still supplied, and
24908 you are on your honor not to misuse the resulting formulas by
24909 substituting mismatched bounds into them. For example,
24910 @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
24911 evaluate the closed form solution for the limits 1 and 10 to get
24912 the rather dubious answer, 29.25.
24914 If the lower limit is greater than the upper limit (assuming a
24915 positive step size), the result is generally zero. However,
24916 Calc only guarantees a zero result when the upper limit is
24917 exactly one step less than the lower limit, i.e., if the number
24918 of iterations is @i{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero
24919 but the sum from @samp{n} to @samp{n-2} may report a nonzero value
24920 if Calc used a closed form solution.
24922 Calc's logical predicates like @cite{a < b} return 1 for ``true''
24923 and 0 for ``false.'' @xref{Logical Operations}. This can be
24924 used to advantage for building conditional sums. For example,
24925 @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
24926 prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
24927 its argument is prime and 0 otherwise. You can read this expression
24928 as ``the sum of @cite{k^2}, where @cite{k} is prime.'' Indeed,
24929 @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
24930 squared, since the limits default to plus and minus infinity, but
24931 there are no such sums that Calc's built-in rules can do in
24934 As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
24935 sum of @cite{f(k)} for all @cite{k} from 1 to @cite{n}, excluding
24936 one value @cite{k_0}. Slightly more tricky is the summand
24937 @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
24938 the sum of all @cite{1/(k-k_0)} except at @cite{k = k_0}, where
24939 this would be a division by zero. But at @cite{k = k_0}, this
24940 formula works out to the indeterminate form @cite{0 / 0}, which
24941 Calc will not assume is zero. Better would be to use
24942 @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
24943 an ``if-then-else'' test: This expression says, ``if @c{$k \ne k_0$}
24945 then @cite{1/(k-k_0)}, else zero.'' Now the formula @cite{1/(k-k_0)}
24946 will not even be evaluated by Calc when @cite{k = k_0}.
24948 @cindex Alternating sums
24950 @pindex calc-alt-summation
24952 The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
24953 computes an alternating sum. Successive terms of the sequence
24954 are given alternating signs, with the first term (corresponding
24955 to the lower index value) being positive. Alternating sums
24956 are converted to normal sums with an extra term of the form
24957 @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately
24958 if the step value is other than one. For example, the Taylor
24959 series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
24960 (Calc cannot evaluate this infinite series, but it can approximate
24961 it if you replace @code{inf} with any particular odd number.)
24962 Calc converts this series to a regular sum with a step of one,
24963 namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
24965 @cindex Product of a sequence
24967 @pindex calc-product
24969 The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
24970 the analogous way to take a product of many terms. Calc also knows
24971 some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
24972 Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
24973 or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
24976 @pindex calc-tabulate
24978 The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
24979 evaluates a formula at a series of iterated index values, just
24980 like @code{sum} and @code{prod}, but its result is simply a
24981 vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)}
24982 produces @samp{[a_1, a_3, a_5, a_7]}.
24984 @node Logical Operations, Rewrite Rules, Summations, Algebra
24985 @section Logical Operations
24988 The following commands and algebraic functions return true/false values,
24989 where 1 represents ``true'' and 0 represents ``false.'' In cases where
24990 a truth value is required (such as for the condition part of a rewrite
24991 rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
24992 nonzero value is accepted to mean ``true.'' (Specifically, anything
24993 for which @code{dnonzero} returns 1 is ``true,'' and anything for
24994 which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
24995 Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
24996 portion if its condition is provably true, but it will execute the
24997 ``else'' portion for any condition like @cite{a = b} that is not
24998 provably true, even if it might be true. Algebraic functions that
24999 have conditions as arguments, like @code{? :} and @code{&&}, remain
25000 unevaluated if the condition is neither provably true nor provably
25001 false. @xref{Declarations}.)
25004 @pindex calc-equal-to
25008 The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
25009 (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
25010 formula) is true if @cite{a} and @cite{b} are equal, either because they
25011 are identical expressions, or because they are numbers which are
25012 numerically equal. (Thus the integer 1 is considered equal to the float
25013 1.0.) If the equality of @cite{a} and @cite{b} cannot be determined,
25014 the comparison is left in symbolic form. Note that as a command, this
25015 operation pops two values from the stack and pushes back either a 1 or
25016 a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
25018 Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
25019 For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
25020 an equation to solve for a given variable. The @kbd{a M}
25021 (@code{calc-map-equation}) command can be used to apply any
25022 function to both sides of an equation; for example, @kbd{2 a M *}
25023 multiplies both sides of the equation by two. Note that just
25024 @kbd{2 *} would not do the same thing; it would produce the formula
25025 @samp{2 (a = b)} which represents 2 if the equality is true or
25028 The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
25029 or @samp{a = b = c}) tests if all of its arguments are equal. In
25030 algebraic notation, the @samp{=} operator is unusual in that it is
25031 neither left- nor right-associative: @samp{a = b = c} is not the
25032 same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
25033 one variable with the 1 or 0 that results from comparing two other
25037 @pindex calc-not-equal-to
25040 The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
25041 @samp{a != b} function, is true if @cite{a} and @cite{b} are not equal.
25042 This also works with more than two arguments; @samp{a != b != c != d}
25043 tests that all four of @cite{a}, @cite{b}, @cite{c}, and @cite{d} are
25060 @pindex calc-less-than
25061 @pindex calc-greater-than
25062 @pindex calc-less-equal
25063 @pindex calc-greater-equal
25092 The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
25093 operation is true if @cite{a} is less than @cite{b}. Similar functions
25094 are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
25095 @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
25096 @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
25098 While the inequality functions like @code{lt} do not accept more
25099 than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
25100 equivalent expression involving intervals: @samp{b in [a .. c)}.
25101 (See the description of @code{in} below.) All four combinations
25102 of @samp{<} and @samp{<=} are allowed, or any of the four combinations
25103 of @samp{>} and @samp{>=}. Four-argument constructions like
25104 @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
25105 involve both equalities and inequalities, are not allowed.
25108 @pindex calc-remove-equal
25110 The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
25111 the righthand side of the equation or inequality on the top of the
25112 stack. It also works elementwise on vectors. For example, if
25113 @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
25114 @samp{[2.34, z / 2]}. As a special case, if the righthand side is a
25115 variable and the lefthand side is a number (as in @samp{2.34 = x}), then
25116 Calc keeps the lefthand side instead. Finally, this command works with
25117 assignments @samp{x := 2.34} as well as equations, always taking the
25118 the righthand side, and for @samp{=>} (evaluates-to) operators, always
25119 taking the lefthand side.
25122 @pindex calc-logical-and
25125 The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
25126 function is true if both of its arguments are true, i.e., are
25127 non-zero numbers. In this case, the result will be either @cite{a} or
25128 @cite{b}, chosen arbitrarily. If either argument is zero, the result is
25129 zero. Otherwise, the formula is left in symbolic form.
25132 @pindex calc-logical-or
25135 The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
25136 function is true if either or both of its arguments are true (nonzero).
25137 The result is whichever argument was nonzero, choosing arbitrarily if both
25138 are nonzero. If both @cite{a} and @cite{b} are zero, the result is
25142 @pindex calc-logical-not
25145 The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
25146 function is true if @cite{a} is false (zero), or false if @cite{a} is
25147 true (nonzero). It is left in symbolic form if @cite{a} is not a
25151 @pindex calc-logical-if
25161 @cindex Arguments, not evaluated
25162 The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
25163 function is equal to either @cite{b} or @cite{c} if @cite{a} is a nonzero
25164 number or zero, respectively. If @cite{a} is not a number, the test is
25165 left in symbolic form and neither @cite{b} nor @cite{c} is evaluated in
25166 any way. In algebraic formulas, this is one of the few Calc functions
25167 whose arguments are not automatically evaluated when the function itself
25168 is evaluated. The others are @code{lambda}, @code{quote}, and
25171 One minor surprise to watch out for is that the formula @samp{a?3:4}
25172 will not work because the @samp{3:4} is parsed as a fraction instead of
25173 as three separate symbols. Type something like @samp{a ? 3 : 4} or
25174 @samp{a?(3):4} instead.
25176 As a special case, if @cite{a} evaluates to a vector, then both @cite{b}
25177 and @cite{c} are evaluated; the result is a vector of the same length
25178 as @cite{a} whose elements are chosen from corresponding elements of
25179 @cite{b} and @cite{c} according to whether each element of @cite{a}
25180 is zero or nonzero. Each of @cite{b} and @cite{c} must be either a
25181 vector of the same length as @cite{a}, or a non-vector which is matched
25182 with all elements of @cite{a}.
25185 @pindex calc-in-set
25187 The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
25188 the number @cite{a} is in the set of numbers represented by @cite{b}.
25189 If @cite{b} is an interval form, @cite{a} must be one of the values
25190 encompassed by the interval. If @cite{b} is a vector, @cite{a} must be
25191 equal to one of the elements of the vector. (If any vector elements are
25192 intervals, @cite{a} must be in any of the intervals.) If @cite{b} is a
25193 plain number, @cite{a} must be numerically equal to @cite{b}.
25194 @xref{Set Operations}, for a group of commands that manipulate sets
25201 The @samp{typeof(a)} function produces an integer or variable which
25202 characterizes @cite{a}. If @cite{a} is a number, vector, or variable,
25203 the result will be one of the following numbers:
25208 3 Floating-point number
25210 5 Rectangular complex number
25211 6 Polar complex number
25217 12 Infinity (inf, uinf, or nan)
25219 101 Vector (but not a matrix)
25223 Otherwise, @cite{a} is a formula, and the result is a variable which
25224 represents the name of the top-level function call.
25238 The @samp{integer(a)} function returns true if @cite{a} is an integer.
25239 The @samp{real(a)} function
25240 is true if @cite{a} is a real number, either integer, fraction, or
25241 float. The @samp{constant(a)} function returns true if @cite{a} is
25242 any of the objects for which @code{typeof} would produce an integer
25243 code result except for variables, and provided that the components of
25244 an object like a vector or error form are themselves constant.
25245 Note that infinities do not satisfy any of these tests, nor do
25246 special constants like @code{pi} and @code{e}.@refill
25248 @xref{Declarations}, for a set of similar functions that recognize
25249 formulas as well as actual numbers. For example, @samp{dint(floor(x))}
25250 is true because @samp{floor(x)} is provably integer-valued, but
25251 @samp{integer(floor(x))} does not because @samp{floor(x)} is not
25252 literally an integer constant.
25258 The @samp{refers(a,b)} function is true if the variable (or sub-expression)
25259 @cite{b} appears in @cite{a}, or false otherwise. Unlike the other
25260 tests described here, this function returns a definite ``no'' answer
25261 even if its arguments are still in symbolic form. The only case where
25262 @code{refers} will be left unevaluated is if @cite{a} is a plain
25263 variable (different from @cite{b}).
25269 The @samp{negative(a)} function returns true if @cite{a} ``looks'' negative,
25270 because it is a negative number, because it is of the form @cite{-x},
25271 or because it is a product or quotient with a term that looks negative.
25272 This is most useful in rewrite rules. Beware that @samp{negative(a)}
25273 evaluates to 1 or 0 for @emph{any} argument @cite{a}, so it can only
25274 be stored in a formula if the default simplifications are turned off
25275 first with @kbd{m O} (or if it appears in an unevaluated context such
25276 as a rewrite rule condition).
25282 The @samp{variable(a)} function is true if @cite{a} is a variable,
25283 or false if not. If @cite{a} is a function call, this test is left
25284 in symbolic form. Built-in variables like @code{pi} and @code{inf}
25285 are considered variables like any others by this test.
25291 The @samp{nonvar(a)} function is true if @cite{a} is a non-variable.
25292 If its argument is a variable it is left unsimplified; it never
25293 actually returns zero. However, since Calc's condition-testing
25294 commands consider ``false'' anything not provably true, this is
25313 @cindex Linearity testing
25314 The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
25315 check if an expression is ``linear,'' i.e., can be written in the form
25316 @cite{a + b x} for some constants @cite{a} and @cite{b}, and some
25317 variable or subformula @cite{x}. The function @samp{islin(f,x)} checks
25318 if formula @cite{f} is linear in @cite{x}, returning 1 if so. For
25319 example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
25320 @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function
25321 is similar, except that instead of returning 1 it returns the vector
25322 @cite{[a, b, x]}. For the above examples, this vector would be
25323 @cite{[0, 1, x]}, @cite{[0, -1, x]}, @cite{[3, 0, x]}, and
25324 @cite{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin}
25325 generally remain unevaluated for expressions which are not linear,
25326 e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second
25327 argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
25330 The @code{linnt} and @code{islinnt} functions perform a similar check,
25331 but require a ``non-trivial'' linear form, which means that the
25332 @cite{b} coefficient must be non-zero. For example, @samp{lin(2,x)}
25333 returns @cite{[2, 0, x]} and @samp{lin(y,x)} returns @cite{[y, 0, x]},
25334 but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
25335 (in other words, these formulas are considered to be only ``trivially''
25336 linear in @cite{x}).
25338 All four linearity-testing functions allow you to omit the second
25339 argument, in which case the input may be linear in any non-constant
25340 formula. Here, the @cite{a=0}, @cite{b=1} case is also considered
25341 trivial, and only constant values for @cite{a} and @cite{b} are
25342 recognized. Thus, @samp{lin(2 x y)} returns @cite{[0, 2, x y]},
25343 @samp{lin(2 - x y)} returns @cite{[2, -1, x y]}, and @samp{lin(x y)}
25344 returns @cite{[0, 1, x y]}. The @code{linnt} function would allow the
25345 first two cases but not the third. Also, neither @code{lin} nor
25346 @code{linnt} accept plain constants as linear in the one-argument
25347 case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
25353 The @samp{istrue(a)} function returns 1 if @cite{a} is a nonzero
25354 number or provably nonzero formula, or 0 if @cite{a} is anything else.
25355 Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
25356 used to make sure they are not evaluated prematurely. (Note that
25357 declarations are used when deciding whether a formula is true;
25358 @code{istrue} returns 1 when @code{dnonzero} would return 1, and
25359 it returns 0 when @code{dnonzero} would return 0 or leave itself
25362 @node Rewrite Rules, , Logical Operations, Algebra
25363 @section Rewrite Rules
25366 @cindex Rewrite rules
25367 @cindex Transformations
25368 @cindex Pattern matching
25370 @pindex calc-rewrite
25372 The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
25373 substitutions in a formula according to a specified pattern or patterns
25374 known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute})
25375 matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
25376 matches only the @code{sin} function applied to the variable @code{x},
25377 rewrite rules match general kinds of formulas; rewriting using the rule
25378 @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
25379 it with @code{cos} of that same argument. The only significance of the
25380 name @code{x} is that the same name is used on both sides of the rule.
25382 Rewrite rules rearrange formulas already in Calc's memory.
25383 @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
25384 similar to algebraic rewrite rules but operate when new algebraic
25385 entries are being parsed, converting strings of characters into
25389 * Entering Rewrite Rules::
25390 * Basic Rewrite Rules::
25391 * Conditional Rewrite Rules::
25392 * Algebraic Properties of Rewrite Rules::
25393 * Other Features of Rewrite Rules::
25394 * Composing Patterns in Rewrite Rules::
25395 * Nested Formulas with Rewrite Rules::
25396 * Multi-Phase Rewrite Rules::
25397 * Selections with Rewrite Rules::
25398 * Matching Commands::
25399 * Automatic Rewrites::
25400 * Debugging Rewrites::
25401 * Examples of Rewrite Rules::
25404 @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
25405 @subsection Entering Rewrite Rules
25408 Rewrite rules normally use the ``assignment'' operator
25409 @samp{@var{old} := @var{new}}.
25410 This operator is equivalent to the function call @samp{assign(old, new)}.
25411 The @code{assign} function is undefined by itself in Calc, so an
25412 assignment formula such as a rewrite rule will be left alone by ordinary
25413 Calc commands. But certain commands, like the rewrite system, interpret
25414 assignments in special ways.@refill
25416 For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
25417 every occurrence of the sine of something, squared, with one minus the
25418 square of the cosine of that same thing. All by itself as a formula
25419 on the stack it does nothing, but when given to the @kbd{a r} command
25420 it turns that command into a sine-squared-to-cosine-squared converter.
25422 To specify a set of rules to be applied all at once, make a vector of
25425 When @kbd{a r} prompts you to enter the rewrite rules, you can answer
25430 With a rule: @kbd{f(x) := g(x) @key{RET}}.
25432 With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
25433 (You can omit the enclosing square brackets if you wish.)
25435 With the name of a variable that contains the rule or rules vector:
25436 @kbd{myrules @key{RET}}.
25438 With any formula except a rule, a vector, or a variable name; this
25439 will be interpreted as the @var{old} half of a rewrite rule,
25440 and you will be prompted a second time for the @var{new} half:
25441 @kbd{f(x) @key{RET} g(x) @key{RET}}.
25443 With a blank line, in which case the rule, rules vector, or variable
25444 will be taken from the top of the stack (and the formula to be
25445 rewritten will come from the second-to-top position).
25448 If you enter the rules directly (as opposed to using rules stored
25449 in a variable), those rules will be put into the Trail so that you
25450 can retrieve them later. @xref{Trail Commands}.
25452 It is most convenient to store rules you use often in a variable and
25453 invoke them by giving the variable name. The @kbd{s e}
25454 (@code{calc-edit-variable}) command is an easy way to create or edit a
25455 rule set stored in a variable. You may also wish to use @kbd{s p}
25456 (@code{calc-permanent-variable}) to save your rules permanently;
25457 @pxref{Operations on Variables}.@refill
25459 Rewrite rules are compiled into a special internal form for faster
25460 matching. If you enter a rule set directly it must be recompiled
25461 every time. If you store the rules in a variable and refer to them
25462 through that variable, they will be compiled once and saved away
25463 along with the variable for later reference. This is another good
25464 reason to store your rules in a variable.
25466 Calc also accepts an obsolete notation for rules, as vectors
25467 @samp{[@var{old}, @var{new}]}. But because it is easily confused with a
25468 vector of two rules, the use of this notation is no longer recommended.
25470 @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
25471 @subsection Basic Rewrite Rules
25474 To match a particular formula @cite{x} with a particular rewrite rule
25475 @samp{@var{old} := @var{new}}, Calc compares the structure of @cite{x} with
25476 the structure of @var{old}. Variables that appear in @var{old} are
25477 treated as @dfn{meta-variables}; the corresponding positions in @cite{x}
25478 may contain any sub-formulas. For example, the pattern @samp{f(x,y)}
25479 would match the expression @samp{f(12, a+1)} with the meta-variable
25480 @samp{x} corresponding to 12 and with @samp{y} corresponding to
25481 @samp{a+1}. However, this pattern would not match @samp{f(12)} or
25482 @samp{g(12, a+1)}, since there is no assignment of the meta-variables
25483 that will make the pattern match these expressions. Notice that if
25484 the pattern is a single meta-variable, it will match any expression.
25486 If a given meta-variable appears more than once in @var{old}, the
25487 corresponding sub-formulas of @cite{x} must be identical. Thus
25488 the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
25489 @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
25490 (@xref{Conditional Rewrite Rules}, for a way to match the latter.)
25492 Things other than variables must match exactly between the pattern
25493 and the target formula. To match a particular variable exactly, use
25494 the pseudo-function @samp{quote(v)} in the pattern. For example, the
25495 pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
25498 The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
25499 @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
25500 literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like
25501 @samp{sin(d + quote(e) + f)}.
25503 If the @var{old} pattern is found to match a given formula, that
25504 formula is replaced by @var{new}, where any occurrences in @var{new}
25505 of meta-variables from the pattern are replaced with the sub-formulas
25506 that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
25507 to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
25509 The normal @kbd{a r} command applies rewrite rules over and over
25510 throughout the target formula until no further changes are possible
25511 (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one
25514 @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
25515 @subsection Conditional Rewrite Rules
25518 A rewrite rule can also be @dfn{conditional}, written in the form
25519 @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete
25520 form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part
25522 rule, this is an additional condition that must be satisfied before
25523 the rule is accepted. Once @var{old} has been successfully matched
25524 to the target expression, @var{cond} is evaluated (with all the
25525 meta-variables substituted for the values they matched) and simplified
25526 with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero
25527 number or any other object known to be nonzero (@pxref{Declarations}),
25528 the rule is accepted. If the result is zero or if it is a symbolic
25529 formula that is not known to be nonzero, the rule is rejected.
25530 @xref{Logical Operations}, for a number of functions that return
25531 1 or 0 according to the results of various tests.@refill
25533 For example, the formula @samp{n > 0} simplifies to 1 or 0 if @cite{n}
25534 is replaced by a positive or nonpositive number, respectively (or if
25535 @cite{n} has been declared to be positive or nonpositive). Thus,
25536 the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
25537 @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
25538 (assuming no outstanding declarations for @cite{a}). In the case of
25539 @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
25540 the case of @samp{f(12, a+1)}, the condition merely cannot be shown
25541 to be satisfied, but that is enough to reject the rule.
25543 While Calc will use declarations to reason about variables in the
25544 formula being rewritten, declarations do not apply to meta-variables.
25545 For example, the rule @samp{f(a) := g(a+1)} will match for any values
25546 of @samp{a}, such as complex numbers, vectors, or formulas, even if
25547 @samp{a} has been declared to be real or scalar. If you want the
25548 meta-variable @samp{a} to match only literal real numbers, use
25549 @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only
25550 reals and formulas which are provably real, use @samp{dreal(a)} as
25553 The @samp{::} operator is a shorthand for the @code{condition}
25554 function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
25555 the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
25557 If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
25558 or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent.
25560 It is also possible to embed conditions inside the pattern:
25561 @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational
25562 convenience, though; where a condition appears in a rule has no
25563 effect on when it is tested. The rewrite-rule compiler automatically
25564 decides when it is best to test each condition while a rule is being
25567 Certain conditions are handled as special cases by the rewrite rule
25568 system and are tested very efficiently: Where @cite{x} is any
25569 meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
25570 @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @cite{y}
25571 is either a constant or another meta-variable and @samp{>=} may be
25572 replaced by any of the six relational operators, and @samp{x % a = b}
25573 where @cite{a} and @cite{b} are constants. Other conditions, like
25574 @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
25575 since Calc must bring the whole evaluator and simplifier into play.
25577 An interesting property of @samp{::} is that neither of its arguments
25578 will be touched by Calc's default simplifications. This is important
25579 because conditions often are expressions that cannot safely be
25580 evaluated early. For example, the @code{typeof} function never
25581 remains in symbolic form; entering @samp{typeof(a)} will put the
25582 number 100 (the type code for variables like @samp{a}) on the stack.
25583 But putting the condition @samp{... :: typeof(a) = 6} on the stack
25584 is safe since @samp{::} prevents the @code{typeof} from being
25585 evaluated until the condition is actually used by the rewrite system.
25587 Since @samp{::} protects its lefthand side, too, you can use a dummy
25588 condition to protect a rule that must itself not evaluate early.
25589 For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
25590 the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
25591 where the meta-variable-ness of @code{f} on the righthand side has been
25592 lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
25593 the condition @samp{1} is always true (nonzero) so it has no effect on
25594 the functioning of the rule. (The rewrite compiler will ensure that
25595 it doesn't even impact the speed of matching the rule.)
25597 @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
25598 @subsection Algebraic Properties of Rewrite Rules
25601 The rewrite mechanism understands the algebraic properties of functions
25602 like @samp{+} and @samp{*}. In particular, pattern matching takes
25603 the associativity and commutativity of the following functions into
25607 + - * = != && || and or xor vint vunion vxor gcd lcm max min beta
25610 For example, the rewrite rule:
25613 a x + b x := (a + b) x
25617 will match formulas of the form,
25620 a x + b x, x a + x b, a x + x b, x a + b x
25623 Rewrites also understand the relationship between the @samp{+} and @samp{-}
25624 operators. The above rewrite rule will also match the formulas,
25627 a x - b x, x a - x b, a x - x b, x a - b x
25631 by matching @samp{b} in the pattern to @samp{-b} from the formula.
25633 Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
25634 pattern will check all pairs of terms for possible matches. The rewrite
25635 will take whichever suitable pair it discovers first.
25637 In general, a pattern using an associative operator like @samp{a + b}
25638 will try @var{2 n} different ways to match a sum of @var{n} terms
25639 like @samp{x + y + z - w}. First, @samp{a} is matched against each
25640 of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
25641 being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
25642 If none of these succeed, then @samp{b} is matched against each of the
25643 four terms with @samp{a} matching the remainder. Half-and-half matches,
25644 like @samp{(x + y) + (z - w)}, are not tried.
25646 Note that @samp{*} is not commutative when applied to matrices, but
25647 rewrite rules pretend that it is. If you type @kbd{m v} to enable
25648 matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
25649 literally, ignoring its usual commutativity property. (In the
25650 current implementation, the associativity also vanishes---it is as
25651 if the pattern had been enclosed in a @code{plain} marker; see below.)
25652 If you are applying rewrites to formulas with matrices, it's best to
25653 enable matrix mode first to prevent algebraically incorrect rewrites
25656 The pattern @samp{-x} will actually match any expression. For example,
25664 will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use
25665 a @code{plain} marker as described below, or add a @samp{negative(x)}
25666 condition. The @code{negative} function is true if its argument
25667 ``looks'' negative, for example, because it is a negative number or
25668 because it is a formula like @samp{-x}. The new rule using this
25672 f(x) := -f(-x) :: negative(x) @r{or, equivalently,}
25673 f(-x) := -f(x) :: negative(-x)
25676 In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
25677 by matching @samp{y} to @samp{-b}.
25679 The pattern @samp{a b} will also match the formula @samp{x/y} if
25680 @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x}
25681 will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
25682 @samp{(a + 1:2) x}, depending on the current fraction mode).
25684 Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
25685 @samp{^}. For example, the pattern @samp{f(a b)} will not match
25686 @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
25687 though conceivably these patterns could match with @samp{a = b = x}.
25688 Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
25689 constant, even though it could be considered to match with @samp{a = x}
25690 and @samp{b = 1/y}. The reasons are partly for efficiency, and partly
25691 because while few mathematical operations are substantively different
25692 for addition and subtraction, often it is preferable to treat the cases
25693 of multiplication, division, and integer powers separately.
25695 Even more subtle is the rule set
25698 [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ]
25702 attempting to match @samp{f(x) - f(y)}. You might think that Calc
25703 will view this subtraction as @samp{f(x) + (-f(y))} and then apply
25704 the above two rules in turn, but actually this will not work because
25705 Calc only does this when considering rules for @samp{+} (like the
25706 first rule in this set). So it will see first that @samp{f(x) + (-f(y))}
25707 does not match @samp{f(a) + f(b)} for any assignments of the
25708 meta-variables, and then it will see that @samp{f(x) - f(y)} does
25709 not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc
25710 tries only one rule at a time, it will not be able to rewrite
25711 @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)}
25712 rule will have to be added.
25714 Another thing patterns will @emph{not} do is break up complex numbers.
25715 The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
25716 involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
25717 it will not match actual complex numbers like @samp{(3, -4)}. A version
25718 of the above rule for complex numbers would be
25721 myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0
25725 (Because the @code{re} and @code{im} functions understand the properties
25726 of the special constant @samp{i}, this rule will also work for
25727 @samp{3 - 4 i}. In fact, this particular rule would probably be better
25728 without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
25729 righthand side of the rule will still give the correct answer for the
25730 conjugate of a real number.)
25732 It is also possible to specify optional arguments in patterns. The rule
25735 opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d)
25739 will match the formula
25746 in a fairly straightforward manner, but it will also match reduced
25750 x + x^2, 2(x + 1) - x, x + x
25754 producing, respectively,
25757 f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0)
25760 (The latter two formulas can be entered only if default simplifications
25761 have been turned off with @kbd{m O}.)
25763 The default value for a term of a sum is zero. The default value
25764 for a part of a product, for a power, or for the denominator of a
25765 quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b}
25766 with @samp{a = -1}.
25768 In particular, the distributive-law rule can be refined to
25771 opt(a) x + opt(b) x := (a + b) x
25775 so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
25777 The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
25778 are linear in @samp{x}. You can also use the @code{lin} and @code{islin}
25779 functions with rewrite conditions to test for this; @pxref{Logical
25780 Operations}. These functions are not as convenient to use in rewrite
25781 rules, but they recognize more kinds of formulas as linear:
25782 @samp{x/z} is considered linear with @cite{b = 1/z} by @code{lin},
25783 but it will not match the above pattern because that pattern calls
25784 for a multiplication, not a division.
25786 As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
25790 sin(x)^2 + cos(x)^2 := 1
25794 misses many cases because the sine and cosine may both be multiplied by
25795 an equal factor. Here's a more successful rule:
25798 opt(a) sin(x)^2 + opt(a) cos(x)^2 := a
25801 Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
25802 because one @cite{a} would have ``matched'' 1 while the other matched 6.
25804 Calc automatically converts a rule like
25814 f(temp, x) := g(x) :: temp = x-1
25818 (where @code{temp} stands for a new, invented meta-variable that
25819 doesn't actually have a name). This modified rule will successfully
25820 match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
25821 respectively, then verifying that they differ by one even though
25822 @samp{6} does not superficially look like @samp{x-1}.
25824 However, Calc does not solve equations to interpret a rule. The
25828 f(x-1, x+1) := g(x)
25832 will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
25833 but not @samp{f(6, 8)}. Calc always interprets at least one occurrence
25834 of a variable by literal matching. If the variable appears ``isolated''
25835 then Calc is smart enough to use it for literal matching. But in this
25836 last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
25837 := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
25838 actual ``something-minus-one'' in the target formula.
25840 A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
25841 You could make this resemble the original form more closely by using
25842 @code{let} notation, which is described in the next section:
25845 f(xm1, x+1) := g(x) :: let(x := xm1+1)
25848 Calc does this rewriting or ``conditionalizing'' for any sub-pattern
25849 which involves only the functions in the following list, operating
25850 only on constants and meta-variables which have already been matched
25851 elsewhere in the pattern. When matching a function call, Calc is
25852 careful to match arguments which are plain variables before arguments
25853 which are calls to any of the functions below, so that a pattern like
25854 @samp{f(x-1, x)} can be conditionalized even though the isolated
25855 @samp{x} comes after the @samp{x-1}.
25858 + - * / \ % ^ abs sign round rounde roundu trunc floor ceil
25859 max min re im conj arg
25862 You can suppress all of the special treatments described in this
25863 section by surrounding a function call with a @code{plain} marker.
25864 This marker causes the function call which is its argument to be
25865 matched literally, without regard to commutativity, associativity,
25866 negation, or conditionalization. When you use @code{plain}, the
25867 ``deep structure'' of the formula being matched can show through.
25871 plain(a - a b) := f(a, b)
25875 will match only literal subtractions. However, the @code{plain}
25876 marker does not affect its arguments' arguments. In this case,
25877 commutativity and associativity is still considered while matching
25878 the @w{@samp{a b}} sub-pattern, so the whole pattern will match
25879 @samp{x - y x} as well as @samp{x - x y}. We could go still
25883 plain(a - plain(a b)) := f(a, b)
25887 which would do a completely strict match for the pattern.
25889 By contrast, the @code{quote} marker means that not only the
25890 function name but also the arguments must be literally the same.
25891 The above pattern will match @samp{x - x y} but
25894 quote(a - a b) := f(a, b)
25898 will match only the single formula @samp{a - a b}. Also,
25901 quote(a - quote(a b)) := f(a, b)
25905 will match only @samp{a - quote(a b)}---probably not the desired
25908 A certain amount of algebra is also done when substituting the
25909 meta-variables on the righthand side of a rule. For example,
25913 a + f(b) := f(a + b)
25917 matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
25918 taken literally, but the rewrite mechanism will simplify the
25919 righthand side to @samp{f(x - y)} automatically. (Of course,
25920 the default simplifications would do this anyway, so this
25921 special simplification is only noticeable if you have turned the
25922 default simplifications off.) This rewriting is done only when
25923 a meta-variable expands to a ``negative-looking'' expression.
25924 If this simplification is not desirable, you can use a @code{plain}
25925 marker on the righthand side:
25928 a + f(b) := f(plain(a + b))
25932 In this example, we are still allowing the pattern-matcher to
25933 use all the algebra it can muster, but the righthand side will
25934 always simplify to a literal addition like @samp{f((-y) + x)}.
25936 @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
25937 @subsection Other Features of Rewrite Rules
25940 Certain ``function names'' serve as markers in rewrite rules.
25941 Here is a complete list of these markers. First are listed the
25942 markers that work inside a pattern; then come the markers that
25943 work in the righthand side of a rule.
25949 One kind of marker, @samp{import(x)}, takes the place of a whole
25950 rule. Here @cite{x} is the name of a variable containing another
25951 rule set; those rules are ``spliced into'' the rule set that
25952 imports them. For example, if @samp{[f(a+b) := f(a) + f(b),
25953 f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
25954 then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
25955 all three rules. It is possible to modify the imported rules
25956 slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports
25957 the rule set @cite{x} with all occurrences of @c{$v_1$}
25958 @cite{v1}, as either
25959 a variable name or a function name, replaced with @c{$x_1$}
25961 so on. (If @c{$v_1$}
25962 @cite{v1} is used as a function name, then @c{$x_1$}
25964 must be either a function name itself or a @w{@samp{< >}} nameless
25965 function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0,
25966 import(linearF, f, g)]} applies the linearity rules to the function
25967 @samp{g} instead of @samp{f}. Imports can be nested, but the
25968 import-with-renaming feature may fail to rename sub-imports properly.
25970 The special functions allowed in patterns are:
25978 This pattern matches exactly @cite{x}; variable names in @cite{x} are
25979 not interpreted as meta-variables. The only flexibility is that
25980 numbers are compared for numeric equality, so that the pattern
25981 @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
25982 (Numbers are always treated this way by the rewrite mechanism:
25983 The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
25984 The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
25985 as a result in this case.)
25992 Here @cite{x} must be a function call @samp{f(x1,x2,@dots{})}. This
25993 pattern matches a call to function @cite{f} with the specified
25994 argument patterns. No special knowledge of the properties of the
25995 function @cite{f} is used in this case; @samp{+} is not commutative or
25996 associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
25997 are treated as patterns. If you wish them to be treated ``plainly''
25998 as well, you must enclose them with more @code{plain} markers:
25999 @samp{plain(plain(@w{-a}) + plain(b c))}.
26006 Here @cite{x} must be a variable name. This must appear as an
26007 argument to a function or an element of a vector; it specifies that
26008 the argument or element is optional.
26009 As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
26010 or as the second argument to @samp{/} or @samp{^}, the value @var{def}
26011 may be omitted. The pattern @samp{x + opt(y)} matches a sum by
26012 binding one summand to @cite{x} and the other to @cite{y}, and it
26013 matches anything else by binding the whole expression to @cite{x} and
26014 zero to @cite{y}. The other operators above work similarly.@refill
26016 For general miscellaneous functions, the default value @code{def}
26017 must be specified. Optional arguments are dropped starting with
26018 the rightmost one during matching. For example, the pattern
26019 @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
26020 or @samp{f(a,b,c)}. Default values of zero and @cite{b} are
26021 supplied in this example for the omitted arguments. Note that
26022 the literal variable @cite{b} will be the default in the latter
26023 case, @emph{not} the value that matched the meta-variable @cite{b}.
26024 In other words, the default @var{def} is effectively quoted.
26026 @item condition(x,c)
26032 This matches the pattern @cite{x}, with the attached condition
26033 @cite{c}. It is the same as @samp{x :: c}.
26041 This matches anything that matches both pattern @cite{x} and
26042 pattern @cite{y}. It is the same as @samp{x &&& y}.
26043 @pxref{Composing Patterns in Rewrite Rules}.
26051 This matches anything that matches either pattern @cite{x} or
26052 pattern @cite{y}. It is the same as @w{@samp{x ||| y}}.
26060 This matches anything that does not match pattern @cite{x}.
26061 It is the same as @samp{!!! x}.
26067 @tindex cons (rewrites)
26068 This matches any vector of one or more elements. The first
26069 element is matched to @cite{h}; a vector of the remaining
26070 elements is matched to @cite{t}. Note that vectors of fixed
26071 length can also be matched as actual vectors: The rule
26072 @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
26073 to the rule @samp{[a,b] := [a+b]}.
26079 @tindex rcons (rewrites)
26080 This is like @code{cons}, except that the @emph{last} element
26081 is matched to @cite{h}, with the remaining elements matched
26084 @item apply(f,args)
26088 @tindex apply (rewrites)
26089 This matches any function call. The name of the function, in
26090 the form of a variable, is matched to @cite{f}. The arguments
26091 of the function, as a vector of zero or more objects, are
26092 matched to @samp{args}. Constants, variables, and vectors
26093 do @emph{not} match an @code{apply} pattern. For example,
26094 @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
26095 matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
26096 matches any function call with exactly two arguments, and
26097 @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
26098 to the function @samp{f} with two or more arguments. Another
26099 way to implement the latter, if the rest of the rule does not
26100 need to refer to the first two arguments of @samp{f} by name,
26101 would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
26102 Here's a more interesting sample use of @code{apply}:
26105 apply(f,[x+n]) := n + apply(f,[x])
26106 :: in(f, [floor,ceil,round,trunc]) :: integer(n)
26109 Note, however, that this will be slower to match than a rule
26110 set with four separate rules. The reason is that Calc sorts
26111 the rules of a rule set according to top-level function name;
26112 if the top-level function is @code{apply}, Calc must try the
26113 rule for every single formula and sub-formula. If the top-level
26114 function in the pattern is, say, @code{floor}, then Calc invokes
26115 the rule only for sub-formulas which are calls to @code{floor}.
26117 Formulas normally written with operators like @code{+} are still
26118 considered function calls: @code{apply(f,x)} matches @samp{a+b}
26119 with @samp{f = add}, @samp{x = [a,b]}.
26121 You must use @code{apply} for meta-variables with function names
26122 on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)}
26123 is @emph{not} correct, because it rewrites @samp{spam(6)} into
26124 @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}.
26125 Also note that you will have to use no-simplify (@kbd{m O})
26126 mode when entering this rule so that the @code{apply} isn't
26127 evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
26128 Or, use @kbd{s e} to enter the rule without going through the stack,
26129 or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
26130 @xref{Conditional Rewrite Rules}.
26137 This is used for applying rules to formulas with selections;
26138 @pxref{Selections with Rewrite Rules}.
26141 Special functions for the righthand sides of rules are:
26145 The notation @samp{quote(x)} is changed to @samp{x} when the
26146 righthand side is used. As far as the rewrite rule is concerned,
26147 @code{quote} is invisible. However, @code{quote} has the special
26148 property in Calc that its argument is not evaluated. Thus,
26149 while it will not work to put the rule @samp{t(a) := typeof(a)}
26150 on the stack because @samp{typeof(a)} is evaluated immediately
26151 to produce @samp{t(a) := 100}, you can use @code{quote} to
26152 protect the righthand side: @samp{t(a) := quote(typeof(a))}.
26153 (@xref{Conditional Rewrite Rules}, for another trick for
26154 protecting rules from evaluation.)
26157 Special properties of and simplifications for the function call
26158 @cite{x} are not used. One interesting case where @code{plain}
26159 is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
26160 shorthand notation for the @code{quote} function. This rule will
26161 not work as shown; instead of replacing @samp{q(foo)} with
26162 @samp{quote(foo)}, it will replace it with @samp{foo}! The correct
26163 rule would be @samp{q(x) := plain(quote(x))}.
26166 Where @cite{t} is a vector, this is converted into an expanded
26167 vector during rewrite processing. Note that @code{cons} is a regular
26168 Calc function which normally does this anyway; the only way @code{cons}
26169 is treated specially by rewrites is that @code{cons} on the righthand
26170 side of a rule will be evaluated even if default simplifications
26171 have been turned off.
26174 Analogous to @code{cons} except putting @cite{h} at the @emph{end} of
26175 the vector @cite{t}.
26177 @item apply(f,args)
26178 Where @cite{f} is a variable and @var{args} is a vector, this
26179 is converted to a function call. Once again, note that @code{apply}
26180 is also a regular Calc function.
26187 The formula @cite{x} is handled in the usual way, then the
26188 default simplifications are applied to it even if they have
26189 been turned off normally. This allows you to treat any function
26190 similarly to the way @code{cons} and @code{apply} are always
26191 treated. However, there is a slight difference: @samp{cons(2+3, [])}
26192 with default simplifications off will be converted to @samp{[2+3]},
26193 whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
26200 The formula @cite{x} has meta-variables substituted in the usual
26201 way, then algebraically simplified as if by the @kbd{a s} command.
26203 @item evalextsimp(x)
26207 @tindex evalextsimp
26208 The formula @cite{x} has meta-variables substituted in the normal
26209 way, then ``extendedly'' simplified as if by the @kbd{a e} command.
26212 @xref{Selections with Rewrite Rules}.
26215 There are also some special functions you can use in conditions.
26223 The expression @cite{x} is evaluated with meta-variables substituted.
26224 The @kbd{a s} command's simplifications are @emph{not} applied by
26225 default, but @cite{x} can include calls to @code{evalsimp} or
26226 @code{evalextsimp} as described above to invoke higher levels
26227 of simplification. The
26228 result of @cite{x} is then bound to the meta-variable @cite{v}. As
26229 usual, if this meta-variable has already been matched to something
26230 else the two values must be equal; if the meta-variable is new then
26231 it is bound to the result of the expression. This variable can then
26232 appear in later conditions, and on the righthand side of the rule.
26233 In fact, @cite{v} may be any pattern in which case the result of
26234 evaluating @cite{x} is matched to that pattern, binding any
26235 meta-variables that appear in that pattern. Note that @code{let}
26236 can only appear by itself as a condition, or as one term of an
26237 @samp{&&} which is a whole condition: It cannot be inside
26238 an @samp{||} term or otherwise buried.@refill
26240 The alternate, equivalent form @samp{let(v, x)} is also recognized.
26241 Note that the use of @samp{:=} by @code{let}, while still being
26242 assignment-like in character, is unrelated to the use of @samp{:=}
26243 in the main part of a rewrite rule.
26245 As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
26246 replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
26247 that inverse exists and is constant. For example, if @samp{a} is a
26248 singular matrix the operation @samp{1/a} is left unsimplified and
26249 @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
26250 then the rule succeeds. Without @code{let} there would be no way
26251 to express this rule that didn't have to invert the matrix twice.
26252 Note that, because the meta-variable @samp{ia} is otherwise unbound
26253 in this rule, the @code{let} condition itself always ``succeeds''
26254 because no matter what @samp{1/a} evaluates to, it can successfully
26255 be bound to @code{ia}.@refill
26257 Here's another example, for integrating cosines of linear
26258 terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
26259 The @code{lin} function returns a 3-vector if its argument is linear,
26260 or leaves itself unevaluated if not. But an unevaluated @code{lin}
26261 call will not match the 3-vector on the lefthand side of the @code{let},
26262 so this @code{let} both verifies that @code{y} is linear, and binds
26263 the coefficients @code{a} and @code{b} for use elsewhere in the rule.
26264 (It would have been possible to use @samp{sin(a x + b)/b} for the
26265 righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
26266 rearrangement of the argument of the sine.)@refill
26272 Similarly, here is a rule that implements an inverse-@code{erf}
26273 function. It uses @code{root} to search for a solution. If
26274 @code{root} succeeds, it will return a vector of two numbers
26275 where the first number is the desired solution. If no solution
26276 is found, @code{root} remains in symbolic form. So we use
26277 @code{let} to check that the result was indeed a vector.
26280 ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5))
26284 The meta-variable @var{v}, which must already have been matched
26285 to something elsewhere in the rule, is compared against pattern
26286 @var{p}. Since @code{matches} is a standard Calc function, it
26287 can appear anywhere in a condition. But if it appears alone or
26288 as a term of a top-level @samp{&&}, then you get the special
26289 extra feature that meta-variables which are bound to things
26290 inside @var{p} can be used elsewhere in the surrounding rewrite
26293 The only real difference between @samp{let(p := v)} and
26294 @samp{matches(v, p)} is that the former evaluates @samp{v} using
26295 the default simplifications, while the latter does not.
26299 This is actually a variable, not a function. If @code{remember}
26300 appears as a condition in a rule, then when that rule succeeds
26301 the original expression and rewritten expression are added to the
26302 front of the rule set that contained the rule. If the rule set
26303 was not stored in a variable, @code{remember} is ignored. The
26304 lefthand side is enclosed in @code{quote} in the added rule if it
26305 contains any variables.
26307 For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
26308 to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
26309 of the rule set. The rule set @code{EvalRules} works slightly
26310 differently: There, the evaluation of @samp{f(6)} will complete before
26311 the result is added to the rule set, in this case as @samp{f(7) := 5040}.
26312 Thus @code{remember} is most useful inside @code{EvalRules}.
26314 It is up to you to ensure that the optimization performed by
26315 @code{remember} is safe. For example, the rule @samp{foo(n) := n
26316 :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
26317 the function equivalent of the @kbd{=} command); if the variable
26318 @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
26319 be added to the rule set and will continue to operate even if
26320 @code{eatfoo} is later changed to 0.
26327 Remember the match as described above, but only if condition @cite{c}
26328 is true. For example, @samp{remember(n % 4 = 0)} in the above factorial
26329 rule remembers only every fourth result. Note that @samp{remember(1)}
26330 is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
26333 @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
26334 @subsection Composing Patterns in Rewrite Rules
26337 There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
26338 that combine rewrite patterns to make larger patterns. The
26339 combinations are ``and,'' ``or,'' and ``not,'' respectively, and
26340 these operators are the pattern equivalents of @samp{&&}, @samp{||}
26341 and @samp{!} (which operate on zero-or-nonzero logical values).
26343 Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
26344 form by all regular Calc features; they have special meaning only in
26345 the context of rewrite rule patterns.
26347 The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
26348 matches both @var{p1} and @var{p2}. One especially useful case is
26349 when one of @var{p1} or @var{p2} is a meta-variable. For example,
26350 here is a rule that operates on error forms:
26353 f(x &&& a +/- b, x) := g(x)
26356 This does the same thing, but is arguably simpler than, the rule
26359 f(a +/- b, a +/- b) := g(a +/- b)
26366 Here's another interesting example:
26369 ends(cons(a, x) &&& rcons(y, b)) := [a, b]
26373 which effectively clips out the middle of a vector leaving just
26374 the first and last elements. This rule will change a one-element
26375 vector @samp{[a]} to @samp{[a, a]}. The similar rule
26378 ends(cons(a, rcons(y, b))) := [a, b]
26382 would do the same thing except that it would fail to match a
26383 one-element vector.
26389 The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
26390 matches either @var{p1} or @var{p2}. Calc first tries matching
26391 against @var{p1}; if that fails, it goes on to try @var{p2}.
26397 A simple example of @samp{|||} is
26400 curve(inf ||| -inf) := 0
26404 which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
26406 Here is a larger example:
26409 log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b)
26412 This matches both generalized and natural logarithms in a single rule.
26413 Note that the @samp{::} term must be enclosed in parentheses because
26414 that operator has lower precedence than @samp{|||} or @samp{:=}.
26416 (In practice this rule would probably include a third alternative,
26417 omitted here for brevity, to take care of @code{log10}.)
26419 While Calc generally treats interior conditions exactly the same as
26420 conditions on the outside of a rule, it does guarantee that if all the
26421 variables in the condition are special names like @code{e}, or already
26422 bound in the pattern to which the condition is attached (say, if
26423 @samp{a} had appeared in this condition), then Calc will process this
26424 condition right after matching the pattern to the left of the @samp{::}.
26425 Thus, we know that @samp{b} will be bound to @samp{e} only if the
26426 @code{ln} branch of the @samp{|||} was taken.
26428 Note that this rule was careful to bind the same set of meta-variables
26429 on both sides of the @samp{|||}. Calc does not check this, but if
26430 you bind a certain meta-variable only in one branch and then use that
26431 meta-variable elsewhere in the rule, results are unpredictable:
26434 f(a,b) ||| g(b) := h(a,b)
26437 Here if the pattern matches @samp{g(17)}, Calc makes no promises about
26438 the value that will be substituted for @samp{a} on the righthand side.
26444 The pattern @samp{!!! @var{pat}} matches anything that does not
26445 match @var{pat}. Any meta-variables that are bound while matching
26446 @var{pat} remain unbound outside of @var{pat}.
26451 f(x &&& !!! a +/- b, !!![]) := g(x)
26455 converts @code{f} whose first argument is anything @emph{except} an
26456 error form, and whose second argument is not the empty vector, into
26457 a similar call to @code{g} (but without the second argument).
26459 If we know that the second argument will be a vector (empty or not),
26460 then an equivalent rule would be:
26463 f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0
26467 where of course 7 is the @code{typeof} code for error forms.
26468 Another final condition, that works for any kind of @samp{y},
26469 would be @samp{!istrue(y == [])}. (The @code{istrue} function
26470 returns an explicit 0 if its argument was left in symbolic form;
26471 plain @samp{!(y == [])} or @samp{y != []} would not work to replace
26472 @samp{!!![]} since these would be left unsimplified, and thus cause
26473 the rule to fail, if @samp{y} was something like a variable name.)
26475 It is possible for a @samp{!!!} to refer to meta-variables bound
26476 elsewhere in the pattern. For example,
26483 matches any call to @code{f} with different arguments, changing
26484 this to @code{g} with only the first argument.
26486 If a function call is to be matched and one of the argument patterns
26487 contains a @samp{!!!} somewhere inside it, that argument will be
26495 will be careful to bind @samp{a} to the second argument of @code{f}
26496 before testing the first argument. If Calc had tried to match the
26497 first argument of @code{f} first, the results would have been
26498 disastrous: since @code{a} was unbound so far, the pattern @samp{a}
26499 would have matched anything at all, and the pattern @samp{!!!a}
26500 therefore would @emph{not} have matched anything at all!
26502 @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
26503 @subsection Nested Formulas with Rewrite Rules
26506 When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
26507 the top of the stack and attempts to match any of the specified rules
26508 to any part of the expression, starting with the whole expression
26509 and then, if that fails, trying deeper and deeper sub-expressions.
26510 For each part of the expression, the rules are tried in the order
26511 they appear in the rules vector. The first rule to match the first
26512 sub-expression wins; it replaces the matched sub-expression according
26513 to the @var{new} part of the rule.
26515 Often, the rule set will match and change the formula several times.
26516 The top-level formula is first matched and substituted repeatedly until
26517 it no longer matches the pattern; then, sub-formulas are tried, and
26518 so on. Once every part of the formula has gotten its chance, the
26519 rewrite mechanism starts over again with the top-level formula
26520 (in case a substitution of one of its arguments has caused it again
26521 to match). This continues until no further matches can be made
26522 anywhere in the formula.
26524 It is possible for a rule set to get into an infinite loop. The
26525 most obvious case, replacing a formula with itself, is not a problem
26526 because a rule is not considered to ``succeed'' unless the righthand
26527 side actually comes out to something different than the original
26528 formula or sub-formula that was matched. But if you accidentally
26529 had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
26530 @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
26531 run forever switching a formula back and forth between the two
26534 To avoid disaster, Calc normally stops after 100 changes have been
26535 made to the formula. This will be enough for most multiple rewrites,
26536 but it will keep an endless loop of rewrites from locking up the
26537 computer forever. (On most systems, you can also type @kbd{C-g} to
26538 halt any Emacs command prematurely.)
26540 To change this limit, give a positive numeric prefix argument.
26541 In particular, @kbd{M-1 a r} applies only one rewrite at a time,
26542 useful when you are first testing your rule (or just if repeated
26543 rewriting is not what is called for by your application).
26552 You can also put a ``function call'' @samp{iterations(@var{n})}
26553 in place of a rule anywhere in your rules vector (but usually at
26554 the top). Then, @var{n} will be used instead of 100 as the default
26555 number of iterations for this rule set. You can use
26556 @samp{iterations(inf)} if you want no iteration limit by default.
26557 A prefix argument will override the @code{iterations} limit in the
26565 More precisely, the limit controls the number of ``iterations,''
26566 where each iteration is a successful matching of a rule pattern whose
26567 righthand side, after substituting meta-variables and applying the
26568 default simplifications, is different from the original sub-formula
26571 A prefix argument of zero sets the limit to infinity. Use with caution!
26573 Given a negative numeric prefix argument, @kbd{a r} will match and
26574 substitute the top-level expression up to that many times, but
26575 will not attempt to match the rules to any sub-expressions.
26577 In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
26578 does a rewriting operation. Here @var{expr} is the expression
26579 being rewritten, @var{rules} is the rule, vector of rules, or
26580 variable containing the rules, and @var{n} is the optional
26581 iteration limit, which may be a positive integer, a negative
26582 integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted
26583 the @code{iterations} value from the rule set is used; if both
26584 are omitted, 100 is used.
26586 @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
26587 @subsection Multi-Phase Rewrite Rules
26590 It is possible to separate a rewrite rule set into several @dfn{phases}.
26591 During each phase, certain rules will be enabled while certain others
26592 will be disabled. A @dfn{phase schedule} controls the order in which
26593 phases occur during the rewriting process.
26600 If a call to the marker function @code{phase} appears in the rules
26601 vector in place of a rule, all rules following that point will be
26602 members of the phase(s) identified in the arguments to @code{phase}.
26603 Phases are given integer numbers. The markers @samp{phase()} and
26604 @samp{phase(all)} both mean the following rules belong to all phases;
26605 this is the default at the start of the rule set.
26607 If you do not explicitly schedule the phases, Calc sorts all phase
26608 numbers that appear in the rule set and executes the phases in
26609 ascending order. For example, the rule set
26626 has three phases, 1 through 3. Phase 1 consists of the @code{f0},
26627 @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of
26628 @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0}
26631 When Calc rewrites a formula using this rule set, it first rewrites
26632 the formula using only the phase 1 rules until no further changes are
26633 possible. Then it switches to the phase 2 rule set and continues
26634 until no further changes occur, then finally rewrites with phase 3.
26635 When no more phase 3 rules apply, rewriting finishes. (This is
26636 assuming @kbd{a r} with a large enough prefix argument to allow the
26637 rewriting to run to completion; the sequence just described stops
26638 early if the number of iterations specified in the prefix argument,
26639 100 by default, is reached.)
26641 During each phase, Calc descends through the nested levels of the
26642 formula as described previously. (@xref{Nested Formulas with Rewrite
26643 Rules}.) Rewriting starts at the top of the formula, then works its
26644 way down to the parts, then goes back to the top and works down again.
26645 The phase 2 rules do not begin until no phase 1 rules apply anywhere
26652 A @code{schedule} marker appearing in the rule set (anywhere, but
26653 conventionally at the top) changes the default schedule of phases.
26654 In the simplest case, @code{schedule} has a sequence of phase numbers
26655 for arguments; each phase number is invoked in turn until the
26656 arguments to @code{schedule} are exhausted. Thus adding
26657 @samp{schedule(3,2,1)} at the top of the above rule set would
26658 reverse the order of the phases; @samp{schedule(1,2,3)} would have
26659 no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
26660 would give phase 1 a second chance after phase 2 has completed, before
26661 moving on to phase 3.
26663 Any argument to @code{schedule} can instead be a vector of phase
26664 numbers (or even of sub-vectors). Then the sub-sequence of phases
26665 described by the vector are tried repeatedly until no change occurs
26666 in any phase in the sequence. For example, @samp{schedule([1, 2], 3)}
26667 tries phase 1, then phase 2, then, if either phase made any changes
26668 to the formula, repeats these two phases until they can make no
26669 further progress. Finally, it goes on to phase 3 for finishing
26672 Also, items in @code{schedule} can be variable names as well as
26673 numbers. A variable name is interpreted as the name of a function
26674 to call on the whole formula. For example, @samp{schedule(1, simplify)}
26675 says to apply the phase-1 rules (presumably, all of them), then to
26676 call @code{simplify} which is the function name equivalent of @kbd{a s}.
26677 Likewise, @samp{schedule([1, simplify])} says to alternate between
26678 phase 1 and @kbd{a s} until no further changes occur.
26680 Phases can be used purely to improve efficiency; if it is known that
26681 a certain group of rules will apply only at the beginning of rewriting,
26682 and a certain other group will apply only at the end, then rewriting
26683 will be faster if these groups are identified as separate phases.
26684 Once the phase 1 rules are done, Calc can put them aside and no longer
26685 spend any time on them while it works on phase 2.
26687 There are also some problems that can only be solved with several
26688 rewrite phases. For a real-world example of a multi-phase rule set,
26689 examine the set @code{FitRules}, which is used by the curve-fitting
26690 command to convert a model expression to linear form.
26691 @xref{Curve Fitting Details}. This set is divided into four phases.
26692 The first phase rewrites certain kinds of expressions to be more
26693 easily linearizable, but less computationally efficient. After the
26694 linear components have been picked out, the final phase includes the
26695 opposite rewrites to put each component back into an efficient form.
26696 If both sets of rules were included in one big phase, Calc could get
26697 into an infinite loop going back and forth between the two forms.
26699 Elsewhere in @code{FitRules}, the components are first isolated,
26700 then recombined where possible to reduce the complexity of the linear
26701 fit, then finally packaged one component at a time into vectors.
26702 If the packaging rules were allowed to begin before the recombining
26703 rules were finished, some components might be put away into vectors
26704 before they had a chance to recombine. By putting these rules in
26705 two separate phases, this problem is neatly avoided.
26707 @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
26708 @subsection Selections with Rewrite Rules
26711 If a sub-formula of the current formula is selected (as by @kbd{j s};
26712 @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
26713 command applies only to that sub-formula. Together with a negative
26714 prefix argument, you can use this fact to apply a rewrite to one
26715 specific part of a formula without affecting any other parts.
26718 @pindex calc-rewrite-selection
26719 The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
26720 sophisticated operations on selections. This command prompts for
26721 the rules in the same way as @kbd{a r}, but it then applies those
26722 rules to the whole formula in question even though a sub-formula
26723 of it has been selected. However, the selected sub-formula will
26724 first have been surrounded by a @samp{select( )} function call.
26725 (Calc's evaluator does not understand the function name @code{select};
26726 this is only a tag used by the @kbd{j r} command.)
26728 For example, suppose the formula on the stack is @samp{2 (a + b)^2}
26729 and the sub-formula @samp{a + b} is selected. This formula will
26730 be rewritten to @samp{2 select(a + b)^2} and then the rewrite
26731 rules will be applied in the usual way. The rewrite rules can
26732 include references to @code{select} to tell where in the pattern
26733 the selected sub-formula should appear.
26735 If there is still exactly one @samp{select( )} function call in
26736 the formula after rewriting is done, it indicates which part of
26737 the formula should be selected afterwards. Otherwise, the
26738 formula will be unselected.
26740 You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
26741 of the rewrite rule with @samp{select()}. However, @kbd{j r}
26742 allows you to use the current selection in more flexible ways.
26743 Suppose you wished to make a rule which removed the exponent from
26744 the selected term; the rule @samp{select(a)^x := select(a)} would
26745 work. In the above example, it would rewrite @samp{2 select(a + b)^2}
26746 to @samp{2 select(a + b)}. This would then be returned to the
26747 stack as @samp{2 (a + b)} with the @samp{a + b} selected.
26749 The @kbd{j r} command uses one iteration by default, unlike
26750 @kbd{a r} which defaults to 100 iterations. A numeric prefix
26751 argument affects @kbd{j r} in the same way as @kbd{a r}.
26752 @xref{Nested Formulas with Rewrite Rules}.
26754 As with other selection commands, @kbd{j r} operates on the stack
26755 entry that contains the cursor. (If the cursor is on the top-of-stack
26756 @samp{.} marker, it works as if the cursor were on the formula
26759 If you don't specify a set of rules, the rules are taken from the
26760 top of the stack, just as with @kbd{a r}. In this case, the
26761 cursor must indicate stack entry 2 or above as the formula to be
26762 rewritten (otherwise the same formula would be used as both the
26763 target and the rewrite rules).
26765 If the indicated formula has no selection, the cursor position within
26766 the formula temporarily selects a sub-formula for the purposes of this
26767 command. If the cursor is not on any sub-formula (e.g., it is in
26768 the line-number area to the left of the formula), the @samp{select( )}
26769 markers are ignored by the rewrite mechanism and the rules are allowed
26770 to apply anywhere in the formula.
26772 As a special feature, the normal @kbd{a r} command also ignores
26773 @samp{select( )} calls in rewrite rules. For example, if you used the
26774 above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
26775 the rule as if it were @samp{a^x := a}. Thus, you can write general
26776 purpose rules with @samp{select( )} hints inside them so that they
26777 will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
26778 both with and without selections.
26780 @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
26781 @subsection Matching Commands
26787 The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
26788 vector of formulas and a rewrite-rule-style pattern, and produces
26789 a vector of all formulas which match the pattern. The command
26790 prompts you to enter the pattern; as for @kbd{a r}, you can enter
26791 a single pattern (i.e., a formula with meta-variables), or a
26792 vector of patterns, or a variable which contains patterns, or
26793 you can give a blank response in which case the patterns are taken
26794 from the top of the stack. The pattern set will be compiled once
26795 and saved if it is stored in a variable. If there are several
26796 patterns in the set, vector elements are kept if they match any
26799 For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
26800 will return @samp{[x+y, x-y, x+y+z]}.
26802 The @code{import} mechanism is not available for pattern sets.
26804 The @kbd{a m} command can also be used to extract all vector elements
26805 which satisfy any condition: The pattern @samp{x :: x>0} will select
26806 all the positive vector elements.
26810 With the Inverse flag [@code{matchnot}], this command extracts all
26811 vector elements which do @emph{not} match the given pattern.
26817 There is also a function @samp{matches(@var{x}, @var{p})} which
26818 evaluates to 1 if expression @var{x} matches pattern @var{p}, or
26819 to 0 otherwise. This is sometimes useful for including into the
26820 conditional clauses of other rewrite rules.
26826 The function @code{vmatches} is just like @code{matches}, except
26827 that if the match succeeds it returns a vector of assignments to
26828 the meta-variables instead of the number 1. For example,
26829 @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
26830 If the match fails, the function returns the number 0.
26832 @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
26833 @subsection Automatic Rewrites
26836 @cindex @code{EvalRules} variable
26838 It is possible to get Calc to apply a set of rewrite rules on all
26839 results, effectively adding to the built-in set of default
26840 simplifications. To do this, simply store your rule set in the
26841 variable @code{EvalRules}. There is a convenient @kbd{s E} command
26842 for editing @code{EvalRules}; @pxref{Operations on Variables}.
26844 For example, suppose you want @samp{sin(a + b)} to be expanded out
26845 to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
26846 similarly for @samp{cos(a + b)}. The corresponding rewrite rule
26851 [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b),
26852 cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ]
26856 To apply these manually, you could put them in a variable called
26857 @code{trigexp} and then use @kbd{a r trigexp} every time you wanted
26858 to expand trig functions. But if instead you store them in the
26859 variable @code{EvalRules}, they will automatically be applied to all
26860 sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on
26861 the stack, typing @kbd{+ S} will (assuming degrees mode) result in
26862 @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
26864 As each level of a formula is evaluated, the rules from
26865 @code{EvalRules} are applied before the default simplifications.
26866 Rewriting continues until no further @code{EvalRules} apply.
26867 Note that this is different from the usual order of application of
26868 rewrite rules: @code{EvalRules} works from the bottom up, simplifying
26869 the arguments to a function before the function itself, while @kbd{a r}
26870 applies rules from the top down.
26872 Because the @code{EvalRules} are tried first, you can use them to
26873 override the normal behavior of any built-in Calc function.
26875 It is important not to write a rule that will get into an infinite
26876 loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
26877 appears to be a good definition of a factorial function, but it is
26878 unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc
26879 will continue to subtract 1 from this argument forever without reaching
26880 zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
26881 Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting
26882 @samp{g(2, 4)}, this would bounce back and forth between that and
26883 @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules}
26884 occurs, Emacs will eventually stop with a ``Computation got stuck
26885 or ran too long'' message.
26887 Another subtle difference between @code{EvalRules} and regular rewrites
26888 concerns rules that rewrite a formula into an identical formula. For
26889 example, @samp{f(n) := f(floor(n))} ``fails to match'' when @cite{n} is
26890 already an integer. But in @code{EvalRules} this case is detected only
26891 if the righthand side literally becomes the original formula before any
26892 further simplification. This means that @samp{f(n) := f(floor(n))} will
26893 get into an infinite loop if it occurs in @code{EvalRules}. Calc will
26894 replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
26895 @samp{f(6)}, so it will consider the rule to have matched and will
26896 continue simplifying that formula; first the argument is simplified
26897 to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
26898 again, ad infinitum. A much safer rule would check its argument first,
26899 say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
26901 (What really happens is that the rewrite mechanism substitutes the
26902 meta-variables in the righthand side of a rule, compares to see if the
26903 result is the same as the original formula and fails if so, then uses
26904 the default simplifications to simplify the result and compares again
26905 (and again fails if the formula has simplified back to its original
26906 form). The only special wrinkle for the @code{EvalRules} is that the
26907 same rules will come back into play when the default simplifications
26908 are used. What Calc wants to do is build @samp{f(floor(6))}, see that
26909 this is different from the original formula, simplify to @samp{f(6)},
26910 see that this is the same as the original formula, and thus halt the
26911 rewriting. But while simplifying, @samp{f(6)} will again trigger
26912 the same @code{EvalRules} rule and Calc will get into a loop inside
26913 the rewrite mechanism itself.)
26915 The @code{phase}, @code{schedule}, and @code{iterations} markers do
26916 not work in @code{EvalRules}. If the rule set is divided into phases,
26917 only the phase 1 rules are applied, and the schedule is ignored.
26918 The rules are always repeated as many times as possible.
26920 The @code{EvalRules} are applied to all function calls in a formula,
26921 but not to numbers (and other number-like objects like error forms),
26922 nor to vectors or individual variable names. (Though they will apply
26923 to @emph{components} of vectors and error forms when appropriate.) You
26924 might try to make a variable @code{phihat} which automatically expands
26925 to its definition without the need to press @kbd{=} by writing the
26926 rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
26927 will not work as part of @code{EvalRules}.
26929 Finally, another limitation is that Calc sometimes calls its built-in
26930 functions directly rather than going through the default simplifications.
26931 When it does this, @code{EvalRules} will not be able to override those
26932 functions. For example, when you take the absolute value of the complex
26933 number @cite{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
26934 the multiplication, addition, and square root functions directly rather
26935 than applying the default simplifications to this formula. So an
26936 @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
26937 would not apply. (However, if you put Calc into symbolic mode so that
26938 @samp{sqrt(13)} will be left in symbolic form by the built-in square
26939 root function, your rule will be able to apply. But if the complex
26940 number were @cite{(3,4)}, so that @samp{sqrt(25)} must be calculated,
26941 then symbolic mode will not help because @samp{sqrt(25)} can be
26942 evaluated exactly to 5.)
26944 One subtle restriction that normally only manifests itself with
26945 @code{EvalRules} is that while a given rewrite rule is in the process
26946 of being checked, that same rule cannot be recursively applied. Calc
26947 effectively removes the rule from its rule set while checking the rule,
26948 then puts it back once the match succeeds or fails. (The technical
26949 reason for this is that compiled pattern programs are not reentrant.)
26950 For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
26951 attempting to match @samp{foo(8)}. This rule will be inactive while
26952 the condition @samp{foo(4) > 0} is checked, even though it might be
26953 an integral part of evaluating that condition. Note that this is not
26954 a problem for the more usual recursive type of rule, such as
26955 @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
26956 been reactivated by the time the righthand side is evaluated.
26958 If @code{EvalRules} has no stored value (its default state), or if
26959 anything but a vector is stored in it, then it is ignored.
26961 Even though Calc's rewrite mechanism is designed to compare rewrite
26962 rules to formulas as quickly as possible, storing rules in
26963 @code{EvalRules} may make Calc run substantially slower. This is
26964 particularly true of rules where the top-level call is a commonly used
26965 function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will
26966 only activate the rewrite mechanism for calls to the function @code{f},
26967 but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
26970 apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
26974 may seem more ``efficient'' than two separate rules for @code{ln} and
26975 @code{log10}, but actually it is vastly less efficient because rules
26976 with @code{apply} as the top-level pattern must be tested against
26977 @emph{every} function call that is simplified.
26979 @cindex @code{AlgSimpRules} variable
26980 @vindex AlgSimpRules
26981 Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
26982 but only when @kbd{a s} is used to simplify the formula. The variable
26983 @code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command
26984 will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as
26985 well as all of its built-in simplifications.
26987 Most of the special limitations for @code{EvalRules} don't apply to
26988 @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules}
26989 command with an infinite repeat count as the first step of @kbd{a s}.
26990 It then applies its own built-in simplifications throughout the
26991 formula, and then repeats these two steps (along with applying the
26992 default simplifications) until no further changes are possible.
26994 @cindex @code{ExtSimpRules} variable
26995 @cindex @code{UnitSimpRules} variable
26996 @vindex ExtSimpRules
26997 @vindex UnitSimpRules
26998 There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
26999 that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
27000 also apply @code{EvalRules} and @code{AlgSimpRules}. The variable
27001 @code{IntegSimpRules} contains simplification rules that are used
27002 only during integration by @kbd{a i}.
27004 @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
27005 @subsection Debugging Rewrites
27008 If a buffer named @samp{*Trace*} exists, the rewrite mechanism will
27009 record some useful information there as it operates. The original
27010 formula is written there, as is the result of each successful rewrite,
27011 and the final result of the rewriting. All phase changes are also
27014 Calc always appends to @samp{*Trace*}. You must empty this buffer
27015 yourself periodically if it is in danger of growing unwieldy.
27017 Note that the rewriting mechanism is substantially slower when the
27018 @samp{*Trace*} buffer exists, even if the buffer is not visible on
27019 the screen. Once you are done, you will probably want to kill this
27020 buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in
27021 existence and forget about it, all your future rewrite commands will
27022 be needlessly slow.
27024 @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
27025 @subsection Examples of Rewrite Rules
27028 Returning to the example of substituting the pattern
27029 @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
27030 @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
27031 finding suitable cases. Another solution would be to use the rule
27032 @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
27033 if necessary. This rule will be the most effective way to do the job,
27034 but at the expense of making some changes that you might not desire.@refill
27036 Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
27037 To make this work with the @w{@kbd{j r}} command so that it can be
27038 easily targeted to a particular exponential in a large formula,
27039 you might wish to write the rule as @samp{select(exp(x+y)) :=
27040 select(exp(x) exp(y))}. The @samp{select} markers will be
27041 ignored by the regular @kbd{a r} command
27042 (@pxref{Selections with Rewrite Rules}).@refill
27044 A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
27045 This will simplify the formula whenever @cite{b} and/or @cite{c} can
27046 be made simpler by squaring. For example, applying this rule to
27047 @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
27048 Symbolic Mode has been enabled to keep the square root from being
27049 evaluated to a floating-point approximation). This rule is also
27050 useful when working with symbolic complex numbers, e.g.,
27051 @samp{(a + b i) / (c + d i)}.
27053 As another example, we could define our own ``triangular numbers'' function
27054 with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter
27055 this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given
27056 a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
27057 to apply these rules repeatedly. After six applications, @kbd{a r} will
27058 stop with 15 on the stack. Once these rules are debugged, it would probably
27059 be most useful to add them to @code{EvalRules} so that Calc will evaluate
27060 the new @code{tri} function automatically. We could then use @kbd{Z K} on
27061 the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
27062 @code{tri} to the value on the top of the stack. @xref{Programming}.
27064 @cindex Quaternions
27065 The following rule set, contributed by @c{Fran\c cois}
27066 @asis{Francois} Pinard, implements
27067 @dfn{quaternions}, a generalization of the concept of complex numbers.
27068 Quaternions have four components, and are here represented by function
27069 calls @samp{quat(@var{w}, [@var{x}, @var{y}, @var{z}])} with ``real
27070 part'' @var{w} and the three ``imaginary'' parts collected into a
27071 vector. Various arithmetical operations on quaternions are supported.
27072 To use these rules, either add them to @code{EvalRules}, or create a
27073 command based on @kbd{a r} for simplifying quaternion formulas.
27074 A convenient way to enter quaternions would be a command defined by
27075 a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $]) @key{RET}}.
27078 [ quat(w, x, y, z) := quat(w, [x, y, z]),
27079 quat(w, [0, 0, 0]) := w,
27080 abs(quat(w, v)) := hypot(w, v),
27081 -quat(w, v) := quat(-w, -v),
27082 r + quat(w, v) := quat(r + w, v) :: real(r),
27083 r - quat(w, v) := quat(r - w, -v) :: real(r),
27084 quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
27085 r * quat(w, v) := quat(r * w, r * v) :: real(r),
27086 plain(quat(w1, v1) * quat(w2, v2))
27087 := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
27088 quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
27089 z / quat(w, v) := z * quatinv(quat(w, v)),
27090 quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
27091 quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
27092 quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
27093 :: integer(k) :: k > 0 :: k % 2 = 0,
27094 quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
27095 :: integer(k) :: k > 2,
27096 quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
27099 Quaternions, like matrices, have non-commutative multiplication.
27100 In other words, @cite{q1 * q2 = q2 * q1} is not necessarily true if
27101 @cite{q1} and @cite{q2} are @code{quat} forms. The @samp{quat*quat}
27102 rule above uses @code{plain} to prevent Calc from rearranging the
27103 product. It may also be wise to add the line @samp{[quat(), matrix]}
27104 to the @code{Decls} matrix, to ensure that Calc's other algebraic
27105 operations will not rearrange a quaternion product. @xref{Declarations}.
27107 These rules also accept a four-argument @code{quat} form, converting
27108 it to the preferred form in the first rule. If you would rather see
27109 results in the four-argument form, just append the two items
27110 @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
27111 of the rule set. (But remember that multi-phase rule sets don't work
27112 in @code{EvalRules}.)
27114 @node Units, Store and Recall, Algebra, Top
27115 @chapter Operating on Units
27118 One special interpretation of algebraic formulas is as numbers with units.
27119 For example, the formula @samp{5 m / s^2} can be read ``five meters
27120 per second squared.'' The commands in this chapter help you
27121 manipulate units expressions in this form. Units-related commands
27122 begin with the @kbd{u} prefix key.
27125 * Basic Operations on Units::
27126 * The Units Table::
27127 * Predefined Units::
27128 * User-Defined Units::
27131 @node Basic Operations on Units, The Units Table, Units, Units
27132 @section Basic Operations on Units
27135 A @dfn{units expression} is a formula which is basically a number
27136 multiplied and/or divided by one or more @dfn{unit names}, which may
27137 optionally be raised to integer powers. Actually, the value part need not
27138 be a number; any product or quotient involving unit names is a units
27139 expression. Many of the units commands will also accept any formula,
27140 where the command applies to all units expressions which appear in the
27143 A unit name is a variable whose name appears in the @dfn{unit table},
27144 or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
27145 or @samp{u} (for ``micro'') followed by a name in the unit table.
27146 A substantial table of built-in units is provided with Calc;
27147 @pxref{Predefined Units}. You can also define your own unit names;
27148 @pxref{User-Defined Units}.@refill
27150 Note that if the value part of a units expression is exactly @samp{1},
27151 it will be removed by the Calculator's automatic algebra routines: The
27152 formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a
27153 display anomaly, however; @samp{mm} will work just fine as a
27154 representation of one millimeter.@refill
27156 You may find that Algebraic Mode (@pxref{Algebraic Entry}) makes working
27157 with units expressions easier. Otherwise, you will have to remember
27158 to hit the apostrophe key every time you wish to enter units.
27161 @pindex calc-simplify-units
27163 @mindex usimpl@idots
27166 The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
27168 expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the
27169 expression first as a regular algebraic formula; it then looks for
27170 features that can be further simplified by converting one object's units
27171 to be compatible with another's. For example, @samp{5 m + 23 mm} will
27172 simplify to @samp{5.023 m}. When different but compatible units are
27173 added, the righthand term's units are converted to match those of the
27174 lefthand term. @xref{Simplification Modes}, for a way to have this done
27175 automatically at all times.@refill
27177 Units simplification also handles quotients of two units with the same
27178 dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
27179 powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
27180 @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
27181 @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
27182 @code{float}, @code{frac}, @code{abs}, and @code{clean}
27183 applied to units expressions, in which case
27184 the operation in question is applied only to the numeric part of the
27185 expression. Finally, trigonometric functions of quantities with units
27186 of angle are evaluated, regardless of the current angular mode.@refill
27189 @pindex calc-convert-units
27190 The @kbd{u c} (@code{calc-convert-units}) command converts a units
27191 expression to new, compatible units. For example, given the units
27192 expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
27193 @samp{24.5872 m/s}. If the units you request are inconsistent with
27194 the original units, the number will be converted into your units
27195 times whatever ``remainder'' units are left over. For example,
27196 converting @samp{55 mph} into acres produces @samp{6.08e-3 acre / m s}.
27197 (Recall that multiplication binds more strongly than division in Calc
27198 formulas, so the units here are acres per meter-second.) Remainder
27199 units are expressed in terms of ``fundamental'' units like @samp{m} and
27200 @samp{s}, regardless of the input units.
27202 One special exception is that if you specify a single unit name, and
27203 a compatible unit appears somewhere in the units expression, then
27204 that compatible unit will be converted to the new unit and the
27205 remaining units in the expression will be left alone. For example,
27206 given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
27207 change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
27208 The ``remainder unit'' @samp{cm} is left alone rather than being
27209 changed to the base unit @samp{m}.
27211 You can use explicit unit conversion instead of the @kbd{u s} command
27212 to gain more control over the units of the result of an expression.
27213 For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
27214 @kbd{u c mm} to express the result in either meters or millimeters.
27215 (For that matter, you could type @kbd{u c fath} to express the result
27216 in fathoms, if you preferred!)
27218 In place of a specific set of units, you can also enter one of the
27219 units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
27220 For example, @kbd{u c si @key{RET}} converts the expression into
27221 International System of Units (SI) base units. Also, @kbd{u c base}
27222 converts to Calc's base units, which are the same as @code{si} units
27223 except that @code{base} uses @samp{g} as the fundamental unit of mass
27224 whereas @code{si} uses @samp{kg}.
27226 @cindex Composite units
27227 The @kbd{u c} command also accepts @dfn{composite units}, which
27228 are expressed as the sum of several compatible unit names. For
27229 example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
27230 feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first
27231 sorts the unit names into order of decreasing relative size.
27232 It then accounts for as much of the input quantity as it can
27233 using an integer number times the largest unit, then moves on
27234 to the next smaller unit, and so on. Only the smallest unit
27235 may have a non-integer amount attached in the result. A few
27236 standard unit names exist for common combinations, such as
27237 @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
27238 Composite units are expanded as if by @kbd{a x}, so that
27239 @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
27241 If the value on the stack does not contain any units, @kbd{u c} will
27242 prompt first for the old units which this value should be considered
27243 to have, then for the new units. Assuming the old and new units you
27244 give are consistent with each other, the result also will not contain
27245 any units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts the number
27246 2 on the stack to 5.08.
27249 @pindex calc-base-units
27250 The @kbd{u b} (@code{calc-base-units}) command is shorthand for
27251 @kbd{u c base}; it converts the units expression on the top of the
27252 stack into @code{base} units. If @kbd{u s} does not simplify a
27253 units expression as far as you would like, try @kbd{u b}.
27255 The @kbd{u c} and @kbd{u b} commands treat temperature units (like
27256 @samp{degC} and @samp{K}) as relative temperatures. For example,
27257 @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10
27258 degrees Celsius corresponds to a change of 18 degrees Fahrenheit.
27261 @pindex calc-convert-temperature
27262 @cindex Temperature conversion
27263 The @kbd{u t} (@code{calc-convert-temperature}) command converts
27264 absolute temperatures. The value on the stack must be a simple units
27265 expression with units of temperature only. This command would convert
27266 @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the
27267 Fahrenheit scale.@refill
27270 @pindex calc-remove-units
27272 @pindex calc-extract-units
27273 The @kbd{u r} (@code{calc-remove-units}) command removes units from the
27274 formula at the top of the stack. The @kbd{u x}
27275 (@code{calc-extract-units}) command extracts only the units portion of a
27276 formula. These commands essentially replace every term of the formula
27277 that does or doesn't (respectively) look like a unit name by the
27278 constant 1, then resimplify the formula.@refill
27281 @pindex calc-autorange-units
27282 The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
27283 mode in which unit prefixes like @code{k} (``kilo'') are automatically
27284 applied to keep the numeric part of a units expression in a reasonable
27285 range. This mode affects @kbd{u s} and all units conversion commands
27286 except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz}
27287 will be simplified to @samp{12.345 kHz}. Autoranging is useful for
27288 some kinds of units (like @code{Hz} and @code{m}), but is probably
27289 undesirable for non-metric units like @code{ft} and @code{tbsp}.
27290 (Composite units are more appropriate for those; see above.)
27292 Autoranging always applies the prefix to the leftmost unit name.
27293 Calc chooses the largest prefix that causes the number to be greater
27294 than or equal to 1.0. Thus an increasing sequence of adjusted times
27295 would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
27296 Generally the rule of thumb is that the number will be adjusted
27297 to be in the interval @samp{[1 .. 1000)}, although there are several
27298 exceptions to this rule. First, if the unit has a power then this
27299 is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
27300 Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
27301 but will not apply to other units. The ``deci-,'' ``deka-,'' and
27302 ``hecto-'' prefixes are never used. Thus the allowable interval is
27303 @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
27304 Finally, a prefix will not be added to a unit if the resulting name
27305 is also the actual name of another unit; @samp{1e-15 t} would normally
27306 be considered a ``femto-ton,'' but it is written as @samp{1000 at}
27307 (1000 atto-tons) instead because @code{ft} would be confused with feet.
27309 @node The Units Table, Predefined Units, Basic Operations on Units, Units
27310 @section The Units Table
27314 @pindex calc-enter-units-table
27315 The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
27316 in another buffer called @code{*Units Table*}. Each entry in this table
27317 gives the unit name as it would appear in an expression, the definition
27318 of the unit in terms of simpler units, and a full name or description of
27319 the unit. Fundamental units are defined as themselves; these are the
27320 units produced by the @kbd{u b} command. The fundamental units are
27321 meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
27324 The Units Table buffer also displays the Unit Prefix Table. Note that
27325 two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
27326 prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M}
27327 prefix. Whenever a unit name can be interpreted as either a built-in name
27328 or a prefix followed by another built-in name, the former interpretation
27329 wins. For example, @samp{2 pt} means two pints, not two pico-tons.
27331 The Units Table buffer, once created, is not rebuilt unless you define
27332 new units. To force the buffer to be rebuilt, give any numeric prefix
27333 argument to @kbd{u v}.
27336 @pindex calc-view-units-table
27337 The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
27338 that the cursor is not moved into the Units Table buffer. You can
27339 type @kbd{u V} again to remove the Units Table from the display. To
27340 return from the Units Table buffer after a @kbd{u v}, type @kbd{M-# c}
27341 again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
27342 command. You can also kill the buffer with @kbd{C-x k} if you wish;
27343 the actual units table is safely stored inside the Calculator.
27346 @pindex calc-get-unit-definition
27347 The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
27348 defining expression and pushes it onto the Calculator stack. For example,
27349 @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the
27350 same definition for the unit that would appear in the Units Table buffer.
27351 Note that this command works only for actual unit names; @kbd{u g km}
27352 will report that no such unit exists, for example, because @code{km} is
27353 really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a
27354 definition of a unit in terms of base units, it is easier to push the
27355 unit name on the stack and then reduce it to base units with @kbd{u b}.
27358 @pindex calc-explain-units
27359 The @kbd{u e} (@code{calc-explain-units}) command displays an English
27360 description of the units of the expression on the stack. For example,
27361 for the expression @samp{62 km^2 g / s^2 mol K}, the description is
27362 ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This
27363 command uses the English descriptions that appear in the righthand
27364 column of the Units Table.
27366 @node Predefined Units, User-Defined Units, The Units Table, Units
27367 @section Predefined Units
27370 Since the exact definitions of many kinds of units have evolved over the
27371 years, and since certain countries sometimes have local differences in
27372 their definitions, it is a good idea to examine Calc's definition of a
27373 unit before depending on its exact value. For example, there are three
27374 different units for gallons, corresponding to the US (@code{gal}),
27375 Canadian (@code{galC}), and British (@code{galUK}) definitions. Also,
27376 note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
27377 ounce, and @code{ozfl} is a fluid ounce.
27379 The temperature units corresponding to degrees Kelvin and Centigrade
27380 (Celsius) are the same in this table, since most units commands treat
27381 temperatures as being relative. The @code{calc-convert-temperature}
27382 command has special rules for handling the different absolute magnitudes
27383 of the various temperature scales.
27385 The unit of volume ``liters'' can be referred to by either the lower-case
27386 @code{l} or the upper-case @code{L}.
27388 The unit @code{A} stands for Amperes; the name @code{Ang} is used
27396 The unit @code{pt} stands for pints; the name @code{point} stands for
27397 a typographical point, defined by @samp{72 point = 1 in}. There is
27398 also @code{tpt}, which stands for a printer's point as defined by the
27399 @TeX{} typesetting system: @samp{72.27 tpt = 1 in}.
27401 The unit @code{e} stands for the elementary (electron) unit of charge;
27402 because algebra command could mistake this for the special constant
27403 @cite{e}, Calc provides the alternate unit name @code{ech} which is
27404 preferable to @code{e}.
27406 The name @code{g} stands for one gram of mass; there is also @code{gf},
27407 one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
27408 Meanwhile, one ``@cite{g}'' of acceleration is denoted @code{ga}.
27410 The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
27411 a metric ton of @samp{1000 kg}.
27413 The names @code{s} (or @code{sec}) and @code{min} refer to units of
27414 time; @code{arcsec} and @code{arcmin} are units of angle.
27416 Some ``units'' are really physical constants; for example, @code{c}
27417 represents the speed of light, and @code{h} represents Planck's
27418 constant. You can use these just like other units: converting
27419 @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
27420 meters per second. You can also use this merely as a handy reference;
27421 the @kbd{u g} command gets the definition of one of these constants
27422 in its normal terms, and @kbd{u b} expresses the definition in base
27425 Two units, @code{pi} and @code{fsc} (the fine structure constant,
27426 approximately @i{1/137}) are dimensionless. The units simplification
27427 commands simply treat these names as equivalent to their corresponding
27428 values. However you can, for example, use @kbd{u c} to convert a pure
27429 number into multiples of the fine structure constant, or @kbd{u b} to
27430 convert this back into a pure number. (When @kbd{u c} prompts for the
27431 ``old units,'' just enter a blank line to signify that the value
27432 really is unitless.)
27434 @c Describe angular units, luminosity vs. steradians problem.
27436 @node User-Defined Units, , Predefined Units, Units
27437 @section User-Defined Units
27440 Calc provides ways to get quick access to your selected ``favorite''
27441 units, as well as ways to define your own new units.
27444 @pindex calc-quick-units
27446 @cindex @code{Units} variable
27447 @cindex Quick units
27448 To select your favorite units, store a vector of unit names or
27449 expressions in the Calc variable @code{Units}. The @kbd{u 1}
27450 through @kbd{u 9} commands (@code{calc-quick-units}) provide access
27451 to these units. If the value on the top of the stack is a plain
27452 number (with no units attached), then @kbd{u 1} gives it the
27453 specified units. (Basically, it multiplies the number by the
27454 first item in the @code{Units} vector.) If the number on the
27455 stack @emph{does} have units, then @kbd{u 1} converts that number
27456 to the new units. For example, suppose the vector @samp{[in, ft]}
27457 is stored in @code{Units}. Then @kbd{30 u 1} will create the
27458 expression @samp{30 in}, and @kbd{u 2} will convert that expression
27461 The @kbd{u 0} command accesses the tenth element of @code{Units}.
27462 Only ten quick units may be defined at a time. If the @code{Units}
27463 variable has no stored value (the default), or if its value is not
27464 a vector, then the quick-units commands will not function. The
27465 @kbd{s U} command is a convenient way to edit the @code{Units}
27466 variable; @pxref{Operations on Variables}.
27469 @pindex calc-define-unit
27470 @cindex User-defined units
27471 The @kbd{u d} (@code{calc-define-unit}) command records the units
27472 expression on the top of the stack as the definition for a new,
27473 user-defined unit. For example, putting @samp{16.5 ft} on the stack and
27474 typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
27475 16.5 feet. The unit conversion and simplification commands will now
27476 treat @code{rod} just like any other unit of length. You will also be
27477 prompted for an optional English description of the unit, which will
27478 appear in the Units Table.
27481 @pindex calc-undefine-unit
27482 The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
27483 unit. It is not possible to remove one of the predefined units,
27486 If you define a unit with an existing unit name, your new definition
27487 will replace the original definition of that unit. If the unit was a
27488 predefined unit, the old definition will not be replaced, only
27489 ``shadowed.'' The built-in definition will reappear if you later use
27490 @kbd{u u} to remove the shadowing definition.
27492 To create a new fundamental unit, use either 1 or the unit name itself
27493 as the defining expression. Otherwise the expression can involve any
27494 other units that you like (except for composite units like @samp{mfi}).
27495 You can create a new composite unit with a sum of other units as the
27496 defining expression. The next unit operation like @kbd{u c} or @kbd{u v}
27497 will rebuild the internal unit table incorporating your modifications.
27498 Note that erroneous definitions (such as two units defined in terms of
27499 each other) will not be detected until the unit table is next rebuilt;
27500 @kbd{u v} is a convenient way to force this to happen.
27502 Temperature units are treated specially inside the Calculator; it is not
27503 possible to create user-defined temperature units.
27506 @pindex calc-permanent-units
27507 @cindex @file{.emacs} file, user-defined units
27508 The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
27509 units in your @file{.emacs} file, so that the units will still be
27510 available in subsequent Emacs sessions. If there was already a set of
27511 user-defined units in your @file{.emacs} file, it is replaced by the
27512 new set. (@xref{General Mode Commands}, for a way to tell Calc to use
27513 a different file instead of @file{.emacs}.)
27515 @node Store and Recall, Graphics, Units, Top
27516 @chapter Storing and Recalling
27519 Calculator variables are really just Lisp variables that contain numbers
27520 or formulas in a form that Calc can understand. The commands in this
27521 section allow you to manipulate variables conveniently. Commands related
27522 to variables use the @kbd{s} prefix key.
27525 * Storing Variables::
27526 * Recalling Variables::
27527 * Operations on Variables::
27529 * Evaluates-To Operator::
27532 @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
27533 @section Storing Variables
27538 @cindex Storing variables
27539 @cindex Quick variables
27542 The @kbd{s s} (@code{calc-store}) command stores the value at the top of
27543 the stack into a specified variable. It prompts you to enter the
27544 name of the variable. If you press a single digit, the value is stored
27545 immediately in one of the ``quick'' variables @code{var-q0} through
27546 @code{var-q9}. Or you can enter any variable name. The prefix @samp{var-}
27547 is supplied for you; when a name appears in a formula (as in @samp{a+q2})
27548 the prefix @samp{var-} is also supplied there, so normally you can simply
27549 forget about @samp{var-} everywhere. Its only purpose is to enable you to
27550 use Calc variables without fear of accidentally clobbering some variable in
27551 another Emacs package. If you really want to store in an arbitrary Lisp
27552 variable, just backspace over the @samp{var-}.
27555 @pindex calc-store-into
27556 The @kbd{s s} command leaves the stored value on the stack. There is
27557 also an @kbd{s t} (@code{calc-store-into}) command, which removes a
27558 value from the stack and stores it in a variable.
27560 If the top of stack value is an equation @samp{a = 7} or assignment
27561 @samp{a := 7} with a variable on the lefthand side, then Calc will
27562 assign that variable with that value by default, i.e., if you type
27563 @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the
27564 value 7 would be stored in the variable @samp{a}. (If you do type
27565 a variable name at the prompt, the top-of-stack value is stored in
27566 its entirety, even if it is an equation: @samp{s s b @key{RET}}
27567 with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
27569 In fact, the top of stack value can be a vector of equations or
27570 assignments with different variables on their lefthand sides; the
27571 default will be to store all the variables with their corresponding
27572 righthand sides simultaneously.
27574 It is also possible to type an equation or assignment directly at
27575 the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}.
27576 In this case the expression to the right of the @kbd{=} or @kbd{:=}
27577 symbol is evaluated as if by the @kbd{=} command, and that value is
27578 stored in the variable. No value is taken from the stack; @kbd{s s}
27579 and @kbd{s t} are equivalent when used in this way.
27583 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
27584 digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
27585 equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used
27586 for trail and time/date commands.)
27622 @pindex calc-store-plus
27623 @pindex calc-store-minus
27624 @pindex calc-store-times
27625 @pindex calc-store-div
27626 @pindex calc-store-power
27627 @pindex calc-store-concat
27628 @pindex calc-store-neg
27629 @pindex calc-store-inv
27630 @pindex calc-store-decr
27631 @pindex calc-store-incr
27632 There are also several ``arithmetic store'' commands. For example,
27633 @kbd{s +} removes a value from the stack and adds it to the specified
27634 variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
27635 @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
27636 @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
27637 and @kbd{s ]} which decrease or increase a variable by one.
27639 All the arithmetic stores accept the Inverse prefix to reverse the
27640 order of the operands. If @cite{v} represents the contents of the
27641 variable, and @cite{a} is the value drawn from the stack, then regular
27642 @w{@kbd{s -}} assigns @c{$v \coloneq v - a$}
27643 @cite{v := v - a}, but @kbd{I s -} assigns
27644 @c{$v \coloneq a - v$}
27645 @cite{v := a - v}. While @kbd{I s *} might seem pointless, it is
27646 useful if matrix multiplication is involved. Actually, all the
27647 arithmetic stores use formulas designed to behave usefully both
27648 forwards and backwards:
27652 s + v := v + a v := a + v
27653 s - v := v - a v := a - v
27654 s * v := v * a v := a * v
27655 s / v := v / a v := a / v
27656 s ^ v := v ^ a v := a ^ v
27657 s | v := v | a v := a | v
27658 s n v := v / (-1) v := (-1) / v
27659 s & v := v ^ (-1) v := (-1) ^ v
27660 s [ v := v - 1 v := 1 - v
27661 s ] v := v - (-1) v := (-1) - v
27665 In the last four cases, a numeric prefix argument will be used in
27666 place of the number one. (For example, @kbd{M-2 s ]} increases
27667 a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
27668 minus-two minus the variable.
27670 The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
27671 etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
27672 arithmetic stores that don't remove the value @cite{a} from the stack.
27674 All arithmetic stores report the new value of the variable in the
27675 Trail for your information. They signal an error if the variable
27676 previously had no stored value. If default simplifications have been
27677 turned off, the arithmetic stores temporarily turn them on for numeric
27678 arguments only (i.e., they temporarily do an @kbd{m N} command).
27679 @xref{Simplification Modes}. Large vectors put in the trail by
27680 these commands always use abbreviated (@kbd{t .}) mode.
27683 @pindex calc-store-map
27684 The @kbd{s m} command is a general way to adjust a variable's value
27685 using any Calc function. It is a ``mapping'' command analogous to
27686 @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see
27687 how to specify a function for a mapping command. Basically,
27688 all you do is type the Calc command key that would invoke that
27689 function normally. For example, @kbd{s m n} applies the @kbd{n}
27690 key to negate the contents of the variable, so @kbd{s m n} is
27691 equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root
27692 of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
27693 reverse the vector stored in the variable, and @kbd{s m H I S}
27694 takes the hyperbolic arcsine of the variable contents.
27696 If the mapping function takes two or more arguments, the additional
27697 arguments are taken from the stack; the old value of the variable
27698 is provided as the first argument. Thus @kbd{s m -} with @cite{a}
27699 on the stack computes @cite{v - a}, just like @kbd{s -}. With the
27700 Inverse prefix, the variable's original value becomes the @emph{last}
27701 argument instead of the first. Thus @kbd{I s m -} is also
27702 equivalent to @kbd{I s -}.
27705 @pindex calc-store-exchange
27706 The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
27707 of a variable with the value on the top of the stack. Naturally, the
27708 variable must already have a stored value for this to work.
27710 You can type an equation or assignment at the @kbd{s x} prompt. The
27711 command @kbd{s x a=6} takes no values from the stack; instead, it
27712 pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
27715 @pindex calc-unstore
27716 @cindex Void variables
27717 @cindex Un-storing variables
27718 Until you store something in them, variables are ``void,'' that is, they
27719 contain no value at all. If they appear in an algebraic formula they
27720 will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
27721 The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
27724 The only variables with predefined values are the ``special constants''
27725 @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free
27726 to unstore these variables or to store new values into them if you like,
27727 although some of the algebraic-manipulation functions may assume these
27728 variables represent their standard values. Calc displays a warning if
27729 you change the value of one of these variables, or of one of the other
27730 special variables @code{inf}, @code{uinf}, and @code{nan} (which are
27733 Note that @code{var-pi} doesn't actually have 3.14159265359 stored
27734 in it, but rather a special magic value that evaluates to @c{$\pi$}
27736 at the current precision. Likewise @code{var-e}, @code{var-i}, and
27737 @code{var-phi} evaluate according to the current precision or polar mode.
27738 If you recall a value from @code{pi} and store it back, this magic
27739 property will be lost.
27742 @pindex calc-copy-variable
27743 The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
27744 value of one variable to another. It differs from a simple @kbd{s r}
27745 followed by an @kbd{s t} in two important ways. First, the value never
27746 goes on the stack and thus is never rounded, evaluated, or simplified
27747 in any way; it is not even rounded down to the current precision.
27748 Second, the ``magic'' contents of a variable like @code{var-e} can
27749 be copied into another variable with this command, perhaps because
27750 you need to unstore @code{var-e} right now but you wish to put it
27751 back when you're done. The @kbd{s c} command is the only way to
27752 manipulate these magic values intact.
27754 @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
27755 @section Recalling Variables
27759 @pindex calc-recall
27760 @cindex Recalling variables
27761 The most straightforward way to extract the stored value from a variable
27762 is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts
27763 for a variable name (similarly to @code{calc-store}), looks up the value
27764 of the specified variable, and pushes that value onto the stack. It is
27765 an error to try to recall a void variable.
27767 It is also possible to recall the value from a variable by evaluating a
27768 formula containing that variable. For example, @kbd{' a @key{RET} =} is
27769 the same as @kbd{s r a @key{RET}} except that if the variable is void, the
27770 former will simply leave the formula @samp{a} on the stack whereas the
27771 latter will produce an error message.
27774 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
27775 equivalent to @kbd{s r 9}. (The @kbd{r} prefix is otherwise unused
27776 in the current version of Calc.)
27778 @node Operations on Variables, Let Command, Recalling Variables, Store and Recall
27779 @section Other Operations on Variables
27783 @pindex calc-edit-variable
27784 The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
27785 value of a variable without ever putting that value on the stack
27786 or simplifying or evaluating the value. It prompts for the name of
27787 the variable to edit. If the variable has no stored value, the
27788 editing buffer will start out empty. If the editing buffer is
27789 empty when you press @kbd{M-# M-#} to finish, the variable will
27790 be made void. @xref{Editing Stack Entries}, for a general
27791 description of editing.
27793 The @kbd{s e} command is especially useful for creating and editing
27794 rewrite rules which are stored in variables. Sometimes these rules
27795 contain formulas which must not be evaluated until the rules are
27796 actually used. (For example, they may refer to @samp{deriv(x,y)},
27797 where @code{x} will someday become some expression involving @code{y};
27798 if you let Calc evaluate the rule while you are defining it, Calc will
27799 replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
27800 not itself refer to @code{y}.) By contrast, recalling the variable,
27801 editing with @kbd{`}, and storing will evaluate the variable's value
27802 as a side effect of putting the value on the stack.
27850 @pindex calc-store-AlgSimpRules
27851 @pindex calc-store-Decls
27852 @pindex calc-store-EvalRules
27853 @pindex calc-store-FitRules
27854 @pindex calc-store-GenCount
27855 @pindex calc-store-Holidays
27856 @pindex calc-store-IntegLimit
27857 @pindex calc-store-LineStyles
27858 @pindex calc-store-PointStyles
27859 @pindex calc-store-PlotRejects
27860 @pindex calc-store-TimeZone
27861 @pindex calc-store-Units
27862 @pindex calc-store-ExtSimpRules
27863 There are several special-purpose variable-editing commands that
27864 use the @kbd{s} prefix followed by a shifted letter:
27868 Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}.
27870 Edit @code{Decls}. @xref{Declarations}.
27872 Edit @code{EvalRules}. @xref{Default Simplifications}.
27874 Edit @code{FitRules}. @xref{Curve Fitting}.
27876 Edit @code{GenCount}. @xref{Solving Equations}.
27878 Edit @code{Holidays}. @xref{Business Days}.
27880 Edit @code{IntegLimit}. @xref{Calculus}.
27882 Edit @code{LineStyles}. @xref{Graphics}.
27884 Edit @code{PointStyles}. @xref{Graphics}.
27886 Edit @code{PlotRejects}. @xref{Graphics}.
27888 Edit @code{TimeZone}. @xref{Time Zones}.
27890 Edit @code{Units}. @xref{User-Defined Units}.
27892 Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}.
27895 These commands are just versions of @kbd{s e} that use fixed variable
27896 names rather than prompting for the variable name.
27899 @pindex calc-permanent-variable
27900 @cindex Storing variables
27901 @cindex Permanent variables
27902 @cindex @file{.emacs} file, variables
27903 The @kbd{s p} (@code{calc-permanent-variable}) command saves a
27904 variable's value permanently in your @file{.emacs} file, so that its
27905 value will still be available in future Emacs sessions. You can
27906 re-execute @w{@kbd{s p}} later on to update the saved value, but the
27907 only way to remove a saved variable is to edit your @file{.emacs} file
27908 by hand. (@xref{General Mode Commands}, for a way to tell Calc to
27909 use a different file instead of @file{.emacs}.)
27911 If you do not specify the name of a variable to save (i.e.,
27912 @kbd{s p @key{RET}}), all @samp{var-} variables with defined values
27913 are saved except for the special constants @code{pi}, @code{e},
27914 @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
27915 and @code{PlotRejects};
27916 @code{FitRules}, @code{DistribRules}, and other built-in rewrite
27917 rules; and @code{PlotData@var{n}} variables generated
27918 by the graphics commands. (You can still save these variables by
27919 explicitly naming them in an @kbd{s p} command.)@refill
27922 @pindex calc-insert-variables
27923 The @kbd{s i} (@code{calc-insert-variables}) command writes
27924 the values of all @samp{var-} variables into a specified buffer.
27925 The variables are written in the form of Lisp @code{setq} commands
27926 which store the values in string form. You can place these commands
27927 in your @file{.emacs} buffer if you wish, though in this case it
27928 would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i}
27929 omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
27930 is that @kbd{s i} will store the variables in any buffer, and it also
27931 stores in a more human-readable format.)
27933 @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
27934 @section The Let Command
27939 @cindex Variables, temporary assignment
27940 @cindex Temporary assignment to variables
27941 If you have an expression like @samp{a+b^2} on the stack and you wish to
27942 compute its value where @cite{b=3}, you can simply store 3 in @cite{b} and
27943 then press @kbd{=} to reevaluate the formula. This has the side-effect
27944 of leaving the stored value of 3 in @cite{b} for future operations.
27946 The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
27947 @emph{temporary} assignment of a variable. It stores the value on the
27948 top of the stack into the specified variable, then evaluates the
27949 second-to-top stack entry, then restores the original value (or lack of one)
27950 in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
27951 the stack will contain the formula @samp{a + 9}. The subsequent command
27952 @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
27953 The variables @samp{a} and @samp{b} are not permanently affected in any way
27956 The value on the top of the stack may be an equation or assignment, or
27957 a vector of equations or assignments, in which case the default will be
27958 analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}.
27960 Also, you can answer the variable-name prompt with an equation or
27961 assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
27962 and typing @kbd{s l b @key{RET}}.
27964 The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
27965 a variable with a value in a formula. It does an actual substitution
27966 rather than temporarily assigning the variable and evaluating. For
27967 example, letting @cite{n=2} in @samp{f(n pi)} with @kbd{a b} will
27968 produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
27969 since the evaluation step will also evaluate @code{pi}.
27971 @node Evaluates-To Operator, , Let Command, Store and Recall
27972 @section The Evaluates-To Operator
27977 @cindex Evaluates-to operator
27978 @cindex @samp{=>} operator
27979 The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
27980 operator}. (It will show up as an @code{evalto} function call in
27981 other language modes like Pascal and @TeX{}.) This is a binary
27982 operator, that is, it has a lefthand and a righthand argument,
27983 although it can be entered with the righthand argument omitted.
27985 A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
27986 follows: First, @var{a} is not simplified or modified in any
27987 way. The previous value of argument @var{b} is thrown away; the
27988 formula @var{a} is then copied and evaluated as if by the @kbd{=}
27989 command according to all current modes and stored variable values,
27990 and the result is installed as the new value of @var{b}.
27992 For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
27993 The number 17 is ignored, and the lefthand argument is left in its
27994 unevaluated form; the result is the formula @samp{2 + 3 => 5}.
27997 @pindex calc-evalto
27998 You can enter an @samp{=>} formula either directly using algebraic
27999 entry (in which case the righthand side may be omitted since it is
28000 going to be replaced right away anyhow), or by using the @kbd{s =}
28001 (@code{calc-evalto}) command, which takes @var{a} from the stack
28002 and replaces it with @samp{@var{a} => @var{b}}.
28004 Calc keeps track of all @samp{=>} operators on the stack, and
28005 recomputes them whenever anything changes that might affect their
28006 values, i.e., a mode setting or variable value. This occurs only
28007 if the @samp{=>} operator is at the top level of the formula, or
28008 if it is part of a top-level vector. In other words, pushing
28009 @samp{2 + (a => 17)} will change the 17 to the actual value of
28010 @samp{a} when you enter the formula, but the result will not be
28011 dynamically updated when @samp{a} is changed later because the
28012 @samp{=>} operator is buried inside a sum. However, a vector
28013 of @samp{=>} operators will be recomputed, since it is convenient
28014 to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
28015 make a concise display of all the variables in your problem.
28016 (Another way to do this would be to use @samp{[a, b, c] =>},
28017 which provides a slightly different format of display. You
28018 can use whichever you find easiest to read.)
28021 @pindex calc-auto-recompute
28022 The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
28023 turn this automatic recomputation on or off. If you turn
28024 recomputation off, you must explicitly recompute an @samp{=>}
28025 operator on the stack in one of the usual ways, such as by
28026 pressing @kbd{=}. Turning recomputation off temporarily can save
28027 a lot of time if you will be changing several modes or variables
28028 before you look at the @samp{=>} entries again.
28030 Most commands are not especially useful with @samp{=>} operators
28031 as arguments. For example, given @samp{x + 2 => 17}, it won't
28032 work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want
28033 to operate on the lefthand side of the @samp{=>} operator on
28034 the top of the stack, type @kbd{j 1} (that's the digit ``one'')
28035 to select the lefthand side, execute your commands, then type
28036 @kbd{j u} to unselect.
28038 All current modes apply when an @samp{=>} operator is computed,
28039 including the current simplification mode. Recall that the
28040 formula @samp{x + y + x} is not handled by Calc's default
28041 simplifications, but the @kbd{a s} command will reduce it to
28042 the simpler form @samp{y + 2 x}. You can also type @kbd{m A}
28043 to enable an algebraic-simplification mode in which the
28044 equivalent of @kbd{a s} is used on all of Calc's results.
28045 If you enter @samp{x + y + x =>} normally, the result will
28046 be @samp{x + y + x => x + y + x}. If you change to
28047 algebraic-simplification mode, the result will be
28048 @samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s}
28049 once will have no effect on @samp{x + y + x => x + y + x},
28050 because the righthand side depends only on the lefthand side
28051 and the current mode settings, and the lefthand side is not
28052 affected by commands like @kbd{a s}.
28054 The ``let'' command (@kbd{s l}) has an interesting interaction
28055 with the @samp{=>} operator. The @kbd{s l} command evaluates the
28056 second-to-top stack entry with the top stack entry supplying
28057 a temporary value for a given variable. As you might expect,
28058 if that stack entry is an @samp{=>} operator its righthand
28059 side will temporarily show this value for the variable. In
28060 fact, all @samp{=>}s on the stack will be updated if they refer
28061 to that variable. But this change is temporary in the sense
28062 that the next command that causes Calc to look at those stack
28063 entries will make them revert to the old variable value.
28067 2: a => a 2: a => 17 2: a => a
28068 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1
28071 17 s l a @key{RET} p 8 @key{RET}
28075 Here the @kbd{p 8} command changes the current precision,
28076 thus causing the @samp{=>} forms to be recomputed after the
28077 influence of the ``let'' is gone. The @kbd{d @key{SPC}} command
28078 (@code{calc-refresh}) is a handy way to force the @samp{=>}
28079 operators on the stack to be recomputed without any other
28083 @pindex calc-assign
28086 Embedded Mode also uses @samp{=>} operators. In embedded mode,
28087 the lefthand side of an @samp{=>} operator can refer to variables
28088 assigned elsewhere in the file by @samp{:=} operators. The
28089 assignment operator @samp{a := 17} does not actually do anything
28090 by itself. But Embedded Mode recognizes it and marks it as a sort
28091 of file-local definition of the variable. You can enter @samp{:=}
28092 operators in algebraic mode, or by using the @kbd{s :}
28093 (@code{calc-assign}) [@code{assign}] command which takes a variable
28094 and value from the stack and replaces them with an assignment.
28096 @xref{TeX Language Mode}, for the way @samp{=>} appears in
28097 @TeX{} language output. The @dfn{eqn} mode gives similar
28098 treatment to @samp{=>}.
28100 @node Graphics, Kill and Yank, Store and Recall, Top
28104 The commands for graphing data begin with the @kbd{g} prefix key. Calc
28105 uses GNUPLOT 2.0 or 3.0 to do graphics. These commands will only work
28106 if GNUPLOT is available on your system. (While GNUPLOT sounds like
28107 a relative of GNU Emacs, it is actually completely unrelated.
28108 However, it is free software and can be obtained from the Free
28109 Software Foundation's machine @samp{prep.ai.mit.edu}.)
28111 @vindex calc-gnuplot-name
28112 If you have GNUPLOT installed on your system but Calc is unable to
28113 find it, you may need to set the @code{calc-gnuplot-name} variable
28114 in your @file{.emacs} file. You may also need to set some Lisp
28115 variables to show Calc how to run GNUPLOT on your system; these
28116 are described under @kbd{g D} and @kbd{g O} below. If you are
28117 using the X window system, Calc will configure GNUPLOT for you
28118 automatically. If you have GNUPLOT 3.0 and you are not using X,
28119 Calc will configure GNUPLOT to display graphs using simple character
28120 graphics that will work on any terminal.
28124 * Three Dimensional Graphics::
28125 * Managing Curves::
28126 * Graphics Options::
28130 @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
28131 @section Basic Graphics
28135 @pindex calc-graph-fast
28136 The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
28137 This command takes two vectors of equal length from the stack.
28138 The vector at the top of the stack represents the ``y'' values of
28139 the various data points. The vector in the second-to-top position
28140 represents the corresponding ``x'' values. This command runs
28141 GNUPLOT (if it has not already been started by previous graphing
28142 commands) and displays the set of data points. The points will
28143 be connected by lines, and there will also be some kind of symbol
28144 to indicate the points themselves.
28146 The ``x'' entry may instead be an interval form, in which case suitable
28147 ``x'' values are interpolated between the minimum and maximum values of
28148 the interval (whether the interval is open or closed is ignored).
28150 The ``x'' entry may also be a number, in which case Calc uses the
28151 sequence of ``x'' values @cite{x}, @cite{x+1}, @cite{x+2}, etc.
28152 (Generally the number 0 or 1 would be used for @cite{x} in this case.)
28154 The ``y'' entry may be any formula instead of a vector. Calc effectively
28155 uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
28156 the result of this must be a formula in a single (unassigned) variable.
28157 The formula is plotted with this variable taking on the various ``x''
28158 values. Graphs of formulas by default use lines without symbols at the
28159 computed data points. Note that if neither ``x'' nor ``y'' is a vector,
28160 Calc guesses at a reasonable number of data points to use. See the
28161 @kbd{g N} command below. (The ``x'' values must be either a vector
28162 or an interval if ``y'' is a formula.)
28168 If ``y'' is (or evaluates to) a formula of the form
28169 @samp{xy(@var{x}, @var{y})} then the result is a
28170 parametric plot. The two arguments of the fictitious @code{xy} function
28171 are used as the ``x'' and ``y'' coordinates of the curve, respectively.
28172 In this case the ``x'' vector or interval you specified is not directly
28173 visible in the graph. For example, if ``x'' is the interval @samp{[0..360]}
28174 and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
28175 will be a circle.@refill
28177 Also, ``x'' and ``y'' may each be variable names, in which case Calc
28178 looks for suitable vectors, intervals, or formulas stored in those
28181 The ``x'' and ``y'' values for the data points (as pulled from the vectors,
28182 calculated from the formulas, or interpolated from the intervals) should
28183 be real numbers (integers, fractions, or floats). If either the ``x''
28184 value or the ``y'' value of a given data point is not a real number, that
28185 data point will be omitted from the graph. The points on either side
28186 of the invalid point will @emph{not} be connected by a line.
28188 See the documentation for @kbd{g a} below for a description of the way
28189 numeric prefix arguments affect @kbd{g f}.
28191 @cindex @code{PlotRejects} variable
28192 @vindex PlotRejects
28193 If you store an empty vector in the variable @code{PlotRejects}
28194 (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
28195 this vector for every data point which was rejected because its
28196 ``x'' or ``y'' values were not real numbers. The result will be
28197 a matrix where each row holds the curve number, data point number,
28198 ``x'' value, and ``y'' value for a rejected data point.
28199 @xref{Evaluates-To Operator}, for a handy way to keep tabs on the
28200 current value of @code{PlotRejects}. @xref{Operations on Variables},
28201 for the @kbd{s R} command which is another easy way to examine
28202 @code{PlotRejects}.
28205 @pindex calc-graph-clear
28206 To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
28207 If the GNUPLOT output device is an X window, the window will go away.
28208 Effects on other kinds of output devices will vary. You don't need
28209 to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
28210 or @kbd{g p} command later on, it will reuse the existing graphics
28211 window if there is one.
28213 @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
28214 @section Three-Dimensional Graphics
28217 @pindex calc-graph-fast-3d
28218 The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
28219 graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
28220 you will see a GNUPLOT error message if you try this command.
28222 The @kbd{g F} command takes three values from the stack, called ``x'',
28223 ``y'', and ``z'', respectively. As was the case for 2D graphs, there
28224 are several options for these values.
28226 In the first case, ``x'' and ``y'' are each vectors (not necessarily of
28227 the same length); either or both may instead be interval forms. The
28228 ``z'' value must be a matrix with the same number of rows as elements
28229 in ``x'', and the same number of columns as elements in ``y''. The
28230 result is a surface plot where @c{$z_{ij}$}
28231 @cite{z_ij} is the height of the point
28232 at coordinate @cite{(x_i, y_j)} on the surface. The 3D graph will
28233 be displayed from a certain default viewpoint; you can change this
28234 viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*}
28235 buffer as described later. See the GNUPLOT 3.0 documentation for a
28236 description of the @samp{set view} command.
28238 Each point in the matrix will be displayed as a dot in the graph,
28239 and these points will be connected by a grid of lines (@dfn{isolines}).
28241 In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
28242 length. The resulting graph displays a 3D line instead of a surface,
28243 where the coordinates of points along the line are successive triplets
28244 of values from the input vectors.
28246 In the third case, ``x'' and ``y'' are vectors or interval forms, and
28247 ``z'' is any formula involving two variables (not counting variables
28248 with assigned values). These variables are sorted into alphabetical
28249 order; the first takes on values from ``x'' and the second takes on
28250 values from ``y'' to form a matrix of results that are graphed as a
28257 If the ``z'' formula evaluates to a call to the fictitious function
28258 @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
28259 ``parametric surface.'' In this case, the axes of the graph are
28260 taken from the @var{x} and @var{y} values in these calls, and the
28261 ``x'' and ``y'' values from the input vectors or intervals are used only
28262 to specify the range of inputs to the formula. For example, plotting
28263 @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
28264 will draw a sphere. (Since the default resolution for 3D plots is
28265 5 steps in each of ``x'' and ``y'', this will draw a very crude
28266 sphere. You could use the @kbd{g N} command, described below, to
28267 increase this resolution, or specify the ``x'' and ``y'' values as
28268 vectors with more than 5 elements.
28270 It is also possible to have a function in a regular @kbd{g f} plot
28271 evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not
28272 a surface, the result will be a 3D parametric line. For example,
28273 @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
28274 helix (a three-dimensional spiral).
28276 As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
28277 variables containing the relevant data.
28279 @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
28280 @section Managing Curves
28283 The @kbd{g f} command is really shorthand for the following commands:
28284 @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for
28285 @kbd{C-u g d g A g p}. You can gain more control over your graph
28286 by using these commands directly.
28289 @pindex calc-graph-add
28290 The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
28291 represented by the two values on the top of the stack to the current
28292 graph. You can have any number of curves in the same graph. When
28293 you give the @kbd{g p} command, all the curves will be drawn superimposed
28296 The @kbd{g a} command (and many others that affect the current graph)
28297 will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed
28298 in another window. This buffer is a template of the commands that will
28299 be sent to GNUPLOT when it is time to draw the graph. The first
28300 @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding
28301 @kbd{g a} commands add extra curves onto that @code{plot} command.
28302 Other graph-related commands put other GNUPLOT commands into this
28303 buffer. In normal usage you never need to work with this buffer
28304 directly, but you can if you wish. The only constraint is that there
28305 must be only one @code{plot} command, and it must be the last command
28306 in the buffer. If you want to save and later restore a complete graph
28307 configuration, you can use regular Emacs commands to save and restore
28308 the contents of the @samp{*Gnuplot Commands*} buffer.
28312 If the values on the stack are not variable names, @kbd{g a} will invent
28313 variable names for them (of the form @samp{PlotData@var{n}}) and store
28314 the values in those variables. The ``x'' and ``y'' variables are what
28315 go into the @code{plot} command in the template. If you add a curve
28316 that uses a certain variable and then later change that variable, you
28317 can replot the graph without having to delete and re-add the curve.
28318 That's because the variable name, not the vector, interval or formula
28319 itself, is what was added by @kbd{g a}.
28321 A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
28322 stack entries are interpreted as curves. With a positive prefix
28323 argument @cite{n}, the top @cite{n} stack entries are ``y'' values
28324 for @cite{n} different curves which share a common ``x'' value in
28325 the @cite{n+1}st stack entry. (Thus @kbd{g a} with no prefix
28326 argument is equivalent to @kbd{C-u 1 g a}.)
28328 A prefix of zero or plain @kbd{C-u} means to take two stack entries,
28329 ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
28330 ``y'' values for several curves that share a common ``x''.
28332 A negative prefix argument tells Calc to read @cite{n} vectors from
28333 the stack; each vector @cite{[x, y]} describes an independent curve.
28334 This is the only form of @kbd{g a} that creates several curves at once
28335 that don't have common ``x'' values. (Of course, the range of ``x''
28336 values covered by all the curves ought to be roughly the same if
28337 they are to look nice on the same graph.)
28339 For example, to plot @c{$\sin n x$}
28340 @cite{sin(n x)} for integers @cite{n}
28341 from 1 to 5, you could use @kbd{v x} to create a vector of integers
28342 (@cite{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
28343 across this vector. The resulting vector of formulas is suitable
28344 for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
28348 @pindex calc-graph-add-3d
28349 The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
28350 to the graph. It is not legal to intermix 2D and 3D curves in a
28351 single graph. This command takes three arguments, ``x'', ``y'',
28352 and ``z'', from the stack. With a positive prefix @cite{n}, it
28353 takes @cite{n+2} arguments (common ``x'' and ``y'', plus @cite{n}
28354 separate ``z''s). With a zero prefix, it takes three stack entries
28355 but the ``z'' entry is a vector of curve values. With a negative
28356 prefix @cite{-n}, it takes @cite{n} vectors of the form @cite{[x, y, z]}.
28357 The @kbd{g A} command works by adding a @code{splot} (surface-plot)
28358 command to the @samp{*Gnuplot Commands*} buffer.
28360 (Although @kbd{g a} adds a 2D @code{plot} command to the
28361 @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
28362 before sending it to GNUPLOT if it notices that the data points are
28363 evaluating to @code{xyz} calls. It will not work to mix 2D and 3D
28364 @kbd{g a} curves in a single graph, although Calc does not currently
28368 @pindex calc-graph-delete
28369 The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
28370 recently added curve from the graph. It has no effect if there are
28371 no curves in the graph. With a numeric prefix argument of any kind,
28372 it deletes all of the curves from the graph.
28375 @pindex calc-graph-hide
28376 The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
28377 the most recently added curve. A hidden curve will not appear in
28378 the actual plot, but information about it such as its name and line and
28379 point styles will be retained.
28382 @pindex calc-graph-juggle
28383 The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
28384 at the end of the list (the ``most recently added curve'') to the
28385 front of the list. The next-most-recent curve is thus exposed for
28386 @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work
28387 with any curve in the graph even though curve-related commands only
28388 affect the last curve in the list.
28391 @pindex calc-graph-plot
28392 The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
28393 the graph described in the @samp{*Gnuplot Commands*} buffer. Any
28394 GNUPLOT parameters which are not defined by commands in this buffer
28395 are reset to their default values. The variables named in the @code{plot}
28396 command are written to a temporary data file and the variable names
28397 are then replaced by the file name in the template. The resulting
28398 plotting commands are fed to the GNUPLOT program. See the documentation
28399 for the GNUPLOT program for more specific information. All temporary
28400 files are removed when Emacs or GNUPLOT exits.
28402 If you give a formula for ``y'', Calc will remember all the values that
28403 it calculates for the formula so that later plots can reuse these values.
28404 Calc throws out these saved values when you change any circumstances
28405 that may affect the data, such as switching from Degrees to Radians
28406 mode, or changing the value of a parameter in the formula. You can
28407 force Calc to recompute the data from scratch by giving a negative
28408 numeric prefix argument to @kbd{g p}.
28410 Calc uses a fairly rough step size when graphing formulas over intervals.
28411 This is to ensure quick response. You can ``refine'' a plot by giving
28412 a positive numeric prefix argument to @kbd{g p}. Calc goes through
28413 the data points it has computed and saved from previous plots of the
28414 function, and computes and inserts a new data point midway between
28415 each of the existing points. You can refine a plot any number of times,
28416 but beware that the amount of calculation involved doubles each time.
28418 Calc does not remember computed values for 3D graphs. This means the
28419 numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
28420 the current graph is three-dimensional.
28423 @pindex calc-graph-print
28424 The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
28425 except that it sends the output to a printer instead of to the
28426 screen. More precisely, @kbd{g p} looks for @samp{set terminal}
28427 or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer;
28428 lacking these it uses the default settings. However, @kbd{g P}
28429 ignores @samp{set terminal} and @samp{set output} commands and
28430 uses a different set of default values. All of these values are
28431 controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
28432 Provided everything is set up properly, @kbd{g p} will plot to
28433 the screen unless you have specified otherwise and @kbd{g P} will
28434 always plot to the printer.
28436 @node Graphics Options, Devices, Managing Curves, Graphics
28437 @section Graphics Options
28441 @pindex calc-graph-grid
28442 The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
28443 on and off. It is off by default; tick marks appear only at the
28444 edges of the graph. With the grid turned on, dotted lines appear
28445 across the graph at each tick mark. Note that this command only
28446 changes the setting in @samp{*Gnuplot Commands*}; to see the effects
28447 of the change you must give another @kbd{g p} command.
28450 @pindex calc-graph-border
28451 The @kbd{g b} (@code{calc-graph-border}) command turns the border
28452 (the box that surrounds the graph) on and off. It is on by default.
28453 This command will only work with GNUPLOT 3.0 and later versions.
28456 @pindex calc-graph-key
28457 The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
28458 on and off. The key is a chart in the corner of the graph that
28459 shows the correspondence between curves and line styles. It is
28460 off by default, and is only really useful if you have several
28461 curves on the same graph.
28464 @pindex calc-graph-num-points
28465 The @kbd{g N} (@code{calc-graph-num-points}) command allows you
28466 to select the number of data points in the graph. This only affects
28467 curves where neither ``x'' nor ``y'' is specified as a vector.
28468 Enter a blank line to revert to the default value (initially 15).
28469 With no prefix argument, this command affects only the current graph.
28470 With a positive prefix argument this command changes or, if you enter
28471 a blank line, displays the default number of points used for all
28472 graphs created by @kbd{g a} that don't specify the resolution explicitly.
28473 With a negative prefix argument, this command changes or displays
28474 the default value (initially 5) used for 3D graphs created by @kbd{g A}.
28475 Note that a 3D setting of 5 means that a total of @cite{5^2 = 25} points
28476 will be computed for the surface.
28478 Data values in the graph of a function are normally computed to a
28479 precision of five digits, regardless of the current precision at the
28480 time. This is usually more than adequate, but there are cases where
28481 it will not be. For example, plotting @cite{1 + x} with @cite{x} in the
28482 interval @samp{[0 ..@: 1e-6]} will round all the data points down
28483 to 1.0! Putting the command @samp{set precision @var{n}} in the
28484 @samp{*Gnuplot Commands*} buffer will cause the data to be computed
28485 at precision @var{n} instead of 5. Since this is such a rare case,
28486 there is no keystroke-based command to set the precision.
28489 @pindex calc-graph-header
28490 The @kbd{g h} (@code{calc-graph-header}) command sets the title
28491 for the graph. This will show up centered above the graph.
28492 The default title is blank (no title).
28495 @pindex calc-graph-name
28496 The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
28497 individual curve. Like the other curve-manipulating commands, it
28498 affects the most recently added curve, i.e., the last curve on the
28499 list in the @samp{*Gnuplot Commands*} buffer. To set the title of
28500 the other curves you must first juggle them to the end of the list
28501 with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand.
28502 Curve titles appear in the key; if the key is turned off they are
28507 @pindex calc-graph-title-x
28508 @pindex calc-graph-title-y
28509 The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
28510 (@code{calc-graph-title-y}) commands set the titles on the ``x''
28511 and ``y'' axes, respectively. These titles appear next to the
28512 tick marks on the left and bottom edges of the graph, respectively.
28513 Calc does not have commands to control the tick marks themselves,
28514 but you can edit them into the @samp{*Gnuplot Commands*} buffer if
28515 you wish. See the GNUPLOT documentation for details.
28519 @pindex calc-graph-range-x
28520 @pindex calc-graph-range-y
28521 The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
28522 (@code{calc-graph-range-y}) commands set the range of values on the
28523 ``x'' and ``y'' axes, respectively. You are prompted to enter a
28524 suitable range. This should be either a pair of numbers of the
28525 form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
28526 default behavior of setting the range based on the range of values
28527 in the data, or @samp{$} to take the range from the top of the stack.
28528 Ranges on the stack can be represented as either interval forms or
28529 vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
28533 @pindex calc-graph-log-x
28534 @pindex calc-graph-log-y
28535 The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
28536 commands allow you to set either or both of the axes of the graph to
28537 be logarithmic instead of linear.
28542 @pindex calc-graph-log-z
28543 @pindex calc-graph-range-z
28544 @pindex calc-graph-title-z
28545 For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
28546 letters with the Control key held down) are the corresponding commands
28547 for the ``z'' axis.
28551 @pindex calc-graph-zero-x
28552 @pindex calc-graph-zero-y
28553 The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
28554 (@code{calc-graph-zero-y}) commands control whether a dotted line is
28555 drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same
28556 dotted lines that would be drawn there anyway if you used @kbd{g g} to
28557 turn the ``grid'' feature on.) Zero-axis lines are on by default, and
28558 may be turned off only in GNUPLOT 3.0 and later versions. They are
28559 not available for 3D plots.
28562 @pindex calc-graph-line-style
28563 The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
28564 lines on or off for the most recently added curve, and optionally selects
28565 the style of lines to be used for that curve. Plain @kbd{g s} simply
28566 toggles the lines on and off. With a numeric prefix argument, @kbd{g s}
28567 turns lines on and sets a particular line style. Line style numbers
28568 start at one and their meanings vary depending on the output device.
28569 GNUPLOT guarantees that there will be at least six different line styles
28570 available for any device.
28573 @pindex calc-graph-point-style
28574 The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
28575 the symbols at the data points on or off, or sets the point style.
28576 If you turn both lines and points off, the data points will show as
28579 @cindex @code{LineStyles} variable
28580 @cindex @code{PointStyles} variable
28582 @vindex PointStyles
28583 Another way to specify curve styles is with the @code{LineStyles} and
28584 @code{PointStyles} variables. These variables initially have no stored
28585 values, but if you store a vector of integers in one of these variables,
28586 the @kbd{g a} and @kbd{g f} commands will use those style numbers
28587 instead of the defaults for new curves that are added to the graph.
28588 An entry should be a positive integer for a specific style, or 0 to let
28589 the style be chosen automatically, or @i{-1} to turn off lines or points
28590 altogether. If there are more curves than elements in the vector, the
28591 last few curves will continue to have the default styles. Of course,
28592 you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
28594 For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
28595 to have lines in style number 2, the second curve to have no connecting
28596 lines, and the third curve to have lines in style 3. Point styles will
28597 still be assigned automatically, but you could store another vector in
28598 @code{PointStyles} to define them, too.
28600 @node Devices, , Graphics Options, Graphics
28601 @section Graphical Devices
28605 @pindex calc-graph-device
28606 The @kbd{g D} (@code{calc-graph-device}) command sets the device name
28607 (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
28608 on this graph. It does not affect the permanent default device name.
28609 If you enter a blank name, the device name reverts to the default.
28610 Enter @samp{?} to see a list of supported devices.
28612 With a positive numeric prefix argument, @kbd{g D} instead sets
28613 the default device name, used by all plots in the future which do
28614 not override it with a plain @kbd{g D} command. If you enter a
28615 blank line this command shows you the current default. The special
28616 name @code{default} signifies that Calc should choose @code{x11} if
28617 the X window system is in use (as indicated by the presence of a
28618 @code{DISPLAY} environment variable), or otherwise @code{dumb} under
28619 GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0.
28620 This is the initial default value.
28622 The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
28623 terminals with no special graphics facilities. It writes a crude
28624 picture of the graph composed of characters like @code{-} and @code{|}
28625 to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays.
28626 The graph is made the same size as the Emacs screen, which on most
28627 dumb terminals will be @c{$80\times24$}
28628 @asis{80x24} characters. The graph is displayed in
28629 an Emacs ``recursive edit''; type @kbd{q} or @kbd{M-# M-#} to exit
28630 the recursive edit and return to Calc. Note that the @code{dumb}
28631 device is present only in GNUPLOT 3.0 and later versions.
28633 The word @code{dumb} may be followed by two numbers separated by
28634 spaces. These are the desired width and height of the graph in
28635 characters. Also, the device name @code{big} is like @code{dumb}
28636 but creates a graph four times the width and height of the Emacs
28637 screen. You will then have to scroll around to view the entire
28638 graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
28639 @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
28640 of the four directions.
28642 With a negative numeric prefix argument, @kbd{g D} sets or displays
28643 the device name used by @kbd{g P} (@code{calc-graph-print}). This
28644 is initially @code{postscript}. If you don't have a PostScript
28645 printer, you may decide once again to use @code{dumb} to create a
28646 plot on any text-only printer.
28649 @pindex calc-graph-output
28650 The @kbd{g O} (@code{calc-graph-output}) command sets the name of
28651 the output file used by GNUPLOT. For some devices, notably @code{x11},
28652 there is no output file and this information is not used. Many other
28653 ``devices'' are really file formats like @code{postscript}; in these
28654 cases the output in the desired format goes into the file you name
28655 with @kbd{g O}. Type @kbd{g O stdout @key{RET}} to set GNUPLOT to write
28656 to its standard output stream, i.e., to @samp{*Gnuplot Trail*}.
28657 This is the default setting.
28659 Another special output name is @code{tty}, which means that GNUPLOT
28660 is going to write graphics commands directly to its standard output,
28661 which you wish Emacs to pass through to your terminal. Tektronix
28662 graphics terminals, among other devices, operate this way. Calc does
28663 this by telling GNUPLOT to write to a temporary file, then running a
28664 sub-shell executing the command @samp{cat tempfile >/dev/tty}. On
28665 typical Unix systems, this will copy the temporary file directly to
28666 the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l}
28667 to Emacs afterwards to refresh the screen.
28669 Once again, @kbd{g O} with a positive or negative prefix argument
28670 sets the default or printer output file names, respectively. In each
28671 case you can specify @code{auto}, which causes Calc to invent a temporary
28672 file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file
28673 will be deleted once it has been displayed or printed. If the output file
28674 name is not @code{auto}, the file is not automatically deleted.
28676 The default and printer devices and output files can be saved
28677 permanently by the @kbd{m m} (@code{calc-save-modes}) command. The
28678 default number of data points (see @kbd{g N}) and the X geometry
28679 (see @kbd{g X}) are also saved. Other graph information is @emph{not}
28680 saved; you can save a graph's configuration simply by saving the contents
28681 of the @samp{*Gnuplot Commands*} buffer.
28683 @vindex calc-gnuplot-plot-command
28684 @vindex calc-gnuplot-default-device
28685 @vindex calc-gnuplot-default-output
28686 @vindex calc-gnuplot-print-command
28687 @vindex calc-gnuplot-print-device
28688 @vindex calc-gnuplot-print-output
28689 If you are installing Calc you may wish to configure the default and
28690 printer devices and output files for the whole system. The relevant
28691 Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
28692 and @code{calc-gnuplot-print-device} and @code{-output}. The output
28693 file names must be either strings as described above, or Lisp
28694 expressions which are evaluated on the fly to get the output file names.
28696 Other important Lisp variables are @code{calc-gnuplot-plot-command} and
28697 @code{calc-gnuplot-print-command}, which give the system commands to
28698 display or print the output of GNUPLOT, respectively. These may be
28699 @code{nil} if no command is necessary, or strings which can include
28700 @samp{%s} to signify the name of the file to be displayed or printed.
28701 Or, these variables may contain Lisp expressions which are evaluated
28702 to display or print the output.
28705 @pindex calc-graph-display
28706 The @kbd{g x} (@code{calc-graph-display}) command lets you specify
28707 on which X window system display your graphs should be drawn. Enter
28708 a blank line to see the current display name. This command has no
28709 effect unless the current device is @code{x11}.
28712 @pindex calc-graph-geometry
28713 The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
28714 command for specifying the position and size of the X window.
28715 The normal value is @code{default}, which generally means your
28716 window manager will let you place the window interactively.
28717 Entering @samp{800x500+0+0} would create an 800-by-500 pixel
28718 window in the upper-left corner of the screen.
28720 The buffer called @samp{*Gnuplot Trail*} holds a transcript of the
28721 session with GNUPLOT. This shows the commands Calc has ``typed'' to
28722 GNUPLOT and the responses it has received. Calc tries to notice when an
28723 error message has appeared here and display the buffer for you when
28724 this happens. You can check this buffer yourself if you suspect
28725 something has gone wrong.
28728 @pindex calc-graph-command
28729 The @kbd{g C} (@code{calc-graph-command}) command prompts you to
28730 enter any line of text, then simply sends that line to the current
28731 GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively
28732 like a Shell buffer but you can't type commands in it yourself.
28733 Instead, you must use @kbd{g C} for this purpose.
28737 @pindex calc-graph-view-commands
28738 @pindex calc-graph-view-trail
28739 The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
28740 (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*}
28741 and @samp{*Gnuplot Trail*} buffers, respectively, in another window.
28742 This happens automatically when Calc thinks there is something you
28743 will want to see in either of these buffers. If you type @kbd{g v}
28744 or @kbd{g V} when the relevant buffer is already displayed, the
28745 buffer is hidden again.
28747 One reason to use @kbd{g v} is to add your own commands to the
28748 @samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use
28749 @kbd{C-x o} to switch into that window. For example, GNUPLOT has
28750 @samp{set label} and @samp{set arrow} commands that allow you to
28751 annotate your plots. Since Calc doesn't understand these commands,
28752 you have to add them to the @samp{*Gnuplot Commands*} buffer
28753 yourself, then use @w{@kbd{g p}} to replot using these new commands. Note
28754 that your commands must appear @emph{before} the @code{plot} command.
28755 To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
28756 You may have to type @kbd{g C @key{RET}} a few times to clear the
28757 ``press return for more'' or ``subtopic of @dots{}'' requests.
28758 Note that Calc always sends commands (like @samp{set nolabel}) to
28759 reset all plotting parameters to the defaults before each plot, so
28760 to delete a label all you need to do is delete the @samp{set label}
28761 line you added (or comment it out with @samp{#}) and then replot
28765 @pindex calc-graph-quit
28766 You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
28767 process that is running. The next graphing command you give will
28768 start a fresh GNUPLOT process. The word @samp{Graph} appears in
28769 the Calc window's mode line whenever a GNUPLOT process is currently
28770 running. The GNUPLOT process is automatically killed when you
28771 exit Emacs if you haven't killed it manually by then.
28774 @pindex calc-graph-kill
28775 The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
28776 except that it also views the @samp{*Gnuplot Trail*} buffer so that
28777 you can see the process being killed. This is better if you are
28778 killing GNUPLOT because you think it has gotten stuck.
28780 @node Kill and Yank, Keypad Mode, Graphics, Top
28781 @chapter Kill and Yank Functions
28784 The commands in this chapter move information between the Calculator and
28785 other Emacs editing buffers.
28787 In many cases Embedded Mode is an easier and more natural way to
28788 work with Calc from a regular editing buffer. @xref{Embedded Mode}.
28791 * Killing From Stack::
28792 * Yanking Into Stack::
28793 * Grabbing From Buffers::
28794 * Yanking Into Buffers::
28795 * X Cut and Paste::
28798 @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
28799 @section Killing from the Stack
28805 @pindex calc-copy-as-kill
28807 @pindex calc-kill-region
28809 @pindex calc-copy-region-as-kill
28811 @dfn{Kill} commands are Emacs commands that insert text into the
28812 ``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y}
28813 command. Three common kill commands in normal Emacs are @kbd{C-k}, which
28814 kills one line, @kbd{C-w}, which kills the region between mark and point,
28815 and @kbd{M-w}, which puts the region into the kill ring without actually
28816 deleting it. All of these commands work in the Calculator, too. Also,
28817 @kbd{M-k} has been provided to complete the set; it puts the current line
28818 into the kill ring without deleting anything.
28820 The kill commands are unusual in that they pay attention to the location
28821 of the cursor in the Calculator buffer. If the cursor is on or below the
28822 bottom line, the kill commands operate on the top of the stack. Otherwise,
28823 they operate on whatever stack element the cursor is on. Calc's kill
28824 commands always operate on whole stack entries. (They act the same as their
28825 standard Emacs cousins except they ``round up'' the specified region to
28826 encompass full lines.) The text is copied into the kill ring exactly as
28827 it appears on the screen, including line numbers if they are enabled.
28829 A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
28830 of lines killed. A positive argument kills the current line and @cite{n-1}
28831 lines below it. A negative argument kills the @cite{-n} lines above the
28832 current line. Again this mirrors the behavior of the standard Emacs
28833 @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k}
28834 with no argument copies only the number itself into the kill ring, whereas
28835 @kbd{C-k} with a prefix argument of 1 copies the number with its trailing
28838 @node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank
28839 @section Yanking into the Stack
28844 The @kbd{C-y} command yanks the most recently killed text back into the
28845 Calculator. It pushes this value onto the top of the stack regardless of
28846 the cursor position. In general it re-parses the killed text as a number
28847 or formula (or a list of these separated by commas or newlines). However if
28848 the thing being yanked is something that was just killed from the Calculator
28849 itself, its full internal structure is yanked. For example, if you have
28850 set the floating-point display mode to show only four significant digits,
28851 then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
28852 full 3.14159, even though yanking it into any other buffer would yank the
28853 number in its displayed form, 3.142. (Since the default display modes
28854 show all objects to their full precision, this feature normally makes no
28857 @node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank
28858 @section Grabbing from Other Buffers
28862 @pindex calc-grab-region
28863 The @kbd{M-# g} (@code{calc-grab-region}) command takes the text between
28864 point and mark in the current buffer and attempts to parse it as a
28865 vector of values. Basically, it wraps the text in vector brackets
28866 @samp{[ ]} unless the text already is enclosed in vector brackets,
28867 then reads the text as if it were an algebraic entry. The contents
28868 of the vector may be numbers, formulas, or any other Calc objects.
28869 If the @kbd{M-# g} command works successfully, it does an automatic
28870 @kbd{M-# c} to enter the Calculator buffer.
28872 A numeric prefix argument grabs the specified number of lines around
28873 point, ignoring the mark. A positive prefix grabs from point to the
28874 @cite{n}th following newline (so that @kbd{M-1 M-# g} grabs from point
28875 to the end of the current line); a negative prefix grabs from point
28876 back to the @cite{n+1}st preceding newline. In these cases the text
28877 that is grabbed is exactly the same as the text that @kbd{C-k} would
28878 delete given that prefix argument.
28880 A prefix of zero grabs the current line; point may be anywhere on the
28883 A plain @kbd{C-u} prefix interprets the region between point and mark
28884 as a single number or formula rather than a vector. For example,
28885 @kbd{M-# g} on the text @samp{2 a b} produces the vector of three
28886 values @samp{[2, a, b]}, but @kbd{C-u M-# g} on the same region
28887 reads a formula which is a product of three things: @samp{2 a b}.
28888 (The text @samp{a + b}, on the other hand, will be grabbed as a
28889 vector of one element by plain @kbd{M-# g} because the interpretation
28890 @samp{[a, +, b]} would be a syntax error.)
28892 If a different language has been specified (@pxref{Language Modes}),
28893 the grabbed text will be interpreted according to that language.
28896 @pindex calc-grab-rectangle
28897 The @kbd{M-# r} (@code{calc-grab-rectangle}) command takes the text between
28898 point and mark and attempts to parse it as a matrix. If point and mark
28899 are both in the leftmost column, the lines in between are parsed in their
28900 entirety. Otherwise, point and mark define the corners of a rectangle
28901 whose contents are parsed.
28903 Each line of the grabbed area becomes a row of the matrix. The result
28904 will actually be a vector of vectors, which Calc will treat as a matrix
28905 only if every row contains the same number of values.
28907 If a line contains a portion surrounded by square brackets (or curly
28908 braces), that portion is interpreted as a vector which becomes a row
28909 of the matrix. Any text surrounding the bracketed portion on the line
28912 Otherwise, the entire line is interpreted as a row vector as if it
28913 were surrounded by square brackets. Leading line numbers (in the
28914 format used in the Calc stack buffer) are ignored. If you wish to
28915 force this interpretation (even if the line contains bracketed
28916 portions), give a negative numeric prefix argument to the
28917 @kbd{M-# r} command.
28919 If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
28920 line is instead interpreted as a single formula which is converted into
28921 a one-element vector. Thus the result of @kbd{C-u M-# r} will be a
28922 one-column matrix. For example, suppose one line of the data is the
28923 expression @samp{2 a}. A plain @w{@kbd{M-# r}} will interpret this as
28924 @samp{[2 a]}, which in turn is read as a two-element vector that forms
28925 one row of the matrix. But a @kbd{C-u M-# r} will interpret this row
28928 If you give a positive numeric prefix argument @var{n}, then each line
28929 will be split up into columns of width @var{n}; each column is parsed
28930 separately as a matrix element. If a line contained
28931 @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
28932 would correctly split the line into two error forms.@refill
28934 @xref{Matrix Functions}, to see how to pull the matrix apart into its
28935 constituent rows and columns. (If it is a @c{$1\times1$}
28936 @asis{1x1} matrix, just hit @kbd{v u}
28937 (@code{calc-unpack}) twice.)
28941 @pindex calc-grab-sum-across
28942 @pindex calc-grab-sum-down
28943 @cindex Summing rows and columns of data
28944 The @kbd{M-# :} (@code{calc-grab-sum-down}) command is a handy way to
28945 grab a rectangle of data and sum its columns. It is equivalent to
28946 typing @kbd{M-# r}, followed by @kbd{V R : +} (the vector reduction
28947 command that sums the columns of a matrix; @pxref{Reducing}). The
28948 result of the command will be a vector of numbers, one for each column
28949 in the input data. The @kbd{M-# _} (@code{calc-grab-sum-across}) command
28950 similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
28952 As well as being more convenient, @kbd{M-# :} and @kbd{M-# _} are also
28953 much faster because they don't actually place the grabbed vector on
28954 the stack. In a @kbd{M-# r V R : +} sequence, formatting the vector
28955 for display on the stack takes a large fraction of the total time
28956 (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
28958 For example, suppose we have a column of numbers in a file which we
28959 wish to sum. Go to one corner of the column and press @kbd{C-@@} to
28960 set the mark; go to the other corner and type @kbd{M-# :}. Since there
28961 is only one column, the result will be a vector of one number, the sum.
28962 (You can type @kbd{v u} to unpack this vector into a plain number if
28963 you want to do further arithmetic with it.)
28965 To compute the product of the column of numbers, we would have to do
28966 it ``by hand'' since there's no special grab-and-multiply command.
28967 Use @kbd{M-# r} to grab the column of numbers into the calculator in
28968 the form of a column matrix. The statistics command @kbd{u *} is a
28969 handy way to find the product of a vector or matrix of numbers.
28970 @xref{Statistical Operations}. Another approach would be to use
28971 an explicit column reduction command, @kbd{V R : *}.
28973 @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
28974 @section Yanking into Other Buffers
28978 @pindex calc-copy-to-buffer
28979 The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
28980 at the top of the stack into the most recently used normal editing buffer.
28981 (More specifically, this is the most recently used buffer which is displayed
28982 in a window and whose name does not begin with @samp{*}. If there is no
28983 such buffer, this is the most recently used buffer except for Calculator
28984 and Calc Trail buffers.) The number is inserted exactly as it appears and
28985 without a newline. (If line-numbering is enabled, the line number is
28986 normally not included.) The number is @emph{not} removed from the stack.
28988 With a prefix argument, @kbd{y} inserts several numbers, one per line.
28989 A positive argument inserts the specified number of values from the top
28990 of the stack. A negative argument inserts the @cite{n}th value from the
28991 top of the stack. An argument of zero inserts the entire stack. Note
28992 that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
28993 with no argument; the former always copies full lines, whereas the
28994 latter strips off the trailing newline.
28996 With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
28997 region in the other buffer with the yanked text, then quits the
28998 Calculator, leaving you in that buffer. A typical use would be to use
28999 @kbd{M-# g} to read a region of data into the Calculator, operate on the
29000 data to produce a new matrix, then type @kbd{C-u y} to replace the
29001 original data with the new data. One might wish to alter the matrix
29002 display style (@pxref{Vector and Matrix Formats}) or change the current
29003 display language (@pxref{Language Modes}) before doing this. Also, note
29004 that this command replaces a linear region of text (as grabbed by
29005 @kbd{M-# g}), not a rectangle (as grabbed by @kbd{M-# r}).@refill
29007 If the editing buffer is in overwrite (as opposed to insert) mode,
29008 and the @kbd{C-u} prefix was not used, then the yanked number will
29009 overwrite the characters following point rather than being inserted
29010 before those characters. The usual conventions of overwrite mode
29011 are observed; for example, characters will be inserted at the end of
29012 a line rather than overflowing onto the next line. Yanking a multi-line
29013 object such as a matrix in overwrite mode overwrites the next @var{n}
29014 lines in the buffer, lengthening or shortening each line as necessary.
29015 Finally, if the thing being yanked is a simple integer or floating-point
29016 number (like @samp{-1.2345e-3}) and the characters following point also
29017 make up such a number, then Calc will replace that number with the new
29018 number, lengthening or shortening as necessary. The concept of
29019 ``overwrite mode'' has thus been generalized from overwriting characters
29020 to overwriting one complete number with another.
29023 The @kbd{M-# y} key sequence is equivalent to @kbd{y} except that
29024 it can be typed anywhere, not just in Calc. This provides an easy
29025 way to guarantee that Calc knows which editing buffer you want to use!
29027 @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
29028 @section X Cut and Paste
29031 If you are using Emacs with the X window system, there is an easier
29032 way to move small amounts of data into and out of the calculator:
29033 Use the mouse-oriented cut and paste facilities of X.
29035 The default bindings for a three-button mouse cause the left button
29036 to move the Emacs cursor to the given place, the right button to
29037 select the text between the cursor and the clicked location, and
29038 the middle button to yank the selection into the buffer at the
29039 clicked location. So, if you have a Calc window and an editing
29040 window on your Emacs screen, you can use left-click/right-click
29041 to select a number, vector, or formula from one window, then
29042 middle-click to paste that value into the other window. When you
29043 paste text into the Calc window, Calc interprets it as an algebraic
29044 entry. It doesn't matter where you click in the Calc window; the
29045 new value is always pushed onto the top of the stack.
29047 The @code{xterm} program that is typically used for general-purpose
29048 shell windows in X interprets the mouse buttons in the same way.
29049 So you can use the mouse to move data between Calc and any other
29050 Unix program. One nice feature of @code{xterm} is that a double
29051 left-click selects one word, and a triple left-click selects a
29052 whole line. So you can usually transfer a single number into Calc
29053 just by double-clicking on it in the shell, then middle-clicking
29054 in the Calc window.
29056 @node Keypad Mode, Embedded Mode, Kill and Yank, Introduction
29057 @chapter ``Keypad'' Mode
29061 @pindex calc-keypad
29062 The @kbd{M-# k} (@code{calc-keypad}) command starts the Calculator
29063 and displays a picture of a calculator-style keypad. If you are using
29064 the X window system, you can click on any of the ``keys'' in the
29065 keypad using the left mouse button to operate the calculator.
29066 The original window remains the selected window; in keypad mode
29067 you can type in your file while simultaneously performing
29068 calculations with the mouse.
29070 @pindex full-calc-keypad
29071 If you have used @kbd{M-# b} first, @kbd{M-# k} instead invokes
29072 the @code{full-calc-keypad} command, which takes over the whole
29073 Emacs screen and displays the keypad, the Calc stack, and the Calc
29074 trail all at once. This mode would normally be used when running
29075 Calc standalone (@pxref{Standalone Operation}).
29077 If you aren't using the X window system, you must switch into
29078 the @samp{*Calc Keypad*} window, place the cursor on the desired
29079 ``key,'' and type @key{SPC} or @key{RET}. If you think this
29080 is easier than using Calc normally, go right ahead.
29082 Calc commands are more or less the same in keypad mode. Certain
29083 keypad keys differ slightly from the corresponding normal Calc
29084 keystrokes; all such deviations are described below.
29086 Keypad Mode includes many more commands than will fit on the keypad
29087 at once. Click the right mouse button [@code{calc-keypad-menu}]
29088 to switch to the next menu. The bottom five rows of the keypad
29089 stay the same; the top three rows change to a new set of commands.
29090 To return to earlier menus, click the middle mouse button
29091 [@code{calc-keypad-menu-back}] or simply advance through the menus
29092 until you wrap around. Typing @key{TAB} inside the keypad window
29093 is equivalent to clicking the right mouse button there.
29095 You can always click the @key{EXEC} button and type any normal
29096 Calc key sequence. This is equivalent to switching into the
29097 Calc buffer, typing the keys, then switching back to your
29101 * Keypad Main Menu::
29102 * Keypad Functions Menu::
29103 * Keypad Binary Menu::
29104 * Keypad Vectors Menu::
29105 * Keypad Modes Menu::
29108 @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
29113 |----+-----Calc 2.00-----+----1
29114 |FLR |CEIL|RND |TRNC|CLN2|FLT |
29115 |----+----+----+----+----+----|
29116 | LN |EXP | |ABS |IDIV|MOD |
29117 |----+----+----+----+----+----|
29118 |SIN |COS |TAN |SQRT|y^x |1/x |
29119 |----+----+----+----+----+----|
29120 | ENTER |+/- |EEX |UNDO| <- |
29121 |-----+---+-+--+--+-+---++----|
29122 | INV | 7 | 8 | 9 | / |
29123 |-----+-----+-----+-----+-----|
29124 | HYP | 4 | 5 | 6 | * |
29125 |-----+-----+-----+-----+-----|
29126 |EXEC | 1 | 2 | 3 | - |
29127 |-----+-----+-----+-----+-----|
29128 | OFF | 0 | . | PI | + |
29129 |-----+-----+-----+-----+-----+
29134 This is the menu that appears the first time you start Keypad Mode.
29135 It will show up in a vertical window on the right side of your screen.
29136 Above this menu is the traditional Calc stack display. On a 24-line
29137 screen you will be able to see the top three stack entries.
29139 The ten digit keys, decimal point, and @key{EEX} key are used for
29140 entering numbers in the obvious way. @key{EEX} begins entry of an
29141 exponent in scientific notation. Just as with regular Calc, the
29142 number is pushed onto the stack as soon as you press @key{ENTER}
29143 or any other function key.
29145 The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During
29146 numeric entry it changes the sign of the number or of the exponent.
29147 At other times it changes the sign of the number on the top of the
29150 The @key{INV} and @key{HYP} keys modify other keys. As well as
29151 having the effects described elsewhere in this manual, Keypad Mode
29152 defines several other ``inverse'' operations. These are described
29153 below and in the following sections.
29155 The @key{ENTER} key finishes the current numeric entry, or otherwise
29156 duplicates the top entry on the stack.
29158 The @key{UNDO} key undoes the most recent Calc operation.
29159 @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
29160 ``last arguments'' (@kbd{M-@key{RET}}).
29162 The @key{<-} key acts as a ``backspace'' during numeric entry.
29163 At other times it removes the top stack entry. @kbd{INV <-}
29164 clears the entire stack. @kbd{HYP <-} takes an integer from
29165 the stack, then removes that many additional stack elements.
29167 The @key{EXEC} key prompts you to enter any keystroke sequence
29168 that would normally work in Calc mode. This can include a
29169 numeric prefix if you wish. It is also possible simply to
29170 switch into the Calc window and type commands in it; there is
29171 nothing ``magic'' about this window when Keypad Mode is active.
29173 The other keys in this display perform their obvious calculator
29174 functions. @key{CLN2} rounds the top-of-stack by temporarily
29175 reducing the precision by 2 digits. @key{FLT} converts an
29176 integer or fraction on the top of the stack to floating-point.
29178 The @key{INV} and @key{HYP} keys combined with several of these keys
29179 give you access to some common functions even if the appropriate menu
29180 is not displayed. Obviously you don't need to learn these keys
29181 unless you find yourself wasting time switching among the menus.
29185 is the same as @key{1/x}.
29187 is the same as @key{SQRT}.
29189 is the same as @key{CONJ}.
29191 is the same as @key{y^x}.
29193 is the same as @key{INV y^x} (the @cite{x}th root of @cite{y}).
29195 are the same as @key{SIN} / @kbd{INV SIN}.
29197 are the same as @key{COS} / @kbd{INV COS}.
29199 are the same as @key{TAN} / @kbd{INV TAN}.
29201 are the same as @key{LN} / @kbd{HYP LN}.
29203 are the same as @key{EXP} / @kbd{HYP EXP}.
29205 is the same as @key{ABS}.
29207 is the same as @key{RND} (@code{calc-round}).
29209 is the same as @key{CLN2}.
29211 is the same as @key{FLT} (@code{calc-float}).
29213 is the same as @key{IMAG}.
29215 is the same as @key{PREC}.
29217 is the same as @key{SWAP}.
29219 is the same as @key{RLL3}.
29220 @item INV HYP ENTER
29221 is the same as @key{OVER}.
29223 packs the top two stack entries as an error form.
29225 packs the top two stack entries as a modulo form.
29227 creates an interval form; this removes an integer which is one
29228 of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
29229 by the two limits of the interval.
29232 The @kbd{OFF} key turns Calc off; typing @kbd{M-# k} or @kbd{M-# M-#}
29233 again has the same effect. This is analogous to typing @kbd{q} or
29234 hitting @kbd{M-# c} again in the normal calculator. If Calc is
29235 running standalone (the @code{full-calc-keypad} command appeared in the
29236 command line that started Emacs), then @kbd{OFF} is replaced with
29237 @kbd{EXIT}; clicking on this actually exits Emacs itself.
29239 @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
29240 @section Functions Menu
29244 |----+----+----+----+----+----2
29245 |IGAM|BETA|IBET|ERF |BESJ|BESY|
29246 |----+----+----+----+----+----|
29247 |IMAG|CONJ| RE |ATN2|RAND|RAGN|
29248 |----+----+----+----+----+----|
29249 |GCD |FACT|DFCT|BNOM|PERM|NXTP|
29250 |----+----+----+----+----+----|
29255 This menu provides various operations from the @kbd{f} and @kbd{k}
29258 @key{IMAG} multiplies the number on the stack by the imaginary
29259 number @cite{i = (0, 1)}.
29261 @key{RE} extracts the real part a complex number. @kbd{INV RE}
29262 extracts the imaginary part.
29264 @key{RAND} takes a number from the top of the stack and computes
29265 a random number greater than or equal to zero but less than that
29266 number. (@xref{Random Numbers}.) @key{RAGN} is the ``random
29267 again'' command; it computes another random number using the
29268 same limit as last time.
29270 @key{INV GCD} computes the LCM (least common multiple) function.
29272 @key{INV FACT} is the gamma function. @c{$\Gamma(x) = (x-1)!$}
29273 @cite{gamma(x) = (x-1)!}.
29275 @key{PERM} is the number-of-permutations function, which is on the
29276 @kbd{H k c} key in normal Calc.
29278 @key{NXTP} finds the next prime after a number. @kbd{INV NXTP}
29279 finds the previous prime.
29281 @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
29282 @section Binary Menu
29286 |----+----+----+----+----+----3
29287 |AND | OR |XOR |NOT |LSH |RSH |
29288 |----+----+----+----+----+----|
29289 |DEC |HEX |OCT |BIN |WSIZ|ARSH|
29290 |----+----+----+----+----+----|
29291 | A | B | C | D | E | F |
29292 |----+----+----+----+----+----|
29297 The keys in this menu perform operations on binary integers.
29298 Note that both logical and arithmetic right-shifts are provided.
29299 @key{INV LSH} rotates one bit to the left.
29301 The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
29302 The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
29304 The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
29305 current radix for display and entry of numbers: Decimal, hexadecimal,
29306 octal, or binary. The six letter keys @key{A} through @key{F} are used
29307 for entering hexadecimal numbers.
29309 The @key{WSIZ} key displays the current word size for binary operations
29310 and allows you to enter a new word size. You can respond to the prompt
29311 using either the keyboard or the digits and @key{ENTER} from the keypad.
29312 The initial word size is 32 bits.
29314 @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
29315 @section Vectors Menu
29319 |----+----+----+----+----+----4
29320 |SUM |PROD|MAX |MAP*|MAP^|MAP$|
29321 |----+----+----+----+----+----|
29322 |MINV|MDET|MTRN|IDNT|CRSS|"x" |
29323 |----+----+----+----+----+----|
29324 |PACK|UNPK|INDX|BLD |LEN |... |
29325 |----+----+----+----+----+----|
29330 The keys in this menu operate on vectors and matrices.
29332 @key{PACK} removes an integer @var{n} from the top of the stack;
29333 the next @var{n} stack elements are removed and packed into a vector,
29334 which is replaced onto the stack. Thus the sequence
29335 @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
29336 @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row
29337 on the stack as a vector, then use a final @key{PACK} to collect the
29338 rows into a matrix.
29340 @key{UNPK} unpacks the vector on the stack, pushing each of its
29341 components separately.
29343 @key{INDX} removes an integer @var{n}, then builds a vector of
29344 integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers
29345 from the stack: The vector size @var{n}, the starting number,
29346 and the increment. @kbd{BLD} takes an integer @var{n} and any
29347 value @var{x} and builds a vector of @var{n} copies of @var{x}.
29349 @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
29352 @key{LEN} replaces a vector by its length, an integer.
29354 @key{...} turns on or off ``abbreviated'' display mode for large vectors.
29356 @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
29357 inverse, determinant, and transpose, and vector cross product.
29359 @key{SUM} replaces a vector by the sum of its elements. It is
29360 equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
29361 @key{PROD} computes the product of the elements of a vector, and
29362 @key{MAX} computes the maximum of all the elements of a vector.
29364 @key{INV SUM} computes the alternating sum of the first element
29365 minus the second, plus the third, minus the fourth, and so on.
29366 @key{INV MAX} computes the minimum of the vector elements.
29368 @key{HYP SUM} computes the mean of the vector elements.
29369 @key{HYP PROD} computes the sample standard deviation.
29370 @key{HYP MAX} computes the median.
29372 @key{MAP*} multiplies two vectors elementwise. It is equivalent
29373 to the @kbd{V M *} command. @key{MAP^} computes powers elementwise.
29374 The arguments must be vectors of equal length, or one must be a vector
29375 and the other must be a plain number. For example, @kbd{2 MAP^} squares
29376 all the elements of a vector.
29378 @key{MAP$} maps the formula on the top of the stack across the
29379 vector in the second-to-top position. If the formula contains
29380 several variables, Calc takes that many vectors starting at the
29381 second-to-top position and matches them to the variables in
29382 alphabetical order. The result is a vector of the same size as
29383 the input vectors, whose elements are the formula evaluated with
29384 the variables set to the various sets of numbers in those vectors.
29385 For example, you could simulate @key{MAP^} using @key{MAP$} with
29386 the formula @samp{x^y}.
29388 The @kbd{"x"} key pushes the variable name @cite{x} onto the
29389 stack. To build the formula @cite{x^2 + 6}, you would use the
29390 key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be
29391 suitable for use with the @key{MAP$} key described above.
29392 With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
29393 @kbd{"x"} key pushes the variable names @cite{y}, @cite{z}, and
29394 @cite{t}, respectively.
29396 @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
29397 @section Modes Menu
29401 |----+----+----+----+----+----5
29402 |FLT |FIX |SCI |ENG |GRP | |
29403 |----+----+----+----+----+----|
29404 |RAD |DEG |FRAC|POLR|SYMB|PREC|
29405 |----+----+----+----+----+----|
29406 |SWAP|RLL3|RLL4|OVER|STO |RCL |
29407 |----+----+----+----+----+----|
29412 The keys in this menu manipulate modes, variables, and the stack.
29414 The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
29415 floating-point, fixed-point, scientific, or engineering notation.
29416 @key{FIX} displays two digits after the decimal by default; the
29417 others display full precision. With the @key{INV} prefix, these
29418 keys pop a number-of-digits argument from the stack.
29420 The @key{GRP} key turns grouping of digits with commas on or off.
29421 @kbd{INV GRP} enables grouping to the right of the decimal point as
29422 well as to the left.
29424 The @key{RAD} and @key{DEG} keys switch between radians and degrees
29425 for trigonometric functions.
29427 The @key{FRAC} key turns Fraction mode on or off. This affects
29428 whether commands like @kbd{/} with integer arguments produce
29429 fractional or floating-point results.
29431 The @key{POLR} key turns Polar mode on or off, determining whether
29432 polar or rectangular complex numbers are used by default.
29434 The @key{SYMB} key turns Symbolic mode on or off, in which
29435 operations that would produce inexact floating-point results
29436 are left unevaluated as algebraic formulas.
29438 The @key{PREC} key selects the current precision. Answer with
29439 the keyboard or with the keypad digit and @key{ENTER} keys.
29441 The @key{SWAP} key exchanges the top two stack elements.
29442 The @key{RLL3} key rotates the top three stack elements upwards.
29443 The @key{RLL4} key rotates the top four stack elements upwards.
29444 The @key{OVER} key duplicates the second-to-top stack element.
29446 The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
29447 @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the
29448 @key{STO} or @key{RCL} key, then one of the ten digits. (Named
29449 variables are not available in Keypad Mode.) You can also use,
29450 for example, @kbd{STO + 3} to add to register 3.
29452 @node Embedded Mode, Programming, Keypad Mode, Top
29453 @chapter Embedded Mode
29456 Embedded Mode in Calc provides an alternative to copying numbers
29457 and formulas back and forth between editing buffers and the Calc
29458 stack. In Embedded Mode, your editing buffer becomes temporarily
29459 linked to the stack and this copying is taken care of automatically.
29462 * Basic Embedded Mode::
29463 * More About Embedded Mode::
29464 * Assignments in Embedded Mode::
29465 * Mode Settings in Embedded Mode::
29466 * Customizing Embedded Mode::
29469 @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
29470 @section Basic Embedded Mode
29474 @pindex calc-embedded
29475 To enter Embedded mode, position the Emacs point (cursor) on a
29476 formula in any buffer and press @kbd{M-# e} (@code{calc-embedded}).
29477 Note that @kbd{M-# e} is not to be used in the Calc stack buffer
29478 like most Calc commands, but rather in regular editing buffers that
29479 are visiting your own files.
29481 Calc normally scans backward and forward in the buffer for the
29482 nearest opening and closing @dfn{formula delimiters}. The simplest
29483 delimiters are blank lines. Other delimiters that Embedded Mode
29488 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
29489 @samp{\[ \]}, and @samp{\( \)};
29491 Lines beginning with @samp{\begin} and @samp{\end};
29493 Lines beginning with @samp{@@} (Texinfo delimiters).
29495 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
29497 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
29500 @xref{Customizing Embedded Mode}, to see how to make Calc recognize
29501 your own favorite delimiters. Delimiters like @samp{$ $} can appear
29502 on their own separate lines or in-line with the formula.
29504 If you give a positive or negative numeric prefix argument, Calc
29505 instead uses the current point as one end of the formula, and moves
29506 forward or backward (respectively) by that many lines to find the
29507 other end. Explicit delimiters are not necessary in this case.
29509 With a prefix argument of zero, Calc uses the current region
29510 (delimited by point and mark) instead of formula delimiters.
29513 @pindex calc-embedded-word
29514 With a prefix argument of @kbd{C-u} only, Calc scans for the first
29515 non-numeric character (i.e., the first character that is not a
29516 digit, sign, decimal point, or upper- or lower-case @samp{e})
29517 forward and backward to delimit the formula. @kbd{M-# w}
29518 (@code{calc-embedded-word}) is equivalent to @kbd{C-u M-# e}.
29520 When you enable Embedded mode for a formula, Calc reads the text
29521 between the delimiters and tries to interpret it as a Calc formula.
29522 It's best if the current Calc language mode is correct for the
29523 formula, but Calc can generally identify @TeX{} formulas and
29524 Big-style formulas even if the language mode is wrong. If Calc
29525 can't make sense of the formula, it beeps and refuses to enter
29526 Embedded mode. But if the current language is wrong, Calc can
29527 sometimes parse the formula successfully (but incorrectly);
29528 for example, the C expression @samp{atan(a[1])} can be parsed
29529 in Normal language mode, but the @code{atan} won't correspond to
29530 the built-in @code{arctan} function, and the @samp{a[1]} will be
29531 interpreted as @samp{a} times the vector @samp{[1]}!
29533 If you press @kbd{M-# e} or @kbd{M-# w} to activate an embedded
29534 formula which is blank, say with the cursor on the space between
29535 the two delimiters @samp{$ $}, Calc will immediately prompt for
29536 an algebraic entry.
29538 Only one formula in one buffer can be enabled at a time. If you
29539 move to another area of the current buffer and give Calc commands,
29540 Calc turns Embedded mode off for the old formula and then tries
29541 to restart Embedded mode at the new position. Other buffers are
29542 not affected by Embedded mode.
29544 When Embedded mode begins, Calc pushes the current formula onto
29545 the stack. No Calc stack window is created; however, Calc copies
29546 the top-of-stack position into the original buffer at all times.
29547 You can create a Calc window by hand with @kbd{M-# o} if you
29548 find you need to see the entire stack.
29550 For example, typing @kbd{M-# e} while somewhere in the formula
29551 @samp{n>2} in the following line enables Embedded mode on that
29555 We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
29559 The formula @cite{n>2} will be pushed onto the Calc stack, and
29560 the top of stack will be copied back into the editing buffer.
29561 This means that spaces will appear around the @samp{>} symbol
29562 to match Calc's usual display style:
29565 We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
29569 No spaces have appeared around the @samp{+} sign because it's
29570 in a different formula, one which we have not yet touched with
29573 Now that Embedded mode is enabled, keys you type in this buffer
29574 are interpreted as Calc commands. At this point we might use
29575 the ``commute'' command @kbd{j C} to reverse the inequality.
29576 This is a selection-based command for which we first need to
29577 move the cursor onto the operator (@samp{>} in this case) that
29578 needs to be commuted.
29581 We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
29584 The @kbd{M-# o} command is a useful way to open a Calc window
29585 without actually selecting that window. Giving this command
29586 verifies that @samp{2 < n} is also on the Calc stack. Typing
29587 @kbd{17 @key{RET}} would produce:
29590 We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
29594 with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
29595 at this point will exchange the two stack values and restore
29596 @samp{2 < n} to the embedded formula. Even though you can't
29597 normally see the stack in Embedded mode, it is still there and
29598 it still operates in the same way. But, as with old-fashioned
29599 RPN calculators, you can only see the value at the top of the
29600 stack at any given time (unless you use @kbd{M-# o}).
29602 Typing @kbd{M-# e} again turns Embedded mode off. The Calc
29603 window reveals that the formula @w{@samp{2 < n}} is automatically
29604 removed from the stack, but the @samp{17} is not. Entering
29605 Embedded mode always pushes one thing onto the stack, and
29606 leaving Embedded mode always removes one thing. Anything else
29607 that happens on the stack is entirely your business as far as
29608 Embedded mode is concerned.
29610 If you press @kbd{M-# e} in the wrong place by accident, it is
29611 possible that Calc will be able to parse the nearby text as a
29612 formula and will mangle that text in an attempt to redisplay it
29613 ``properly'' in the current language mode. If this happens,
29614 press @kbd{M-# e} again to exit Embedded mode, then give the
29615 regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
29616 the text back the way it was before Calc edited it. Note that Calc's
29617 own Undo command (typed before you turn Embedded mode back off)
29618 will not do you any good, because as far as Calc is concerned
29619 you haven't done anything with this formula yet.
29621 @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
29622 @section More About Embedded Mode
29625 When Embedded mode ``activates'' a formula, i.e., when it examines
29626 the formula for the first time since the buffer was created or
29627 loaded, Calc tries to sense the language in which the formula was
29628 written. If the formula contains any @TeX{}-like @samp{\} sequences,
29629 it is parsed (i.e., read) in @TeX{} mode. If the formula appears to
29630 be written in multi-line Big mode, it is parsed in Big mode. Otherwise,
29631 it is parsed according to the current language mode.
29633 Note that Calc does not change the current language mode according
29634 to what it finds. Even though it can read a @TeX{} formula when
29635 not in @TeX{} mode, it will immediately rewrite this formula using
29636 whatever language mode is in effect. You must then type @kbd{d T}
29637 to switch Calc permanently into @TeX{} mode if that is what you
29645 @pindex calc-show-plain
29646 Calc's parser is unable to read certain kinds of formulas. For
29647 example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
29648 specify matrix display styles which the parser is unable to
29649 recognize as matrices. The @kbd{d p} (@code{calc-show-plain})
29650 command turns on a mode in which a ``plain'' version of a
29651 formula is placed in front of the fully-formatted version.
29652 When Calc reads a formula that has such a plain version in
29653 front, it reads the plain version and ignores the formatted
29656 Plain formulas are preceded and followed by @samp{%%%} signs
29657 by default. This notation has the advantage that the @samp{%}
29658 character begins a comment in @TeX{}, so if your formula is
29659 embedded in a @TeX{} document its plain version will be
29660 invisible in the final printed copy. @xref{Customizing
29661 Embedded Mode}, to see how to change the ``plain'' formula
29662 delimiters, say to something that @dfn{eqn} or some other
29663 formatter will treat as a comment.
29665 There are several notations which Calc's parser for ``big''
29666 formatted formulas can't yet recognize. In particular, it can't
29667 read the large symbols for @code{sum}, @code{prod}, and @code{integ},
29668 and it can't handle @samp{=>} with the righthand argument omitted.
29669 Also, Calc won't recognize special formats you have defined with
29670 the @kbd{Z C} command (@pxref{User-Defined Compositions}). In
29671 these cases it is important to use ``plain'' mode to make sure
29672 Calc will be able to read your formula later.
29674 Another example where ``plain'' mode is important is if you have
29675 specified a float mode with few digits of precision. Normally
29676 any digits that are computed but not displayed will simply be
29677 lost when you save and re-load your embedded buffer, but ``plain''
29678 mode allows you to make sure that the complete number is present
29679 in the file as well as the rounded-down number.
29685 Embedded buffers remember active formulas for as long as they
29686 exist in Emacs memory. Suppose you have an embedded formula
29688 @cite{pi} to the normal 12 decimal places, and then
29689 type @w{@kbd{C-u 5 d n}} to display only five decimal places.
29690 If you then type @kbd{d n}, all 12 places reappear because the
29691 full number is still there on the Calc stack. More surprisingly,
29692 even if you exit Embedded mode and later re-enter it for that
29693 formula, typing @kbd{d n} will restore all 12 places because
29694 each buffer remembers all its active formulas. However, if you
29695 save the buffer in a file and reload it in a new Emacs session,
29696 all non-displayed digits will have been lost unless you used
29703 In some applications of Embedded mode, you will want to have a
29704 sequence of copies of a formula that show its evolution as you
29705 work on it. For example, you might want to have a sequence
29706 like this in your file (elaborating here on the example from
29707 the ``Getting Started'' chapter):
29716 @r{(the derivative of }ln(ln(x))@r{)}
29718 whose value at x = 2 is
29728 @pindex calc-embedded-duplicate
29729 The @kbd{M-# d} (@code{calc-embedded-duplicate}) command is a
29730 handy way to make sequences like this. If you type @kbd{M-# d},
29731 the formula under the cursor (which may or may not have Embedded
29732 mode enabled for it at the time) is copied immediately below and
29733 Embedded mode is then enabled for that copy.
29735 For this example, you would start with just
29744 and press @kbd{M-# d} with the cursor on this formula. The result
29757 with the second copy of the formula enabled in Embedded mode.
29758 You can now press @kbd{a d x @key{RET}} to take the derivative, and
29759 @kbd{M-# d M-# d} to make two more copies of the derivative.
29760 To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
29761 the last formula, then move up to the second-to-last formula
29762 and type @kbd{2 s l x @key{RET}}.
29764 Finally, you would want to press @kbd{M-# e} to exit Embedded
29765 mode, then go up and insert the necessary text in between the
29766 various formulas and numbers.
29774 @pindex calc-embedded-new-formula
29775 The @kbd{M-# f} (@code{calc-embedded-new-formula}) command
29776 creates a new embedded formula at the current point. It inserts
29777 some default delimiters, which are usually just blank lines,
29778 and then does an algebraic entry to get the formula (which is
29779 then enabled for Embedded mode). This is just shorthand for
29780 typing the delimiters yourself, positioning the cursor between
29781 the new delimiters, and pressing @kbd{M-# e}. The key sequence
29782 @kbd{M-# '} is equivalent to @kbd{M-# f}.
29786 @pindex calc-embedded-next
29787 @pindex calc-embedded-previous
29788 The @kbd{M-# n} (@code{calc-embedded-next}) and @kbd{M-# p}
29789 (@code{calc-embedded-previous}) commands move the cursor to the
29790 next or previous active embedded formula in the buffer. They
29791 can take positive or negative prefix arguments to move by several
29792 formulas. Note that these commands do not actually examine the
29793 text of the buffer looking for formulas; they only see formulas
29794 which have previously been activated in Embedded mode. In fact,
29795 @kbd{M-# n} and @kbd{M-# p} are a useful way to tell which
29796 embedded formulas are currently active. Also, note that these
29797 commands do not enable Embedded mode on the next or previous
29798 formula, they just move the cursor. (By the way, @kbd{M-# n} is
29799 not as awkward to type as it may seem, because @kbd{M-#} ignores
29800 Shift and Meta on the second keystroke: @kbd{M-# M-N} can be typed
29801 by holding down Shift and Meta and alternately typing two keys.)
29804 @pindex calc-embedded-edit
29805 The @kbd{M-# `} (@code{calc-embedded-edit}) command edits the
29806 embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
29807 Embedded mode does not have to be enabled for this to work. Press
29808 @kbd{M-# M-#} to finish the edit, or @kbd{M-# x} to cancel.
29810 @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
29811 @section Assignments in Embedded Mode
29814 The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
29815 are especially useful in Embedded mode. They allow you to make
29816 a definition in one formula, then refer to that definition in
29817 other formulas embedded in the same buffer.
29819 An embedded formula which is an assignment to a variable, as in
29826 records @cite{5} as the stored value of @code{foo} for the
29827 purposes of Embedded mode operations in the current buffer. It
29828 does @emph{not} actually store @cite{5} as the ``global'' value
29829 of @code{foo}, however. Regular Calc operations, and Embedded
29830 formulas in other buffers, will not see this assignment.
29832 One way to use this assigned value is simply to create an
29833 Embedded formula elsewhere that refers to @code{foo}, and to press
29834 @kbd{=} in that formula. However, this permanently replaces the
29835 @code{foo} in the formula with its current value. More interesting
29836 is to use @samp{=>} elsewhere:
29842 @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
29844 If you move back and change the assignment to @code{foo}, any
29845 @samp{=>} formulas which refer to it are automatically updated.
29853 The obvious question then is, @emph{how} can one easily change the
29854 assignment to @code{foo}? If you simply select the formula in
29855 Embedded mode and type 17, the assignment itself will be replaced
29856 by the 17. The effect on the other formula will be that the
29857 variable @code{foo} becomes unassigned:
29865 The right thing to do is first to use a selection command (@kbd{j 2}
29866 will do the trick) to select the righthand side of the assignment.
29867 Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
29868 Subformulas}, to see how this works).
29871 @pindex calc-embedded-select
29872 The @kbd{M-# j} (@code{calc-embedded-select}) command provides an
29873 easy way to operate on assignments. It is just like @kbd{M-# e},
29874 except that if the enabled formula is an assignment, it uses
29875 @kbd{j 2} to select the righthand side. If the enabled formula
29876 is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
29877 A formula can also be a combination of both:
29880 bar := foo + 3 => 20
29884 in which case @kbd{M-# j} will select the middle part (@samp{foo + 3}).
29886 The formula is automatically deselected when you leave Embedded
29891 @pindex calc-embedded-update
29892 Another way to change the assignment to @code{foo} would simply be
29893 to edit the number using regular Emacs editing rather than Embedded
29894 mode. Then, we have to find a way to get Embedded mode to notice
29895 the change. The @kbd{M-# u} or @kbd{M-# =}
29896 (@code{calc-embedded-update-formula}) command is a convenient way
29905 Pressing @kbd{M-# u} is much like pressing @kbd{M-# e = M-# e}, that
29906 is, temporarily enabling Embedded mode for the formula under the
29907 cursor and then evaluating it with @kbd{=}. But @kbd{M-# u} does
29908 not actually use @kbd{M-# e}, and in fact another formula somewhere
29909 else can be enabled in Embedded mode while you use @kbd{M-# u} and
29910 that formula will not be disturbed.
29912 With a numeric prefix argument, @kbd{M-# u} updates all active
29913 @samp{=>} formulas in the buffer. Formulas which have not yet
29914 been activated in Embedded mode, and formulas which do not have
29915 @samp{=>} as their top-level operator, are not affected by this.
29916 (This is useful only if you have used @kbd{m C}; see below.)
29918 With a plain @kbd{C-u} prefix, @kbd{C-u M-# u} updates only in the
29919 region between mark and point rather than in the whole buffer.
29921 @kbd{M-# u} is also a handy way to activate a formula, such as an
29922 @samp{=>} formula that has freshly been typed in or loaded from a
29926 @pindex calc-embedded-activate
29927 The @kbd{M-# a} (@code{calc-embedded-activate}) command scans
29928 through the current buffer and activates all embedded formulas
29929 that contain @samp{:=} or @samp{=>} symbols. This does not mean
29930 that Embedded mode is actually turned on, but only that the
29931 formulas' positions are registered with Embedded mode so that
29932 the @samp{=>} values can be properly updated as assignments are
29935 It is a good idea to type @kbd{M-# a} right after loading a file
29936 that uses embedded @samp{=>} operators. Emacs includes a nifty
29937 ``buffer-local variables'' feature that you can use to do this
29938 automatically. The idea is to place near the end of your file
29939 a few lines that look like this:
29942 --- Local Variables: ---
29943 --- eval:(calc-embedded-activate) ---
29948 where the leading and trailing @samp{---} can be replaced by
29949 any suitable strings (which must be the same on all three lines)
29950 or omitted altogether; in a @TeX{} file, @samp{%} would be a good
29951 leading string and no trailing string would be necessary. In a
29952 C program, @samp{/*} and @samp{*/} would be good leading and
29955 When Emacs loads a file into memory, it checks for a Local Variables
29956 section like this one at the end of the file. If it finds this
29957 section, it does the specified things (in this case, running
29958 @kbd{M-# a} automatically) before editing of the file begins.
29959 The Local Variables section must be within 3000 characters of the
29960 end of the file for Emacs to find it, and it must be in the last
29961 page of the file if the file has any page separators.
29962 @xref{File Variables, , Local Variables in Files, emacs, the
29965 Note that @kbd{M-# a} does not update the formulas it finds.
29966 To do this, type, say, @kbd{M-1 M-# u} after @w{@kbd{M-# a}}.
29967 Generally this should not be a problem, though, because the
29968 formulas will have been up-to-date already when the file was
29971 Normally, @kbd{M-# a} activates all the formulas it finds, but
29972 any previous active formulas remain active as well. With a
29973 positive numeric prefix argument, @kbd{M-# a} first deactivates
29974 all current active formulas, then actives the ones it finds in
29975 its scan of the buffer. With a negative prefix argument,
29976 @kbd{M-# a} simply deactivates all formulas.
29978 Embedded mode has two symbols, @samp{Active} and @samp{~Active},
29979 which it puts next to the major mode name in a buffer's mode line.
29980 It puts @samp{Active} if it has reason to believe that all
29981 formulas in the buffer are active, because you have typed @kbd{M-# a}
29982 and Calc has not since had to deactivate any formulas (which can
29983 happen if Calc goes to update an @samp{=>} formula somewhere because
29984 a variable changed, and finds that the formula is no longer there
29985 due to some kind of editing outside of Embedded mode). Calc puts
29986 @samp{~Active} in the mode line if some, but probably not all,
29987 formulas in the buffer are active. This happens if you activate
29988 a few formulas one at a time but never use @kbd{M-# a}, or if you
29989 used @kbd{M-# a} but then Calc had to deactivate a formula
29990 because it lost track of it. If neither of these symbols appears
29991 in the mode line, no embedded formulas are active in the buffer
29992 (e.g., before Embedded mode has been used, or after a @kbd{M-- M-# a}).
29994 Embedded formulas can refer to assignments both before and after them
29995 in the buffer. If there are several assignments to a variable, the
29996 nearest preceding assignment is used if there is one, otherwise the
29997 following assignment is used.
30011 As well as simple variables, you can also assign to subscript
30012 expressions of the form @samp{@var{var}_@var{number}} (as in
30013 @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
30014 Assignments to other kinds of objects can be represented by Calc,
30015 but the automatic linkage between assignments and references works
30016 only for plain variables and these two kinds of subscript expressions.
30018 If there are no assignments to a given variable, the global
30019 stored value for the variable is used (@pxref{Storing Variables}),
30020 or, if no value is stored, the variable is left in symbolic form.
30021 Note that global stored values will be lost when the file is saved
30022 and loaded in a later Emacs session, unless you have used the
30023 @kbd{s p} (@code{calc-permanent-variable}) command to save them;
30024 @pxref{Operations on Variables}.
30026 The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
30027 recomputation of @samp{=>} forms on and off. If you turn automatic
30028 recomputation off, you will have to use @kbd{M-# u} to update these
30029 formulas manually after an assignment has been changed. If you
30030 plan to change several assignments at once, it may be more efficient
30031 to type @kbd{m C}, change all the assignments, then use @kbd{M-1 M-# u}
30032 to update the entire buffer afterwards. The @kbd{m C} command also
30033 controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
30034 Operator}. When you turn automatic recomputation back on, the
30035 stack will be updated but the Embedded buffer will not; you must
30036 use @kbd{M-# u} to update the buffer by hand.
30038 @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
30039 @section Mode Settings in Embedded Mode
30042 Embedded Mode has a rather complicated mechanism for handling mode
30043 settings in Embedded formulas. It is possible to put annotations
30044 in the file that specify mode settings either global to the entire
30045 file or local to a particular formula or formulas. In the latter
30046 case, different modes can be specified for use when a formula
30047 is the enabled Embedded Mode formula.
30049 When you give any mode-setting command, like @kbd{m f} (for fraction
30050 mode) or @kbd{d s} (for scientific notation), Embedded Mode adds
30051 a line like the following one to the file just before the opening
30052 delimiter of the formula.
30055 % [calc-mode: fractions: t]
30056 % [calc-mode: float-format: (sci 0)]
30059 When Calc interprets an embedded formula, it scans the text before
30060 the formula for mode-setting annotations like these and sets the
30061 Calc buffer to match these modes. Modes not explicitly described
30062 in the file are not changed. Calc scans all the way to the top of
30063 the file, or up to a line of the form
30070 which you can insert at strategic places in the file if this backward
30071 scan is getting too slow, or just to provide a barrier between one
30072 ``zone'' of mode settings and another.
30074 If the file contains several annotations for the same mode, the
30075 closest one before the formula is used. Annotations after the
30076 formula are never used (except for global annotations, described
30079 The scan does not look for the leading @samp{% }, only for the
30080 square brackets and the text they enclose. You can edit the mode
30081 annotations to a style that works better in context if you wish.
30082 @xref{Customizing Embedded Mode}, to see how to change the style
30083 that Calc uses when it generates the annotations. You can write
30084 mode annotations into the file yourself if you know the syntax;
30085 the easiest way to find the syntax for a given mode is to let
30086 Calc write the annotation for it once and see what it does.
30088 If you give a mode-changing command for a mode that already has
30089 a suitable annotation just above the current formula, Calc will
30090 modify that annotation rather than generating a new, conflicting
30093 Mode annotations have three parts, separated by colons. (Spaces
30094 after the colons are optional.) The first identifies the kind
30095 of mode setting, the second is a name for the mode itself, and
30096 the third is the value in the form of a Lisp symbol, number,
30097 or list. Annotations with unrecognizable text in the first or
30098 second parts are ignored. The third part is not checked to make
30099 sure the value is of a legal type or range; if you write an
30100 annotation by hand, be sure to give a proper value or results
30101 will be unpredictable. Mode-setting annotations are case-sensitive.
30103 While Embedded Mode is enabled, the word @code{Local} appears in
30104 the mode line. This is to show that mode setting commands generate
30105 annotations that are ``local'' to the current formula or set of
30106 formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command
30107 causes Calc to generate different kinds of annotations. Pressing
30108 @kbd{m R} repeatedly cycles through the possible modes.
30110 @code{LocEdit} and @code{LocPerm} modes generate annotations
30111 that look like this, respectively:
30114 % [calc-edit-mode: float-format: (sci 0)]
30115 % [calc-perm-mode: float-format: (sci 5)]
30118 The first kind of annotation will be used only while a formula
30119 is enabled in Embedded Mode. The second kind will be used only
30120 when the formula is @emph{not} enabled. (Whether the formula
30121 is ``active'' or not, i.e., whether Calc has seen this formula
30122 yet, is not relevant here.)
30124 @code{Global} mode generates an annotation like this at the end
30128 % [calc-global-mode: fractions t]
30131 Global mode annotations affect all formulas throughout the file,
30132 and may appear anywhere in the file. This allows you to tuck your
30133 mode annotations somewhere out of the way, say, on a new page of
30134 the file, as long as those mode settings are suitable for all
30135 formulas in the file.
30137 Enabling a formula with @kbd{M-# e} causes a fresh scan for local
30138 mode annotations; you will have to use this after adding annotations
30139 above a formula by hand to get the formula to notice them. Updating
30140 a formula with @kbd{M-# u} will also re-scan the local modes, but
30141 global modes are only re-scanned by @kbd{M-# a}.
30143 Another way that modes can get out of date is if you add a local
30144 mode annotation to a formula that has another formula after it.
30145 In this example, we have used the @kbd{d s} command while the
30146 first of the two embedded formulas is active. But the second
30147 formula has not changed its style to match, even though by the
30148 rules of reading annotations the @samp{(sci 0)} applies to it, too.
30151 % [calc-mode: float-format: (sci 0)]
30157 We would have to go down to the other formula and press @kbd{M-# u}
30158 on it in order to get it to notice the new annotation.
30160 Two more mode-recording modes selectable by @kbd{m R} are @code{Save}
30161 (which works even outside of Embedded Mode), in which mode settings
30162 are recorded permanently in your Emacs startup file @file{~/.emacs}
30163 rather than by annotating the current document, and no-recording
30164 mode (where there is no symbol like @code{Save} or @code{Local} in
30165 the mode line), in which mode-changing commands do not leave any
30166 annotations at all.
30168 When Embedded Mode is not enabled, mode-recording modes except
30169 for @code{Save} have no effect.
30171 @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
30172 @section Customizing Embedded Mode
30175 You can modify Embedded Mode's behavior by setting various Lisp
30176 variables described here. Use @kbd{M-x set-variable} or
30177 @kbd{M-x edit-options} to adjust a variable on the fly, or
30178 put a suitable @code{setq} statement in your @file{~/.emacs}
30179 file to set a variable permanently. (Another possibility would
30180 be to use a file-local variable annotation at the end of the
30181 file; @pxref{File Variables, , Local Variables in Files, emacs, the
30184 While none of these variables will be buffer-local by default, you
30185 can make any of them local to any embedded-mode buffer. (Their
30186 values in the @samp{*Calculator*} buffer are never used.)
30188 @vindex calc-embedded-open-formula
30189 The @code{calc-embedded-open-formula} variable holds a regular
30190 expression for the opening delimiter of a formula. @xref{Regexp Search,
30191 , Regular Expression Search, emacs, the Emacs manual}, to see
30192 how regular expressions work. Basically, a regular expression is a
30193 pattern that Calc can search for. A regular expression that considers
30194 blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
30195 @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this
30196 regular expression is not completely plain, let's go through it
30199 The surrounding @samp{" "} marks quote the text between them as a
30200 Lisp string. If you left them off, @code{set-variable} or
30201 @code{edit-options} would try to read the regular expression as a
30204 The most obvious property of this regular expression is that it
30205 contains indecently many backslashes. There are actually two levels
30206 of backslash usage going on here. First, when Lisp reads a quoted
30207 string, all pairs of characters beginning with a backslash are
30208 interpreted as special characters. Here, @code{\n} changes to a
30209 new-line character, and @code{\\} changes to a single backslash.
30210 So the actual regular expression seen by Calc is
30211 @samp{\`\|^ @r{(newline)} \|\$\$?}.
30213 Regular expressions also consider pairs beginning with backslash
30214 to have special meanings. Sometimes the backslash is used to quote
30215 a character that otherwise would have a special meaning in a regular
30216 expression, like @samp{$}, which normally means ``end-of-line,''
30217 or @samp{?}, which means that the preceding item is optional. So
30218 @samp{\$\$?} matches either one or two dollar signs.
30220 The other codes in this regular expression are @samp{^}, which matches
30221 ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
30222 which matches ``beginning-of-buffer.'' So the whole pattern means
30223 that a formula begins at the beginning of the buffer, or on a newline
30224 that occurs at the beginning of a line (i.e., a blank line), or at
30225 one or two dollar signs.
30227 The default value of @code{calc-embedded-open-formula} looks just
30228 like this example, with several more alternatives added on to
30229 recognize various other common kinds of delimiters.
30231 By the way, the reason to use @samp{^\n} rather than @samp{^$}
30232 or @samp{\n\n}, which also would appear to match blank lines,
30233 is that the former expression actually ``consumes'' only one
30234 newline character as @emph{part of} the delimiter, whereas the
30235 latter expressions consume zero or two newlines, respectively.
30236 The former choice gives the most natural behavior when Calc
30237 must operate on a whole formula including its delimiters.
30239 See the Emacs manual for complete details on regular expressions.
30240 But just for your convenience, here is a list of all characters
30241 which must be quoted with backslash (like @samp{\$}) to avoid
30242 some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note
30243 the backslash in this list; for example, to match @samp{\[} you
30244 must use @code{"\\\\\\["}. An exercise for the reader is to
30245 account for each of these six backslashes!)
30247 @vindex calc-embedded-close-formula
30248 The @code{calc-embedded-close-formula} variable holds a regular
30249 expression for the closing delimiter of a formula. A closing
30250 regular expression to match the above example would be
30251 @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the
30252 other one, except it now uses @samp{\'} (``end-of-buffer'') and
30253 @samp{\n$} (newline occurring at end of line, yet another way
30254 of describing a blank line that is more appropriate for this
30257 @vindex calc-embedded-open-word
30258 @vindex calc-embedded-close-word
30259 The @code{calc-embedded-open-word} and @code{calc-embedded-close-word}
30260 variables are similar expressions used when you type @kbd{M-# w}
30261 instead of @kbd{M-# e} to enable Embedded mode.
30263 @vindex calc-embedded-open-plain
30264 The @code{calc-embedded-open-plain} variable is a string which
30265 begins a ``plain'' formula written in front of the formatted
30266 formula when @kbd{d p} mode is turned on. Note that this is an
30267 actual string, not a regular expression, because Calc must be able
30268 to write this string into a buffer as well as to recognize it.
30269 The default string is @code{"%%% "} (note the trailing space).
30271 @vindex calc-embedded-close-plain
30272 The @code{calc-embedded-close-plain} variable is a string which
30273 ends a ``plain'' formula. The default is @code{" %%%\n"}. Without
30274 the trailing newline here, the first line of a ``big'' mode formula
30275 that followed might be shifted over with respect to the other lines.
30277 @vindex calc-embedded-open-new-formula
30278 The @code{calc-embedded-open-new-formula} variable is a string
30279 which is inserted at the front of a new formula when you type
30280 @kbd{M-# f}. Its default value is @code{"\n\n"}. If this
30281 string begins with a newline character and the @kbd{M-# f} is
30282 typed at the beginning of a line, @kbd{M-# f} will skip this
30283 first newline to avoid introducing unnecessary blank lines in
30286 @vindex calc-embedded-close-new-formula
30287 The @code{calc-embedded-close-new-formula} variable is the corresponding
30288 string which is inserted at the end of a new formula. Its default
30289 value is also @code{"\n\n"}. The final newline is omitted by
30290 @w{@kbd{M-# f}} if typed at the end of a line. (It follows that if
30291 @kbd{M-# f} is typed on a blank line, both a leading opening
30292 newline and a trailing closing newline are omitted.)
30294 @vindex calc-embedded-announce-formula
30295 The @code{calc-embedded-announce-formula} variable is a regular
30296 expression which is sure to be followed by an embedded formula.
30297 The @kbd{M-# a} command searches for this pattern as well as for
30298 @samp{=>} and @samp{:=} operators. Note that @kbd{M-# a} will
30299 not activate just anything surrounded by formula delimiters; after
30300 all, blank lines are considered formula delimiters by default!
30301 But if your language includes a delimiter which can only occur
30302 actually in front of a formula, you can take advantage of it here.
30303 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which
30304 checks for @samp{%Embed} followed by any number of lines beginning
30305 with @samp{%} and a space. This last is important to make Calc
30306 consider mode annotations part of the pattern, so that the formula's
30307 opening delimiter really is sure to follow the pattern.
30309 @vindex calc-embedded-open-mode
30310 The @code{calc-embedded-open-mode} variable is a string (not a
30311 regular expression) which should precede a mode annotation.
30312 Calc never scans for this string; Calc always looks for the
30313 annotation itself. But this is the string that is inserted before
30314 the opening bracket when Calc adds an annotation on its own.
30315 The default is @code{"% "}.
30317 @vindex calc-embedded-close-mode
30318 The @code{calc-embedded-close-mode} variable is a string which
30319 follows a mode annotation written by Calc. Its default value
30320 is simply a newline, @code{"\n"}. If you change this, it is a
30321 good idea still to end with a newline so that mode annotations
30322 will appear on lines by themselves.
30324 @node Programming, Installation, Embedded Mode, Top
30325 @chapter Programming
30328 There are several ways to ``program'' the Emacs Calculator, depending
30329 on the nature of the problem you need to solve.
30333 @dfn{Keyboard macros} allow you to record a sequence of keystrokes
30334 and play them back at a later time. This is just the standard Emacs
30335 keyboard macro mechanism, dressed up with a few more features such
30336 as loops and conditionals.
30339 @dfn{Algebraic definitions} allow you to use any formula to define a
30340 new function. This function can then be used in algebraic formulas or
30341 as an interactive command.
30344 @dfn{Rewrite rules} are discussed in the section on algebra commands.
30345 @xref{Rewrite Rules}. If you put your rewrite rules in the variable
30346 @code{EvalRules}, they will be applied automatically to all Calc
30347 results in just the same way as an internal ``rule'' is applied to
30348 evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}.
30351 @dfn{Lisp} is the programming language that Calc (and most of Emacs)
30352 is written in. If the above techniques aren't powerful enough, you
30353 can write Lisp functions to do anything that built-in Calc commands
30354 can do. Lisp code is also somewhat faster than keyboard macros or
30359 Programming features are available through the @kbd{z} and @kbd{Z}
30360 prefix keys. New commands that you define are two-key sequences
30361 beginning with @kbd{z}. Commands for managing these definitions
30362 use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing})
30363 command is described elsewhere; @pxref{Troubleshooting Commands}.
30364 The @kbd{Z C} (@code{calc-user-define-composition}) command is also
30365 described elsewhere; @pxref{User-Defined Compositions}.)
30368 * Creating User Keys::
30369 * Keyboard Macros::
30370 * Invocation Macros::
30371 * Algebraic Definitions::
30372 * Lisp Definitions::
30375 @node Creating User Keys, Keyboard Macros, Programming, Programming
30376 @section Creating User Keys
30380 @pindex calc-user-define
30381 Any Calculator command may be bound to a key using the @kbd{Z D}
30382 (@code{calc-user-define}) command. Actually, it is bound to a two-key
30383 sequence beginning with the lower-case @kbd{z} prefix.
30385 The @kbd{Z D} command first prompts for the key to define. For example,
30386 press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then
30387 prompted for the name of the Calculator command that this key should
30388 run. For example, the @code{calc-sincos} command is not normally
30389 available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the
30390 @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain
30391 in effect for the rest of this Emacs session, or until you redefine
30392 @kbd{z s} to be something else.
30394 You can actually bind any Emacs command to a @kbd{z} key sequence by
30395 backspacing over the @samp{calc-} when you are prompted for the command name.
30397 As with any other prefix key, you can type @kbd{z ?} to see a list of
30398 all the two-key sequences you have defined that start with @kbd{z}.
30399 Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
30401 User keys are typically letters, but may in fact be any key.
30402 (@key{META}-keys are not permitted, nor are a terminal's special
30403 function keys which generate multi-character sequences when pressed.)
30404 You can define different commands on the shifted and unshifted versions
30405 of a letter if you wish.
30408 @pindex calc-user-undefine
30409 The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
30410 For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
30411 key we defined above.
30414 @pindex calc-user-define-permanent
30415 @cindex Storing user definitions
30416 @cindex Permanent user definitions
30417 @cindex @file{.emacs} file, user-defined commands
30418 The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
30419 binding permanent so that it will remain in effect even in future Emacs
30420 sessions. (It does this by adding a suitable bit of Lisp code into
30421 your @file{.emacs} file.) For example, @kbd{Z P s} would register
30422 our @code{sincos} command permanently. If you later wish to unregister
30423 this command you must edit your @file{.emacs} file by hand.
30424 (@xref{General Mode Commands}, for a way to tell Calc to use a
30425 different file instead of @file{.emacs}.)
30427 The @kbd{Z P} command also saves the user definition, if any, for the
30428 command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user
30429 key could invoke a command, which in turn calls an algebraic function,
30430 which might have one or more special display formats. A single @kbd{Z P}
30431 command will save all of these definitions.
30433 To save a command or function without its key binding (or if there is
30434 no key binding for the command or function), type @kbd{'} (the apostrophe)
30435 when prompted for a key. Then, type the function name, or backspace
30436 to change the @samp{calcFunc-} prefix to @samp{calc-} and enter a
30437 command name. (If the command you give implies a function, the function
30438 will be saved, and if the function has any display formats, those will
30439 be saved, but not the other way around: Saving a function will not save
30440 any commands or key bindings associated with the function.)
30443 @pindex calc-user-define-edit
30444 @cindex Editing user definitions
30445 The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
30446 of a user key. This works for keys that have been defined by either
30447 keyboard macros or formulas; further details are contained in the relevant
30448 following sections.
30450 @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
30451 @section Programming with Keyboard Macros
30455 @cindex Programming with keyboard macros
30456 @cindex Keyboard macros
30457 The easiest way to ``program'' the Emacs Calculator is to use standard
30458 keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From
30459 this point on, keystrokes you type will be saved away as well as
30460 performing their usual functions. Press @kbd{C-x )} to end recording.
30461 Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
30462 execute your keyboard macro by replaying the recorded keystrokes.
30463 @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
30464 information.@refill
30466 When you use @kbd{X} to invoke a keyboard macro, the entire macro is
30467 treated as a single command by the undo and trail features. The stack
30468 display buffer is not updated during macro execution, but is instead
30469 fixed up once the macro completes. Thus, commands defined with keyboard
30470 macros are convenient and efficient. The @kbd{C-x e} command, on the
30471 other hand, invokes the keyboard macro with no special treatment: Each
30472 command in the macro will record its own undo information and trail entry,
30473 and update the stack buffer accordingly. If your macro uses features
30474 outside of Calc's control to operate on the contents of the Calc stack
30475 buffer, or if it includes Undo, Redo, or last-arguments commands, you
30476 must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
30477 at all times. You could also consider using @kbd{K} (@code{calc-keep-args})
30478 instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
30480 Calc extends the standard Emacs keyboard macros in several ways.
30481 Keyboard macros can be used to create user-defined commands. Keyboard
30482 macros can include conditional and iteration structures, somewhat
30483 analogous to those provided by a traditional programmable calculator.
30486 * Naming Keyboard Macros::
30487 * Conditionals in Macros::
30488 * Loops in Macros::
30489 * Local Values in Macros::
30490 * Queries in Macros::
30493 @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
30494 @subsection Naming Keyboard Macros
30498 @pindex calc-user-define-kbd-macro
30499 Once you have defined a keyboard macro, you can bind it to a @kbd{z}
30500 key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
30501 This command prompts first for a key, then for a command name. For
30502 example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
30503 define a keyboard macro which negates the top two numbers on the stack
30504 (@key{TAB} swaps the top two stack elements). Now you can type
30505 @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
30506 sequence. The default command name (if you answer the second prompt with
30507 just the @key{RET} key as in this example) will be something like
30508 @samp{calc-User-n}. The keyboard macro will now be available as both
30509 @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more
30510 descriptive command name if you wish.@refill
30512 Macros defined by @kbd{Z K} act like single commands; they are executed
30513 in the same way as by the @kbd{X} key. If you wish to define the macro
30514 as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
30515 give a negative prefix argument to @kbd{Z K}.
30517 Once you have bound your keyboard macro to a key, you can use
30518 @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}.
30520 @cindex Keyboard macros, editing
30521 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
30522 been defined by a keyboard macro tries to use the @code{edit-kbd-macro}
30523 command to edit the macro. This command may be found in the
30524 @file{macedit} package, a copy of which comes with Calc. It decomposes
30525 the macro definition into full Emacs command names, like @code{calc-pop}
30526 and @code{calc-add}. Type @kbd{M-# M-#} to finish editing and update
30527 the definition stored on the key, or, to cancel the edit, type
30528 @kbd{M-# x}.@refill
30530 If you give a negative numeric prefix argument to @kbd{Z E}, the keyboard
30531 macro is edited in spelled-out keystroke form. For example, the editing
30532 buffer might contain the nine characters @w{@samp{1 @key{RET} 2 +}}. When you press
30533 @kbd{M-# M-#}, the @code{read-kbd-macro} feature of the @file{macedit}
30534 package is used to reinterpret these key names. The
30535 notations @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL}, and
30536 @code{NUL} must be written in all uppercase, as must the prefixes @code{C-}
30537 and @code{M-}. Spaces and line breaks are ignored. Other characters are
30538 copied verbatim into the keyboard macro. Basically, the notation is the
30539 same as is used in all of this manual's examples, except that the manual
30540 takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}}, we take
30541 it for granted that it is clear we really mean @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}},
30542 which is what @code{read-kbd-macro} wants to see.@refill
30544 If @file{macedit} is not available, @kbd{Z E} edits the keyboard macro
30545 in ``raw'' form; the editing buffer simply contains characters like
30546 @samp{1^M2+} (here @samp{^M} represents the carriage-return character).
30547 Editing in this mode, you will have to use @kbd{C-q} to enter new
30548 control characters into the buffer.@refill
30551 @pindex read-kbd-macro
30552 The @kbd{M-# m} (@code{read-kbd-macro}) command reads an Emacs ``region''
30553 of spelled-out keystrokes and defines it as the current keyboard macro.
30554 It is a convenient way to define a keyboard macro that has been stored
30555 in a file, or to define a macro without executing it at the same time.
30556 The @kbd{M-# m} command works only if @file{macedit} is present.
30558 @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
30559 @subsection Conditionals in Keyboard Macros
30564 @pindex calc-kbd-if
30565 @pindex calc-kbd-else
30566 @pindex calc-kbd-else-if
30567 @pindex calc-kbd-end-if
30568 @cindex Conditional structures
30569 The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
30570 commands allow you to put simple tests in a keyboard macro. When Calc
30571 sees the @kbd{Z [}, it pops an object from the stack and, if the object is
30572 a non-zero value, continues executing keystrokes. But if the object is
30573 zero, or if it is not provably nonzero, Calc skips ahead to the matching
30574 @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for
30575 performing tests which conveniently produce 1 for true and 0 for false.
30577 For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
30578 function in the form of a keyboard macro. This macro duplicates the
30579 number on the top of the stack, pushes zero and compares using @kbd{a <}
30580 (@code{calc-less-than}), then, if the number was less than zero,
30581 executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign
30582 command is skipped.
30584 To program this macro, type @kbd{C-x (}, type the above sequence of
30585 keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be
30586 executed while you are making the definition as well as when you later
30587 re-execute the macro by typing @kbd{X}. Thus you should make sure a
30588 suitable number is on the stack before defining the macro so that you
30589 don't get a stack-underflow error during the definition process.
30591 Conditionals can be nested arbitrarily. However, there should be exactly
30592 one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
30595 The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
30596 two keystroke sequences. The general format is @kbd{@var{cond} Z [
30597 @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true
30598 (i.e., if the top of stack contains a non-zero number after @var{cond}
30599 has been executed), the @var{then-part} will be executed and the
30600 @var{else-part} will be skipped. Otherwise, the @var{then-part} will
30601 be skipped and the @var{else-part} will be executed.
30604 The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
30605 between any number of alternatives. For example,
30606 @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
30607 @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
30608 otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
30609 it will execute @var{part3}.
30611 More precisely, @kbd{Z [} pops a number and conditionally skips to the
30612 next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when
30613 actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}.
30614 @kbd{Z |} pops a number and conditionally skips to the next matching
30615 @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
30616 equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
30619 Calc's conditional and looping constructs work by scanning the
30620 keyboard macro for occurrences of character sequences like @samp{Z:}
30621 and @samp{Z]}. One side-effect of this is that if you use these
30622 constructs you must be careful that these character pairs do not
30623 occur by accident in other parts of the macros. Since Calc rarely
30624 uses shift-@kbd{Z} for any purpose except as a prefix character, this
30625 is not likely to be a problem. Another side-effect is that it will
30626 not work to define your own custom key bindings for these commands.
30627 Only the standard shift-@kbd{Z} bindings will work correctly.
30630 If Calc gets stuck while skipping characters during the definition of a
30631 macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g}
30632 actually adds a @kbd{C-g} keystroke to the macro.)
30634 @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
30635 @subsection Loops in Keyboard Macros
30640 @pindex calc-kbd-repeat
30641 @pindex calc-kbd-end-repeat
30642 @cindex Looping structures
30643 @cindex Iterative structures
30644 The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
30645 (@code{calc-kbd-end-repeat}) commands pop a number from the stack,
30646 which must be an integer, then repeat the keystrokes between the brackets
30647 the specified number of times. If the integer is zero or negative, the
30648 body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >}
30649 computes two to a nonnegative integer power. First, we push 1 on the
30650 stack and then swap the integer argument back to the top. The @kbd{Z <}
30651 pops that argument leaving the 1 back on top of the stack. Then, we
30652 repeat a multiply-by-two step however many times.@refill
30654 Once again, the keyboard macro is executed as it is being entered.
30655 In this case it is especially important to set up reasonable initial
30656 conditions before making the definition: Suppose the integer 1000 just
30657 happened to be sitting on the stack before we typed the above definition!
30658 Another approach is to enter a harmless dummy definition for the macro,
30659 then go back and edit in the real one with a @kbd{Z E} command. Yet
30660 another approach is to type the macro as written-out keystroke names
30661 in a buffer, then use @kbd{M-# m} (@code{read-kbd-macro}) to read the
30666 The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
30667 of a keyboard macro loop prematurely. It pops an object from the stack;
30668 if that object is true (a non-zero number), control jumps out of the
30669 innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
30670 after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no
30671 effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
30672 in the C language.@refill
30676 @pindex calc-kbd-for
30677 @pindex calc-kbd-end-for
30678 The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
30679 commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
30680 value of the counter available inside the loop. The general layout is
30681 @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (}
30682 command pops initial and final values from the stack. It then creates
30683 a temporary internal counter and initializes it with the value @var{init}.
30684 The @kbd{Z (} command then repeatedly pushes the counter value onto the
30685 stack and executes @var{body} and @var{step}, adding @var{step} to the
30686 counter each time until the loop finishes.@refill
30688 @cindex Summations (by keyboard macros)
30689 By default, the loop finishes when the counter becomes greater than (or
30690 less than) @var{final}, assuming @var{initial} is less than (greater
30691 than) @var{final}. If @var{initial} is equal to @var{final}, the body
30692 executes exactly once. The body of the loop always executes at least
30693 once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
30694 squares of the integers from 1 to 10, in steps of 1.
30696 If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
30697 forced to use upward-counting conventions. In this case, if @var{initial}
30698 is greater than @var{final} the body will not be executed at all.
30699 Note that @var{step} may still be negative in this loop; the prefix
30700 argument merely constrains the loop-finished test. Likewise, a prefix
30701 argument of @i{-1} forces downward-counting conventions.
30705 @pindex calc-kbd-loop
30706 @pindex calc-kbd-end-loop
30707 The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
30708 (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
30709 @kbd{Z >}, except that they do not pop a count from the stack---they
30710 effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}}
30711 loop ought to include at least one @kbd{Z /} to make sure the loop
30712 doesn't run forever. (If any error message occurs which causes Emacs
30713 to beep, the keyboard macro will also be halted; this is a standard
30714 feature of Emacs. You can also generally press @kbd{C-g} to halt a
30715 running keyboard macro, although not all versions of Unix support
30718 The conditional and looping constructs are not actually tied to
30719 keyboard macros, but they are most often used in that context.
30720 For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
30721 ten copies of 23 onto the stack. This can be typed ``live'' just
30722 as easily as in a macro definition.
30724 @xref{Conditionals in Macros}, for some additional notes about
30725 conditional and looping commands.
30727 @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
30728 @subsection Local Values in Macros
30731 @cindex Local variables
30732 @cindex Restoring saved modes
30733 Keyboard macros sometimes want to operate under known conditions
30734 without affecting surrounding conditions. For example, a keyboard
30735 macro may wish to turn on Fraction Mode, or set a particular
30736 precision, independent of the user's normal setting for those
30741 @pindex calc-kbd-push
30742 @pindex calc-kbd-pop
30743 Macros also sometimes need to use local variables. Assignments to
30744 local variables inside the macro should not affect any variables
30745 outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
30746 (@code{calc-kbd-pop}) commands give you both of these capabilities.
30748 When you type @kbd{Z `} (with a backquote or accent grave character),
30749 the values of various mode settings are saved away. The ten ``quick''
30750 variables @code{q0} through @code{q9} are also saved. When
30751 you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
30752 Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
30754 If a keyboard macro halts due to an error in between a @kbd{Z `} and
30755 a @kbd{Z '}, the saved values will be restored correctly even though
30756 the macro never reaches the @kbd{Z '} command. Thus you can use
30757 @kbd{Z `} and @kbd{Z '} without having to worry about what happens
30758 in exceptional conditions.
30760 If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
30761 you into a ``recursive edit.'' You can tell you are in a recursive
30762 edit because there will be extra square brackets in the mode line,
30763 as in @samp{[(Calculator)]}. These brackets will go away when you
30764 type the matching @kbd{Z '} command. The modes and quick variables
30765 will be saved and restored in just the same way as if actual keyboard
30766 macros were involved.
30768 The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
30769 and binary word size, the angular mode (Deg, Rad, or HMS), the
30770 simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
30771 Matrix or Scalar mode, Fraction mode, and the current complex mode
30772 (Polar or Rectangular). The ten ``quick'' variables' values (or lack
30773 thereof) are also saved.
30775 Most mode-setting commands act as toggles, but with a numeric prefix
30776 they force the mode either on (positive prefix) or off (negative
30777 or zero prefix). Since you don't know what the environment might
30778 be when you invoke your macro, it's best to use prefix arguments
30779 for all mode-setting commands inside the macro.
30781 In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
30782 listed above to their default values. As usual, the matching @kbd{Z '}
30783 will restore the modes to their settings from before the @kbd{C-u Z `}.
30784 Also, @w{@kbd{Z `}} with a negative prefix argument resets algebraic mode
30785 to its default (off) but leaves the other modes the same as they were
30786 outside the construct.
30788 The contents of the stack and trail, values of non-quick variables, and
30789 other settings such as the language mode and the various display modes,
30790 are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
30792 @node Queries in Macros, , Local Values in Macros, Keyboard Macros
30793 @subsection Queries in Keyboard Macros
30797 @pindex calc-kbd-report
30798 The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
30799 message including the value on the top of the stack. You are prompted
30800 to enter a string. That string, along with the top-of-stack value,
30801 is displayed unless @kbd{m w} (@code{calc-working}) has been used
30802 to turn such messages off.
30805 @pindex calc-kbd-query
30806 The @kbd{Z #} (@code{calc-kbd-query}) command displays a prompt message
30807 (which you enter during macro definition), then does an algebraic entry
30808 which takes its input from the keyboard, even during macro execution.
30809 This command allows your keyboard macros to accept numbers or formulas
30810 as interactive input. All the normal conventions of algebraic input,
30811 including the use of @kbd{$} characters, are supported.
30813 @xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of
30814 @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
30815 keyboard input during a keyboard macro. In particular, you can use
30816 @kbd{C-x q} to enter a recursive edit, which allows the user to perform
30817 any Calculator operations interactively before pressing @kbd{C-M-c} to
30818 return control to the keyboard macro.
30820 @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
30821 @section Invocation Macros
30825 @pindex calc-user-invocation
30826 @pindex calc-user-define-invocation
30827 Calc provides one special keyboard macro, called up by @kbd{M-# z}
30828 (@code{calc-user-invocation}), that is intended to allow you to define
30829 your own special way of starting Calc. To define this ``invocation
30830 macro,'' create the macro in the usual way with @kbd{C-x (} and
30831 @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
30832 There is only one invocation macro, so you don't need to type any
30833 additional letters after @kbd{Z I}. From now on, you can type
30834 @kbd{M-# z} at any time to execute your invocation macro.
30836 For example, suppose you find yourself often grabbing rectangles of
30837 numbers into Calc and multiplying their columns. You can do this
30838 by typing @kbd{M-# r} to grab, and @kbd{V R : *} to multiply columns.
30839 To make this into an invocation macro, just type @kbd{C-x ( M-# r
30840 V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data,
30841 just mark the data in its buffer in the usual way and type @kbd{M-# z}.
30843 Invocation macros are treated like regular Emacs keyboard macros;
30844 all the special features described above for @kbd{Z K}-style macros
30845 do not apply. @kbd{M-# z} is just like @kbd{C-x e}, except that it
30846 uses the macro that was last stored by @kbd{Z I}. (In fact, the
30847 macro does not even have to have anything to do with Calc!)
30849 The @kbd{m m} command saves the last invocation macro defined by
30850 @kbd{Z I} along with all the other Calc mode settings.
30851 @xref{General Mode Commands}.
30853 @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
30854 @section Programming with Formulas
30858 @pindex calc-user-define-formula
30859 @cindex Programming with algebraic formulas
30860 Another way to create a new Calculator command uses algebraic formulas.
30861 The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
30862 formula at the top of the stack as the definition for a key. This
30863 command prompts for five things: The key, the command name, the function
30864 name, the argument list, and the behavior of the command when given
30865 non-numeric arguments.
30867 For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
30868 @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this
30869 formula on the @kbd{z m} key sequence. The next prompt is for a command
30870 name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
30871 for the new command. If you simply press @key{RET}, a default name like
30872 @code{calc-User-m} will be constructed. In our example, suppose we enter
30873 @kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
30875 If you want to give the formula a long-style name only, you can press
30876 @key{SPC} or @key{RET} when asked which single key to use. For example
30877 @kbd{Z F @key{RET} spam @key{RET}} defines the new command as
30878 @kbd{M-x calc-spam}, with no keyboard equivalent.
30880 The third prompt is for a function name. The default is to use the same
30881 name as the command name but with @samp{calcFunc-} in place of
30882 @samp{calc-}. This is the name you will use if you want to enter your
30883 new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}.
30884 Then the new function can be invoked by pushing two numbers on the
30885 stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
30886 formula @samp{yow(x,y)}.@refill
30888 The fourth prompt is for the function's argument list. This is used to
30889 associate values on the stack with the variables that appear in the formula.
30890 The default is a list of all variables which appear in the formula, sorted
30891 into alphabetical order. In our case, the default would be @samp{(a b)}.
30892 This means that, when the user types @kbd{z m}, the Calculator will remove
30893 two numbers from the stack, substitute these numbers for @samp{a} and
30894 @samp{b} (respectively) in the formula, then simplify the formula and
30895 push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m}
30896 would replace the 10 and 100 on the stack with the number 210, which is
30897 @cite{a + 2 b} with @cite{a=10} and @cite{b=100}. Likewise, the formula
30898 @samp{yow(10, 100)} will be evaluated by substituting @cite{a=10} and
30899 @cite{b=100} in the definition.
30901 You can rearrange the order of the names before pressing @key{RET} to
30902 control which stack positions go to which variables in the formula. If
30903 you remove a variable from the argument list, that variable will be left
30904 in symbolic form by the command. Thus using an argument list of @samp{(b)}
30905 for our function would cause @kbd{10 z m} to replace the 10 on the stack
30906 with the formula @samp{a + 20}. If we had used an argument list of
30907 @samp{(b a)}, the result with inputs 10 and 100 would have been 120.
30909 You can also put a nameless function on the stack instead of just a
30910 formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}.
30911 In this example, the command will be defined by the formula @samp{a + 2 b}
30912 using the argument list @samp{(a b)}.
30914 The final prompt is a y-or-n question concerning what to do if symbolic
30915 arguments are given to your function. If you answer @kbd{y}, then
30916 executing @kbd{z m} (using the original argument list @samp{(a b)}) with
30917 arguments @cite{10} and @cite{x} will leave the function in symbolic
30918 form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n},
30919 then the formula will always be expanded, even for non-constant
30920 arguments: @samp{10 + 2 x}. If you never plan to feed algebraic
30921 formulas to your new function, it doesn't matter how you answer this
30924 If you answered @kbd{y} to this question you can still cause a function
30925 call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
30926 Also, Calc will expand the function if necessary when you take a
30927 derivative or integral or solve an equation involving the function.
30930 @pindex calc-get-user-defn
30931 Once you have defined a formula on a key, you can retrieve this formula
30932 with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a
30933 key, and this command pushes the formula that was used to define that
30934 key onto the stack. Actually, it pushes a nameless function that
30935 specifies both the argument list and the defining formula. You will get
30936 an error message if the key is undefined, or if the key was not defined
30937 by a @kbd{Z F} command.@refill
30939 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
30940 been defined by a formula uses a variant of the @code{calc-edit} command
30941 to edit the defining formula. Press @kbd{M-# M-#} to finish editing and
30942 store the new formula back in the definition, or @kbd{M-# x} to
30943 cancel the edit. (The argument list and other properties of the
30944 definition are unchanged; to adjust the argument list, you can use
30945 @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
30946 then re-execute the @kbd{Z F} command.)
30948 As usual, the @kbd{Z P} command records your definition permanently.
30949 In this case it will permanently record all three of the relevant
30950 definitions: the key, the command, and the function.
30952 You may find it useful to turn off the default simplifications with
30953 @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
30954 used as a function definition. For example, the formula @samp{deriv(a^2,v)}
30955 which might be used to define a new function @samp{dsqr(a,v)} will be
30956 ``simplified'' to 0 immediately upon entry since @code{deriv} considers
30957 @cite{a} to be constant with respect to @cite{v}. Turning off
30958 default simplifications cures this problem: The definition will be stored
30959 in symbolic form without ever activating the @code{deriv} function. Press
30960 @kbd{m D} to turn the default simplifications back on afterwards.
30962 @node Lisp Definitions, , Algebraic Definitions, Programming
30963 @section Programming with Lisp
30966 The Calculator can be programmed quite extensively in Lisp. All you
30967 do is write a normal Lisp function definition, but with @code{defmath}
30968 in place of @code{defun}. This has the same form as @code{defun}, but it
30969 automagically replaces calls to standard Lisp functions like @code{+} and
30970 @code{zerop} with calls to the corresponding functions in Calc's own library.
30971 Thus you can write natural-looking Lisp code which operates on all of the
30972 standard Calculator data types. You can then use @kbd{Z D} if you wish to
30973 bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command
30974 will not edit a Lisp-based definition.
30976 Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section
30977 assumes a familiarity with Lisp programming concepts; if you do not know
30978 Lisp, you may find keyboard macros or rewrite rules to be an easier way
30979 to program the Calculator.
30981 This section first discusses ways to write commands, functions, or
30982 small programs to be executed inside of Calc. Then it discusses how
30983 your own separate programs are able to call Calc from the outside.
30984 Finally, there is a list of internal Calc functions and data structures
30985 for the true Lisp enthusiast.
30988 * Defining Functions::
30989 * Defining Simple Commands::
30990 * Defining Stack Commands::
30991 * Argument Qualifiers::
30992 * Example Definitions::
30994 * Calling Calc from Your Programs::
30998 @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
30999 @subsection Defining New Functions
31003 The @code{defmath} function (actually a Lisp macro) is like @code{defun}
31004 except that code in the body of the definition can make use of the full
31005 range of Calculator data types. The prefix @samp{calcFunc-} is added
31006 to the specified name to get the actual Lisp function name. As a simple
31010 (defmath myfact (n)
31012 (* n (myfact (1- n)))
31017 This actually expands to the code,
31020 (defun calcFunc-myfact (n)
31022 (math-mul n (calcFunc-myfact (math-add n -1)))
31027 This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
31029 The @samp{myfact} function as it is defined above has the bug that an
31030 expression @samp{myfact(a+b)} will be simplified to 1 because the
31031 formula @samp{a+b} is not considered to be @code{posp}. A robust
31032 factorial function would be written along the following lines:
31035 (defmath myfact (n)
31037 (* n (myfact (1- n)))
31040 nil))) ; this could be simplified as: (and (= n 0) 1)
31043 If a function returns @code{nil}, it is left unsimplified by the Calculator
31044 (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)}
31045 will be simplified to @samp{myfact(a+3)} but no further. Beware that every
31046 time the Calculator reexamines this formula it will attempt to resimplify
31047 it, so your function ought to detect the returning-@code{nil} case as
31048 efficiently as possible.
31050 The following standard Lisp functions are treated by @code{defmath}:
31051 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
31052 @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
31053 @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
31054 @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for
31055 @code{math-nearly-equal}, which is useful in implementing Taylor series.@refill
31057 For other functions @var{func}, if a function by the name
31058 @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
31059 name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
31060 is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
31061 used on the assumption that this is a to-be-defined math function. Also, if
31062 the function name is quoted as in @samp{('integerp a)} the function name is
31063 always used exactly as written (but not quoted).@refill
31065 Variable names have @samp{var-} prepended to them unless they appear in
31066 the function's argument list or in an enclosing @code{let}, @code{let*},
31067 @code{for}, or @code{foreach} form,
31068 or their names already contain a @samp{-} character. Thus a reference to
31069 @samp{foo} is the same as a reference to @samp{var-foo}.@refill
31071 A few other Lisp extensions are available in @code{defmath} definitions:
31075 The @code{elt} function accepts any number of index variables.
31076 Note that Calc vectors are stored as Lisp lists whose first
31077 element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
31078 the second element of vector @code{v}, and @samp{(elt m i j)}
31079 yields one element of a Calc matrix.
31082 The @code{setq} function has been extended to act like the Common
31083 Lisp @code{setf} function. (The name @code{setf} is recognized as
31084 a synonym of @code{setq}.) Specifically, the first argument of
31085 @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
31086 in which case the effect is to store into the specified
31087 element of a list. Thus, @samp{(setq (elt m i j) x)} stores @cite{x}
31088 into one element of a matrix.
31091 A @code{for} looping construct is available. For example,
31092 @samp{(for ((i 0 10)) body)} executes @code{body} once for each
31093 binding of @cite{i} from zero to 10. This is like a @code{let}
31094 form in that @cite{i} is temporarily bound to the loop count
31095 without disturbing its value outside the @code{for} construct.
31096 Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
31097 are also available. For each value of @cite{i} from zero to 10,
31098 @cite{j} counts from 0 to @cite{i-1} in steps of two. Note that
31099 @code{for} has the same general outline as @code{let*}, except
31100 that each element of the header is a list of three or four
31101 things, not just two.
31104 The @code{foreach} construct loops over elements of a list.
31105 For example, @samp{(foreach ((x (cdr v))) body)} executes
31106 @code{body} with @cite{x} bound to each element of Calc vector
31107 @cite{v} in turn. The purpose of @code{cdr} here is to skip over
31108 the initial @code{vec} symbol in the vector.
31111 The @code{break} function breaks out of the innermost enclosing
31112 @code{while}, @code{for}, or @code{foreach} loop. If given a
31113 value, as in @samp{(break x)}, this value is returned by the
31114 loop. (Lisp loops otherwise always return @code{nil}.)
31117 The @code{return} function prematurely returns from the enclosing
31118 function. For example, @samp{(return (+ x y))} returns @cite{x+y}
31119 as the value of a function. You can use @code{return} anywhere
31120 inside the body of the function.
31123 Non-integer numbers (and extremely large integers) cannot be included
31124 directly into a @code{defmath} definition. This is because the Lisp
31125 reader will fail to parse them long before @code{defmath} ever gets control.
31126 Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic
31127 formula can go between the quotes. For example,
31130 (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
31138 (defun calcFunc-sqexp (x)
31139 (and (math-numberp x)
31140 (calcFunc-exp (math-mul x '(float 5 -1)))))
31143 Note the use of @code{numberp} as a guard to ensure that the argument is
31144 a number first, returning @code{nil} if not. The exponential function
31145 could itself have been included in the expression, if we had preferred:
31146 @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion
31147 step of @code{myfact} could have been written
31153 If a file named @file{.emacs} exists in your home directory, Emacs reads
31154 and executes the Lisp forms in this file as it starts up. While it may
31155 seem like a good idea to put your favorite @code{defmath} commands here,
31156 this has the unfortunate side-effect that parts of the Calculator must be
31157 loaded in to process the @code{defmath} commands whether or not you will
31158 actually use the Calculator! A better effect can be had by writing
31161 (put 'calc-define 'thing '(progn
31168 @vindex calc-define
31169 The @code{put} function adds a @dfn{property} to a symbol. Each Lisp
31170 symbol has a list of properties associated with it. Here we add a
31171 property with a name of @code{thing} and a @samp{(progn ...)} form as
31172 its value. When Calc starts up, and at the start of every Calc command,
31173 the property list for the symbol @code{calc-define} is checked and the
31174 values of any properties found are evaluated as Lisp forms. The
31175 properties are removed as they are evaluated. The property names
31176 (like @code{thing}) are not used; you should choose something like the
31177 name of your project so as not to conflict with other properties.
31179 The net effect is that you can put the above code in your @file{.emacs}
31180 file and it will not be executed until Calc is loaded. Or, you can put
31181 that same code in another file which you load by hand either before or
31182 after Calc itself is loaded.
31184 The properties of @code{calc-define} are evaluated in the same order
31185 that they were added. They can assume that the Calc modules @file{calc.el},
31186 @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
31187 that the @samp{*Calculator*} buffer will be the current buffer.
31189 If your @code{calc-define} property only defines algebraic functions,
31190 you can be sure that it will have been evaluated before Calc tries to
31191 call your function, even if the file defining the property is loaded
31192 after Calc is loaded. But if the property defines commands or key
31193 sequences, it may not be evaluated soon enough. (Suppose it defines the
31194 new command @code{tweak-calc}; the user can load your file, then type
31195 @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To
31196 protect against this situation, you can put
31199 (run-hooks 'calc-check-defines)
31202 @findex calc-check-defines
31204 at the end of your file. The @code{calc-check-defines} function is what
31205 looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
31206 has the advantage that it is quietly ignored if @code{calc-check-defines}
31207 is not yet defined because Calc has not yet been loaded.
31209 Examples of things that ought to be enclosed in a @code{calc-define}
31210 property are @code{defmath} calls, @code{define-key} calls that modify
31211 the Calc key map, and any calls that redefine things defined inside Calc.
31212 Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
31214 @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
31215 @subsection Defining New Simple Commands
31218 @findex interactive
31219 If a @code{defmath} form contains an @code{interactive} clause, it defines
31220 a Calculator command. Actually such a @code{defmath} results in @emph{two}
31221 function definitions: One, a @samp{calcFunc-} function as was just described,
31222 with the @code{interactive} clause removed. Two, a @samp{calc-} function
31223 with a suitable @code{interactive} clause and some sort of wrapper to make
31224 the command work in the Calc environment.
31226 In the simple case, the @code{interactive} clause has the same form as
31227 for normal Emacs Lisp commands:
31230 (defmath increase-precision (delta)
31231 "Increase precision by DELTA." ; This is the "documentation string"
31232 (interactive "p") ; Register this as a M-x-able command
31233 (setq calc-internal-prec (+ calc-internal-prec delta)))
31236 This expands to the pair of definitions,
31239 (defun calc-increase-precision (delta)
31240 "Increase precision by DELTA."
31243 (setq calc-internal-prec (math-add calc-internal-prec delta))))
31245 (defun calcFunc-increase-precision (delta)
31246 "Increase precision by DELTA."
31247 (setq calc-internal-prec (math-add calc-internal-prec delta)))
31251 where in this case the latter function would never really be used! Note
31252 that since the Calculator stores small integers as plain Lisp integers,
31253 the @code{math-add} function will work just as well as the native
31254 @code{+} even when the intent is to operate on native Lisp integers.
31256 @findex calc-wrapper
31257 The @samp{calc-wrapper} call invokes a macro which surrounds the body of
31258 the function with code that looks roughly like this:
31261 (let ((calc-command-flags nil))
31264 (calc-select-buffer)
31265 @emph{body of function}
31266 @emph{renumber stack}
31267 @emph{clear} Working @emph{message})
31268 @emph{realign cursor and window}
31269 @emph{clear Inverse, Hyperbolic, and Keep Args flags}
31270 @emph{update Emacs mode line}))
31273 @findex calc-select-buffer
31274 The @code{calc-select-buffer} function selects the @samp{*Calculator*}
31275 buffer if necessary, say, because the command was invoked from inside
31276 the @samp{*Calc Trail*} window.
31278 @findex calc-set-command-flag
31279 You can call, for example, @code{(calc-set-command-flag 'no-align)} to
31280 set the above-mentioned command flags. Calc routines recognize the
31281 following command flags:
31285 Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
31286 after this command completes. This is set by routines like
31289 @item clear-message
31290 Calc should call @samp{(message "")} if this command completes normally
31291 (to clear a ``Working@dots{}'' message out of the echo area).
31294 Do not move the cursor back to the @samp{.} top-of-stack marker.
31296 @item position-point
31297 Use the variables @code{calc-position-point-line} and
31298 @code{calc-position-point-column} to position the cursor after
31299 this command finishes.
31302 Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
31303 and @code{calc-keep-args-flag} at the end of this command.
31306 Switch to buffer @samp{*Calc Edit*} after this command.
31309 Do not move trail pointer to end of trail when something is recorded
31315 @vindex calc-Y-help-msgs
31316 Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
31317 extensions to Calc. There are no built-in commands that work with
31318 this prefix key; you must call @code{define-key} from Lisp (probably
31319 from inside a @code{calc-define} property) to add to it. Initially only
31320 @kbd{Y ?} is defined; it takes help messages from a list of strings
31321 (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All
31322 other undefined keys except for @kbd{Y} are reserved for use by
31323 future versions of Calc.
31325 If you are writing a Calc enhancement which you expect to give to
31326 others, it is best to minimize the number of @kbd{Y}-key sequences
31327 you use. In fact, if you have more than one key sequence you should
31328 consider defining three-key sequences with a @kbd{Y}, then a key that
31329 stands for your package, then a third key for the particular command
31330 within your package.
31332 Users may wish to install several Calc enhancements, and it is possible
31333 that several enhancements will choose to use the same key. In the
31334 example below, a variable @code{inc-prec-base-key} has been defined
31335 to contain the key that identifies the @code{inc-prec} package. Its
31336 value is initially @code{"P"}, but a user can change this variable
31337 if necessary without having to modify the file.
31339 Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
31340 command that increases the precision, and a @kbd{Y P D} command that
31341 decreases the precision.
31344 ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91.
31345 ;;; (Include copyright or copyleft stuff here.)
31347 (defvar inc-prec-base-key "P"
31348 "Base key for inc-prec.el commands.")
31350 (put 'calc-define 'inc-prec '(progn
31352 (define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
31353 'increase-precision)
31354 (define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
31355 'decrease-precision)
31357 (setq calc-Y-help-msgs
31358 (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
31361 (defmath increase-precision (delta)
31362 "Increase precision by DELTA."
31364 (setq calc-internal-prec (+ calc-internal-prec delta)))
31366 (defmath decrease-precision (delta)
31367 "Decrease precision by DELTA."
31369 (setq calc-internal-prec (- calc-internal-prec delta)))
31371 )) ; end of calc-define property
31373 (run-hooks 'calc-check-defines)
31376 @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
31377 @subsection Defining New Stack-Based Commands
31380 To define a new computational command which takes and/or leaves arguments
31381 on the stack, a special form of @code{interactive} clause is used.
31384 (interactive @var{num} @var{tag})
31388 where @var{num} is an integer, and @var{tag} is a string. The effect is
31389 to pop @var{num} values off the stack, resimplify them by calling
31390 @code{calc-normalize}, and hand them to your function according to the
31391 function's argument list. Your function may include @code{&optional} and
31392 @code{&rest} parameters, so long as calling the function with @var{num}
31393 parameters is legal.
31395 Your function must return either a number or a formula in a form
31396 acceptable to Calc, or a list of such numbers or formulas. These value(s)
31397 are pushed onto the stack when the function completes. They are also
31398 recorded in the Calc Trail buffer on a line beginning with @var{tag},
31399 a string of (normally) four characters or less. If you omit @var{tag}
31400 or use @code{nil} as a tag, the result is not recorded in the trail.
31402 As an example, the definition
31405 (defmath myfact (n)
31406 "Compute the factorial of the integer at the top of the stack."
31407 (interactive 1 "fact")
31409 (* n (myfact (1- n)))
31414 is a version of the factorial function shown previously which can be used
31415 as a command as well as an algebraic function. It expands to
31418 (defun calc-myfact ()
31419 "Compute the factorial of the integer at the top of the stack."
31422 (calc-enter-result 1 "fact"
31423 (cons 'calcFunc-myfact (calc-top-list-n 1)))))
31425 (defun calcFunc-myfact (n)
31426 "Compute the factorial of the integer at the top of the stack."
31428 (math-mul n (calcFunc-myfact (math-add n -1)))
31429 (and (math-zerop n) 1)))
31432 @findex calc-slow-wrapper
31433 The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
31434 that automatically puts up a @samp{Working...} message before the
31435 computation begins. (This message can be turned off by the user
31436 with an @kbd{m w} (@code{calc-working}) command.)
31438 @findex calc-top-list-n
31439 The @code{calc-top-list-n} function returns a list of the specified number
31440 of values from the top of the stack. It resimplifies each value by
31441 calling @code{calc-normalize}. If its argument is zero it returns an
31442 empty list. It does not actually remove these values from the stack.
31444 @findex calc-enter-result
31445 The @code{calc-enter-result} function takes an integer @var{num} and string
31446 @var{tag} as described above, plus a third argument which is either a
31447 Calculator data object or a list of such objects. These objects are
31448 resimplified and pushed onto the stack after popping the specified number
31449 of values from the stack. If @var{tag} is non-@code{nil}, the values
31450 being pushed are also recorded in the trail.
31452 Note that if @code{calcFunc-myfact} returns @code{nil} this represents
31453 ``leave the function in symbolic form.'' To return an actual empty list,
31454 in the sense that @code{calc-enter-result} will push zero elements back
31455 onto the stack, you should return the special value @samp{'(nil)}, a list
31456 containing the single symbol @code{nil}.
31458 The @code{interactive} declaration can actually contain a limited
31459 Emacs-style code string as well which comes just before @var{num} and
31460 @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in
31463 (defmath foo (a b &optional c)
31464 (interactive "p" 2 "foo")
31468 In this example, the command @code{calc-foo} will evaluate the expression
31469 @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
31470 executed with a numeric prefix argument of @cite{n}.
31472 The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
31473 code as used with @code{defun}). It uses the numeric prefix argument as the
31474 number of objects to remove from the stack and pass to the function.
31475 In this case, the integer @var{num} serves as a default number of
31476 arguments to be used when no prefix is supplied.
31478 @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
31479 @subsection Argument Qualifiers
31482 Anywhere a parameter name can appear in the parameter list you can also use
31483 an @dfn{argument qualifier}. Thus the general form of a definition is:
31486 (defmath @var{name} (@var{param} @var{param...}
31487 &optional @var{param} @var{param...}
31493 where each @var{param} is either a symbol or a list of the form
31496 (@var{qual} @var{param})
31499 The following qualifiers are recognized:
31504 The argument must not be an incomplete vector, interval, or complex number.
31505 (This is rarely needed since the Calculator itself will never call your
31506 function with an incomplete argument. But there is nothing stopping your
31507 own Lisp code from calling your function with an incomplete argument.)@refill
31511 The argument must be an integer. If it is an integer-valued float
31512 it will be accepted but converted to integer form. Non-integers and
31513 formulas are rejected.
31517 Like @samp{integer}, but the argument must be non-negative.
31521 Like @samp{integer}, but the argument must fit into a native Lisp integer,
31522 which on most systems means less than 2^23 in absolute value. The
31523 argument is converted into Lisp-integer form if necessary.
31527 The argument is converted to floating-point format if it is a number or
31528 vector. If it is a formula it is left alone. (The argument is never
31529 actually rejected by this qualifier.)
31532 The argument must satisfy predicate @var{pred}, which is one of the
31533 standard Calculator predicates. @xref{Predicates}.
31535 @item not-@var{pred}
31536 The argument must @emph{not} satisfy predicate @var{pred}.
31542 (defmath foo (a (constp (not-matrixp b)) &optional (float c)
31551 (defun calcFunc-foo (a b &optional c &rest d)
31552 (and (math-matrixp b)
31553 (math-reject-arg b 'not-matrixp))
31554 (or (math-constp b)
31555 (math-reject-arg b 'constp))
31556 (and c (setq c (math-check-float c)))
31557 (setq d (mapcar 'math-check-integer d))
31562 which performs the necessary checks and conversions before executing the
31563 body of the function.
31565 @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
31566 @subsection Example Definitions
31569 This section includes some Lisp programming examples on a larger scale.
31570 These programs make use of some of the Calculator's internal functions;
31574 * Bit Counting Example::
31578 @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
31579 @subsubsection Bit-Counting
31586 Calc does not include a built-in function for counting the number of
31587 ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u}
31588 to convert the integer to a set, and @kbd{V #} to count the elements of
31589 that set; let's write a function that counts the bits without having to
31590 create an intermediate set.
31593 (defmath bcount ((natnum n))
31594 (interactive 1 "bcnt")
31598 (setq count (1+ count)))
31599 (setq n (lsh n -1)))
31604 When this is expanded by @code{defmath}, it will become the following
31605 Emacs Lisp function:
31608 (defun calcFunc-bcount (n)
31609 (setq n (math-check-natnum n))
31611 (while (math-posp n)
31613 (setq count (math-add count 1)))
31614 (setq n (calcFunc-lsh n -1)))
31618 If the input numbers are large, this function involves a fair amount
31619 of arithmetic. A binary right shift is essentially a division by two;
31620 recall that Calc stores integers in decimal form so bit shifts must
31621 involve actual division.
31623 To gain a bit more efficiency, we could divide the integer into
31624 @var{n}-bit chunks, each of which can be handled quickly because
31625 they fit into Lisp integers. It turns out that Calc's arithmetic
31626 routines are especially fast when dividing by an integer less than
31627 1000, so we can set @var{n = 9} bits and use repeated division by 512:
31630 (defmath bcount ((natnum n))
31631 (interactive 1 "bcnt")
31633 (while (not (fixnump n))
31634 (let ((qr (idivmod n 512)))
31635 (setq count (+ count (bcount-fixnum (cdr qr)))
31637 (+ count (bcount-fixnum n))))
31639 (defun bcount-fixnum (n)
31642 (setq count (+ count (logand n 1))
31648 Note that the second function uses @code{defun}, not @code{defmath}.
31649 Because this function deals only with native Lisp integers (``fixnums''),
31650 it can use the actual Emacs @code{+} and related functions rather
31651 than the slower but more general Calc equivalents which @code{defmath}
31654 The @code{idivmod} function does an integer division, returning both
31655 the quotient and the remainder at once. Again, note that while it
31656 might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
31657 more efficient ways to split off the bottom nine bits of @code{n},
31658 actually they are less efficient because each operation is really
31659 a division by 512 in disguise; @code{idivmod} allows us to do the
31660 same thing with a single division by 512.
31662 @node Sine Example, , Bit Counting Example, Example Definitions
31663 @subsubsection The Sine Function
31670 A somewhat limited sine function could be defined as follows, using the
31671 well-known Taylor series expansion for @c{$\sin x$}
31675 (defmath mysin ((float (anglep x)))
31676 (interactive 1 "mysn")
31677 (setq x (to-radians x)) ; Convert from current angular mode.
31678 (let ((sum x) ; Initial term of Taylor expansion of sin.
31680 (nfact 1) ; "nfact" equals "n" factorial at all times.
31681 (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
31682 (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution.
31683 (working "mysin" sum) ; Display "Working" message, if enabled.
31684 (setq nfact (* nfact (1- n) n)
31686 newsum (+ sum (/ x nfact)))
31687 (if (~= newsum sum) ; If newsum is "nearly equal to" sum,
31688 (break)) ; then we are done.
31693 The actual @code{sin} function in Calc works by first reducing the problem
31694 to a sine or cosine of a nonnegative number less than @c{$\pi \over 4$}
31696 ensures that the Taylor series will converge quickly. Also, the calculation
31697 is carried out with two extra digits of precision to guard against cumulative
31698 round-off in @samp{sum}. Finally, complex arguments are allowed and handled
31699 by a separate algorithm.
31702 (defmath mysin ((float (scalarp x)))
31703 (interactive 1 "mysn")
31704 (setq x (to-radians x)) ; Convert from current angular mode.
31705 (with-extra-prec 2 ; Evaluate with extra precision.
31706 (cond ((complexp x)
31709 (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0.
31710 (t (mysin-raw x))))))
31712 (defmath mysin-raw (x)
31714 (mysin-raw (% x (two-pi)))) ; Now x < 7.
31716 (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2.
31718 (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4.
31719 ((< x (- (pi-over-4)))
31720 (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4,
31721 (t (mysin-series x)))) ; so the series will be efficient.
31725 where @code{mysin-complex} is an appropriate function to handle complex
31726 numbers, @code{mysin-series} is the routine to compute the sine Taylor
31727 series as before, and @code{mycos-raw} is a function analogous to
31728 @code{mysin-raw} for cosines.
31730 The strategy is to ensure that @cite{x} is nonnegative before calling
31731 @code{mysin-raw}. This function then recursively reduces its argument
31732 to a suitable range, namely, plus-or-minus @c{$\pi \over 4$}
31733 @cite{pi/4}. Note that each
31734 test, and particularly the first comparison against 7, is designed so
31735 that small roundoff errors cannot produce an infinite loop. (Suppose
31736 we compared with @samp{(two-pi)} instead; if due to roundoff problems
31737 the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
31738 recursion could result!) We use modulo only for arguments that will
31739 clearly get reduced, knowing that the next rule will catch any reductions
31740 that this rule misses.
31742 If a program is being written for general use, it is important to code
31743 it carefully as shown in this second example. For quick-and-dirty programs,
31744 when you know that your own use of the sine function will never encounter
31745 a large argument, a simpler program like the first one shown is fine.
31747 @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
31748 @subsection Calling Calc from Your Lisp Programs
31751 A later section (@pxref{Internals}) gives a full description of
31752 Calc's internal Lisp functions. It's not hard to call Calc from
31753 inside your programs, but the number of these functions can be daunting.
31754 So Calc provides one special ``programmer-friendly'' function called
31755 @code{calc-eval} that can be made to do just about everything you
31756 need. It's not as fast as the low-level Calc functions, but it's
31757 much simpler to use!
31759 It may seem that @code{calc-eval} itself has a daunting number of
31760 options, but they all stem from one simple operation.
31762 In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
31763 string @code{"1+2"} as if it were a Calc algebraic entry and returns
31764 the result formatted as a string: @code{"3"}.
31766 Since @code{calc-eval} is on the list of recommended @code{autoload}
31767 functions, you don't need to make any special preparations to load
31768 Calc before calling @code{calc-eval} the first time. Calc will be
31769 loaded and initialized for you.
31771 All the Calc modes that are currently in effect will be used when
31772 evaluating the expression and formatting the result.
31779 @subsubsection Additional Arguments to @code{calc-eval}
31782 If the input string parses to a list of expressions, Calc returns
31783 the results separated by @code{", "}. You can specify a different
31784 separator by giving a second string argument to @code{calc-eval}:
31785 @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
31787 The ``separator'' can also be any of several Lisp symbols which
31788 request other behaviors from @code{calc-eval}. These are discussed
31791 You can give additional arguments to be substituted for
31792 @samp{$}, @samp{$$}, and so on in the main expression. For
31793 example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
31794 expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
31795 (assuming Fraction mode is not in effect). Note the @code{nil}
31796 used as a placeholder for the item-separator argument.
31803 @subsubsection Error Handling
31806 If @code{calc-eval} encounters an error, it returns a list containing
31807 the character position of the error, plus a suitable message as a
31808 string. Note that @samp{1 / 0} is @emph{not} an error by Calc's
31809 standards; it simply returns the string @code{"1 / 0"} which is the
31810 division left in symbolic form. But @samp{(calc-eval "1/")} will
31811 return the list @samp{(2 "Expected a number")}.
31813 If you bind the variable @code{calc-eval-error} to @code{t}
31814 using a @code{let} form surrounding the call to @code{calc-eval},
31815 errors instead call the Emacs @code{error} function which aborts
31816 to the Emacs command loop with a beep and an error message.
31818 If you bind this variable to the symbol @code{string}, error messages
31819 are returned as strings instead of lists. The character position is
31822 As a courtesy to other Lisp code which may be using Calc, be sure
31823 to bind @code{calc-eval-error} using @code{let} rather than changing
31824 it permanently with @code{setq}.
31831 @subsubsection Numbers Only
31834 Sometimes it is preferable to treat @samp{1 / 0} as an error
31835 rather than returning a symbolic result. If you pass the symbol
31836 @code{num} as the second argument to @code{calc-eval}, results
31837 that are not constants are treated as errors. The error message
31838 reported is the first @code{calc-why} message if there is one,
31839 or otherwise ``Number expected.''
31841 A result is ``constant'' if it is a number, vector, or other
31842 object that does not include variables or function calls. If it
31843 is a vector, the components must themselves be constants.
31850 @subsubsection Default Modes
31853 If the first argument to @code{calc-eval} is a list whose first
31854 element is a formula string, then @code{calc-eval} sets all the
31855 various Calc modes to their default values while the formula is
31856 evaluated and formatted. For example, the precision is set to 12
31857 digits, digit grouping is turned off, and the normal language
31860 This same principle applies to the other options discussed below.
31861 If the first argument would normally be @var{x}, then it can also
31862 be the list @samp{(@var{x})} to use the default mode settings.
31864 If there are other elements in the list, they are taken as
31865 variable-name/value pairs which override the default mode
31866 settings. Look at the documentation at the front of the
31867 @file{calc.el} file to find the names of the Lisp variables for
31868 the various modes. The mode settings are restored to their
31869 original values when @code{calc-eval} is done.
31871 For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
31872 computes the sum of two numbers, requiring a numeric result, and
31873 using default mode settings except that the precision is 8 instead
31874 of the default of 12.
31876 It's usually best to use this form of @code{calc-eval} unless your
31877 program actually considers the interaction with Calc's mode settings
31878 to be a feature. This will avoid all sorts of potential ``gotchas'';
31879 consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
31880 when the user has left Calc in symbolic mode or no-simplify mode.
31882 As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
31883 checks if the number in string @cite{a} is less than the one in
31884 string @cite{b}. Without using a list, the integer 1 might
31885 come out in a variety of formats which would be hard to test for
31886 conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But
31887 see ``Predicates'' mode, below.)
31894 @subsubsection Raw Numbers
31897 Normally all input and output for @code{calc-eval} is done with strings.
31898 You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
31899 in place of @samp{(+ a b)}, but this is very inefficient since the
31900 numbers must be converted to and from string format as they are passed
31901 from one @code{calc-eval} to the next.
31903 If the separator is the symbol @code{raw}, the result will be returned
31904 as a raw Calc data structure rather than a string. You can read about
31905 how these objects look in the following sections, but usually you can
31906 treat them as ``black box'' objects with no important internal
31909 There is also a @code{rawnum} symbol, which is a combination of
31910 @code{raw} (returning a raw Calc object) and @code{num} (signaling
31911 an error if that object is not a constant).
31913 You can pass a raw Calc object to @code{calc-eval} in place of a
31914 string, either as the formula itself or as one of the @samp{$}
31915 arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
31916 addition function that operates on raw Calc objects. Of course
31917 in this case it would be easier to call the low-level @code{math-add}
31918 function in Calc, if you can remember its name.
31920 In particular, note that a plain Lisp integer is acceptable to Calc
31921 as a raw object. (All Lisp integers are accepted on input, but
31922 integers of more than six decimal digits are converted to ``big-integer''
31923 form for output. @xref{Data Type Formats}.)
31925 When it comes time to display the object, just use @samp{(calc-eval a)}
31926 to format it as a string.
31928 It is an error if the input expression evaluates to a list of
31929 values. The separator symbol @code{list} is like @code{raw}
31930 except that it returns a list of one or more raw Calc objects.
31932 Note that a Lisp string is not a valid Calc object, nor is a list
31933 containing a string. Thus you can still safely distinguish all the
31934 various kinds of error returns discussed above.
31941 @subsubsection Predicates
31944 If the separator symbol is @code{pred}, the result of the formula is
31945 treated as a true/false value; @code{calc-eval} returns @code{t} or
31946 @code{nil}, respectively. A value is considered ``true'' if it is a
31947 non-zero number, or false if it is zero or if it is not a number.
31949 For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
31950 one value is less than another.
31952 As usual, it is also possible for @code{calc-eval} to return one of
31953 the error indicators described above. Lisp will interpret such an
31954 indicator as ``true'' if you don't check for it explicitly. If you
31955 wish to have an error register as ``false'', use something like
31956 @samp{(eq (calc-eval ...) t)}.
31963 @subsubsection Variable Values
31966 Variables in the formula passed to @code{calc-eval} are not normally
31967 replaced by their values. If you wish this, you can use the
31968 @code{evalv} function (@pxref{Algebraic Manipulation}). For example,
31969 if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
31970 @code{var-a}), then @samp{(calc-eval "a+pi")} will return the
31971 formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
31972 will return @code{"7.14159265359"}.
31974 To store in a Calc variable, just use @code{setq} to store in the
31975 corresponding Lisp variable. (This is obtained by prepending
31976 @samp{var-} to the Calc variable name.) Calc routines will
31977 understand either string or raw form values stored in variables,
31978 although raw data objects are much more efficient. For example,
31979 to increment the Calc variable @code{a}:
31982 (setq var-a (calc-eval "evalv(a+1)" 'raw))
31990 @subsubsection Stack Access
31993 If the separator symbol is @code{push}, the formula argument is
31994 evaluated (with possible @samp{$} expansions, as usual). The
31995 result is pushed onto the Calc stack. The return value is @code{nil}
31996 (unless there is an error from evaluating the formula, in which
31997 case the return value depends on @code{calc-eval-error} in the
32000 If the separator symbol is @code{pop}, the first argument to
32001 @code{calc-eval} must be an integer instead of a string. That
32002 many values are popped from the stack and thrown away. A negative
32003 argument deletes the entry at that stack level. The return value
32004 is the number of elements remaining in the stack after popping;
32005 @samp{(calc-eval 0 'pop)} is a good way to measure the size of
32008 If the separator symbol is @code{top}, the first argument to
32009 @code{calc-eval} must again be an integer. The value at that
32010 stack level is formatted as a string and returned. Thus
32011 @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the
32012 integer is out of range, @code{nil} is returned.
32014 The separator symbol @code{rawtop} is just like @code{top} except
32015 that the stack entry is returned as a raw Calc object instead of
32018 In all of these cases the first argument can be made a list in
32019 order to force the default mode settings, as described above.
32020 Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
32021 second-to-top stack entry, formatted as a string using the default
32022 instead of current display modes, except that the radix is
32023 hexadecimal instead of decimal.
32025 It is, of course, polite to put the Calc stack back the way you
32026 found it when you are done, unless the user of your program is
32027 actually expecting it to affect the stack.
32029 Note that you do not actually have to switch into the @samp{*Calculator*}
32030 buffer in order to use @code{calc-eval}; it temporarily switches into
32031 the stack buffer if necessary.
32038 @subsubsection Keyboard Macros
32041 If the separator symbol is @code{macro}, the first argument must be a
32042 string of characters which Calc can execute as a sequence of keystrokes.
32043 This switches into the Calc buffer for the duration of the macro.
32044 For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
32045 vector @samp{[1,2,3,4,5]} on the stack and then replaces it
32046 with the sum of those numbers. Note that @samp{\r} is the Lisp
32047 notation for the carriage-return, @key{RET}, character.
32049 If your keyboard macro wishes to pop the stack, @samp{\C-d} is
32050 safer than @samp{\177} (the @key{DEL} character) because some
32051 installations may have switched the meanings of @key{DEL} and
32052 @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for
32053 ``pop-stack'' regardless of key mapping.
32055 If you provide a third argument to @code{calc-eval}, evaluation
32056 of the keyboard macro will leave a record in the Trail using
32057 that argument as a tag string. Normally the Trail is unaffected.
32059 The return value in this case is always @code{nil}.
32066 @subsubsection Lisp Evaluation
32069 Finally, if the separator symbol is @code{eval}, then the Lisp
32070 @code{eval} function is called on the first argument, which must
32071 be a Lisp expression rather than a Calc formula. Remember to
32072 quote the expression so that it is not evaluated until inside
32075 The difference from plain @code{eval} is that @code{calc-eval}
32076 switches to the Calc buffer before evaluating the expression.
32077 For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
32078 will correctly affect the buffer-local Calc precision variable.
32080 An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
32081 This is evaluating a call to the function that is normally invoked
32082 by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
32083 Note that this function will leave a message in the echo area as
32084 a side effect. Also, all Calc functions switch to the Calc buffer
32085 automatically if not invoked from there, so the above call is
32086 also equivalent to @samp{(calc-precision 17)} by itself.
32087 In all cases, Calc uses @code{save-excursion} to switch back to
32088 your original buffer when it is done.
32090 As usual the first argument can be a list that begins with a Lisp
32091 expression to use default instead of current mode settings.
32093 The result of @code{calc-eval} in this usage is just the result
32094 returned by the evaluated Lisp expression.
32101 @subsubsection Example
32104 @findex convert-temp
32105 Here is a sample Emacs command that uses @code{calc-eval}. Suppose
32106 you have a document with lots of references to temperatures on the
32107 Fahrenheit scale, say ``98.6 F'', and you wish to convert these
32108 references to Centigrade. The following command does this conversion.
32109 Place the Emacs cursor right after the letter ``F'' and invoke the
32110 command to change ``98.6 F'' to ``37 C''. Or, if the temperature is
32111 already in Centigrade form, the command changes it back to Fahrenheit.
32114 (defun convert-temp ()
32117 (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
32118 (let* ((top1 (match-beginning 1))
32119 (bot1 (match-end 1))
32120 (number (buffer-substring top1 bot1))
32121 (top2 (match-beginning 2))
32122 (bot2 (match-end 2))
32123 (type (buffer-substring top2 bot2)))
32124 (if (equal type "F")
32126 number (calc-eval "($ - 32)*5/9" nil number))
32128 number (calc-eval "$*9/5 + 32" nil number)))
32130 (delete-region top2 bot2)
32131 (insert-before-markers type)
32133 (delete-region top1 bot1)
32134 (if (string-match "\\.$" number) ; change "37." to "37"
32135 (setq number (substring number 0 -1)))
32139 Note the use of @code{insert-before-markers} when changing between
32140 ``F'' and ``C'', so that the character winds up before the cursor
32141 instead of after it.
32143 @node Internals, , Calling Calc from Your Programs, Lisp Definitions
32144 @subsection Calculator Internals
32147 This section describes the Lisp functions defined by the Calculator that
32148 may be of use to user-written Calculator programs (as described in the
32149 rest of this chapter). These functions are shown by their names as they
32150 conventionally appear in @code{defmath}. Their full Lisp names are
32151 generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
32152 apparent names. (Names that begin with @samp{calc-} are already in
32153 their full Lisp form.) You can use the actual full names instead if you
32154 prefer them, or if you are calling these functions from regular Lisp.
32156 The functions described here are scattered throughout the various
32157 Calc component files. Note that @file{calc.el} includes @code{autoload}s
32158 for only a few component files; when Calc wants to call an advanced
32159 function it calls @samp{(calc-extensions)} first; this function
32160 autoloads @file{calc-ext.el}, which in turn autoloads all the functions
32161 in the remaining component files.
32163 Because @code{defmath} itself uses the extensions, user-written code
32164 generally always executes with the extensions already loaded, so
32165 normally you can use any Calc function and be confident that it will
32166 be autoloaded for you when necessary. If you are doing something
32167 special, check carefully to make sure each function you are using is
32168 from @file{calc.el} or its components, and call @samp{(calc-extensions)}
32169 before using any function based in @file{calc-ext.el} if you can't
32170 prove this file will already be loaded.
32173 * Data Type Formats::
32174 * Interactive Lisp Functions::
32175 * Stack Lisp Functions::
32177 * Computational Lisp Functions::
32178 * Vector Lisp Functions::
32179 * Symbolic Lisp Functions::
32180 * Formatting Lisp Functions::
32184 @node Data Type Formats, Interactive Lisp Functions, Internals, Internals
32185 @subsubsection Data Type Formats
32188 Integers are stored in either of two ways, depending on their magnitude.
32189 Integers less than one million in absolute value are stored as standard
32190 Lisp integers. This is the only storage format for Calc data objects
32191 which is not a Lisp list.
32193 Large integers are stored as lists of the form @samp{(bigpos @var{d0}
32194 @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or
32195 @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers
32196 @i{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer
32197 from 0 to 999. The least significant digit is @var{d0}; the last digit,
32198 @var{dn}, which is always nonzero, is the most significant digit. For
32199 example, the integer @i{-12345678} is stored as @samp{(bigneg 678 345 12)}.
32201 The distinction between small and large integers is entirely hidden from
32202 the user. In @code{defmath} definitions, the Lisp predicate @code{integerp}
32203 returns true for either kind of integer, and in general both big and small
32204 integers are accepted anywhere the word ``integer'' is used in this manual.
32205 If the distinction must be made, native Lisp integers are called @dfn{fixnums}
32206 and large integers are called @dfn{bignums}.
32208 Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
32209 where @var{n} is an integer (big or small) numerator, @var{d} is an
32210 integer denominator greater than one, and @var{n} and @var{d} are relatively
32211 prime. Note that fractions where @var{d} is one are automatically converted
32212 to plain integers by all math routines; fractions where @var{d} is negative
32213 are normalized by negating the numerator and denominator.
32215 Floating-point numbers are stored in the form, @samp{(float @var{mant}
32216 @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
32217 @samp{10^@var{p}} in absolute value (@var{p} represents the current
32218 precision), and @var{exp} (the ``exponent'') is a fixnum. The value of
32219 the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number
32220 @i{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints
32221 are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
32222 except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
32223 always nonzero. (If the rightmost digit is zero, the number is
32224 rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)@refill
32226 Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
32227 @var{im})}, where @var{re} and @var{im} are each real numbers, either
32228 integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}.
32229 The @var{im} part is nonzero; complex numbers with zero imaginary
32230 components are converted to real numbers automatically.@refill
32232 Polar complex numbers are stored in the form @samp{(polar @var{r}
32233 @var{theta})}, where @var{r} is a positive real value and @var{theta}
32234 is a real value or HMS form representing an angle. This angle is
32235 usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
32236 or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
32237 If the angle is 0 the value is converted to a real number automatically.
32238 (If the angle is 180 degrees, the value is usually also converted to a
32239 negative real number.)@refill
32241 Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
32242 @var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
32243 a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
32244 float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
32245 in the range @samp{[0 ..@: 60)}.@refill
32247 Date forms are stored as @samp{(date @var{n})}, where @var{n} is
32248 a real number that counts days since midnight on the morning of
32249 January 1, 1 AD. If @var{n} is an integer, this is a pure date
32250 form. If @var{n} is a fraction or float, this is a date/time form.
32252 Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
32253 positive real number or HMS form, and @var{n} is a real number or HMS
32254 form in the range @samp{[0 ..@: @var{m})}.
32256 Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
32257 is the mean value and @var{sigma} is the standard deviation. Each
32258 component is either a number, an HMS form, or a symbolic object
32259 (a variable or function call). If @var{sigma} is zero, the value is
32260 converted to a plain real number. If @var{sigma} is negative or
32261 complex, it is automatically normalized to be a positive real.
32263 Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
32264 where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
32265 @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask}
32266 is a binary integer where 1 represents the fact that the interval is
32267 closed on the high end, and 2 represents the fact that it is closed on
32268 the low end. (Thus 3 represents a fully closed interval.) The interval
32269 @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
32270 intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
32271 represent empty intervals. If @var{hi} is less than @var{lo}, the interval
32272 is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
32274 Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
32275 is the first element of the vector, @var{v2} is the second, and so on.
32276 An empty vector is stored as @samp{(vec)}. A matrix is simply a vector
32277 where all @var{v}'s are themselves vectors of equal lengths. Note that
32278 Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
32279 generally unused by Calc data structures.
32281 Variables are stored as @samp{(var @var{name} @var{sym})}, where
32282 @var{name} is a Lisp symbol whose print name is used as the visible name
32283 of the variable, and @var{sym} is a Lisp symbol in which the variable's
32284 value is actually stored. Thus, @samp{(var pi var-pi)} represents the
32285 special constant @samp{pi}. Almost always, the form is @samp{(var
32286 @var{v} var-@var{v})}. If the variable name was entered with @code{#}
32287 signs (which are converted to hyphens internally), the form is
32288 @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
32289 contains @code{#} characters, and @var{v} is a symbol that contains
32290 @code{-} characters instead. The value of a variable is the Calc
32291 object stored in its @var{sym} symbol's value cell. If the symbol's
32292 value cell is void or if it contains @code{nil}, the variable has no
32293 value. Special constants have the form @samp{(special-const
32294 @var{value})} stored in their value cell, where @var{value} is a formula
32295 which is evaluated when the constant's value is requested. Variables
32296 which represent units are not stored in any special way; they are units
32297 only because their names appear in the units table. If the value
32298 cell contains a string, it is parsed to get the variable's value when
32299 the variable is used.@refill
32301 A Lisp list with any other symbol as the first element is a function call.
32302 The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
32303 and @code{|} represent special binary operators; these lists are always
32304 of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
32305 sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
32306 right. The symbol @code{neg} represents unary negation; this list is always
32307 of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a
32308 function that would be displayed in function-call notation; the symbol
32309 @var{func} is in general always of the form @samp{calcFunc-@var{name}}.
32310 The function cell of the symbol @var{func} should contain a Lisp function
32311 for evaluating a call to @var{func}. This function is passed the remaining
32312 elements of the list (themselves already evaluated) as arguments; such
32313 functions should return @code{nil} or call @code{reject-arg} to signify
32314 that they should be left in symbolic form, or they should return a Calc
32315 object which represents their value, or a list of such objects if they
32316 wish to return multiple values. (The latter case is allowed only for
32317 functions which are the outer-level call in an expression whose value is
32318 about to be pushed on the stack; this feature is considered obsolete
32319 and is not used by any built-in Calc functions.)@refill
32321 @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
32322 @subsubsection Interactive Functions
32325 The functions described here are used in implementing interactive Calc
32326 commands. Note that this list is not exhaustive! If there is an
32327 existing command that behaves similarly to the one you want to define,
32328 you may find helpful tricks by checking the source code for that command.
32330 @defun calc-set-command-flag flag
32331 Set the command flag @var{flag}. This is generally a Lisp symbol, but
32332 may in fact be anything. The effect is to add @var{flag} to the list
32333 stored in the variable @code{calc-command-flags}, unless it is already
32334 there. @xref{Defining Simple Commands}.
32337 @defun calc-clear-command-flag flag
32338 If @var{flag} appears among the list of currently-set command flags,
32339 remove it from that list.
32342 @defun calc-record-undo rec
32343 Add the ``undo record'' @var{rec} to the list of steps to take if the
32344 current operation should need to be undone. Stack push and pop functions
32345 automatically call @code{calc-record-undo}, so the kinds of undo records
32346 you might need to create take the form @samp{(set @var{sym} @var{value})},
32347 which says that the Lisp variable @var{sym} was changed and had previously
32348 contained @var{value}; @samp{(store @var{var} @var{value})} which says that
32349 the Calc variable @var{var} (a string which is the name of the symbol that
32350 contains the variable's value) was stored and its previous value was
32351 @var{value} (either a Calc data object, or @code{nil} if the variable was
32352 previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
32353 which means that to undo requires calling the function @samp{(@var{undo}
32354 @var{args} @dots{})} and, if the undo is later redone, calling
32355 @samp{(@var{redo} @var{args} @dots{})}.@refill
32358 @defun calc-record-why msg args
32359 Record the error or warning message @var{msg}, which is normally a string.
32360 This message will be replayed if the user types @kbd{w} (@code{calc-why});
32361 if the message string begins with a @samp{*}, it is considered important
32362 enough to display even if the user doesn't type @kbd{w}. If one or more
32363 @var{args} are present, the displayed message will be of the form,
32364 @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
32365 formatted on the assumption that they are either strings or Calc objects of
32366 some sort. If @var{msg} is a symbol, it is the name of a Calc predicate
32367 (such as @code{integerp} or @code{numvecp}) which the arguments did not
32368 satisfy; it is expanded to a suitable string such as ``Expected an
32369 integer.'' The @code{reject-arg} function calls @code{calc-record-why}
32370 automatically; @pxref{Predicates}.@refill
32373 @defun calc-is-inverse
32374 This predicate returns true if the current command is inverse,
32375 i.e., if the Inverse (@kbd{I} key) flag was set.
32378 @defun calc-is-hyperbolic
32379 This predicate is the analogous function for the @kbd{H} key.
32382 @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
32383 @subsubsection Stack-Oriented Functions
32386 The functions described here perform various operations on the Calc
32387 stack and trail. They are to be used in interactive Calc commands.
32389 @defun calc-push-list vals n
32390 Push the Calc objects in list @var{vals} onto the stack at stack level
32391 @var{n}. If @var{n} is omitted it defaults to 1, so that the elements
32392 are pushed at the top of the stack. If @var{n} is greater than 1, the
32393 elements will be inserted into the stack so that the last element will
32394 end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
32395 The elements of @var{vals} are assumed to be valid Calc objects, and
32396 are not evaluated, rounded, or renormalized in any way. If @var{vals}
32397 is an empty list, nothing happens.@refill
32399 The stack elements are pushed without any sub-formula selections.
32400 You can give an optional third argument to this function, which must
32401 be a list the same size as @var{vals} of selections. Each selection
32402 must be @code{eq} to some sub-formula of the corresponding formula
32403 in @var{vals}, or @code{nil} if that formula should have no selection.
32406 @defun calc-top-list n m
32407 Return a list of the @var{n} objects starting at level @var{m} of the
32408 stack. If @var{m} is omitted it defaults to 1, so that the elements are
32409 taken from the top of the stack. If @var{n} is omitted, it also
32410 defaults to 1, so that the top stack element (in the form of a
32411 one-element list) is returned. If @var{m} is greater than 1, the
32412 @var{m}th stack element will be at the end of the list, the @var{m}+1st
32413 element will be next-to-last, etc. If @var{n} or @var{m} are out of
32414 range, the command is aborted with a suitable error message. If @var{n}
32415 is zero, the function returns an empty list. The stack elements are not
32416 evaluated, rounded, or renormalized.@refill
32418 If any stack elements contain selections, and selections have not
32419 been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
32420 this function returns the selected portions rather than the entire
32421 stack elements. It can be given a third ``selection-mode'' argument
32422 which selects other behaviors. If it is the symbol @code{t}, then
32423 a selection in any of the requested stack elements produces an
32424 ``illegal operation on selections'' error. If it is the symbol @code{full},
32425 the whole stack entry is always returned regardless of selections.
32426 If it is the symbol @code{sel}, the selected portion is always returned,
32427 or @code{nil} if there is no selection. (This mode ignores the @kbd{j e}
32428 command.) If the symbol is @code{entry}, the complete stack entry in
32429 list form is returned; the first element of this list will be the whole
32430 formula, and the third element will be the selection (or @code{nil}).
32433 @defun calc-pop-stack n m
32434 Remove the specified elements from the stack. The parameters @var{n}
32435 and @var{m} are defined the same as for @code{calc-top-list}. The return
32436 value of @code{calc-pop-stack} is uninteresting.
32438 If there are any selected sub-formulas among the popped elements, and
32439 @kbd{j e} has not been used to disable selections, this produces an
32440 error without changing the stack. If you supply an optional third
32441 argument of @code{t}, the stack elements are popped even if they
32442 contain selections.
32445 @defun calc-record-list vals tag
32446 This function records one or more results in the trail. The @var{vals}
32447 are a list of strings or Calc objects. The @var{tag} is the four-character
32448 tag string to identify the values. If @var{tag} is omitted, a blank tag
32452 @defun calc-normalize n
32453 This function takes a Calc object and ``normalizes'' it. At the very
32454 least this involves re-rounding floating-point values according to the
32455 current precision and other similar jobs. Also, unless the user has
32456 selected no-simplify mode (@pxref{Simplification Modes}), this involves
32457 actually evaluating a formula object by executing the function calls
32458 it contains, and possibly also doing algebraic simplification, etc.
32461 @defun calc-top-list-n n m
32462 This function is identical to @code{calc-top-list}, except that it calls
32463 @code{calc-normalize} on the values that it takes from the stack. They
32464 are also passed through @code{check-complete}, so that incomplete
32465 objects will be rejected with an error message. All computational
32466 commands should use this in preference to @code{calc-top-list}; the only
32467 standard Calc commands that operate on the stack without normalizing
32468 are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
32469 This function accepts the same optional selection-mode argument as
32470 @code{calc-top-list}.
32473 @defun calc-top-n m
32474 This function is a convenient form of @code{calc-top-list-n} in which only
32475 a single element of the stack is taken and returned, rather than a list
32476 of elements. This also accepts an optional selection-mode argument.
32479 @defun calc-enter-result n tag vals
32480 This function is a convenient interface to most of the above functions.
32481 The @var{vals} argument should be either a single Calc object, or a list
32482 of Calc objects; the object or objects are normalized, and the top @var{n}
32483 stack entries are replaced by the normalized objects. If @var{tag} is
32484 non-@code{nil}, the normalized objects are also recorded in the trail.
32485 A typical stack-based computational command would take the form,
32488 (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
32489 (calc-top-list-n @var{n})))
32492 If any of the @var{n} stack elements replaced contain sub-formula
32493 selections, and selections have not been disabled by @kbd{j e},
32494 this function takes one of two courses of action. If @var{n} is
32495 equal to the number of elements in @var{vals}, then each element of
32496 @var{vals} is spliced into the corresponding selection; this is what
32497 happens when you use the @key{TAB} key, or when you use a unary
32498 arithmetic operation like @code{sqrt}. If @var{vals} has only one
32499 element but @var{n} is greater than one, there must be only one
32500 selection among the top @var{n} stack elements; the element from
32501 @var{vals} is spliced into that selection. This is what happens when
32502 you use a binary arithmetic operation like @kbd{+}. Any other
32503 combination of @var{n} and @var{vals} is an error when selections
32507 @defun calc-unary-op tag func arg
32508 This function implements a unary operator that allows a numeric prefix
32509 argument to apply the operator over many stack entries. If the prefix
32510 argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
32511 as outlined above. Otherwise, it maps the function over several stack
32512 elements; @pxref{Prefix Arguments}. For example,@refill
32515 (defun calc-zeta (arg)
32517 (calc-unary-op "zeta" 'calcFunc-zeta arg))
32521 @defun calc-binary-op tag func arg ident unary
32522 This function implements a binary operator, analogously to
32523 @code{calc-unary-op}. The optional @var{ident} and @var{unary}
32524 arguments specify the behavior when the prefix argument is zero or
32525 one, respectively. If the prefix is zero, the value @var{ident}
32526 is pushed onto the stack, if specified, otherwise an error message
32527 is displayed. If the prefix is one, the unary function @var{unary}
32528 is applied to the top stack element, or, if @var{unary} is not
32529 specified, nothing happens. When the argument is two or more,
32530 the binary function @var{func} is reduced across the top @var{arg}
32531 stack elements; when the argument is negative, the function is
32532 mapped between the next-to-top @i{-@var{arg}} stack elements and the
32533 top element.@refill
32536 @defun calc-stack-size
32537 Return the number of elements on the stack as an integer. This count
32538 does not include elements that have been temporarily hidden by stack
32539 truncation; @pxref{Truncating the Stack}.
32542 @defun calc-cursor-stack-index n
32543 Move the point to the @var{n}th stack entry. If @var{n} is zero, this
32544 will be the @samp{.} line. If @var{n} is from 1 to the current stack size,
32545 this will be the beginning of the first line of that stack entry's display.
32546 If line numbers are enabled, this will move to the first character of the
32547 line number, not the stack entry itself.@refill
32550 @defun calc-substack-height n
32551 Return the number of lines between the beginning of the @var{n}th stack
32552 entry and the bottom of the buffer. If @var{n} is zero, this
32553 will be one (assuming no stack truncation). If all stack entries are
32554 one line long (i.e., no matrices are displayed), the return value will
32555 be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big
32556 mode, the return value includes the blank lines that separate stack
32560 @defun calc-refresh
32561 Erase the @code{*Calculator*} buffer and reformat its contents from memory.
32562 This must be called after changing any parameter, such as the current
32563 display radix, which might change the appearance of existing stack
32564 entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing
32565 is suppressed, but a flag is set so that the entire stack will be refreshed
32566 rather than just the top few elements when the macro finishes.)@refill
32569 @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
32570 @subsubsection Predicates
32573 The functions described here are predicates, that is, they return a
32574 true/false value where @code{nil} means false and anything else means
32575 true. These predicates are expanded by @code{defmath}, for example,
32576 from @code{zerop} to @code{math-zerop}. In many cases they correspond
32577 to native Lisp functions by the same name, but are extended to cover
32578 the full range of Calc data types.
32581 Returns true if @var{x} is numerically zero, in any of the Calc data
32582 types. (Note that for some types, such as error forms and intervals,
32583 it never makes sense to return true.) In @code{defmath}, the expression
32584 @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
32585 and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
32589 Returns true if @var{x} is negative. This accepts negative real numbers
32590 of various types, negative HMS and date forms, and intervals in which
32591 all included values are negative. In @code{defmath}, the expression
32592 @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
32593 and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
32597 Returns true if @var{x} is positive (and non-zero). For complex
32598 numbers, none of these three predicates will return true.
32601 @defun looks-negp x
32602 Returns true if @var{x} is ``negative-looking.'' This returns true if
32603 @var{x} is a negative number, or a formula with a leading minus sign
32604 such as @samp{-a/b}. In other words, this is an object which can be
32605 made simpler by calling @code{(- @var{x})}.
32609 Returns true if @var{x} is an integer of any size.
32613 Returns true if @var{x} is a native Lisp integer.
32617 Returns true if @var{x} is a nonnegative integer of any size.
32620 @defun fixnatnump x
32621 Returns true if @var{x} is a nonnegative Lisp integer.
32624 @defun num-integerp x
32625 Returns true if @var{x} is numerically an integer, i.e., either a
32626 true integer or a float with no significant digits to the right of
32630 @defun messy-integerp x
32631 Returns true if @var{x} is numerically, but not literally, an integer.
32632 A value is @code{num-integerp} if it is @code{integerp} or
32633 @code{messy-integerp} (but it is never both at once).
32636 @defun num-natnump x
32637 Returns true if @var{x} is numerically a nonnegative integer.
32641 Returns true if @var{x} is an even integer.
32644 @defun looks-evenp x
32645 Returns true if @var{x} is an even integer, or a formula with a leading
32646 multiplicative coefficient which is an even integer.
32650 Returns true if @var{x} is an odd integer.
32654 Returns true if @var{x} is a rational number, i.e., an integer or a
32659 Returns true if @var{x} is a real number, i.e., an integer, fraction,
32660 or floating-point number.
32664 Returns true if @var{x} is a real number or HMS form.
32668 Returns true if @var{x} is a float, or a complex number, error form,
32669 interval, date form, or modulo form in which at least one component
32674 Returns true if @var{x} is a rectangular or polar complex number
32675 (but not a real number).
32678 @defun rect-complexp x
32679 Returns true if @var{x} is a rectangular complex number.
32682 @defun polar-complexp x
32683 Returns true if @var{x} is a polar complex number.
32687 Returns true if @var{x} is a real number or a complex number.
32691 Returns true if @var{x} is a real or complex number or an HMS form.
32695 Returns true if @var{x} is a vector (this simply checks if its argument
32696 is a list whose first element is the symbol @code{vec}).
32700 Returns true if @var{x} is a number or vector.
32704 Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
32705 all of the same size.
32708 @defun square-matrixp x
32709 Returns true if @var{x} is a square matrix.
32713 Returns true if @var{x} is any numeric Calc object, including real and
32714 complex numbers, HMS forms, date forms, error forms, intervals, and
32715 modulo forms. (Note that error forms and intervals may include formulas
32716 as their components; see @code{constp} below.)
32720 Returns true if @var{x} is an object or a vector. This also accepts
32721 incomplete objects, but it rejects variables and formulas (except as
32722 mentioned above for @code{objectp}).
32726 Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
32727 i.e., one whose components cannot be regarded as sub-formulas. This
32728 includes variables, and all @code{objectp} types except error forms
32733 Returns true if @var{x} is constant, i.e., a real or complex number,
32734 HMS form, date form, or error form, interval, or vector all of whose
32735 components are @code{constp}.
32739 Returns true if @var{x} is numerically less than @var{y}. Returns false
32740 if @var{x} is greater than or equal to @var{y}, or if the order is
32741 undefined or cannot be determined. Generally speaking, this works
32742 by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In
32743 @code{defmath}, the expression @samp{(< x y)} will automatically be
32744 converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
32745 and @code{>=} are similarly converted in terms of @code{lessp}.@refill
32749 Returns true if @var{x} comes before @var{y} in a canonical ordering
32750 of Calc objects. If @var{x} and @var{y} are both real numbers, this
32751 will be the same as @code{lessp}. But whereas @code{lessp} considers
32752 other types of objects to be unordered, @code{beforep} puts any two
32753 objects into a definite, consistent order. The @code{beforep}
32754 function is used by the @kbd{V S} vector-sorting command, and also
32755 by @kbd{a s} to put the terms of a product into canonical order:
32756 This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}.
32760 This is the standard Lisp @code{equal} predicate; it returns true if
32761 @var{x} and @var{y} are structurally identical. This is the usual way
32762 to compare numbers for equality, but note that @code{equal} will treat
32763 0 and 0.0 as different.
32766 @defun math-equal x y
32767 Returns true if @var{x} and @var{y} are numerically equal, either because
32768 they are @code{equal}, or because their difference is @code{zerop}. In
32769 @code{defmath}, the expression @samp{(= x y)} will automatically be
32770 converted to @samp{(math-equal x y)}.
32773 @defun equal-int x n
32774 Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
32775 is a fixnum which is not a multiple of 10. This will automatically be
32776 used by @code{defmath} in place of the more general @code{math-equal}
32777 whenever possible.@refill
32780 @defun nearly-equal x y
32781 Returns true if @var{x} and @var{y}, as floating-point numbers, are
32782 equal except possibly in the last decimal place. For example,
32783 314.159 and 314.166 are considered nearly equal if the current
32784 precision is 6 (since they differ by 7 units), but not if the current
32785 precision is 7 (since they differ by 70 units). Most functions which
32786 use series expansions use @code{with-extra-prec} to evaluate the
32787 series with 2 extra digits of precision, then use @code{nearly-equal}
32788 to decide when the series has converged; this guards against cumulative
32789 error in the series evaluation without doing extra work which would be
32790 lost when the result is rounded back down to the current precision.
32791 In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
32792 The @var{x} and @var{y} can be numbers of any kind, including complex.
32795 @defun nearly-zerop x y
32796 Returns true if @var{x} is nearly zero, compared to @var{y}. This
32797 checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
32798 to @var{y} itself, to within the current precision, in other words,
32799 if adding @var{x} to @var{y} would have a negligible effect on @var{y}
32800 due to roundoff error. @var{X} may be a real or complex number, but
32801 @var{y} must be real.
32805 Return true if the formula @var{x} represents a true value in
32806 Calc, not Lisp, terms. It tests if @var{x} is a non-zero number
32807 or a provably non-zero formula.
32810 @defun reject-arg val pred
32811 Abort the current function evaluation due to unacceptable argument values.
32812 This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
32813 Lisp error which @code{normalize} will trap. The net effect is that the
32814 function call which led here will be left in symbolic form.@refill
32817 @defun inexact-value
32818 If Symbolic Mode is enabled, this will signal an error that causes
32819 @code{normalize} to leave the formula in symbolic form, with the message
32820 ``Inexact result.'' (This function has no effect when not in Symbolic Mode.)
32821 Note that if your function calls @samp{(sin 5)} in Symbolic Mode, the
32822 @code{sin} function will call @code{inexact-value}, which will cause your
32823 function to be left unsimplified. You may instead wish to call
32824 @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic Mode will
32825 return the formula @samp{sin(5)} to your function.@refill
32829 This signals an error that will be reported as a floating-point overflow.
32833 This signals a floating-point underflow.
32836 @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
32837 @subsubsection Computational Functions
32840 The functions described here do the actual computational work of the
32841 Calculator. In addition to these, note that any function described in
32842 the main body of this manual may be called from Lisp; for example, if
32843 the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
32844 this means @code{calc-sqrt} is an interactive stack-based square-root
32845 command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
32846 is the actual Lisp function for taking square roots.@refill
32848 The functions @code{math-add}, @code{math-sub}, @code{math-mul},
32849 @code{math-div}, @code{math-mod}, and @code{math-neg} are not included
32850 in this list, since @code{defmath} allows you to write native Lisp
32851 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
32852 respectively, instead.@refill
32854 @defun normalize val
32855 (Full form: @code{math-normalize}.)
32856 Reduce the value @var{val} to standard form. For example, if @var{val}
32857 is a fixnum, it will be converted to a bignum if it is too large, and
32858 if @var{val} is a bignum it will be normalized by clipping off trailing
32859 (i.e., most-significant) zero digits and converting to a fixnum if it is
32860 small. All the various data types are similarly converted to their standard
32861 forms. Variables are left alone, but function calls are actually evaluated
32862 in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
32865 If a function call fails, because the function is void or has the wrong
32866 number of parameters, or because it returns @code{nil} or calls
32867 @code{reject-arg} or @code{inexact-result}, @code{normalize} returns
32868 the formula still in symbolic form.@refill
32870 If the current Simplification Mode is ``none'' or ``numeric arguments
32871 only,'' @code{normalize} will act appropriately. However, the more
32872 powerful simplification modes (like algebraic simplification) are
32873 not handled by @code{normalize}. They are handled by @code{calc-normalize},
32874 which calls @code{normalize} and possibly some other routines, such
32875 as @code{simplify} or @code{simplify-units}. Programs generally will
32876 never call @code{calc-normalize} except when popping or pushing values
32877 on the stack.@refill
32880 @defun evaluate-expr expr
32881 Replace all variables in @var{expr} that have values with their values,
32882 then use @code{normalize} to simplify the result. This is what happens
32883 when you press the @kbd{=} key interactively.@refill
32886 @defmac with-extra-prec n body
32887 Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
32888 digits. This is a macro which expands to
32892 (let ((calc-internal-prec (+ calc-internal-prec @var{n})))
32896 The surrounding call to @code{math-normalize} causes a floating-point
32897 result to be rounded down to the original precision afterwards. This
32898 is important because some arithmetic operations assume a number's
32899 mantissa contains no more digits than the current precision allows.
32902 @defun make-frac n d
32903 Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling
32904 @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
32907 @defun make-float mant exp
32908 Build a floating-point value out of @var{mant} and @var{exp}, both
32909 of which are arbitrary integers. This function will return a
32910 properly normalized float value, or signal an overflow or underflow
32911 if @var{exp} is out of range.
32914 @defun make-sdev x sigma
32915 Build an error form out of @var{x} and the absolute value of @var{sigma}.
32916 If @var{sigma} is zero, the result is the number @var{x} directly.
32917 If @var{sigma} is negative or complex, its absolute value is used.
32918 If @var{x} or @var{sigma} is not a valid type of object for use in
32919 error forms, this calls @code{reject-arg}.
32922 @defun make-intv mask lo hi
32923 Build an interval form out of @var{mask} (which is assumed to be an
32924 integer from 0 to 3), and the limits @var{lo} and @var{hi}. If
32925 @var{lo} is greater than @var{hi}, an empty interval form is returned.
32926 This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
32929 @defun sort-intv mask lo hi
32930 Build an interval form, similar to @code{make-intv}, except that if
32931 @var{lo} is less than @var{hi} they are simply exchanged, and the
32932 bits of @var{mask} are swapped accordingly.
32935 @defun make-mod n m
32936 Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo
32937 forms do not allow formulas as their components, if @var{n} or @var{m}
32938 is not a real number or HMS form the result will be a formula which
32939 is a call to @code{makemod}, the algebraic version of this function.
32943 Convert @var{x} to floating-point form. Integers and fractions are
32944 converted to numerically equivalent floats; components of complex
32945 numbers, vectors, HMS forms, date forms, error forms, intervals, and
32946 modulo forms are recursively floated. If the argument is a variable
32947 or formula, this calls @code{reject-arg}.
32951 Compare the numbers @var{x} and @var{y}, and return @i{-1} if
32952 @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
32953 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
32954 undefined or cannot be determined.@refill
32958 Return the number of digits of integer @var{n}, effectively
32959 @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is
32960 considered to have zero digits.
32963 @defun scale-int x n
32964 Shift integer @var{x} left @var{n} decimal digits, or right @i{-@var{n}}
32965 digits with truncation toward zero.
32968 @defun scale-rounding x n
32969 Like @code{scale-int}, except that a right shift rounds to the nearest
32970 integer rather than truncating.
32974 Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
32975 If @var{n} is outside the permissible range for Lisp integers (usually
32976 24 binary bits) the result is undefined.
32980 Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
32983 @defun quotient x y
32984 Divide integer @var{x} by integer @var{y}; return an integer quotient
32985 and discard the remainder. If @var{x} or @var{y} is negative, the
32986 direction of rounding is undefined.
32990 Perform an integer division; if @var{x} and @var{y} are both nonnegative
32991 integers, this uses the @code{quotient} function, otherwise it computes
32992 @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but
32993 slower than for @code{quotient}.
32997 Divide integer @var{x} by integer @var{y}; return the integer remainder
32998 and discard the quotient. Like @code{quotient}, this works only for
32999 integer arguments and is not well-defined for negative arguments.
33000 For a more well-defined result, use @samp{(% @var{x} @var{y})}.
33004 Divide integer @var{x} by integer @var{y}; return a cons cell whose
33005 @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
33006 is @samp{(imod @var{x} @var{y})}.@refill
33010 Compute @var{x} to the power @var{y}. In @code{defmath} code, this can
33011 also be written @samp{(^ @var{x} @var{y})} or
33012 @w{@samp{(expt @var{x} @var{y})}}.@refill
33015 @defun abs-approx x
33016 Compute a fast approximation to the absolute value of @var{x}. For
33017 example, for a rectangular complex number the result is the sum of
33018 the absolute values of the components.
33024 @findex pi-over-180
33025 @findex sqrt-two-pi
33031 The function @samp{(pi)} computes @samp{pi} to the current precision.
33032 Other related constant-generating functions are @code{two-pi},
33033 @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
33034 @code{e}, @code{sqrt-e}, @code{ln-2}, and @code{ln-10}. Each function
33035 returns a floating-point value in the current precision, and each uses
33036 caching so that all calls after the first are essentially free.@refill
33039 @defmac math-defcache @var{func} @var{initial} @var{form}
33040 This macro, usually used as a top-level call like @code{defun} or
33041 @code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
33042 It defines a function @code{func} which returns the requested value;
33043 if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
33044 form which serves as an initial value for the cache. If @var{func}
33045 is called when the cache is empty or does not have enough digits to
33046 satisfy the current precision, the Lisp expression @var{form} is evaluated
33047 with the current precision increased by four, and the result minus its
33048 two least significant digits is stored in the cache. For example,
33049 calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
33050 digits, rounds it down to 32 digits for future use, then rounds it
33051 again to 30 digits for use in the present request.@refill
33054 @findex half-circle
33055 @findex quarter-circle
33056 @defun full-circle symb
33057 If the current angular mode is Degrees or HMS, this function returns the
33058 integer 360. In Radians mode, this function returns either the
33059 corresponding value in radians to the current precision, or the formula
33060 @samp{2*pi}, depending on the Symbolic Mode. There are also similar
33061 function @code{half-circle} and @code{quarter-circle}.
33064 @defun power-of-2 n
33065 Compute two to the integer power @var{n}, as a (potentially very large)
33066 integer. Powers of two are cached, so only the first call for a
33067 particular @var{n} is expensive.
33070 @defun integer-log2 n
33071 Compute the base-2 logarithm of @var{n}, which must be an integer which
33072 is a power of two. If @var{n} is not a power of two, this function will
33076 @defun div-mod a b m
33077 Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if
33078 there is no solution, or if any of the arguments are not integers.@refill
33081 @defun pow-mod a b m
33082 Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a},
33083 @var{b}, and @var{m} are integers, this uses an especially efficient
33084 algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}.
33088 Compute the integer square root of @var{n}. This is the square root
33089 of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
33090 If @var{n} is itself an integer, the computation is especially efficient.
33093 @defun to-hms a ang
33094 Convert the argument @var{a} into an HMS form. If @var{ang} is specified,
33095 it is the angular mode in which to interpret @var{a}, either @code{deg}
33096 or @code{rad}. Otherwise, the current angular mode is used. If @var{a}
33097 is already an HMS form it is returned as-is.
33100 @defun from-hms a ang
33101 Convert the HMS form @var{a} into a real number. If @var{ang} is specified,
33102 it is the angular mode in which to express the result, otherwise the
33103 current angular mode is used. If @var{a} is already a real number, it
33107 @defun to-radians a
33108 Convert the number or HMS form @var{a} to radians from the current
33112 @defun from-radians a
33113 Convert the number @var{a} from radians to the current angular mode.
33114 If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
33117 @defun to-radians-2 a
33118 Like @code{to-radians}, except that in Symbolic Mode a degrees to
33119 radians conversion yields a formula like @samp{@var{a}*pi/180}.
33122 @defun from-radians-2 a
33123 Like @code{from-radians}, except that in Symbolic Mode a radians to
33124 degrees conversion yields a formula like @samp{@var{a}*180/pi}.
33127 @defun random-digit
33128 Produce a random base-1000 digit in the range 0 to 999.
33131 @defun random-digits n
33132 Produce a random @var{n}-digit integer; this will be an integer
33133 in the interval @samp{[0, 10^@var{n})}.
33136 @defun random-float
33137 Produce a random float in the interval @samp{[0, 1)}.
33140 @defun prime-test n iters
33141 Determine whether the integer @var{n} is prime. Return a list which has
33142 one of these forms: @samp{(nil @var{f})} means the number is non-prime
33143 because it was found to be divisible by @var{f}; @samp{(nil)} means it
33144 was found to be non-prime by table look-up (so no factors are known);
33145 @samp{(nil unknown)} means it is definitely non-prime but no factors
33146 are known because @var{n} was large enough that Fermat's probabilistic
33147 test had to be used; @samp{(t)} means the number is definitely prime;
33148 and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
33149 iterations, is @var{p} percent sure that the number is prime. The
33150 @var{iters} parameter is the number of Fermat iterations to use, in the
33151 case that this is necessary. If @code{prime-test} returns ``maybe,''
33152 you can call it again with the same @var{n} to get a greater certainty;
33153 @code{prime-test} remembers where it left off.@refill
33156 @defun to-simple-fraction f
33157 If @var{f} is a floating-point number which can be represented exactly
33158 as a small rational number. return that number, else return @var{f}.
33159 For example, 0.75 would be converted to 3:4. This function is very
33163 @defun to-fraction f tol
33164 Find a rational approximation to floating-point number @var{f} to within
33165 a specified tolerance @var{tol}; this corresponds to the algebraic
33166 function @code{frac}, and can be rather slow.
33169 @defun quarter-integer n
33170 If @var{n} is an integer or integer-valued float, this function
33171 returns zero. If @var{n} is a half-integer (i.e., an integer plus
33172 @i{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer,
33173 it returns 1 or 3. If @var{n} is anything else, this function
33174 returns @code{nil}.
33177 @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
33178 @subsubsection Vector Functions
33181 The functions described here perform various operations on vectors and
33184 @defun math-concat x y
33185 Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
33186 in a symbolic formula. @xref{Building Vectors}.
33189 @defun vec-length v
33190 Return the length of vector @var{v}. If @var{v} is not a vector, the
33191 result is zero. If @var{v} is a matrix, this returns the number of
33192 rows in the matrix.
33195 @defun mat-dimens m
33196 Determine the dimensions of vector or matrix @var{m}. If @var{m} is not
33197 a vector, the result is an empty list. If @var{m} is a plain vector
33198 but not a matrix, the result is a one-element list containing the length
33199 of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns,
33200 the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors
33201 produce lists of more than two dimensions. Note that the object
33202 @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
33203 and is treated by this and other Calc routines as a plain vector of two
33207 @defun dimension-error
33208 Abort the current function with a message of ``Dimension error.''
33209 The Calculator will leave the function being evaluated in symbolic
33210 form; this is really just a special case of @code{reject-arg}.
33213 @defun build-vector args
33214 Return a Calc vector with @var{args} as elements.
33215 For example, @samp{(build-vector 1 2 3)} returns the Calc vector
33216 @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
33219 @defun make-vec obj dims
33220 Return a Calc vector or matrix all of whose elements are equal to
33221 @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
33225 @defun row-matrix v
33226 If @var{v} is a plain vector, convert it into a row matrix, i.e.,
33227 a matrix whose single row is @var{v}. If @var{v} is already a matrix,
33231 @defun col-matrix v
33232 If @var{v} is a plain vector, convert it into a column matrix, i.e., a
33233 matrix with each element of @var{v} as a separate row. If @var{v} is
33234 already a matrix, leave it alone.
33238 Map the Lisp function @var{f} over the Calc vector @var{v}. For example,
33239 @samp{(map-vec 'math-floor v)} returns a vector of the floored components
33243 @defun map-vec-2 f a b
33244 Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
33245 If @var{a} and @var{b} are vectors of equal length, the result is a
33246 vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
33247 for each pair of elements @var{ai} and @var{bi}. If either @var{a} or
33248 @var{b} is a scalar, it is matched with each value of the other vector.
33249 For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
33250 with each element increased by one. Note that using @samp{'+} would not
33251 work here, since @code{defmath} does not expand function names everywhere,
33252 just where they are in the function position of a Lisp expression.@refill
33255 @defun reduce-vec f v
33256 Reduce the function @var{f} over the vector @var{v}. For example, if
33257 @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
33258 If @var{v} is a matrix, this reduces over the rows of @var{v}.
33261 @defun reduce-cols f m
33262 Reduce the function @var{f} over the columns of matrix @var{m}. For
33263 example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
33264 is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
33268 Return the @var{n}th row of matrix @var{m}. This is equivalent to
33269 @samp{(elt m n)}. For a slower but safer version, use @code{mrow}.
33270 (@xref{Extracting Elements}.)
33274 Return the @var{n}th column of matrix @var{m}, in the form of a vector.
33275 The arguments are not checked for correctness.
33278 @defun mat-less-row m n
33279 Return a copy of matrix @var{m} with its @var{n}th row deleted. The
33280 number @var{n} must be in range from 1 to the number of rows in @var{m}.
33283 @defun mat-less-col m n
33284 Return a copy of matrix @var{m} with its @var{n}th column deleted.
33288 Return the transpose of matrix @var{m}.
33291 @defun flatten-vector v
33292 Flatten nested vector @var{v} into a vector of scalars. For example,
33293 if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
33296 @defun copy-matrix m
33297 If @var{m} is a matrix, return a copy of @var{m}. This maps
33298 @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
33299 element of the result matrix will be @code{eq} to the corresponding
33300 element of @var{m}, but none of the @code{cons} cells that make up
33301 the structure of the matrix will be @code{eq}. If @var{m} is a plain
33302 vector, this is the same as @code{copy-sequence}.@refill
33305 @defun swap-rows m r1 r2
33306 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In
33307 other words, unlike most of the other functions described here, this
33308 function changes @var{m} itself rather than building up a new result
33309 matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
33310 is true, with the side effect of exchanging the first two rows of
33314 @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
33315 @subsubsection Symbolic Functions
33318 The functions described here operate on symbolic formulas in the
33321 @defun calc-prepare-selection num
33322 Prepare a stack entry for selection operations. If @var{num} is
33323 omitted, the stack entry containing the cursor is used; otherwise,
33324 it is the number of the stack entry to use. This function stores
33325 useful information about the current stack entry into a set of
33326 variables. @code{calc-selection-cache-num} contains the number of
33327 the stack entry involved (equal to @var{num} if you specified it);
33328 @code{calc-selection-cache-entry} contains the stack entry as a
33329 list (such as @code{calc-top-list} would return with @code{entry}
33330 as the selection mode); and @code{calc-selection-cache-comp} contains
33331 a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
33332 which allows Calc to relate cursor positions in the buffer with
33333 their corresponding sub-formulas.
33335 A slight complication arises in the selection mechanism because
33336 formulas may contain small integers. For example, in the vector
33337 @samp{[1, 2, 1]} the first and last elements are @code{eq} to each
33338 other; selections are recorded as the actual Lisp object that
33339 appears somewhere in the tree of the whole formula, but storing
33340 @code{1} would falsely select both @code{1}'s in the vector. So
33341 @code{calc-prepare-selection} also checks the stack entry and
33342 replaces any plain integers with ``complex number'' lists of the form
33343 @samp{(cplx @var{n} 0)}. This list will be displayed the same as a
33344 plain @var{n} and the change will be completely invisible to the
33345 user, but it will guarantee that no two sub-formulas of the stack
33346 entry will be @code{eq} to each other. Next time the stack entry
33347 is involved in a computation, @code{calc-normalize} will replace
33348 these lists with plain numbers again, again invisibly to the user.
33351 @defun calc-encase-atoms x
33352 This modifies the formula @var{x} to ensure that each part of the
33353 formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
33354 described above. This function may use @code{setcar} to modify
33355 the formula in-place.
33358 @defun calc-find-selected-part
33359 Find the smallest sub-formula of the current formula that contains
33360 the cursor. This assumes @code{calc-prepare-selection} has been
33361 called already. If the cursor is not actually on any part of the
33362 formula, this returns @code{nil}.
33365 @defun calc-change-current-selection selection
33366 Change the currently prepared stack element's selection to
33367 @var{selection}, which should be @code{eq} to some sub-formula
33368 of the stack element, or @code{nil} to unselect the formula.
33369 The stack element's appearance in the Calc buffer is adjusted
33370 to reflect the new selection.
33373 @defun calc-find-nth-part expr n
33374 Return the @var{n}th sub-formula of @var{expr}. This function is used
33375 by the selection commands, and (unless @kbd{j b} has been used) treats
33376 sums and products as flat many-element formulas. Thus if @var{expr}
33377 is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
33378 @var{n} equal to four will return @samp{d}.
33381 @defun calc-find-parent-formula expr part
33382 Return the sub-formula of @var{expr} which immediately contains
33383 @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
33384 is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
33385 will return @samp{(c+1)*d}. If @var{part} turns out not to be a
33386 sub-formula of @var{expr}, the function returns @code{nil}. If
33387 @var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
33388 This function does not take associativity into account.
33391 @defun calc-find-assoc-parent-formula expr part
33392 This is the same as @code{calc-find-parent-formula}, except that
33393 (unless @kbd{j b} has been used) it continues widening the selection
33394 to contain a complete level of the formula. Given @samp{a} from
33395 @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
33396 return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
33397 return the whole expression.
33400 @defun calc-grow-assoc-formula expr part
33401 This expands sub-formula @var{part} of @var{expr} to encompass a
33402 complete level of the formula. If @var{part} and its immediate
33403 parent are not compatible associative operators, or if @kbd{j b}
33404 has been used, this simply returns @var{part}.
33407 @defun calc-find-sub-formula expr part
33408 This finds the immediate sub-formula of @var{expr} which contains
33409 @var{part}. It returns an index @var{n} such that
33410 @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
33411 If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
33412 If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This
33413 function does not take associativity into account.
33416 @defun calc-replace-sub-formula expr old new
33417 This function returns a copy of formula @var{expr}, with the
33418 sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
33421 @defun simplify expr
33422 Simplify the expression @var{expr} by applying various algebraic rules.
33423 This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This
33424 always returns a copy of the expression; the structure @var{expr} points
33425 to remains unchanged in memory.
33427 More precisely, here is what @code{simplify} does: The expression is
33428 first normalized and evaluated by calling @code{normalize}. If any
33429 @code{AlgSimpRules} have been defined, they are then applied. Then
33430 the expression is traversed in a depth-first, bottom-up fashion; at
33431 each level, any simplifications that can be made are made until no
33432 further changes are possible. Once the entire formula has been
33433 traversed in this way, it is compared with the original formula (from
33434 before the call to @code{normalize}) and, if it has changed,
33435 the entire procedure is repeated (starting with @code{normalize})
33436 until no further changes occur. Usually only two iterations are
33437 needed:@: one to simplify the formula, and another to verify that no
33438 further simplifications were possible.
33441 @defun simplify-extended expr
33442 Simplify the expression @var{expr}, with additional rules enabled that
33443 help do a more thorough job, while not being entirely ``safe'' in all
33444 circumstances. (For example, this mode will simplify @samp{sqrt(x^2)}
33445 to @samp{x}, which is only valid when @var{x} is positive.) This is
33446 implemented by temporarily binding the variable @code{math-living-dangerously}
33447 to @code{t} (using a @code{let} form) and calling @code{simplify}.
33448 Dangerous simplification rules are written to check this variable
33449 before taking any action.@refill
33452 @defun simplify-units expr
33453 Simplify the expression @var{expr}, treating variable names as units
33454 whenever possible. This works by binding the variable
33455 @code{math-simplifying-units} to @code{t} while calling @code{simplify}.
33458 @defmac math-defsimplify funcs body
33459 Register a new simplification rule; this is normally called as a top-level
33460 form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol
33461 (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
33462 applied to the formulas which are calls to the specified function. Or,
33463 @var{funcs} can be a list of such symbols; the rule applies to all
33464 functions on the list. The @var{body} is written like the body of a
33465 function with a single argument called @code{expr}. The body will be
33466 executed with @code{expr} bound to a formula which is a call to one of
33467 the functions @var{funcs}. If the function body returns @code{nil}, or
33468 if it returns a result @code{equal} to the original @code{expr}, it is
33469 ignored and Calc goes on to try the next simplification rule that applies.
33470 If the function body returns something different, that new formula is
33471 substituted for @var{expr} in the original formula.@refill
33473 At each point in the formula, rules are tried in the order of the
33474 original calls to @code{math-defsimplify}; the search stops after the
33475 first rule that makes a change. Thus later rules for that same
33476 function will not have a chance to trigger until the next iteration
33477 of the main @code{simplify} loop.
33479 Note that, since @code{defmath} is not being used here, @var{body} must
33480 be written in true Lisp code without the conveniences that @code{defmath}
33481 provides. If you prefer, you can have @var{body} simply call another
33482 function (defined with @code{defmath}) which does the real work.
33484 The arguments of a function call will already have been simplified
33485 before any rules for the call itself are invoked. Since a new argument
33486 list is consed up when this happens, this means that the rule's body is
33487 allowed to rearrange the function's arguments destructively if that is
33488 convenient. Here is a typical example of a simplification rule:
33491 (math-defsimplify calcFunc-arcsinh
33492 (or (and (math-looks-negp (nth 1 expr))
33493 (math-neg (list 'calcFunc-arcsinh
33494 (math-neg (nth 1 expr)))))
33495 (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
33496 (or math-living-dangerously
33497 (math-known-realp (nth 1 (nth 1 expr))))
33498 (nth 1 (nth 1 expr)))))
33501 This is really a pair of rules written with one @code{math-defsimplify}
33502 for convenience; the first replaces @samp{arcsinh(-x)} with
33503 @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
33504 replaces @samp{arcsinh(sinh(x))} with @samp{x}.@refill
33507 @defun common-constant-factor expr
33508 Check @var{expr} to see if it is a sum of terms all multiplied by the
33509 same rational value. If so, return this value. If not, return @code{nil}.
33510 For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
33511 3 is a common factor of all the terms.
33514 @defun cancel-common-factor expr factor
33515 Assuming @var{expr} is a sum with @var{factor} as a common factor,
33516 divide each term of the sum by @var{factor}. This is done by
33517 destructively modifying parts of @var{expr}, on the assumption that
33518 it is being used by a simplification rule (where such things are
33519 allowed; see above). For example, consider this built-in rule for
33523 (math-defsimplify calcFunc-sqrt
33524 (let ((fac (math-common-constant-factor (nth 1 expr))))
33525 (and fac (not (eq fac 1))
33526 (math-mul (math-normalize (list 'calcFunc-sqrt fac))
33528 (list 'calcFunc-sqrt
33529 (math-cancel-common-factor
33530 (nth 1 expr) fac)))))))
33534 @defun frac-gcd a b
33535 Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
33536 rational numbers. This is the fraction composed of the GCD of the
33537 numerators of @var{a} and @var{b}, over the GCD of the denominators.
33538 It is used by @code{common-constant-factor}. Note that the standard
33539 @code{gcd} function uses the LCM to combine the denominators.@refill
33542 @defun map-tree func expr many
33543 Try applying Lisp function @var{func} to various sub-expressions of
33544 @var{expr}. Initially, call @var{func} with @var{expr} itself as an
33545 argument. If this returns an expression which is not @code{equal} to
33546 @var{expr}, apply @var{func} again until eventually it does return
33547 @var{expr} with no changes. Then, if @var{expr} is a function call,
33548 recursively apply @var{func} to each of the arguments. This keeps going
33549 until no changes occur anywhere in the expression; this final expression
33550 is returned by @code{map-tree}. Note that, unlike simplification rules,
33551 @var{func} functions may @emph{not} make destructive changes to
33552 @var{expr}. If a third argument @var{many} is provided, it is an
33553 integer which says how many times @var{func} may be applied; the
33554 default, as described above, is infinitely many times.@refill
33557 @defun compile-rewrites rules
33558 Compile the rewrite rule set specified by @var{rules}, which should
33559 be a formula that is either a vector or a variable name. If the latter,
33560 the compiled rules are saved so that later @code{compile-rules} calls
33561 for that same variable can return immediately. If there are problems
33562 with the rules, this function calls @code{error} with a suitable
33566 @defun apply-rewrites expr crules heads
33567 Apply the compiled rewrite rule set @var{crules} to the expression
33568 @var{expr}. This will make only one rewrite and only checks at the
33569 top level of the expression. The result @code{nil} if no rules
33570 matched, or if the only rules that matched did not actually change
33571 the expression. The @var{heads} argument is optional; if is given,
33572 it should be a list of all function names that (may) appear in
33573 @var{expr}. The rewrite compiler tags each rule with the
33574 rarest-looking function name in the rule; if you specify @var{heads},
33575 @code{apply-rewrites} can use this information to narrow its search
33576 down to just a few rules in the rule set.
33579 @defun rewrite-heads expr
33580 Compute a @var{heads} list for @var{expr} suitable for use with
33581 @code{apply-rewrites}, as discussed above.
33584 @defun rewrite expr rules many
33585 This is an all-in-one rewrite function. It compiles the rule set
33586 specified by @var{rules}, then uses @code{map-tree} to apply the
33587 rules throughout @var{expr} up to @var{many} (default infinity)
33591 @defun match-patterns pat vec not-flag
33592 Given a Calc vector @var{vec} and an uncompiled pattern set or
33593 pattern set variable @var{pat}, this function returns a new vector
33594 of all elements of @var{vec} which do (or don't, if @var{not-flag} is
33595 non-@code{nil}) match any of the patterns in @var{pat}.
33598 @defun deriv expr var value symb
33599 Compute the derivative of @var{expr} with respect to variable @var{var}
33600 (which may actually be any sub-expression). If @var{value} is specified,
33601 the derivative is evaluated at the value of @var{var}; otherwise, the
33602 derivative is left in terms of @var{var}. If the expression contains
33603 functions for which no derivative formula is known, new derivative
33604 functions are invented by adding primes to the names; @pxref{Calculus}.
33605 However, if @var{symb} is non-@code{nil}, the presence of undifferentiable
33606 functions in @var{expr} instead cancels the whole differentiation, and
33607 @code{deriv} returns @code{nil} instead.
33609 Derivatives of an @var{n}-argument function can be defined by
33610 adding a @code{math-derivative-@var{n}} property to the property list
33611 of the symbol for the function's derivative, which will be the
33612 function name followed by an apostrophe. The value of the property
33613 should be a Lisp function; it is called with the same arguments as the
33614 original function call that is being differentiated. It should return
33615 a formula for the derivative. For example, the derivative of @code{ln}
33619 (put 'calcFunc-ln\' 'math-derivative-1
33620 (function (lambda (u) (math-div 1 u))))
33623 The two-argument @code{log} function has two derivatives,
33625 (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx
33626 (function (lambda (x b) ... )))
33627 (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db
33628 (function (lambda (x b) ... )))
33632 @defun tderiv expr var value symb
33633 Compute the total derivative of @var{expr}. This is the same as
33634 @code{deriv}, except that variables other than @var{var} are not
33635 assumed to be constant with respect to @var{var}.
33638 @defun integ expr var low high
33639 Compute the integral of @var{expr} with respect to @var{var}.
33640 @xref{Calculus}, for further details.
33643 @defmac math-defintegral funcs body
33644 Define a rule for integrating a function or functions of one argument;
33645 this macro is very similar in format to @code{math-defsimplify}.
33646 The main difference is that here @var{body} is the body of a function
33647 with a single argument @code{u} which is bound to the argument to the
33648 function being integrated, not the function call itself. Also, the
33649 variable of integration is available as @code{math-integ-var}. If
33650 evaluation of the integral requires doing further integrals, the body
33651 should call @samp{(math-integral @var{x})} to find the integral of
33652 @var{x} with respect to @code{math-integ-var}; this function returns
33653 @code{nil} if the integral could not be done. Some examples:
33656 (math-defintegral calcFunc-conj
33657 (let ((int (math-integral u)))
33659 (list 'calcFunc-conj int))))
33661 (math-defintegral calcFunc-cos
33662 (and (equal u math-integ-var)
33663 (math-from-radians-2 (list 'calcFunc-sin u))))
33666 In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
33667 relying on the general integration-by-substitution facility to handle
33668 cosines of more complicated arguments. An integration rule should return
33669 @code{nil} if it can't do the integral; if several rules are defined for
33670 the same function, they are tried in order until one returns a non-@code{nil}
33674 @defmac math-defintegral-2 funcs body
33675 Define a rule for integrating a function or functions of two arguments.
33676 This is exactly analogous to @code{math-defintegral}, except that @var{body}
33677 is written as the body of a function with two arguments, @var{u} and
33681 @defun solve-for lhs rhs var full
33682 Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
33683 the variable @var{var} on the lefthand side; return the resulting righthand
33684 side, or @code{nil} if the equation cannot be solved. The variable
33685 @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that
33686 the return value is a formula which does not contain @var{var}; this is
33687 different from the user-level @code{solve} and @code{finv} functions,
33688 which return a rearranged equation or a functional inverse, respectively.
33689 If @var{full} is non-@code{nil}, a full solution including dummy signs
33690 and dummy integers will be produced. User-defined inverses are provided
33691 as properties in a manner similar to derivatives:@refill
33694 (put 'calcFunc-ln 'math-inverse
33695 (function (lambda (x) (list 'calcFunc-exp x))))
33698 This function can call @samp{(math-solve-get-sign @var{x})} to create
33699 a new arbitrary sign variable, returning @var{x} times that sign, and
33700 @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
33701 variable multiplied by @var{x}. These functions simply return @var{x}
33702 if the caller requested a non-``full'' solution.
33705 @defun solve-eqn expr var full
33706 This version of @code{solve-for} takes an expression which will
33707 typically be an equation or inequality. (If it is not, it will be
33708 interpreted as the equation @samp{@var{expr} = 0}.) It returns an
33709 equation or inequality, or @code{nil} if no solution could be found.
33712 @defun solve-system exprs vars full
33713 This function solves a system of equations. Generally, @var{exprs}
33714 and @var{vars} will be vectors of equal length.
33715 @xref{Solving Systems of Equations}, for other options.
33718 @defun expr-contains expr var
33719 Returns a non-@code{nil} value if @var{var} occurs as a subexpression
33722 This function might seem at first to be identical to
33723 @code{calc-find-sub-formula}. The key difference is that
33724 @code{expr-contains} uses @code{equal} to test for matches, whereas
33725 @code{calc-find-sub-formula} uses @code{eq}. In the formula
33726 @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
33727 @code{eq} to each other.@refill
33730 @defun expr-contains-count expr var
33731 Returns the number of occurrences of @var{var} as a subexpression
33732 of @var{expr}, or @code{nil} if there are no occurrences.@refill
33735 @defun expr-depends expr var
33736 Returns true if @var{expr} refers to any variable the occurs in @var{var}.
33737 In other words, it checks if @var{expr} and @var{var} have any variables
33741 @defun expr-contains-vars expr
33742 Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
33743 contains only constants and functions with constant arguments.
33746 @defun expr-subst expr old new
33747 Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
33748 by @var{new}. This treats @code{lambda} forms specially with respect
33749 to the dummy argument variables, so that the effect is always to return
33750 @var{expr} evaluated at @var{old} = @var{new}.@refill
33753 @defun multi-subst expr old new
33754 This is like @code{expr-subst}, except that @var{old} and @var{new}
33755 are lists of expressions to be substituted simultaneously. If one
33756 list is shorter than the other, trailing elements of the longer list
33760 @defun expr-weight expr
33761 Returns the ``weight'' of @var{expr}, basically a count of the total
33762 number of objects and function calls that appear in @var{expr}. For
33763 ``primitive'' objects, this will be one.
33766 @defun expr-height expr
33767 Returns the ``height'' of @var{expr}, which is the deepest level to
33768 which function calls are nested. (Note that @samp{@var{a} + @var{b}}
33769 counts as a function call.) For primitive objects, this returns zero.@refill
33772 @defun polynomial-p expr var
33773 Check if @var{expr} is a polynomial in variable (or sub-expression)
33774 @var{var}. If so, return the degree of the polynomial, that is, the
33775 highest power of @var{var} that appears in @var{expr}. For example,
33776 for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns
33777 @code{nil} unless @var{expr}, when expanded out by @kbd{a x}
33778 (@code{calc-expand}), would consist of a sum of terms in which @var{var}
33779 appears only raised to nonnegative integer powers. Note that if
33780 @var{var} does not occur in @var{expr}, then @var{expr} is considered
33781 a polynomial of degree 0.@refill
33784 @defun is-polynomial expr var degree loose
33785 Check if @var{expr} is a polynomial in variable or sub-expression
33786 @var{var}, and, if so, return a list representation of the polynomial
33787 where the elements of the list are coefficients of successive powers of
33788 @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
33789 list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
33790 produce the list @samp{(1 2 1)}. The highest element of the list will
33791 be non-zero, with the special exception that if @var{expr} is the
33792 constant zero, the returned value will be @samp{(0)}. Return @code{nil}
33793 if @var{expr} is not a polynomial in @var{var}. If @var{degree} is
33794 specified, this will not consider polynomials of degree higher than that
33795 value. This is a good precaution because otherwise an input of
33796 @samp{(x+1)^1000} will cause a huge coefficient list to be built. If
33797 @var{loose} is non-@code{nil}, then a looser definition of a polynomial
33798 is used in which coefficients are no longer required not to depend on
33799 @var{var}, but are only required not to take the form of polynomials
33800 themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose
33801 polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
33802 x))}. The result will never be @code{nil} in loose mode, since any
33803 expression can be interpreted as a ``constant'' loose polynomial.@refill
33806 @defun polynomial-base expr pred
33807 Check if @var{expr} is a polynomial in any variable that occurs in it;
33808 if so, return that variable. (If @var{expr} is a multivariate polynomial,
33809 this chooses one variable arbitrarily.) If @var{pred} is specified, it should
33810 be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
33811 and which should return true if @code{mpb-top-expr} (a global name for
33812 the original @var{expr}) is a suitable polynomial in @var{subexpr}.
33813 The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
33814 you can use @var{pred} to specify additional conditions. Or, you could
33815 have @var{pred} build up a list of every suitable @var{subexpr} that
33819 @defun poly-simplify poly
33820 Simplify polynomial coefficient list @var{poly} by (destructively)
33821 clipping off trailing zeros.
33824 @defun poly-mix a ac b bc
33825 Mix two polynomial lists @var{a} and @var{b} (in the form returned by
33826 @code{is-polynomial}) in a linear combination with coefficient expressions
33827 @var{ac} and @var{bc}. The result is a (not necessarily simplified)
33828 polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.@refill
33831 @defun poly-mul a b
33832 Multiply two polynomial coefficient lists @var{a} and @var{b}. The
33833 result will be in simplified form if the inputs were simplified.
33836 @defun build-polynomial-expr poly var
33837 Construct a Calc formula which represents the polynomial coefficient
33838 list @var{poly} applied to variable @var{var}. The @kbd{a c}
33839 (@code{calc-collect}) command uses @code{is-polynomial} to turn an
33840 expression into a coefficient list, then @code{build-polynomial-expr}
33841 to turn the list back into an expression in regular form.@refill
33844 @defun check-unit-name var
33845 Check if @var{var} is a variable which can be interpreted as a unit
33846 name. If so, return the units table entry for that unit. This
33847 will be a list whose first element is the unit name (not counting
33848 prefix characters) as a symbol and whose second element is the
33849 Calc expression which defines the unit. (Refer to the Calc sources
33850 for details on the remaining elements of this list.) If @var{var}
33851 is not a variable or is not a unit name, return @code{nil}.
33854 @defun units-in-expr-p expr sub-exprs
33855 Return true if @var{expr} contains any variables which can be
33856 interpreted as units. If @var{sub-exprs} is @code{t}, the entire
33857 expression is searched. If @var{sub-exprs} is @code{nil}, this
33858 checks whether @var{expr} is directly a units expression.@refill
33861 @defun single-units-in-expr-p expr
33862 Check whether @var{expr} contains exactly one units variable. If so,
33863 return the units table entry for the variable. If @var{expr} does
33864 not contain any units, return @code{nil}. If @var{expr} contains
33865 two or more units, return the symbol @code{wrong}.
33868 @defun to-standard-units expr which
33869 Convert units expression @var{expr} to base units. If @var{which}
33870 is @code{nil}, use Calc's native base units. Otherwise, @var{which}
33871 can specify a units system, which is a list of two-element lists,
33872 where the first element is a Calc base symbol name and the second
33873 is an expression to substitute for it.@refill
33876 @defun remove-units expr
33877 Return a copy of @var{expr} with all units variables replaced by ones.
33878 This expression is generally normalized before use.
33881 @defun extract-units expr
33882 Return a copy of @var{expr} with everything but units variables replaced
33886 @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
33887 @subsubsection I/O and Formatting Functions
33890 The functions described here are responsible for parsing and formatting
33891 Calc numbers and formulas.
33893 @defun calc-eval str sep arg1 arg2 @dots{}
33894 This is the simplest interface to the Calculator from another Lisp program.
33895 @xref{Calling Calc from Your Programs}.
33898 @defun read-number str
33899 If string @var{str} contains a valid Calc number, either integer,
33900 fraction, float, or HMS form, this function parses and returns that
33901 number. Otherwise, it returns @code{nil}.
33904 @defun read-expr str
33905 Read an algebraic expression from string @var{str}. If @var{str} does
33906 not have the form of a valid expression, return a list of the form
33907 @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
33908 into @var{str} of the general location of the error, and @var{msg} is
33909 a string describing the problem.@refill
33912 @defun read-exprs str
33913 Read a list of expressions separated by commas, and return it as a
33914 Lisp list. If an error occurs in any expressions, an error list as
33915 shown above is returned instead.
33918 @defun calc-do-alg-entry initial prompt no-norm
33919 Read an algebraic formula or formulas using the minibuffer. All
33920 conventions of regular algebraic entry are observed. The return value
33921 is a list of Calc formulas; there will be more than one if the user
33922 entered a list of values separated by commas. The result is @code{nil}
33923 if the user presses Return with a blank line. If @var{initial} is
33924 given, it is a string which the minibuffer will initially contain.
33925 If @var{prompt} is given, it is the prompt string to use; the default
33926 is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will
33927 be returned exactly as parsed; otherwise, they will be passed through
33928 @code{calc-normalize} first.@refill
33930 To support the use of @kbd{$} characters in the algebraic entry, use
33931 @code{let} to bind @code{calc-dollar-values} to a list of the values
33932 to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
33933 @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used}
33934 will have been changed to the highest number of consecutive @kbd{$}s
33935 that actually appeared in the input.@refill
33938 @defun format-number a
33939 Convert the real or complex number or HMS form @var{a} to string form.
33942 @defun format-flat-expr a prec
33943 Convert the arbitrary Calc number or formula @var{a} to string form,
33944 in the style used by the trail buffer and the @code{calc-edit} command.
33945 This is a simple format designed
33946 mostly to guarantee the string is of a form that can be re-parsed by
33947 @code{read-expr}. Most formatting modes, such as digit grouping,
33948 complex number format, and point character, are ignored to ensure the
33949 result will be re-readable. The @var{prec} parameter is normally 0; if
33950 you pass a large integer like 1000 instead, the expression will be
33951 surrounded by parentheses unless it is a plain number or variable name.@refill
33954 @defun format-nice-expr a width
33955 This is like @code{format-flat-expr} (with @var{prec} equal to 0),
33956 except that newlines will be inserted to keep lines down to the
33957 specified @var{width}, and vectors that look like matrices or rewrite
33958 rules are written in a pseudo-matrix format. The @code{calc-edit}
33959 command uses this when only one stack entry is being edited.
33962 @defun format-value a width
33963 Convert the Calc number or formula @var{a} to string form, using the
33964 format seen in the stack buffer. Beware the string returned may
33965 not be re-readable by @code{read-expr}, for example, because of digit
33966 grouping. Multi-line objects like matrices produce strings that
33967 contain newline characters to separate the lines. The @var{w}
33968 parameter, if given, is the target window size for which to format
33969 the expressions. If @var{w} is omitted, the width of the Calculator
33970 window is used.@refill
33973 @defun compose-expr a prec
33974 Format the Calc number or formula @var{a} according to the current
33975 language mode, returning a ``composition.'' To learn about the
33976 structure of compositions, see the comments in the Calc source code.
33977 You can specify the format of a given type of function call by putting
33978 a @code{math-compose-@var{lang}} property on the function's symbol,
33979 whose value is a Lisp function that takes @var{a} and @var{prec} as
33980 arguments and returns a composition. Here @var{lang} is a language
33981 mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
33982 @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
33983 In Big mode, Calc actually tries @code{math-compose-big} first, then
33984 tries @code{math-compose-normal}. If this property does not exist,
33985 or if the function returns @code{nil}, the function is written in the
33986 normal function-call notation for that language.
33989 @defun composition-to-string c w
33990 Convert a composition structure returned by @code{compose-expr} into
33991 a string. Multi-line compositions convert to strings containing
33992 newline characters. The target window size is given by @var{w}.
33993 The @code{format-value} function basically calls @code{compose-expr}
33994 followed by @code{composition-to-string}.
33997 @defun comp-width c
33998 Compute the width in characters of composition @var{c}.
34001 @defun comp-height c
34002 Compute the height in lines of composition @var{c}.
34005 @defun comp-ascent c
34006 Compute the portion of the height of composition @var{c} which is on or
34007 above the baseline. For a one-line composition, this will be one.
34010 @defun comp-descent c
34011 Compute the portion of the height of composition @var{c} which is below
34012 the baseline. For a one-line composition, this will be zero.
34015 @defun comp-first-char c
34016 If composition @var{c} is a ``flat'' composition, return the first
34017 (leftmost) character of the composition as an integer. Otherwise,
34018 return @code{nil}.@refill
34021 @defun comp-last-char c
34022 If composition @var{c} is a ``flat'' composition, return the last
34023 (rightmost) character, otherwise return @code{nil}.
34026 @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
34027 @comment @subsubsection Lisp Variables
34030 @comment (This section is currently unfinished.)
34032 @node Hooks, , Formatting Lisp Functions, Internals
34033 @subsubsection Hooks
34036 Hooks are variables which contain Lisp functions (or lists of functions)
34037 which are called at various times. Calc defines a number of hooks
34038 that help you to customize it in various ways. Calc uses the Lisp
34039 function @code{run-hooks} to invoke the hooks shown below. Several
34040 other customization-related variables are also described here.
34042 @defvar calc-load-hook
34043 This hook is called at the end of @file{calc.el}, after the file has
34044 been loaded, before any functions in it have been called, but after
34045 @code{calc-mode-map} and similar variables have been set up.
34048 @defvar calc-ext-load-hook
34049 This hook is called at the end of @file{calc-ext.el}.
34052 @defvar calc-start-hook
34053 This hook is called as the last step in a @kbd{M-x calc} command.
34054 At this point, the Calc buffer has been created and initialized if
34055 necessary, the Calc window and trail window have been created,
34056 and the ``Welcome to Calc'' message has been displayed.
34059 @defvar calc-mode-hook
34060 This hook is called when the Calc buffer is being created. Usually
34061 this will only happen once per Emacs session. The hook is called
34062 after Emacs has switched to the new buffer, the mode-settings file
34063 has been read if necessary, and all other buffer-local variables
34064 have been set up. After this hook returns, Calc will perform a
34065 @code{calc-refresh} operation, set up the mode line display, then
34066 evaluate any deferred @code{calc-define} properties that have not
34067 been evaluated yet.
34070 @defvar calc-trail-mode-hook
34071 This hook is called when the Calc Trail buffer is being created.
34072 It is called as the very last step of setting up the Trail buffer.
34073 Like @code{calc-mode-hook}, this will normally happen only once
34077 @defvar calc-end-hook
34078 This hook is called by @code{calc-quit}, generally because the user
34079 presses @kbd{q} or @kbd{M-# c} while in Calc. The Calc buffer will
34080 be the current buffer. The hook is called as the very first
34081 step, before the Calc window is destroyed.
34084 @defvar calc-window-hook
34085 If this hook exists, it is called to create the Calc window.
34086 Upon return, this new Calc window should be the current window.
34087 (The Calc buffer will already be the current buffer when the
34088 hook is called.) If the hook is not defined, Calc will
34089 generally use @code{split-window}, @code{set-window-buffer},
34090 and @code{select-window} to create the Calc window.
34093 @defvar calc-trail-window-hook
34094 If this hook exists, it is called to create the Calc Trail window.
34095 The variable @code{calc-trail-buffer} will contain the buffer
34096 which the window should use. Unlike @code{calc-window-hook},
34097 this hook must @emph{not} switch into the new window.
34100 @defvar calc-edit-mode-hook
34101 This hook is called by @code{calc-edit} (and the other ``edit''
34102 commands) when the temporary editing buffer is being created.
34103 The buffer will have been selected and set up to be in
34104 @code{calc-edit-mode}, but will not yet have been filled with
34105 text. (In fact it may still have leftover text from a previous
34106 @code{calc-edit} command.)
34109 @defvar calc-mode-save-hook
34110 This hook is called by the @code{calc-save-modes} command,
34111 after Calc's own mode features have been inserted into the
34112 @file{.emacs} buffer and just before the ``End of mode settings''
34113 message is inserted.
34116 @defvar calc-reset-hook
34117 This hook is called after @kbd{M-# 0} (@code{calc-reset}) has
34118 reset all modes. The Calc buffer will be the current buffer.
34121 @defvar calc-other-modes
34122 This variable contains a list of strings. The strings are
34123 concatenated at the end of the modes portion of the Calc
34124 mode line (after standard modes such as ``Deg'', ``Inv'' and
34125 ``Hyp''). Each string should be a short, single word followed
34126 by a space. The variable is @code{nil} by default.
34129 @defvar calc-mode-map
34130 This is the keymap that is used by Calc mode. The best time
34131 to adjust it is probably in a @code{calc-mode-hook}. If the
34132 Calc extensions package (@file{calc-ext.el}) has not yet been
34133 loaded, many of these keys will be bound to @code{calc-missing-key},
34134 which is a command that loads the extensions package and
34135 ``retypes'' the key. If your @code{calc-mode-hook} rebinds
34136 one of these keys, it will probably be overridden when the
34137 extensions are loaded.
34140 @defvar calc-digit-map
34141 This is the keymap that is used during numeric entry. Numeric
34142 entry uses the minibuffer, but this map binds every non-numeric
34143 key to @code{calcDigit-nondigit} which generally calls
34144 @code{exit-minibuffer} and ``retypes'' the key.
34147 @defvar calc-alg-ent-map
34148 This is the keymap that is used during algebraic entry. This is
34149 mostly a copy of @code{minibuffer-local-map}.
34152 @defvar calc-store-var-map
34153 This is the keymap that is used during entry of variable names for
34154 commands like @code{calc-store} and @code{calc-recall}. This is
34155 mostly a copy of @code{minibuffer-local-completion-map}.
34158 @defvar calc-edit-mode-map
34159 This is the (sparse) keymap used by @code{calc-edit} and other
34160 temporary editing commands. It binds @key{RET}, @key{LFD},
34161 and @kbd{C-c C-c} to @code{calc-edit-finish}.
34164 @defvar calc-mode-var-list
34165 This is a list of variables which are saved by @code{calc-save-modes}.
34166 Each entry is a list of two items, the variable (as a Lisp symbol)
34167 and its default value. When modes are being saved, each variable
34168 is compared with its default value (using @code{equal}) and any
34169 non-default variables are written out.
34172 @defvar calc-local-var-list
34173 This is a list of variables which should be buffer-local to the
34174 Calc buffer. Each entry is a variable name (as a Lisp symbol).
34175 These variables also have their default values manipulated by
34176 the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
34177 Since @code{calc-mode-hook} is called after this list has been
34178 used the first time, your hook should add a variable to the
34179 list and also call @code{make-local-variable} itself.
34182 @node Installation, Reporting Bugs, Programming, Top
34183 @appendix Installation
34186 As of Calc 2.02g, Calc is integrated with GNU Emacs, and thus requires
34187 no separate installation of its Lisp files and this manual.
34189 @appendixsec The GNUPLOT Program
34192 Calc's graphing commands use the GNUPLOT program. If you have GNUPLOT
34193 but you must type some command other than @file{gnuplot} to get it,
34194 you should add a command to set the Lisp variable @code{calc-gnuplot-name}
34195 to the appropriate file name. You may also need to change the variables
34196 @code{calc-gnuplot-plot-command} and @code{calc-gnuplot-print-command} in
34197 order to get correct displays and hardcopies, respectively, of your
34205 @appendixsec Printed Documentation
34208 Because the Calc manual is so large, you should only make a printed
34209 copy if you really need it. To print the manual, you will need the
34210 @TeX{} typesetting program (this is a free program by Donald Knuth
34211 at Stanford University) as well as the @file{texindex} program and
34212 @file{texinfo.tex} file, both of which can be obtained from the FSF
34213 as part of the @code{texinfo} package.@refill
34215 To print the Calc manual in one huge 470 page tome, you will need the
34216 source code to this manual, @file{calc.texi}, available as part of the
34217 Emacs source. Once you have this file, type @kbd{texi2dvi calc.texi}.
34218 Alternatively, change to the @file{man} subdirectory of the Emacs
34219 source distribution, and type @kbd{make calc.dvi}. (Don't worry if you
34220 get some ``overfull box'' warnings while @TeX{} runs.)
34222 The result will be a device-independent output file called
34223 @file{calc.dvi}, which you must print in whatever way is right
34224 for your system. On many systems, the command is
34237 @c the bumpoddpages macro was deleted
34239 @cindex Marginal notes, adjusting
34240 Marginal notes for each function and key sequence normally alternate
34241 between the left and right sides of the page, which is correct if the
34242 manual is going to be bound as double-sided pages. Near the top of
34243 the file @file{calc.texi} you will find alternate definitions of
34244 the @code{\bumpoddpages} macro that put the marginal notes always on
34245 the same side, best if you plan to be binding single-sided pages.
34248 @appendixsec Settings File
34251 @vindex calc-settings-file
34252 Another variable you might want to set is @code{calc-settings-file},
34253 which holds the file name in which commands like @kbd{m m} and @kbd{Z P}
34254 store ``permanent'' definitions. The default value for this variable
34255 is @code{"~/.emacs"}. If @code{calc-settings-file} does not contain
34256 @code{".emacs"} as a substring, and if the variable
34257 @code{calc-loaded-settings-file} is @code{nil}, then Calc will
34258 automatically load your settings file (if it exists) the first time
34259 Calc is invoked.@refill
34266 @appendixsec Testing the Installation
34269 To test your installation of Calc, start a new Emacs and type @kbd{M-# c}
34270 to make sure the autoloads and key bindings work. Type @kbd{M-# i}
34271 to make sure Calc can find its Info documentation. Press @kbd{q} to
34272 exit the Info system and @kbd{M-# c} to re-enter the Calculator.
34273 Type @kbd{20 S} to compute the sine of 20 degrees; this will test the
34274 autoloading of the extensions modules. The result should be
34275 0.342020143326. Finally, press @kbd{M-# c} again to make sure the
34276 Calculator can exit.
34278 You may also wish to test the GNUPLOT interface; to plot a sine wave,
34279 type @kbd{' [0 ..@: 360], sin(x) @key{RET} g f}. Type @kbd{g q} when you
34280 are done viewing the plot.
34282 Calc is now ready to use. If you wish to go through the Calc Tutorial,
34283 press @kbd{M-# t} to begin.
34287 @node Reporting Bugs, Summary, Installation, Top
34288 @appendix Reporting Bugs
34291 If you find a bug in Calc, send e-mail to Colin Walters,
34294 walters@@debian.org @r{or}
34295 walters@@verbum.org
34299 (In the following text, ``I'' refers to the original Calc author, Dave
34302 While I cannot guarantee that I will have time to work on your bug,
34303 I do try to fix bugs quickly whenever I can.
34305 The latest version of Calc is available from Savannah, in the Emacs
34306 CVS tree. See @uref{http://savannah.gnu.org/projects/emacs}.
34308 There is an automatic command @kbd{M-x report-calc-bug} which helps
34309 you to report bugs. This command prompts you for a brief subject
34310 line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to
34311 send your mail. Make sure your subject line indicates that you are
34312 reporting a Calc bug; this command sends mail to the maintainer's
34315 If you have suggestions for additional features for Calc, I would
34316 love to hear them. Some have dared to suggest that Calc is already
34317 top-heavy with features; I really don't see what they're talking
34318 about, so, if you have ideas, send them right in. (I may even have
34319 time to implement them!)
34321 At the front of the source file, @file{calc.el}, is a list of ideas for
34322 future work which I have not had time to do. If any enthusiastic souls
34323 wish to take it upon themselves to work on these, I would be delighted.
34324 Please let me know if you plan to contribute to Calc so I can coordinate
34325 your efforts with mine and those of others. I will do my best to help
34326 you in whatever way I can.
34329 @node Summary, Key Index, Reporting Bugs, Top
34330 @appendix Calc Summary
34333 This section includes a complete list of Calc 2.02 keystroke commands.
34334 Each line lists the stack entries used by the command (top-of-stack
34335 last), the keystrokes themselves, the prompts asked by the command,
34336 and the result of the command (also with top-of-stack last).
34337 The result is expressed using the equivalent algebraic function.
34338 Commands which put no results on the stack show the full @kbd{M-x}
34339 command name in that position. Numbers preceding the result or
34340 command name refer to notes at the end.
34342 Algebraic functions and @kbd{M-x} commands that don't have corresponding
34343 keystrokes are not listed in this summary.
34344 @xref{Command Index}. @xref{Function Index}.
34349 \vskip-2\baselineskip \null
34350 \gdef\sumrow#1{\sumrowx#1\relax}%
34351 \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
34354 \hbox to5em{\sl\hss#1}%
34355 \hbox to5em{\tt#2\hss}%
34356 \hbox to4em{\sl#3\hss}%
34357 \hbox to5em{\rm\hss#4}%
34362 \gdef\sumlpar{{\rm(}}%
34363 \gdef\sumrpar{{\rm)}}%
34364 \gdef\sumcomma{{\rm,\thinspace}}%
34365 \gdef\sumexcl{{\rm!}}%
34366 \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
34367 \gdef\minus#1{{\tt-}}%
34371 @catcode`@(=@active @let(=@sumlpar
34372 @catcode`@)=@active @let)=@sumrpar
34373 @catcode`@,=@active @let,=@sumcomma
34374 @catcode`@!=@active @let!=@sumexcl
34378 @advance@baselineskip-2.5pt
34381 @r{ @: M-# a @: @: 33 @:calc-embedded-activate@:}
34382 @r{ @: M-# b @: @: @:calc-big-or-small@:}
34383 @r{ @: M-# c @: @: @:calc@:}
34384 @r{ @: M-# d @: @: @:calc-embedded-duplicate@:}
34385 @r{ @: M-# e @: @: 34 @:calc-embedded@:}
34386 @r{ @: M-# f @:formula @: @:calc-embedded-new-formula@:}
34387 @r{ @: M-# g @: @: 35 @:calc-grab-region@:}
34388 @r{ @: M-# i @: @: @:calc-info@:}
34389 @r{ @: M-# j @: @: @:calc-embedded-select@:}
34390 @r{ @: M-# k @: @: @:calc-keypad@:}
34391 @r{ @: M-# l @: @: @:calc-load-everything@:}
34392 @r{ @: M-# m @: @: @:read-kbd-macro@:}
34393 @r{ @: M-# n @: @: 4 @:calc-embedded-next@:}
34394 @r{ @: M-# o @: @: @:calc-other-window@:}
34395 @r{ @: M-# p @: @: 4 @:calc-embedded-previous@:}
34396 @r{ @: M-# q @:formula @: @:quick-calc@:}
34397 @r{ @: M-# r @: @: 36 @:calc-grab-rectangle@:}
34398 @r{ @: M-# s @: @: @:calc-info-summary@:}
34399 @r{ @: M-# t @: @: @:calc-tutorial@:}
34400 @r{ @: M-# u @: @: @:calc-embedded-update@:}
34401 @r{ @: M-# w @: @: @:calc-embedded-word@:}
34402 @r{ @: M-# x @: @: @:calc-quit@:}
34403 @r{ @: M-# y @: @:1,28,49 @:calc-copy-to-buffer@:}
34404 @r{ @: M-# z @: @: @:calc-user-invocation@:}
34405 @r{ @: M-# : @: @: 36 @:calc-grab-sum-down@:}
34406 @r{ @: M-# _ @: @: 36 @:calc-grab-sum-across@:}
34407 @r{ @: M-# ` @:editing @: 30 @:calc-embedded-edit@:}
34408 @r{ @: M-# 0 @:(zero) @: @:calc-reset@:}
34411 @r{ @: 0-9 @:number @: @:@:number}
34412 @r{ @: . @:number @: @:@:0.number}
34413 @r{ @: _ @:number @: @:-@:number}
34414 @r{ @: e @:number @: @:@:1e number}
34415 @r{ @: # @:number @: @:@:current-radix@t{#}number}
34416 @r{ @: P @:(in number) @: @:+/-@:}
34417 @r{ @: M @:(in number) @: @:mod@:}
34418 @r{ @: @@ ' " @: (in number)@: @:@:HMS form}
34419 @r{ @: h m s @: (in number)@: @:@:HMS form}
34422 @r{ @: ' @:formula @: 37,46 @:@:formula}
34423 @r{ @: $ @:formula @: 37,46 @:$@:formula}
34424 @r{ @: " @:string @: 37,46 @:@:string}
34427 @r{ a b@: + @: @: 2 @:add@:(a,b) a+b}
34428 @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b}
34429 @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b}
34430 @r{ a b@: / @: @: 2 @:div@:(a,b) a/b}
34431 @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b}
34432 @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)}
34433 @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b}
34434 @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b}
34435 @r{ a b@: : @: @: 2 @:fdiv@:(a,b)}
34436 @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b}
34437 @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a}
34438 @r{ a b@: H | @: @: 2 @:append@:(a,b)}
34439 @r{ a b@: I H | @: @: @:append@:(b,a)}
34440 @r{ a@: & @: @: 1 @:inv@:(a) 1/a}
34441 @r{ a@: ! @: @: 1 @:fact@:(a) a!}
34442 @r{ a@: = @: @: 1 @:evalv@:(a)}
34443 @r{ a@: M-% @: @: @:percent@:(a) a%}
34446 @r{ ... a@: @key{RET} @: @: 1 @:@:... a a}
34447 @r{ ... a@: @key{SPC} @: @: 1 @:@:... a a}
34448 @r{... a b@: @key{TAB} @: @: 3 @:@:... b a}
34449 @r{. a b c@: M-@key{TAB} @: @: 3 @:@:... b c a}
34450 @r{... a b@: @key{LFD} @: @: 1 @:@:... a b a}
34451 @r{ ... a@: @key{DEL} @: @: 1 @:@:...}
34452 @r{... a b@: M-@key{DEL} @: @: 1 @:@:... b}
34453 @r{ @: M-@key{RET} @: @: 4 @:calc-last-args@:}
34454 @r{ a@: ` @:editing @: 1,30 @:calc-edit@:}
34457 @r{ ... a@: C-d @: @: 1 @:@:...}
34458 @r{ @: C-k @: @: 27 @:calc-kill@:}
34459 @r{ @: C-w @: @: 27 @:calc-kill-region@:}
34460 @r{ @: C-y @: @: @:calc-yank@:}
34461 @r{ @: C-_ @: @: 4 @:calc-undo@:}
34462 @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:}
34463 @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:}
34466 @r{ @: [ @: @: @:@:[...}
34467 @r{[.. a b@: ] @: @: @:@:[a,b]}
34468 @r{ @: ( @: @: @:@:(...}
34469 @r{(.. a b@: ) @: @: @:@:(a,b)}
34470 @r{ @: , @: @: @:@:vector or rect complex}
34471 @r{ @: ; @: @: @:@:matrix or polar complex}
34472 @r{ @: .. @: @: @:@:interval}
34475 @r{ @: ~ @: @: @:calc-num-prefix@:}
34476 @r{ @: < @: @: 4 @:calc-scroll-left@:}
34477 @r{ @: > @: @: 4 @:calc-scroll-right@:}
34478 @r{ @: @{ @: @: 4 @:calc-scroll-down@:}
34479 @r{ @: @} @: @: 4 @:calc-scroll-up@:}
34480 @r{ @: ? @: @: @:calc-help@:}
34483 @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a}
34484 @r{ @: o @: @: 4 @:calc-realign@:}
34485 @r{ @: p @:precision @: 31 @:calc-precision@:}
34486 @r{ @: q @: @: @:calc-quit@:}
34487 @r{ @: w @: @: @:calc-why@:}
34488 @r{ @: x @:command @: @:M-x calc-@:command}
34489 @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:}
34492 @r{ a@: A @: @: 1 @:abs@:(a)}
34493 @r{ a b@: B @: @: 2 @:log@:(a,b)}
34494 @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a}
34495 @r{ a@: C @: @: 1 @:cos@:(a)}
34496 @r{ a@: I C @: @: 1 @:arccos@:(a)}
34497 @r{ a@: H C @: @: 1 @:cosh@:(a)}
34498 @r{ a@: I H C @: @: 1 @:arccosh@:(a)}
34499 @r{ @: D @: @: 4 @:calc-redo@:}
34500 @r{ a@: E @: @: 1 @:exp@:(a)}
34501 @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a}
34502 @r{ a@: F @: @: 1,11 @:floor@:(a,d)}
34503 @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)}
34504 @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)}
34505 @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)}
34506 @r{ a@: G @: @: 1 @:arg@:(a)}
34507 @r{ @: H @:command @: 32 @:@:Hyperbolic}
34508 @r{ @: I @:command @: 32 @:@:Inverse}
34509 @r{ a@: J @: @: 1 @:conj@:(a)}
34510 @r{ @: K @:command @: 32 @:@:Keep-args}
34511 @r{ a@: L @: @: 1 @:ln@:(a)}
34512 @r{ a@: H L @: @: 1 @:log10@:(a)}
34513 @r{ @: M @: @: @:calc-more-recursion-depth@:}
34514 @r{ @: I M @: @: @:calc-less-recursion-depth@:}
34515 @r{ a@: N @: @: 5 @:evalvn@:(a)}
34516 @r{ @: P @: @: @:@:pi}
34517 @r{ @: I P @: @: @:@:gamma}
34518 @r{ @: H P @: @: @:@:e}
34519 @r{ @: I H P @: @: @:@:phi}
34520 @r{ a@: Q @: @: 1 @:sqrt@:(a)}
34521 @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2}
34522 @r{ a@: R @: @: 1,11 @:round@:(a,d)}
34523 @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)}
34524 @r{ a@: H R @: @: 1,11 @:fround@:(a,d)}
34525 @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)}
34526 @r{ a@: S @: @: 1 @:sin@:(a)}
34527 @r{ a@: I S @: @: 1 @:arcsin@:(a)}
34528 @r{ a@: H S @: @: 1 @:sinh@:(a)}
34529 @r{ a@: I H S @: @: 1 @:arcsinh@:(a)}
34530 @r{ a@: T @: @: 1 @:tan@:(a)}
34531 @r{ a@: I T @: @: 1 @:arctan@:(a)}
34532 @r{ a@: H T @: @: 1 @:tanh@:(a)}
34533 @r{ a@: I H T @: @: 1 @:arctanh@:(a)}
34534 @r{ @: U @: @: 4 @:calc-undo@:}
34535 @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:}
34538 @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b}
34539 @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b}
34540 @r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b}
34541 @r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b}
34542 @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b}
34543 @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b}
34544 @r{ a b@: a @{ @: @: 2 @:in@:(a,b)}
34545 @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b}
34546 @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b}
34547 @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a}
34548 @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c}
34549 @r{ a@: a . @: @: 1 @:rmeq@:(a)}
34550 @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:}
34553 @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)}
34554 @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)}
34555 @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)}
34556 @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b}
34559 @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)}
34560 @r{ a b@: a % @: @: 2 @:prem@:(a,b)}
34561 @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]}
34562 @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b}
34565 @r{ a@: a a @: @: 1 @:apart@:(a)}
34566 @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)}
34567 @r{ a@: a c @:v @: 38 @:collect@:(a,v)}
34568 @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)}
34569 @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)}
34570 @r{ a@: a e @: @: @:esimplify@:(a)}
34571 @r{ a@: a f @: @: 1 @:factor@:(a)}
34572 @r{ a@: H a f @: @: 1 @:factors@:(a)}
34573 @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)}
34574 @r{ a@: a i @:v @: 38 @:integ@:(a,v)}
34575 @r{ a@: a m @:pats @: 38 @:match@:(a,pats)}
34576 @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)}
34577 @r{ data x@: a p @: @: 28 @:polint@:(data,x)}
34578 @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)}
34579 @r{ a@: a n @: @: 1 @:nrat@:(a)}
34580 @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)}
34581 @r{ a@: a s @: @: @:simplify@:(a)}
34582 @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)}
34583 @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:}
34584 @r{ a@: a x @: @: 4,8 @:expand@:(a)}
34587 @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)}
34588 @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)}
34589 @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)}
34590 @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)}
34591 @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)}
34592 @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)}
34593 @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)}
34594 @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)}
34595 @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)}
34596 @r{ a@: a P @:v @: 38 @:roots@:(a,v)}
34597 @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)}
34598 @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)}
34599 @r{ a@: a S @:v @: 38 @:solve@:(a,v)}
34600 @r{ a@: I a S @:v @: 38 @:finv@:(a,v)}
34601 @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)}
34602 @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)}
34603 @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)}
34604 @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)}
34605 @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)}
34608 @r{ a b@: b a @: @: 9 @:and@:(a,b,w)}
34609 @r{ a@: b c @: @: 9 @:clip@:(a,w)}
34610 @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)}
34611 @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)}
34612 @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)}
34613 @r{ a@: b n @: @: 9 @:not@:(a,w)}
34614 @r{ a b@: b o @: @: 9 @:or@:(a,b,w)}
34615 @r{ v@: b p @: @: 1 @:vpack@:(v)}
34616 @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)}
34617 @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)}
34618 @r{ a@: b t @: @: 10 @:rot@:(a,n,w)}
34619 @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)}
34620 @r{ a@: b u @: @: 1 @:vunpack@:(a)}
34621 @r{ @: b w @:w @: 9,50 @:calc-word-size@:}
34622 @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)}
34625 @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)}
34626 @r{ r n p@: b F @: @: @:fv@:(r,n,p)}
34627 @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)}
34628 @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)}
34629 @r{ v@: b I @: @: 19 @:irr@:(v)}
34630 @r{ v@: I b I @: @: 19 @:irrb@:(v)}
34631 @r{ a@: b L @: @: 10 @:ash@:(a,n,w)}
34632 @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)}
34633 @r{ r n a@: b M @: @: @:pmt@:(r,n,a)}
34634 @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)}
34635 @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)}
34636 @r{ r v@: b N @: @: 19 @:npv@:(r,v)}
34637 @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)}
34638 @r{ r n p@: b P @: @: @:pv@:(r,n,p)}
34639 @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)}
34640 @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)}
34641 @r{ a@: b R @: @: 10 @:rash@:(a,n,w)}
34642 @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)}
34643 @r{ c s l@: b S @: @: @:sln@:(c,s,l)}
34644 @r{ n p a@: b T @: @: @:rate@:(n,p,a)}
34645 @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)}
34646 @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)}
34647 @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)}
34649 @r{ r p a@: b # @: @: @:nper@:(r,p,a)}
34650 @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)}
34651 @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)}
34652 @r{ a b@: b % @: @: @:relch@:(a,b)}
34655 @r{ a@: c c @: @: 5 @:pclean@:(a,p)}
34656 @r{ a@: c 0-9 @: @: @:pclean@:(a,p)}
34657 @r{ a@: H c c @: @: 5 @:clean@:(a,p)}
34658 @r{ a@: H c 0-9 @: @: @:clean@:(a,p)}
34659 @r{ a@: c d @: @: 1 @:deg@:(a)}
34660 @r{ a@: c f @: @: 1 @:pfloat@:(a)}
34661 @r{ a@: H c f @: @: 1 @:float@:(a)}
34662 @r{ a@: c h @: @: 1 @:hms@:(a)}
34663 @r{ a@: c p @: @: @:polar@:(a)}
34664 @r{ a@: I c p @: @: @:rect@:(a)}
34665 @r{ a@: c r @: @: 1 @:rad@:(a)}
34668 @r{ a@: c F @: @: 5 @:pfrac@:(a,p)}
34669 @r{ a@: H c F @: @: 5 @:frac@:(a,p)}
34672 @r{ a@: c % @: @: @:percent@:(a*100)}
34675 @r{ @: d . @:char @: 50 @:calc-point-char@:}
34676 @r{ @: d , @:char @: 50 @:calc-group-char@:}
34677 @r{ @: d < @: @: 13,50 @:calc-left-justify@:}
34678 @r{ @: d = @: @: 13,50 @:calc-center-justify@:}
34679 @r{ @: d > @: @: 13,50 @:calc-right-justify@:}
34680 @r{ @: d @{ @:label @: 50 @:calc-left-label@:}
34681 @r{ @: d @} @:label @: 50 @:calc-right-label@:}
34682 @r{ @: d [ @: @: 4 @:calc-truncate-up@:}
34683 @r{ @: d ] @: @: 4 @:calc-truncate-down@:}
34684 @r{ @: d " @: @: 12,50 @:calc-display-strings@:}
34685 @r{ @: d @key{SPC} @: @: @:calc-refresh@:}
34686 @r{ @: d @key{RET} @: @: 1 @:calc-refresh-top@:}
34689 @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:}
34690 @r{ @: d 2 @: @: 50 @:calc-binary-radix@:}
34691 @r{ @: d 6 @: @: 50 @:calc-hex-radix@:}
34692 @r{ @: d 8 @: @: 50 @:calc-octal-radix@:}
34695 @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:}
34696 @r{ @: d c @: @: 50 @:calc-complex-notation@:}
34697 @r{ @: d d @:format @: 50 @:calc-date-notation@:}
34698 @r{ @: d e @: @: 5,50 @:calc-eng-notation@:}
34699 @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:}
34700 @r{ @: d g @: @:12,13,50 @:calc-group-digits@:}
34701 @r{ @: d h @:format @: 50 @:calc-hms-notation@:}
34702 @r{ @: d i @: @: 50 @:calc-i-notation@:}
34703 @r{ @: d j @: @: 50 @:calc-j-notation@:}
34704 @r{ @: d l @: @: 12,50 @:calc-line-numbering@:}
34705 @r{ @: d n @: @: 5,50 @:calc-normal-notation@:}
34706 @r{ @: d o @:format @: 50 @:calc-over-notation@:}
34707 @r{ @: d p @: @: 12,50 @:calc-show-plain@:}
34708 @r{ @: d r @:radix @: 31,50 @:calc-radix@:}
34709 @r{ @: d s @: @: 5,50 @:calc-sci-notation@:}
34710 @r{ @: d t @: @: 27 @:calc-truncate-stack@:}
34711 @r{ @: d w @: @: 12,13 @:calc-auto-why@:}
34712 @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:}
34715 @r{ @: d B @: @: 50 @:calc-big-language@:}
34716 @r{ @: d C @: @: 50 @:calc-c-language@:}
34717 @r{ @: d E @: @: 50 @:calc-eqn-language@:}
34718 @r{ @: d F @: @: 50 @:calc-fortran-language@:}
34719 @r{ @: d M @: @: 50 @:calc-mathematica-language@:}
34720 @r{ @: d N @: @: 50 @:calc-normal-language@:}
34721 @r{ @: d O @: @: 50 @:calc-flat-language@:}
34722 @r{ @: d P @: @: 50 @:calc-pascal-language@:}
34723 @r{ @: d T @: @: 50 @:calc-tex-language@:}
34724 @r{ @: d U @: @: 50 @:calc-unformatted-language@:}
34725 @r{ @: d W @: @: 50 @:calc-maple-language@:}
34728 @r{ a@: f [ @: @: 4 @:decr@:(a,n)}
34729 @r{ a@: f ] @: @: 4 @:incr@:(a,n)}
34732 @r{ a b@: f b @: @: 2 @:beta@:(a,b)}
34733 @r{ a@: f e @: @: 1 @:erf@:(a)}
34734 @r{ a@: I f e @: @: 1 @:erfc@:(a)}
34735 @r{ a@: f g @: @: 1 @:gamma@:(a)}
34736 @r{ a b@: f h @: @: 2 @:hypot@:(a,b)}
34737 @r{ a@: f i @: @: 1 @:im@:(a)}
34738 @r{ n a@: f j @: @: 2 @:besJ@:(n,a)}
34739 @r{ a b@: f n @: @: 2 @:min@:(a,b)}
34740 @r{ a@: f r @: @: 1 @:re@:(a)}
34741 @r{ a@: f s @: @: 1 @:sign@:(a)}
34742 @r{ a b@: f x @: @: 2 @:max@:(a,b)}
34743 @r{ n a@: f y @: @: 2 @:besY@:(n,a)}
34746 @r{ a@: f A @: @: 1 @:abssqr@:(a)}
34747 @r{ x a b@: f B @: @: @:betaI@:(x,a,b)}
34748 @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)}
34749 @r{ a@: f E @: @: 1 @:expm1@:(a)}
34750 @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)}
34751 @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)}
34752 @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)}
34753 @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)}
34754 @r{ a b@: f I @: @: 2 @:ilog@:(a,b)}
34755 @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a}
34756 @r{ a@: f L @: @: 1 @:lnp1@:(a)}
34757 @r{ a@: f M @: @: 1 @:mant@:(a)}
34758 @r{ a@: f Q @: @: 1 @:isqrt@:(a)}
34759 @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2}
34760 @r{ a n@: f S @: @: 2 @:scf@:(a,n)}
34761 @r{ y x@: f T @: @: @:arctan2@:(y,x)}
34762 @r{ a@: f X @: @: 1 @:xpon@:(a)}
34765 @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:}
34766 @r{ @: g b @: @: 12 @:calc-graph-border@:}
34767 @r{ @: g c @: @: @:calc-graph-clear@:}
34768 @r{ @: g d @: @: 41 @:calc-graph-delete@:}
34769 @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:}
34770 @r{ @: g g @: @: 12 @:calc-graph-grid@:}
34771 @r{ @: g h @:title @: @:calc-graph-header@:}
34772 @r{ @: g j @: @: 4 @:calc-graph-juggle@:}
34773 @r{ @: g k @: @: 12 @:calc-graph-key@:}
34774 @r{ @: g l @: @: 12 @:calc-graph-log-x@:}
34775 @r{ @: g n @:name @: @:calc-graph-name@:}
34776 @r{ @: g p @: @: 42 @:calc-graph-plot@:}
34777 @r{ @: g q @: @: @:calc-graph-quit@:}
34778 @r{ @: g r @:range @: @:calc-graph-range-x@:}
34779 @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:}
34780 @r{ @: g t @:title @: @:calc-graph-title-x@:}
34781 @r{ @: g v @: @: @:calc-graph-view-commands@:}
34782 @r{ @: g x @:display @: @:calc-graph-display@:}
34783 @r{ @: g z @: @: 12 @:calc-graph-zero-x@:}
34786 @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:}
34787 @r{ @: g C @:command @: @:calc-graph-command@:}
34788 @r{ @: g D @:device @: 43,44 @:calc-graph-device@:}
34789 @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:}
34790 @r{ @: g H @: @: 12 @:calc-graph-hide@:}
34791 @r{ @: g K @: @: @:calc-graph-kill@:}
34792 @r{ @: g L @: @: 12 @:calc-graph-log-y@:}
34793 @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:}
34794 @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:}
34795 @r{ @: g P @: @: 42 @:calc-graph-print@:}
34796 @r{ @: g R @:range @: @:calc-graph-range-y@:}
34797 @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:}
34798 @r{ @: g T @:title @: @:calc-graph-title-y@:}
34799 @r{ @: g V @: @: @:calc-graph-view-trail@:}
34800 @r{ @: g X @:format @: @:calc-graph-geometry@:}
34801 @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:}
34804 @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:}
34805 @r{ @: g C-r @:range @: @:calc-graph-range-z@:}
34806 @r{ @: g C-t @:title @: @:calc-graph-title-z@:}
34809 @r{ @: h b @: @: @:calc-describe-bindings@:}
34810 @r{ @: h c @:key @: @:calc-describe-key-briefly@:}
34811 @r{ @: h f @:function @: @:calc-describe-function@:}
34812 @r{ @: h h @: @: @:calc-full-help@:}
34813 @r{ @: h i @: @: @:calc-info@:}
34814 @r{ @: h k @:key @: @:calc-describe-key@:}
34815 @r{ @: h n @: @: @:calc-view-news@:}
34816 @r{ @: h s @: @: @:calc-info-summary@:}
34817 @r{ @: h t @: @: @:calc-tutorial@:}
34818 @r{ @: h v @:var @: @:calc-describe-variable@:}
34821 @r{ @: j 1-9 @: @: @:calc-select-part@:}
34822 @r{ @: j @key{RET} @: @: 27 @:calc-copy-selection@:}
34823 @r{ @: j @key{DEL} @: @: 27 @:calc-del-selection@:}
34824 @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:}
34825 @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:}
34826 @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:}
34829 @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:}
34830 @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:}
34831 @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:}
34832 @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:}
34833 @r{ @: j & @: @: 27 @:calc-sel-invert@:}
34836 @r{ @: j a @: @: 27 @:calc-select-additional@:}
34837 @r{ @: j b @: @: 12 @:calc-break-selections@:}
34838 @r{ @: j c @: @: @:calc-clear-selections@:}
34839 @r{ @: j d @: @: 12,50 @:calc-show-selections@:}
34840 @r{ @: j e @: @: 12 @:calc-enable-selections@:}
34841 @r{ @: j l @: @: 4,27 @:calc-select-less@:}
34842 @r{ @: j m @: @: 4,27 @:calc-select-more@:}
34843 @r{ @: j n @: @: 4 @:calc-select-next@:}
34844 @r{ @: j o @: @: 4,27 @:calc-select-once@:}
34845 @r{ @: j p @: @: 4 @:calc-select-previous@:}
34846 @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:}
34847 @r{ @: j s @: @: 4,27 @:calc-select-here@:}
34848 @r{ @: j u @: @: 27 @:calc-unselect@:}
34849 @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:}
34852 @r{ @: j C @: @: 27 @:calc-sel-commute@:}
34853 @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:}
34854 @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:}
34855 @r{ @: j I @: @: 27 @:calc-sel-isolate@:}
34856 @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)}
34857 @r{ @: j L @: @: 4,27 @:calc-commute-left@:}
34858 @r{ @: j M @: @: 27 @:calc-sel-merge@:}
34859 @r{ @: j N @: @: 27 @:calc-sel-negate@:}
34860 @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:}
34861 @r{ @: j R @: @: 4,27 @:calc-commute-right@:}
34862 @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:}
34863 @r{ @: j U @: @: 27 @:calc-sel-unpack@:}
34866 @r{ @: k a @: @: @:calc-random-again@:}
34867 @r{ n@: k b @: @: 1 @:bern@:(n)}
34868 @r{ n x@: H k b @: @: 2 @:bern@:(n,x)}
34869 @r{ n m@: k c @: @: 2 @:choose@:(n,m)}
34870 @r{ n m@: H k c @: @: 2 @:perm@:(n,m)}
34871 @r{ n@: k d @: @: 1 @:dfact@:(n) n!!}
34872 @r{ n@: k e @: @: 1 @:euler@:(n)}
34873 @r{ n x@: H k e @: @: 2 @:euler@:(n,x)}
34874 @r{ n@: k f @: @: 4 @:prfac@:(n)}
34875 @r{ n m@: k g @: @: 2 @:gcd@:(n,m)}
34876 @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)}
34877 @r{ n m@: k l @: @: 2 @:lcm@:(n,m)}
34878 @r{ n@: k m @: @: 1 @:moebius@:(n)}
34879 @r{ n@: k n @: @: 4 @:nextprime@:(n)}
34880 @r{ n@: I k n @: @: 4 @:prevprime@:(n)}
34881 @r{ n@: k p @: @: 4,28 @:calc-prime-test@:}
34882 @r{ m@: k r @: @: 14 @:random@:(m)}
34883 @r{ n m@: k s @: @: 2 @:stir1@:(n,m)}
34884 @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)}
34885 @r{ n@: k t @: @: 1 @:totient@:(n)}
34888 @r{ n p x@: k B @: @: @:utpb@:(x,n,p)}
34889 @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)}
34890 @r{ v x@: k C @: @: @:utpc@:(x,v)}
34891 @r{ v x@: I k C @: @: @:ltpc@:(x,v)}
34892 @r{ n m@: k E @: @: @:egcd@:(n,m)}
34893 @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)}
34894 @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)}
34895 @r{ m s x@: k N @: @: @:utpn@:(x,m,s)}
34896 @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)}
34897 @r{ m x@: k P @: @: @:utpp@:(x,m)}
34898 @r{ m x@: I k P @: @: @:ltpp@:(x,m)}
34899 @r{ v x@: k T @: @: @:utpt@:(x,v)}
34900 @r{ v x@: I k T @: @: @:ltpt@:(x,v)}
34903 @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:}
34904 @r{ @: m d @: @: @:calc-degrees-mode@:}
34905 @r{ @: m f @: @: 12 @:calc-frac-mode@:}
34906 @r{ @: m g @: @: 52 @:calc-get-modes@:}
34907 @r{ @: m h @: @: @:calc-hms-mode@:}
34908 @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:}
34909 @r{ @: m m @: @: @:calc-save-modes@:}
34910 @r{ @: m p @: @: 12 @:calc-polar-mode@:}
34911 @r{ @: m r @: @: @:calc-radians-mode@:}
34912 @r{ @: m s @: @: 12 @:calc-symbolic-mode@:}
34913 @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:}
34914 @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:}
34915 @r{ @: m w @: @: 13 @:calc-working@:}
34916 @r{ @: m x @: @: @:calc-always-load-extensions@:}
34919 @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:}
34920 @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:}
34921 @r{ @: m C @: @: 12 @:calc-auto-recompute@:}
34922 @r{ @: m D @: @: @:calc-default-simplify-mode@:}
34923 @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:}
34924 @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:}
34925 @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:}
34926 @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:}
34927 @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:}
34928 @r{ @: m S @: @: 12 @:calc-shift-prefix@:}
34929 @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:}
34932 @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:}
34933 @r{ @: s d @:var, decl @: @:calc-declare-variable@:}
34934 @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:}
34935 @r{ @: s i @:buffer @: @:calc-insert-variables@:}
34936 @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)}
34937 @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:}
34938 @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)}
34939 @r{ @: s p @:var @: 29 @:calc-permanent-variable@:}
34940 @r{ @: s r @:var @: 29 @:@:v (recalled value)}
34941 @r{ @: r 0-9 @: @: @:calc-recall-quick@:}
34942 @r{ a@: s s @:var @: 28,29 @:calc-store@:}
34943 @r{ a@: s 0-9 @: @: @:calc-store-quick@:}
34944 @r{ a@: s t @:var @: 29 @:calc-store-into@:}
34945 @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:}
34946 @r{ @: s u @:var @: 29 @:calc-unstore@:}
34947 @r{ a@: s x @:var @: 29 @:calc-store-exchange@:}
34950 @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:}
34951 @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:}
34952 @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:}
34953 @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:}
34954 @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:}
34955 @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:}
34956 @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:}
34957 @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:}
34958 @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:}
34959 @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:}
34960 @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:}
34961 @r{ @: s U @:editing @: 30 @:calc-edit-Units@:}
34962 @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:}
34965 @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)}
34966 @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)}
34967 @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)}
34968 @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)}
34969 @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)}
34970 @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)}
34971 @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)}
34972 @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)}
34973 @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))}
34974 @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @t{:=} b}
34975 @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @t{=>}}
34978 @r{ @: t [ @: @: 4 @:calc-trail-first@:}
34979 @r{ @: t ] @: @: 4 @:calc-trail-last@:}
34980 @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:}
34981 @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:}
34982 @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:}
34985 @r{ @: t b @: @: 4 @:calc-trail-backward@:}
34986 @r{ @: t d @: @: 12,50 @:calc-trail-display@:}
34987 @r{ @: t f @: @: 4 @:calc-trail-forward@:}
34988 @r{ @: t h @: @: @:calc-trail-here@:}
34989 @r{ @: t i @: @: @:calc-trail-in@:}
34990 @r{ @: t k @: @: 4 @:calc-trail-kill@:}
34991 @r{ @: t m @:string @: @:calc-trail-marker@:}
34992 @r{ @: t n @: @: 4 @:calc-trail-next@:}
34993 @r{ @: t o @: @: @:calc-trail-out@:}
34994 @r{ @: t p @: @: 4 @:calc-trail-previous@:}
34995 @r{ @: t r @:string @: @:calc-trail-isearch-backward@:}
34996 @r{ @: t s @:string @: @:calc-trail-isearch-forward@:}
34997 @r{ @: t y @: @: 4 @:calc-trail-yank@:}
35000 @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)}
35001 @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)}
35002 @r{ d@: t D @: @: 15 @:date@:(d)}
35003 @r{ d@: t I @: @: 4 @:incmonth@:(d,n)}
35004 @r{ d@: t J @: @: 16 @:julian@:(d,z)}
35005 @r{ d@: t M @: @: 17 @:newmonth@:(d,n)}
35006 @r{ @: t N @: @: 16 @:now@:(z)}
35007 @r{ d@: t P @:1 @: 31 @:year@:(d)}
35008 @r{ d@: t P @:2 @: 31 @:month@:(d)}
35009 @r{ d@: t P @:3 @: 31 @:day@:(d)}
35010 @r{ d@: t P @:4 @: 31 @:hour@:(d)}
35011 @r{ d@: t P @:5 @: 31 @:minute@:(d)}
35012 @r{ d@: t P @:6 @: 31 @:second@:(d)}
35013 @r{ d@: t P @:7 @: 31 @:weekday@:(d)}
35014 @r{ d@: t P @:8 @: 31 @:yearday@:(d)}
35015 @r{ d@: t P @:9 @: 31 @:time@:(d)}
35016 @r{ d@: t U @: @: 16 @:unixtime@:(d,z)}
35017 @r{ d@: t W @: @: 17 @:newweek@:(d,w)}
35018 @r{ d@: t Y @: @: 17 @:newyear@:(d,n)}
35021 @r{ a b@: t + @: @: 2 @:badd@:(a,b)}
35022 @r{ a b@: t - @: @: 2 @:bsub@:(a,b)}
35025 @r{ @: u a @: @: 12 @:calc-autorange-units@:}
35026 @r{ a@: u b @: @: @:calc-base-units@:}
35027 @r{ a@: u c @:units @: 18 @:calc-convert-units@:}
35028 @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:}
35029 @r{ @: u e @: @: @:calc-explain-units@:}
35030 @r{ @: u g @:unit @: @:calc-get-unit-definition@:}
35031 @r{ @: u p @: @: @:calc-permanent-units@:}
35032 @r{ a@: u r @: @: @:calc-remove-units@:}
35033 @r{ a@: u s @: @: @:usimplify@:(a)}
35034 @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:}
35035 @r{ @: u u @:unit @: @:calc-undefine-unit@:}
35036 @r{ @: u v @: @: @:calc-enter-units-table@:}
35037 @r{ a@: u x @: @: @:calc-extract-units@:}
35038 @r{ a@: u 0-9 @: @: @:calc-quick-units@:}
35041 @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)}
35042 @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)}
35043 @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)}
35044 @r{ v@: u G @: @: 19 @:vgmean@:(v)}
35045 @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)}
35046 @r{ v@: u M @: @: 19 @:vmean@:(v)}
35047 @r{ v@: I u M @: @: 19 @:vmeane@:(v)}
35048 @r{ v@: H u M @: @: 19 @:vmedian@:(v)}
35049 @r{ v@: I H u M @: @: 19 @:vhmean@:(v)}
35050 @r{ v@: u N @: @: 19 @:vmin@:(v)}
35051 @r{ v@: u S @: @: 19 @:vsdev@:(v)}
35052 @r{ v@: I u S @: @: 19 @:vpsdev@:(v)}
35053 @r{ v@: H u S @: @: 19 @:vvar@:(v)}
35054 @r{ v@: I H u S @: @: 19 @:vpvar@:(v)}
35055 @r{ @: u V @: @: @:calc-view-units-table@:}
35056 @r{ v@: u X @: @: 19 @:vmax@:(v)}
35059 @r{ v@: u + @: @: 19 @:vsum@:(v)}
35060 @r{ v@: u * @: @: 19 @:vprod@:(v)}
35061 @r{ v@: u # @: @: 19 @:vcount@:(v)}
35064 @r{ @: V ( @: @: 50 @:calc-vector-parens@:}
35065 @r{ @: V @{ @: @: 50 @:calc-vector-braces@:}
35066 @r{ @: V [ @: @: 50 @:calc-vector-brackets@:}
35067 @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:}
35068 @r{ @: V , @: @: 50 @:calc-vector-commas@:}
35069 @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:}
35070 @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:}
35071 @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:}
35072 @r{ @: V / @: @: 12,50 @:calc-break-vectors@:}
35073 @r{ @: V . @: @: 12,50 @:calc-full-vectors@:}
35076 @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)}
35077 @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)}
35078 @r{ s@: V ~ @: @: 1 @:vcompl@:(s)}
35079 @r{ s@: V # @: @: 1 @:vcard@:(s)}
35080 @r{ s@: V : @: @: 1 @:vspan@:(s)}
35081 @r{ s@: V + @: @: 1 @:rdup@:(s)}
35084 @r{ m@: V & @: @: 1 @:inv@:(m) 1/m}
35087 @r{ v@: v a @:n @: @:arrange@:(v,n)}
35088 @r{ a@: v b @:n @: @:cvec@:(a,n)}
35089 @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)}
35090 @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)}
35091 @r{ m@: v c @:0 @: 31 @:getdiag@:(m)}
35092 @r{ v@: v d @: @: 25 @:diag@:(v,n)}
35093 @r{ v m@: v e @: @: 2 @:vexp@:(v,m)}
35094 @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)}
35095 @r{ v a@: v f @: @: 26 @:find@:(v,a,n)}
35096 @r{ v@: v h @: @: 1 @:head@:(v)}
35097 @r{ v@: I v h @: @: 1 @:tail@:(v)}
35098 @r{ v@: H v h @: @: 1 @:rhead@:(v)}
35099 @r{ v@: I H v h @: @: 1 @:rtail@:(v)}
35100 @r{ @: v i @:n @: 31 @:idn@:(1,n)}
35101 @r{ @: v i @:0 @: 31 @:idn@:(1)}
35102 @r{ h t@: v k @: @: 2 @:cons@:(h,t)}
35103 @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)}
35104 @r{ v@: v l @: @: 1 @:vlen@:(v)}
35105 @r{ v@: H v l @: @: 1 @:mdims@:(v)}
35106 @r{ v m@: v m @: @: 2 @:vmask@:(v,m)}
35107 @r{ v@: v n @: @: 1 @:rnorm@:(v)}
35108 @r{ a b c@: v p @: @: 24 @:calc-pack@:}
35109 @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)}
35110 @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)}
35111 @r{ m@: v r @:0 @: 31 @:getdiag@:(m)}
35112 @r{ v i j@: v s @: @: @:subvec@:(v,i,j)}
35113 @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)}
35114 @r{ m@: v t @: @: 1 @:trn@:(m)}
35115 @r{ v@: v u @: @: 24 @:calc-unpack@:}
35116 @r{ v@: v v @: @: 1 @:rev@:(v)}
35117 @r{ @: v x @:n @: 31 @:index@:(n)}
35118 @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)}
35121 @r{ v@: V A @:op @: 22 @:apply@:(op,v)}
35122 @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)}
35123 @r{ m@: V D @: @: 1 @:det@:(m)}
35124 @r{ s@: V E @: @: 1 @:venum@:(s)}
35125 @r{ s@: V F @: @: 1 @:vfloor@:(s)}
35126 @r{ v@: V G @: @: @:grade@:(v)}
35127 @r{ v@: I V G @: @: @:rgrade@:(v)}
35128 @r{ v@: V H @:n @: 31 @:histogram@:(v,n)}
35129 @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)}
35130 @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)}
35131 @r{ m@: V J @: @: 1 @:ctrn@:(m)}
35132 @r{ m@: V L @: @: 1 @:lud@:(m)}
35133 @r{ v@: V M @:op @: 22,23 @:map@:(op,v)}
35134 @r{ v@: V N @: @: 1 @:cnorm@:(v)}
35135 @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)}
35136 @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)}
35137 @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)}
35138 @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)}
35139 @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)}
35140 @r{ v@: V S @: @: @:sort@:(v)}
35141 @r{ v@: I V S @: @: @:rsort@:(v)}
35142 @r{ m@: V T @: @: 1 @:tr@:(m)}
35143 @r{ v@: V U @:op @: 22 @:accum@:(op,v)}
35144 @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)}
35145 @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)}
35146 @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)}
35147 @r{ s t@: V V @: @: 2 @:vunion@:(s,t)}
35148 @r{ s t@: V X @: @: 2 @:vxor@:(s,t)}
35151 @r{ @: Y @: @: @:@:user commands}
35154 @r{ @: z @: @: @:@:user commands}
35157 @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:}
35158 @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:}
35159 @r{ @: Z : @: @: @:calc-kbd-else@:}
35160 @r{ @: Z ] @: @: @:calc-kbd-end-if@:}
35163 @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:}
35164 @r{ c@: Z / @: @: 45 @:calc-kbd-break@:}
35165 @r{ @: Z @} @: @: @:calc-kbd-end-loop@:}
35166 @r{ n@: Z < @: @: @:calc-kbd-repeat@:}
35167 @r{ @: Z > @: @: @:calc-kbd-end-repeat@:}
35168 @r{ n m@: Z ( @: @: @:calc-kbd-for@:}
35169 @r{ s@: Z ) @: @: @:calc-kbd-end-for@:}
35172 @r{ @: Z C-g @: @: @:@:cancel if/loop command}
35175 @r{ @: Z ` @: @: @:calc-kbd-push@:}
35176 @r{ @: Z ' @: @: @:calc-kbd-pop@:}
35177 @r{ a@: Z = @:message @: 28 @:calc-kbd-report@:}
35178 @r{ @: Z # @:prompt @: @:calc-kbd-query@:}
35181 @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:}
35182 @r{ @: Z D @:key, command @: @:calc-user-define@:}
35183 @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:}
35184 @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:}
35185 @r{ @: Z G @:key @: @:calc-get-user-defn@:}
35186 @r{ @: Z I @: @: @:calc-user-define-invocation@:}
35187 @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:}
35188 @r{ @: Z P @:key @: @:calc-user-define-permanent@:}
35189 @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:}
35190 @r{ @: Z T @: @: 12 @:calc-timing@:}
35191 @r{ @: Z U @:key @: @:calc-user-undefine@:}
35201 Positive prefix arguments apply to @cite{n} stack entries.
35202 Negative prefix arguments apply to the @cite{-n}th stack entry.
35203 A prefix of zero applies to the entire stack. (For @key{LFD} and
35204 @kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
35208 Positive prefix arguments apply to @cite{n} stack entries.
35209 Negative prefix arguments apply to the top stack entry
35210 and the next @cite{-n} stack entries.
35214 Positive prefix arguments rotate top @cite{n} stack entries by one.
35215 Negative prefix arguments rotate the entire stack by @cite{-n}.
35216 A prefix of zero reverses the entire stack.
35220 Prefix argument specifies a repeat count or distance.
35224 Positive prefix arguments specify a precision @cite{p}.
35225 Negative prefix arguments reduce the current precision by @cite{-p}.
35229 A prefix argument is interpreted as an additional step-size parameter.
35230 A plain @kbd{C-u} prefix means to prompt for the step size.
35234 A prefix argument specifies simplification level and depth.
35235 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}.
35239 A negative prefix operates only on the top level of the input formula.
35243 Positive prefix arguments specify a word size of @cite{w} bits, unsigned.
35244 Negative prefix arguments specify a word size of @cite{w} bits, signed.
35248 Prefix arguments specify the shift amount @cite{n}. The @cite{w} argument
35249 cannot be specified in the keyboard version of this command.
35253 From the keyboard, @cite{d} is omitted and defaults to zero.
35257 Mode is toggled; a positive prefix always sets the mode, and a negative
35258 prefix always clears the mode.
35262 Some prefix argument values provide special variations of the mode.
35266 A prefix argument, if any, is used for @cite{m} instead of taking
35267 @cite{m} from the stack. @cite{M} may take any of these values:
35269 {@advance@tableindent10pt
35273 Random integer in the interval @cite{[0 .. m)}.
35275 Random floating-point number in the interval @cite{[0 .. m)}.
35277 Gaussian with mean 1 and standard deviation 0.
35279 Gaussian with specified mean and standard deviation.
35281 Random integer or floating-point number in that interval.
35283 Random element from the vector.
35291 A prefix argument from 1 to 6 specifies number of date components
35292 to remove from the stack. @xref{Date Conversions}.
35296 A prefix argument specifies a time zone; @kbd{C-u} says to take the
35297 time zone number or name from the top of the stack. @xref{Time Zones}.
35301 A prefix argument specifies a day number (0-6, 0-31, or 0-366).
35305 If the input has no units, you will be prompted for both the old and
35310 With a prefix argument, collect that many stack entries to form the
35311 input data set. Each entry may be a single value or a vector of values.
35315 With a prefix argument of 1, take a single @c{$@var{n}\times2$}
35316 @i{@var{N}x2} matrix from the
35317 stack instead of two separate data vectors.
35321 The row or column number @cite{n} may be given as a numeric prefix
35322 argument instead. A plain @kbd{C-u} prefix says to take @cite{n}
35323 from the top of the stack. If @cite{n} is a vector or interval,
35324 a subvector/submatrix of the input is created.
35328 The @cite{op} prompt can be answered with the key sequence for the
35329 desired function, or with @kbd{x} or @kbd{z} followed by a function name,
35330 or with @kbd{$} to take a formula from the top of the stack, or with
35331 @kbd{'} and a typed formula. In the last two cases, the formula may
35332 be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
35333 may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
35334 last argument of the created function), or otherwise you will be
35335 prompted for an argument list. The number of vectors popped from the
35336 stack by @kbd{V M} depends on the number of arguments of the function.
35340 One of the mapping direction keys @kbd{_} (horizontal, i.e., map
35341 by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
35342 reduce down), or @kbd{=} (map or reduce by rows) may be used before
35343 entering @cite{op}; these modify the function name by adding the letter
35344 @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
35345 or @code{d} for ``down.''
35349 The prefix argument specifies a packing mode. A nonnegative mode
35350 is the number of items (for @kbd{v p}) or the number of levels
35351 (for @kbd{v u}). A negative mode is as described below. With no
35352 prefix argument, the mode is taken from the top of the stack and
35353 may be an integer or a vector of integers.
35355 {@advance@tableindent-20pt
35359 (@var{2}) Rectangular complex number.
35361 (@var{2}) Polar complex number.
35363 (@var{3}) HMS form.
35365 (@var{2}) Error form.
35367 (@var{2}) Modulo form.
35369 (@var{2}) Closed interval.
35371 (@var{2}) Closed .. open interval.
35373 (@var{2}) Open .. closed interval.
35375 (@var{2}) Open interval.
35377 (@var{2}) Fraction.
35379 (@var{2}) Float with integer mantissa.
35381 (@var{2}) Float with mantissa in @cite{[1 .. 10)}.
35383 (@var{1}) Date form (using date numbers).
35385 (@var{3}) Date form (using year, month, day).
35387 (@var{6}) Date form (using year, month, day, hour, minute, second).
35395 A prefix argument specifies the size @cite{n} of the matrix. With no
35396 prefix argument, @cite{n} is omitted and the size is inferred from
35401 The prefix argument specifies the starting position @cite{n} (default 1).
35405 Cursor position within stack buffer affects this command.
35409 Arguments are not actually removed from the stack by this command.
35413 Variable name may be a single digit or a full name.
35417 Editing occurs in a separate buffer. Press @kbd{M-# M-#} (or @kbd{C-c C-c},
35418 @key{LFD}, or in some cases @key{RET}) to finish the edit, or press
35419 @kbd{M-# x} to cancel the edit. The @key{LFD} key prevents evaluation
35420 of the result of the edit.
35424 The number prompted for can also be provided as a prefix argument.
35428 Press this key a second time to cancel the prefix.
35432 With a negative prefix, deactivate all formulas. With a positive
35433 prefix, deactivate and then reactivate from scratch.
35437 Default is to scan for nearest formula delimiter symbols. With a
35438 prefix of zero, formula is delimited by mark and point. With a
35439 non-zero prefix, formula is delimited by scanning forward or
35440 backward by that many lines.
35444 Parse the region between point and mark as a vector. A nonzero prefix
35445 parses @var{n} lines before or after point as a vector. A zero prefix
35446 parses the current line as a vector. A @kbd{C-u} prefix parses the
35447 region between point and mark as a single formula.
35451 Parse the rectangle defined by point and mark as a matrix. A positive
35452 prefix @var{n} divides the rectangle into columns of width @var{n}.
35453 A zero or @kbd{C-u} prefix parses each line as one formula. A negative
35454 prefix suppresses special treatment of bracketed portions of a line.
35458 A numeric prefix causes the current language mode to be ignored.
35462 Responding to a prompt with a blank line answers that and all
35463 later prompts by popping additional stack entries.
35467 Answer for @cite{v} may also be of the form @cite{v = v_0} or
35472 With a positive prefix argument, stack contains many @cite{y}'s and one
35473 common @cite{x}. With a zero prefix, stack contains a vector of
35474 @cite{y}s and a common @cite{x}. With a negative prefix, stack
35475 contains many @cite{[x,y]} vectors. (For 3D plots, substitute
35476 @cite{z} for @cite{y} and @cite{x,y} for @cite{x}.)
35480 With any prefix argument, all curves in the graph are deleted.
35484 With a positive prefix, refines an existing plot with more data points.
35485 With a negative prefix, forces recomputation of the plot data.
35489 With any prefix argument, set the default value instead of the
35490 value for this graph.
35494 With a negative prefix argument, set the value for the printer.
35498 Condition is considered ``true'' if it is a nonzero real or complex
35499 number, or a formula whose value is known to be nonzero; it is ``false''
35504 Several formulas separated by commas are pushed as multiple stack
35505 entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
35506 delimiters may be omitted. The notation @kbd{$$$} refers to the value
35507 in stack level three, and causes the formula to replace the top three
35508 stack levels. The notation @kbd{$3} refers to stack level three without
35509 causing that value to be removed from the stack. Use @key{LFD} in place
35510 of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
35511 to evaluate variables.@refill
35515 The variable is replaced by the formula shown on the right. The
35516 Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
35517 assigns @c{$x \coloneq a-x$}
35522 Press @kbd{?} repeatedly to see how to choose a model. Answer the
35523 variables prompt with @cite{iv} or @cite{iv;pv} to specify
35524 independent and parameter variables. A positive prefix argument
35525 takes @i{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
35526 and a vector from the stack.
35530 With a plain @kbd{C-u} prefix, replace the current region of the
35531 destination buffer with the yanked text instead of inserting.
35535 All stack entries are reformatted; the @kbd{H} prefix inhibits this.
35536 The @kbd{I} prefix sets the mode temporarily, redraws the top stack
35537 entry, then restores the original setting of the mode.
35541 A negative prefix sets the default 3D resolution instead of the
35542 default 2D resolution.
35546 This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
35547 @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
35548 @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12
35549 grabs the @var{n}th mode value only.
35553 (Space is provided below for you to keep your own written notes.)
35561 @node Key Index, Command Index, Summary, Top
35562 @unnumbered Index of Key Sequences
35566 @node Command Index, Function Index, Key Index, Top
35567 @unnumbered Index of Calculator Commands
35569 Since all Calculator commands begin with the prefix @samp{calc-}, the
35570 @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
35571 types @samp{calc-} for you. Thus, @kbd{x last-args} is short for
35572 @kbd{M-x calc-last-args}.
35576 @node Function Index, Concept Index, Command Index, Top
35577 @unnumbered Index of Algebraic Functions
35579 This is a list of built-in functions and operators usable in algebraic
35580 expressions. Their full Lisp names are derived by adding the prefix
35581 @samp{calcFunc-}, as in @code{calcFunc-sqrt}.
35583 All functions except those noted with ``*'' have corresponding
35584 Calc keystrokes and can also be found in the Calc Summary.
35589 @node Concept Index, Variable Index, Function Index, Top
35590 @unnumbered Concept Index
35594 @node Variable Index, Lisp Function Index, Concept Index, Top
35595 @unnumbered Index of Variables
35597 The variables in this list that do not contain dashes are accessible
35598 as Calc variables. Add a @samp{var-} prefix to get the name of the
35599 corresponding Lisp variable.
35601 The remaining variables are Lisp variables suitable for @code{setq}ing
35602 in your @file{.emacs} file.
35606 @node Lisp Function Index, , Variable Index, Top
35607 @unnumbered Index of Lisp Math Functions
35609 The following functions are meant to be used with @code{defmath}, not
35610 @code{defun} definitions. For names that do not start with @samp{calc-},
35611 the corresponding full Lisp name is derived by adding a prefix of
35625 arch-tag: 77a71809-fa4d-40be-b2cc-da3e8fb137c0