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.)
10 @c The following macros are used for conditional output for single lines.
12 @c `foo' will appear only in TeX output
14 @c `foo' will appear only in non-TeX output
16 @c @expr{expr} will typeset an expression;
17 @c $x$ in TeX, @samp{x} otherwise.
23 @alias infoline=comment
25 \gdef\exprsetup{\tex \let\t\ttfont \turnoffactive}
26 \gdef\expr{\exprsetup$\exprfinish}
27 \gdef\exprfinish#1{#1$\endgroup}
39 @alias texline=comment
40 @macro infoline{stuff}
55 % Suggested by Karl Berry <karl@@freefriends.org>
56 \gdef\!{\mskip-\thinmuskip}
59 @c Fix some other things specifically for this manual.
62 @mathcode`@:=`@: @c Make Calc fractions come out right in math mode
64 \gdef\coloneq{\mathrel{\mathord:\mathord=}}
66 \gdef\beforedisplay{\vskip-10pt}
67 \gdef\afterdisplay{\vskip-5pt}
68 \gdef\beforedisplayh{\vskip-25pt}
69 \gdef\afterdisplayh{\vskip-10pt}
71 @newdimen@kyvpos @kyvpos=0pt
72 @newdimen@kyhpos @kyhpos=0pt
73 @newcount@calcclubpenalty @calcclubpenalty=1000
76 @newtoks@calcoldeverypar @calcoldeverypar=@everypar
77 @everypar={@calceverypar@the@calcoldeverypar}
78 @ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi
79 @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
80 @catcode`@\=0 \catcode`\@=11
82 \catcode`\@=0 @catcode`@\=@active
87 This file documents Calc, the GNU Emacs calculator.
89 Copyright (C) 1990, 1991, 2001, 2002 Free Software Foundation, Inc.
92 Permission is granted to copy, distribute and/or modify this document
93 under the terms of the GNU Free Documentation License, Version 1.1 or
94 any later version published by the Free Software Foundation; with the
95 Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the
96 Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover
97 Texts as in (a) below.
99 (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
100 this GNU Manual, like GNU software. Copies published by the Free
101 Software Foundation raise funds for GNU development.''
107 * Calc: (calc). Advanced desk calculator and mathematical tool.
112 @center @titlefont{Calc Manual}
114 @center GNU Emacs Calc Version 2.02g
119 @center Dave Gillespie
120 @center daveg@@synaptics.com
123 @vskip 0pt plus 1filll
124 Copyright @copyright{} 1990, 1991, 2001, 2002 Free Software Foundation, Inc.
130 @node Top, , (dir), (dir)
131 @chapter The GNU Emacs Calculator
134 @dfn{Calc} is an advanced desk calculator and mathematical tool
135 that runs as part of the GNU Emacs environment.
137 This manual is divided into three major parts: ``Getting Started,''
138 the ``Calc Tutorial,'' and the ``Calc Reference.'' The Tutorial
139 introduces all the major aspects of Calculator use in an easy,
140 hands-on way. The remainder of the manual is a complete reference to
141 the features of the Calculator.
143 For help in the Emacs Info system (which you are using to read this
144 file), type @kbd{?}. (You can also type @kbd{h} to run through a
145 longer Info tutorial.)
149 * Copying:: How you can copy and share Calc.
151 * Getting Started:: General description and overview.
152 * Interactive Tutorial::
153 * Tutorial:: A step-by-step introduction for beginners.
155 * Introduction:: Introduction to the Calc reference manual.
156 * Data Types:: Types of objects manipulated by Calc.
157 * Stack and Trail:: Manipulating the stack and trail buffers.
158 * Mode Settings:: Adjusting display format and other modes.
159 * Arithmetic:: Basic arithmetic functions.
160 * Scientific Functions:: Transcendentals and other scientific functions.
161 * Matrix Functions:: Operations on vectors and matrices.
162 * Algebra:: Manipulating expressions algebraically.
163 * Units:: Operations on numbers with units.
164 * Store and Recall:: Storing and recalling variables.
165 * Graphics:: Commands for making graphs of data.
166 * Kill and Yank:: Moving data into and out of Calc.
167 * Embedded Mode:: Working with formulas embedded in a file.
168 * Programming:: Calc as a programmable calculator.
170 * Installation:: Installing Calc as a part of GNU Emacs.
171 * Reporting Bugs:: How to report bugs and make suggestions.
173 * Summary:: Summary of Calc commands and functions.
175 * Key Index:: The standard Calc key sequences.
176 * Command Index:: The interactive Calc commands.
177 * Function Index:: Functions (in algebraic formulas).
178 * Concept Index:: General concepts.
179 * Variable Index:: Variables used by Calc (both user and internal).
180 * Lisp Function Index:: Internal Lisp math functions.
183 @node Copying, Getting Started, Top, Top
184 @unnumbered GNU GENERAL PUBLIC LICENSE
185 @center Version 1, February 1989
188 Copyright @copyright{} 1989 Free Software Foundation, Inc.
189 675 Mass Ave, Cambridge, MA 02139, USA
191 Everyone is permitted to copy and distribute verbatim copies
192 of this license document, but changing it is not allowed.
195 @unnumberedsec Preamble
197 The license agreements of most software companies try to keep users
198 at the mercy of those companies. By contrast, our General Public
199 License is intended to guarantee your freedom to share and change free
200 software---to make sure the software is free for all its users. The
201 General Public License applies to the Free Software Foundation's
202 software and to any other program whose authors commit to using it.
203 You can use it for your programs, too.
205 When we speak of free software, we are referring to freedom, not
206 price. Specifically, the General Public License is designed to make
207 sure that you have the freedom to give away or sell copies of free
208 software, that you receive source code or can get it if you want it,
209 that you can change the software or use pieces of it in new free
210 programs; and that you know you can do these things.
212 To protect your rights, we need to make restrictions that forbid
213 anyone to deny you these rights or to ask you to surrender the rights.
214 These restrictions translate to certain responsibilities for you if you
215 distribute copies of the software, or if you modify it.
217 For example, if you distribute copies of a such a program, whether
218 gratis or for a fee, you must give the recipients all the rights that
219 you have. You must make sure that they, too, receive or can get the
220 source code. And you must tell them their rights.
222 We protect your rights with two steps: (1) copyright the software, and
223 (2) offer you this license which gives you legal permission to copy,
224 distribute and/or modify the software.
226 Also, for each author's protection and ours, we want to make certain
227 that everyone understands that there is no warranty for this free
228 software. If the software is modified by someone else and passed on, we
229 want its recipients to know that what they have is not the original, so
230 that any problems introduced by others will not reflect on the original
231 authors' reputations.
233 The precise terms and conditions for copying, distribution and
237 @unnumberedsec TERMS AND CONDITIONS
240 @center TERMS AND CONDITIONS
245 This License Agreement applies to any program or other work which
246 contains a notice placed by the copyright holder saying it may be
247 distributed under the terms of this General Public License. The
248 ``Program'', below, refers to any such program or work, and a ``work based
249 on the Program'' means either the Program or any work containing the
250 Program or a portion of it, either verbatim or with modifications. Each
251 licensee is addressed as ``you''.
254 You may copy and distribute verbatim copies of the Program's source
255 code as you receive it, in any medium, provided that you conspicuously and
256 appropriately publish on each copy an appropriate copyright notice and
257 disclaimer of warranty; keep intact all the notices that refer to this
258 General Public License and to the absence of any warranty; and give any
259 other recipients of the Program a copy of this General Public License
260 along with the Program. You may charge a fee for the physical act of
264 You may modify your copy or copies of the Program or any portion of
265 it, and copy and distribute such modifications under the terms of Paragraph
266 1 above, provided that you also do the following:
270 cause the modified files to carry prominent notices stating that
271 you changed the files and the date of any change; and
274 cause the whole of any work that you distribute or publish, that
275 in whole or in part contains the Program or any part thereof, either
276 with or without modifications, to be licensed at no charge to all
277 third parties under the terms of this General Public License (except
278 that you may choose to grant warranty protection to some or all
279 third parties, at your option).
282 If the modified program normally reads commands interactively when
283 run, you must cause it, when started running for such interactive use
284 in the simplest and most usual way, to print or display an
285 announcement including an appropriate copyright notice and a notice
286 that there is no warranty (or else, saying that you provide a
287 warranty) and that users may redistribute the program under these
288 conditions, and telling the user how to view a copy of this General
292 You may charge a fee for the physical act of transferring a
293 copy, and you may at your option offer warranty protection in
297 Mere aggregation of another independent work with the Program (or its
298 derivative) on a volume of a storage or distribution medium does not bring
299 the other work under the scope of these terms.
302 You may copy and distribute the Program (or a portion or derivative of
303 it, under Paragraph 2) in object code or executable form under the terms of
304 Paragraphs 1 and 2 above provided that you also do one of the following:
308 accompany it with the complete corresponding machine-readable
309 source code, which must be distributed under the terms of
310 Paragraphs 1 and 2 above; or,
313 accompany it with a written offer, valid for at least three
314 years, to give any third party free (except for a nominal charge
315 for the cost of distribution) a complete machine-readable copy of the
316 corresponding source code, to be distributed under the terms of
317 Paragraphs 1 and 2 above; or,
320 accompany it with the information you received as to where the
321 corresponding source code may be obtained. (This alternative is
322 allowed only for noncommercial distribution and only if you
323 received the program in object code or executable form alone.)
326 Source code for a work means the preferred form of the work for making
327 modifications to it. For an executable file, complete source code means
328 all the source code for all modules it contains; but, as a special
329 exception, it need not include source code for modules which are standard
330 libraries that accompany the operating system on which the executable
331 file runs, or for standard header files or definitions files that
332 accompany that operating system.
335 You may not copy, modify, sublicense, distribute or transfer the
336 Program except as expressly provided under this General Public License.
337 Any attempt otherwise to copy, modify, sublicense, distribute or transfer
338 the Program is void, and will automatically terminate your rights to use
339 the Program under this License. However, parties who have received
340 copies, or rights to use copies, from you under this General Public
341 License will not have their licenses terminated so long as such parties
342 remain in full compliance.
345 By copying, distributing or modifying the Program (or any work based
346 on the Program) you indicate your acceptance of this license to do so,
347 and all its terms and conditions.
350 Each time you redistribute the Program (or any work based on the
351 Program), the recipient automatically receives a license from the original
352 licensor to copy, distribute or modify the Program subject to these
353 terms and conditions. You may not impose any further restrictions on the
354 recipients' exercise of the rights granted herein.
357 The Free Software Foundation may publish revised and/or new versions
358 of the General Public License from time to time. Such new versions will
359 be similar in spirit to the present version, but may differ in detail to
360 address new problems or concerns.
362 Each version is given a distinguishing version number. If the Program
363 specifies a version number of the license which applies to it and ``any
364 later version'', you have the option of following the terms and conditions
365 either of that version or of any later version published by the Free
366 Software Foundation. If the Program does not specify a version number of
367 the license, you may choose any version ever published by the Free Software
371 If you wish to incorporate parts of the Program into other free
372 programs whose distribution conditions are different, write to the author
373 to ask for permission. For software which is copyrighted by the Free
374 Software Foundation, write to the Free Software Foundation; we sometimes
375 make exceptions for this. Our decision will be guided by the two goals
376 of preserving the free status of all derivatives of our free software and
377 of promoting the sharing and reuse of software generally.
387 BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
388 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
389 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
390 PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
391 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
392 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
393 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
394 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
395 REPAIR OR CORRECTION.
398 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
399 ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
400 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
401 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
402 ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
403 LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
404 SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
405 WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
406 ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
409 @node Getting Started, Tutorial, Copying, Top
410 @chapter Getting Started
412 This chapter provides a general overview of Calc, the GNU Emacs
413 Calculator: What it is, how to start it and how to exit from it,
414 and what are the various ways that it can be used.
418 * About This Manual::
419 * Notations Used in This Manual::
421 * Demonstration of Calc::
422 * History and Acknowledgements::
425 @node What is Calc, About This Manual, Getting Started, Getting Started
426 @section What is Calc?
429 @dfn{Calc} is an advanced calculator and mathematical tool that runs as
430 part of the GNU Emacs environment. Very roughly based on the HP-28/48
431 series of calculators, its many features include:
435 Choice of algebraic or RPN (stack-based) entry of calculations.
438 Arbitrary precision integers and floating-point numbers.
441 Arithmetic on rational numbers, complex numbers (rectangular and polar),
442 error forms with standard deviations, open and closed intervals, vectors
443 and matrices, dates and times, infinities, sets, quantities with units,
444 and algebraic formulas.
447 Mathematical operations such as logarithms and trigonometric functions.
450 Programmer's features (bitwise operations, non-decimal numbers).
453 Financial functions such as future value and internal rate of return.
456 Number theoretical features such as prime factorization and arithmetic
457 modulo @var{m} for any @var{m}.
460 Algebraic manipulation features, including symbolic calculus.
463 Moving data to and from regular editing buffers.
466 Embedded mode for manipulating Calc formulas and data directly
467 inside any editing buffer.
470 Graphics using GNUPLOT, a versatile (and free) plotting program.
473 Easy programming using keyboard macros, algebraic formulas,
474 algebraic rewrite rules, or extended Emacs Lisp.
477 Calc tries to include a little something for everyone; as a result it is
478 large and might be intimidating to the first-time user. If you plan to
479 use Calc only as a traditional desk calculator, all you really need to
480 read is the ``Getting Started'' chapter of this manual and possibly the
481 first few sections of the tutorial. As you become more comfortable with
482 the program you can learn its additional features. In terms of efficiency,
483 scope and depth, Calc cannot replace a powerful tool like Mathematica.
484 But Calc has the advantages of convenience, portability, and availability
485 of the source code. And, of course, it's free!
487 @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
488 @section About This Manual
491 This document serves as a complete description of the GNU Emacs
492 Calculator. It works both as an introduction for novices, and as
493 a reference for experienced users. While it helps to have some
494 experience with GNU Emacs in order to get the most out of Calc,
495 this manual ought to be readable even if you don't know or use Emacs
499 The manual is divided into three major parts:@: the ``Getting
500 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
501 and the Calc reference manual (the remaining chapters and appendices).
504 The manual is divided into three major parts:@: the ``Getting
505 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
506 and the Calc reference manual (the remaining chapters and appendices).
508 @c This manual has been printed in two volumes, the @dfn{Tutorial} and the
509 @c @dfn{Reference}. Both volumes include a copy of the ``Getting Started''
513 If you are in a hurry to use Calc, there is a brief ``demonstration''
514 below which illustrates the major features of Calc in just a couple of
515 pages. If you don't have time to go through the full tutorial, this
516 will show you everything you need to know to begin.
517 @xref{Demonstration of Calc}.
519 The tutorial chapter walks you through the various parts of Calc
520 with lots of hands-on examples and explanations. If you are new
521 to Calc and you have some time, try going through at least the
522 beginning of the tutorial. The tutorial includes about 70 exercises
523 with answers. These exercises give you some guided practice with
524 Calc, as well as pointing out some interesting and unusual ways
527 The reference section discusses Calc in complete depth. You can read
528 the reference from start to finish if you want to learn every aspect
529 of Calc. Or, you can look in the table of contents or the Concept
530 Index to find the parts of the manual that discuss the things you
533 @cindex Marginal notes
534 Every Calc keyboard command is listed in the Calc Summary, and also
535 in the Key Index. Algebraic functions, @kbd{M-x} commands, and
536 variables also have their own indices.
538 @infoline In the printed manual, each
539 paragraph that is referenced in the Key or Function Index is marked
540 in the margin with its index entry.
542 @c [fix-ref Help Commands]
543 You can access this manual on-line at any time within Calc by
544 pressing the @kbd{h i} key sequence. Outside of the Calc window,
545 you can press @kbd{M-# i} to read the manual on-line. Also, you
546 can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{M-# t},
547 or to the Summary by pressing @kbd{h s} or @kbd{M-# s}. Within Calc,
548 you can also go to the part of the manual describing any Calc key,
549 function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v},
550 respectively. @xref{Help Commands}.
552 Printed copies of this manual are also available from the Free Software
555 @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
556 @section Notations Used in This Manual
559 This section describes the various notations that are used
560 throughout the Calc manual.
562 In keystroke sequences, uppercase letters mean you must hold down
563 the shift key while typing the letter. Keys pressed with Control
564 held down are shown as @kbd{C-x}. Keys pressed with Meta held down
565 are shown as @kbd{M-x}. Other notations are @key{RET} for the
566 Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
567 @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.
568 The @key{DEL} key is called Backspace on some keyboards, it is
569 whatever key you would use to correct a simple typing error when
570 regularly using Emacs.
572 (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
573 the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
574 If you don't have a Meta key, look for Alt or Extend Char. You can
575 also press @key{ESC} or @key{C-[} first to get the same effect, so
576 that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
578 Sometimes the @key{RET} key is not shown when it is ``obvious''
579 that you must press @key{RET} to proceed. For example, the @key{RET}
580 is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
582 Commands are generally shown like this: @kbd{p} (@code{calc-precision})
583 or @kbd{M-# k} (@code{calc-keypad}). This means that the command is
584 normally used by pressing the @kbd{p} key or @kbd{M-# k} key sequence,
585 but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
587 Commands that correspond to functions in algebraic notation
588 are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means
589 the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
590 the corresponding function in an algebraic-style formula would
591 be @samp{cos(@var{x})}.
593 A few commands don't have key equivalents: @code{calc-sincos}
596 @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
597 @section A Demonstration of Calc
600 @cindex Demonstration of Calc
601 This section will show some typical small problems being solved with
602 Calc. The focus is more on demonstration than explanation, but
603 everything you see here will be covered more thoroughly in the
606 To begin, start Emacs if necessary (usually the command @code{emacs}
607 does this), and type @kbd{M-# c} (or @kbd{@key{ESC} # c}) to start the
608 Calculator. (@xref{Starting Calc}, if this doesn't work for you.)
610 Be sure to type all the sample input exactly, especially noting the
611 difference between lower-case and upper-case letters. Remember,
612 @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
613 Delete, and Space keys.
615 @strong{RPN calculation.} In RPN, you type the input number(s) first,
616 then the command to operate on the numbers.
619 Type @kbd{2 @key{RET} 3 + Q} to compute
620 @texline @math{\sqrt{2+3} = 2.2360679775}.
621 @infoline the square root of 2+3, which is 2.2360679775.
624 Type @kbd{P 2 ^} to compute
625 @texline @math{\pi^2 = 9.86960440109}.
626 @infoline the value of `pi' squared, 9.86960440109.
629 Type @key{TAB} to exchange the order of these two results.
632 Type @kbd{- I H S} to subtract these results and compute the Inverse
633 Hyperbolic sine of the difference, 2.72996136574.
636 Type @key{DEL} to erase this result.
638 @strong{Algebraic calculation.} You can also enter calculations using
639 conventional ``algebraic'' notation. To enter an algebraic formula,
640 use the apostrophe key.
643 Type @kbd{' sqrt(2+3) @key{RET}} to compute
644 @texline @math{\sqrt{2+3}}.
645 @infoline the square root of 2+3.
648 Type @kbd{' pi^2 @key{RET}} to enter
649 @texline @math{\pi^2}.
650 @infoline `pi' squared.
651 To evaluate this symbolic formula as a number, type @kbd{=}.
654 Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
655 result from the most-recent and compute the Inverse Hyperbolic sine.
657 @strong{Keypad mode.} If you are using the X window system, press
658 @w{@kbd{M-# k}} to get Keypad mode. (If you don't use X, skip to
662 Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
663 ``buttons'' using your left mouse button.
666 Click on @key{PI}, @key{2}, and @t{y^x}.
669 Click on @key{INV}, then @key{ENTER} to swap the two results.
672 Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
675 Click on @key{<-} to erase the result, then click @key{OFF} to turn
676 the Keypad Calculator off.
678 @strong{Grabbing data.} Type @kbd{M-# x} if necessary to exit Calc.
679 Now select the following numbers as an Emacs region: ``Mark'' the
680 front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
681 then move to the other end of the list. (Either get this list from
682 the on-line copy of this manual, accessed by @w{@kbd{M-# i}}, or just
683 type these numbers into a scratch file.) Now type @kbd{M-# g} to
684 ``grab'' these numbers into Calc.
695 The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
696 Type @w{@kbd{V R +}} to compute the sum of these numbers.
699 Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
700 the product of the numbers.
703 You can also grab data as a rectangular matrix. Place the cursor on
704 the upper-leftmost @samp{1} and set the mark, then move to just after
705 the lower-right @samp{8} and press @kbd{M-# r}.
708 Type @kbd{v t} to transpose this
709 @texline @math{3\times2}
712 @texline @math{2\times3}
714 matrix. Type @w{@kbd{v u}} to unpack the rows into two separate
715 vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums
716 of the two original columns. (There is also a special
717 grab-and-sum-columns command, @kbd{M-# :}.)
719 @strong{Units conversion.} Units are entered algebraically.
720 Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
721 Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}.
723 @strong{Date arithmetic.} Type @kbd{t N} to get the current date and
724 time. Type @kbd{90 +} to find the date 90 days from now. Type
725 @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
726 many weeks have passed since then.
728 @strong{Algebra.} Algebraic entries can also include formulas
729 or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
730 to enter a pair of equations involving three variables.
731 (Note the leading apostrophe in this example; also, note that the space
732 between @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve
733 these equations for the variables @expr{x} and @expr{y}.
736 Type @kbd{d B} to view the solutions in more readable notation.
737 Type @w{@kbd{d C}} to view them in C language notation, and @kbd{d T}
738 to view them in the notation for the @TeX{} typesetting system.
739 Type @kbd{d N} to return to normal notation.
742 Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas.
743 (That's a letter @kbd{l}, not a numeral @kbd{1}.)
746 @strong{Help functions.} You can read about any command in the on-line
747 manual. Type @kbd{M-# c} to return to Calc after each of these
748 commands: @kbd{h k t N} to read about the @kbd{t N} command,
749 @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
750 @kbd{h s} to read the Calc summary.
753 @strong{Help functions.} You can read about any command in the on-line
754 manual. Remember to type the letter @kbd{l}, then @kbd{M-# c}, to
755 return here after each of these commands: @w{@kbd{h k t N}} to read
756 about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
757 @code{sqrt} function, and @kbd{h s} to read the Calc summary.
760 Press @key{DEL} repeatedly to remove any leftover results from the stack.
761 To exit from Calc, press @kbd{q} or @kbd{M-# c} again.
763 @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
767 Calc has several user interfaces that are specialized for
768 different kinds of tasks. As well as Calc's standard interface,
769 there are Quick mode, Keypad mode, and Embedded mode.
773 * The Standard Interface::
774 * Quick Mode Overview::
775 * Keypad Mode Overview::
776 * Standalone Operation::
777 * Embedded Mode Overview::
778 * Other M-# Commands::
781 @node Starting Calc, The Standard Interface, Using Calc, Using Calc
782 @subsection Starting Calc
785 On most systems, you can type @kbd{M-#} to start the Calculator.
786 The notation @kbd{M-#} is short for Meta-@kbd{#}. On most
787 keyboards this means holding down the Meta (or Alt) and
788 Shift keys while typing @kbd{3}.
791 Once again, if you don't have a Meta key on your keyboard you can type
792 @key{ESC} first, then @kbd{#}, to accomplish the same thing. If you
793 don't even have an @key{ESC} key, you can fake it by holding down
794 Control or @key{CTRL} while typing a left square bracket
795 (that's @kbd{C-[} in Emacs notation).
797 @kbd{M-#} is a @dfn{prefix key}; when you press it, Emacs waits for
798 you to press a second key to complete the command. In this case,
799 you will follow @kbd{M-#} with a letter (upper- or lower-case, it
800 doesn't matter for @kbd{M-#}) that says which Calc interface you
803 To get Calc's standard interface, type @kbd{M-# c}. To get
804 Keypad mode, type @kbd{M-# k}. Type @kbd{M-# ?} to get a brief
805 list of the available options, and type a second @kbd{?} to get
808 To ease typing, @kbd{M-# M-#} (or @kbd{M-# #} if that's easier)
809 also works to start Calc. It starts the same interface (either
810 @kbd{M-# c} or @w{@kbd{M-# k}}) that you last used, selecting the
811 @kbd{M-# c} interface by default. (If your installation has
812 a special function key set up to act like @kbd{M-#}, hitting that
813 function key twice is just like hitting @kbd{M-# M-#}.)
815 If @kbd{M-#} doesn't work for you, you can always type explicit
816 commands like @kbd{M-x calc} (for the standard user interface) or
817 @w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x}
818 (that's Meta with the letter @kbd{x}), then, at the prompt,
819 type the full command (like @kbd{calc-keypad}) and press Return.
821 The same commands (like @kbd{M-# c} or @kbd{M-# M-#}) that start
822 the Calculator also turn it off if it is already on.
824 @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
825 @subsection The Standard Calc Interface
828 @cindex Standard user interface
829 Calc's standard interface acts like a traditional RPN calculator,
830 operated by the normal Emacs keyboard. When you type @kbd{M-# c}
831 to start the Calculator, the Emacs screen splits into two windows
832 with the file you were editing on top and Calc on the bottom.
838 --**-Emacs: myfile (Fundamental)----All----------------------
839 --- Emacs Calculator Mode --- |Emacs Calc Mode v2.00...
847 --%%-Calc: 12 Deg (Calculator)----All----- --%%-Emacs: *Calc Trail*
851 In this figure, the mode-line for @file{myfile} has moved up and the
852 ``Calculator'' window has appeared below it. As you can see, Calc
853 actually makes two windows side-by-side. The lefthand one is
854 called the @dfn{stack window} and the righthand one is called the
855 @dfn{trail window.} The stack holds the numbers involved in the
856 calculation you are currently performing. The trail holds a complete
857 record of all calculations you have done. In a desk calculator with
858 a printer, the trail corresponds to the paper tape that records what
861 In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
862 were first entered into the Calculator, then the 2 and 4 were
863 multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}.
864 (The @samp{>} symbol shows that this was the most recent calculation.)
865 The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack.
867 Most Calculator commands deal explicitly with the stack only, but
868 there is a set of commands that allow you to search back through
869 the trail and retrieve any previous result.
871 Calc commands use the digits, letters, and punctuation keys.
872 Shifted (i.e., upper-case) letters are different from lowercase
873 letters. Some letters are @dfn{prefix} keys that begin two-letter
874 commands. For example, @kbd{e} means ``enter exponent'' and shifted
875 @kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix
876 the letter ``e'' takes on very different meanings: @kbd{d e} means
877 ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
879 There is nothing stopping you from switching out of the Calc
880 window and back into your editing window, say by using the Emacs
881 @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is
882 inside a regular window, Emacs acts just like normal. When the
883 cursor is in the Calc stack or trail windows, keys are interpreted
886 When you quit by pressing @kbd{M-# c} a second time, the Calculator
887 windows go away but the actual Stack and Trail are not gone, just
888 hidden. When you press @kbd{M-# c} once again you will get the
889 same stack and trail contents you had when you last used the
892 The Calculator does not remember its state between Emacs sessions.
893 Thus if you quit Emacs and start it again, @kbd{M-# c} will give you
894 a fresh stack and trail. There is a command (@kbd{m m}) that lets
895 you save your favorite mode settings between sessions, though.
896 One of the things it saves is which user interface (standard or
897 Keypad) you last used; otherwise, a freshly started Emacs will
898 always treat @kbd{M-# M-#} the same as @kbd{M-# c}.
900 The @kbd{q} key is another equivalent way to turn the Calculator off.
902 If you type @kbd{M-# b} first and then @kbd{M-# c}, you get a
903 full-screen version of Calc (@code{full-calc}) in which the stack and
904 trail windows are still side-by-side but are now as tall as the whole
905 Emacs screen. When you press @kbd{q} or @kbd{M-# c} again to quit,
906 the file you were editing before reappears. The @kbd{M-# b} key
907 switches back and forth between ``big'' full-screen mode and the
908 normal partial-screen mode.
910 Finally, @kbd{M-# o} (@code{calc-other-window}) is like @kbd{M-# c}
911 except that the Calc window is not selected. The buffer you were
912 editing before remains selected instead. @kbd{M-# o} is a handy
913 way to switch out of Calc momentarily to edit your file; type
914 @kbd{M-# c} to switch back into Calc when you are done.
916 @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
917 @subsection Quick Mode (Overview)
920 @dfn{Quick mode} is a quick way to use Calc when you don't need the
921 full complexity of the stack and trail. To use it, type @kbd{M-# q}
922 (@code{quick-calc}) in any regular editing buffer.
924 Quick mode is very simple: It prompts you to type any formula in
925 standard algebraic notation (like @samp{4 - 2/3}) and then displays
926 the result at the bottom of the Emacs screen (@mathit{3.33333333333}
927 in this case). You are then back in the same editing buffer you
928 were in before, ready to continue editing or to type @kbd{M-# q}
929 again to do another quick calculation. The result of the calculation
930 will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
931 at this point will yank the result into your editing buffer.
933 Calc mode settings affect Quick mode, too, though you will have to
934 go into regular Calc (with @kbd{M-# c}) to change the mode settings.
936 @c [fix-ref Quick Calculator mode]
937 @xref{Quick Calculator}, for further information.
939 @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
940 @subsection Keypad Mode (Overview)
943 @dfn{Keypad mode} is a mouse-based interface to the Calculator.
944 It is designed for use with terminals that support a mouse. If you
945 don't have a mouse, you will have to operate Keypad mode with your
946 arrow keys (which is probably more trouble than it's worth).
948 Type @kbd{M-# k} to turn Keypad mode on or off. Once again you
949 get two new windows, this time on the righthand side of the screen
950 instead of at the bottom. The upper window is the familiar Calc
951 Stack; the lower window is a picture of a typical calculator keypad.
955 \advance \dimen0 by 24\baselineskip%
956 \ifdim \dimen0>\pagegoal \vfill\eject \fi%
960 |--- Emacs Calculator Mode ---
964 |--%%-Calc: 12 Deg (Calcul
965 |----+-----Calc 2.00-----+----1
966 |FLR |CEIL|RND |TRNC|CLN2|FLT |
967 |----+----+----+----+----+----|
968 | LN |EXP | |ABS |IDIV|MOD |
969 |----+----+----+----+----+----|
970 |SIN |COS |TAN |SQRT|y^x |1/x |
971 |----+----+----+----+----+----|
972 | ENTER |+/- |EEX |UNDO| <- |
973 |-----+---+-+--+--+-+---++----|
974 | INV | 7 | 8 | 9 | / |
975 |-----+-----+-----+-----+-----|
976 | HYP | 4 | 5 | 6 | * |
977 |-----+-----+-----+-----+-----|
978 |EXEC | 1 | 2 | 3 | - |
979 |-----+-----+-----+-----+-----|
980 | OFF | 0 | . | PI | + |
981 |-----+-----+-----+-----+-----+
984 Keypad mode is much easier for beginners to learn, because there
985 is no need to memorize lots of obscure key sequences. But not all
986 commands in regular Calc are available on the Keypad. You can
987 always switch the cursor into the Calc stack window to use
988 standard Calc commands if you need. Serious Calc users, though,
989 often find they prefer the standard interface over Keypad mode.
991 To operate the Calculator, just click on the ``buttons'' of the
992 keypad using your left mouse button. To enter the two numbers
993 shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
994 add them together you would then click @kbd{+} (to get 12.3 on
997 If you click the right mouse button, the top three rows of the
998 keypad change to show other sets of commands, such as advanced
999 math functions, vector operations, and operations on binary
1002 Because Keypad mode doesn't use the regular keyboard, Calc leaves
1003 the cursor in your original editing buffer. You can type in
1004 this buffer in the usual way while also clicking on the Calculator
1005 keypad. One advantage of Keypad mode is that you don't need an
1006 explicit command to switch between editing and calculating.
1008 If you press @kbd{M-# b} first, you get a full-screen Keypad mode
1009 (@code{full-calc-keypad}) with three windows: The keypad in the lower
1010 left, the stack in the lower right, and the trail on top.
1012 @c [fix-ref Keypad Mode]
1013 @xref{Keypad Mode}, for further information.
1015 @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
1016 @subsection Standalone Operation
1019 @cindex Standalone Operation
1020 If you are not in Emacs at the moment but you wish to use Calc,
1021 you must start Emacs first. If all you want is to run Calc, you
1022 can give the commands:
1032 emacs -f full-calc-keypad
1036 which run a full-screen Calculator (as if by @kbd{M-# b M-# c}) or
1037 a full-screen X-based Calculator (as if by @kbd{M-# b M-# k}).
1038 In standalone operation, quitting the Calculator (by pressing
1039 @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
1042 @node Embedded Mode Overview, Other M-# Commands, Standalone Operation, Using Calc
1043 @subsection Embedded Mode (Overview)
1046 @dfn{Embedded mode} is a way to use Calc directly from inside an
1047 editing buffer. Suppose you have a formula written as part of a
1061 and you wish to have Calc compute and format the derivative for
1062 you and store this derivative in the buffer automatically. To
1063 do this with Embedded mode, first copy the formula down to where
1064 you want the result to be:
1078 Now, move the cursor onto this new formula and press @kbd{M-# e}.
1079 Calc will read the formula (using the surrounding blank lines to
1080 tell how much text to read), then push this formula (invisibly)
1081 onto the Calc stack. The cursor will stay on the formula in the
1082 editing buffer, but the buffer's mode line will change to look
1083 like the Calc mode line (with mode indicators like @samp{12 Deg}
1084 and so on). Even though you are still in your editing buffer,
1085 the keyboard now acts like the Calc keyboard, and any new result
1086 you get is copied from the stack back into the buffer. To take
1087 the derivative, you would type @kbd{a d x @key{RET}}.
1101 To make this look nicer, you might want to press @kbd{d =} to center
1102 the formula, and even @kbd{d B} to use Big display mode.
1111 % [calc-mode: justify: center]
1112 % [calc-mode: language: big]
1120 Calc has added annotations to the file to help it remember the modes
1121 that were used for this formula. They are formatted like comments
1122 in the @TeX{} typesetting language, just in case you are using @TeX{}.
1123 (In this example @TeX{} is not being used, so you might want to move
1124 these comments up to the top of the file or otherwise put them out
1127 As an extra flourish, we can add an equation number using a
1128 righthand label: Type @kbd{d @} (1) @key{RET}}.
1132 % [calc-mode: justify: center]
1133 % [calc-mode: language: big]
1134 % [calc-mode: right-label: " (1)"]
1142 To leave Embedded mode, type @kbd{M-# e} again. The mode line
1143 and keyboard will revert to the way they were before. (If you have
1144 actually been trying this as you read along, you'll want to press
1145 @kbd{M-# 0} [with the digit zero] now to reset the modes you changed.)
1147 The related command @kbd{M-# w} operates on a single word, which
1148 generally means a single number, inside text. It uses any
1149 non-numeric characters rather than blank lines to delimit the
1150 formula it reads. Here's an example of its use:
1153 A slope of one-third corresponds to an angle of 1 degrees.
1156 Place the cursor on the @samp{1}, then type @kbd{M-# w} to enable
1157 Embedded mode on that number. Now type @kbd{3 /} (to get one-third),
1158 and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
1159 then @w{@kbd{M-# w}} again to exit Embedded mode.
1162 A slope of one-third corresponds to an angle of 18.4349488229 degrees.
1165 @c [fix-ref Embedded Mode]
1166 @xref{Embedded Mode}, for full details.
1168 @node Other M-# Commands, , Embedded Mode Overview, Using Calc
1169 @subsection Other @kbd{M-#} Commands
1172 Two more Calc-related commands are @kbd{M-# g} and @kbd{M-# r},
1173 which ``grab'' data from a selected region of a buffer into the
1174 Calculator. The region is defined in the usual Emacs way, by
1175 a ``mark'' placed at one end of the region, and the Emacs
1176 cursor or ``point'' placed at the other.
1178 The @kbd{M-# g} command reads the region in the usual left-to-right,
1179 top-to-bottom order. The result is packaged into a Calc vector
1180 of numbers and placed on the stack. Calc (in its standard
1181 user interface) is then started. Type @kbd{v u} if you want
1182 to unpack this vector into separate numbers on the stack. Also,
1183 @kbd{C-u M-# g} interprets the region as a single number or
1186 The @kbd{M-# r} command reads a rectangle, with the point and
1187 mark defining opposite corners of the rectangle. The result
1188 is a matrix of numbers on the Calculator stack.
1190 Complementary to these is @kbd{M-# y}, which ``yanks'' the
1191 value at the top of the Calc stack back into an editing buffer.
1192 If you type @w{@kbd{M-# y}} while in such a buffer, the value is
1193 yanked at the current position. If you type @kbd{M-# y} while
1194 in the Calc buffer, Calc makes an educated guess as to which
1195 editing buffer you want to use. The Calc window does not have
1196 to be visible in order to use this command, as long as there
1197 is something on the Calc stack.
1199 Here, for reference, is the complete list of @kbd{M-#} commands.
1200 The shift, control, and meta keys are ignored for the keystroke
1201 following @kbd{M-#}.
1204 Commands for turning Calc on and off:
1208 Turn Calc on or off, employing the same user interface as last time.
1211 Turn Calc on or off using its standard bottom-of-the-screen
1212 interface. If Calc is already turned on but the cursor is not
1213 in the Calc window, move the cursor into the window.
1216 Same as @kbd{C}, but don't select the new Calc window. If
1217 Calc is already turned on and the cursor is in the Calc window,
1218 move it out of that window.
1221 Control whether @kbd{M-# c} and @kbd{M-# k} use the full screen.
1224 Use Quick mode for a single short calculation.
1227 Turn Calc Keypad mode on or off.
1230 Turn Calc Embedded mode on or off at the current formula.
1233 Turn Calc Embedded mode on or off, select the interesting part.
1236 Turn Calc Embedded mode on or off at the current word (number).
1239 Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
1242 Quit Calc; turn off standard, Keypad, or Embedded mode if on.
1243 (This is like @kbd{q} or @key{OFF} inside of Calc.)
1250 Commands for moving data into and out of the Calculator:
1254 Grab the region into the Calculator as a vector.
1257 Grab the rectangular region into the Calculator as a matrix.
1260 Grab the rectangular region and compute the sums of its columns.
1263 Grab the rectangular region and compute the sums of its rows.
1266 Yank a value from the Calculator into the current editing buffer.
1273 Commands for use with Embedded mode:
1277 ``Activate'' the current buffer. Locate all formulas that
1278 contain @samp{:=} or @samp{=>} symbols and record their locations
1279 so that they can be updated automatically as variables are changed.
1282 Duplicate the current formula immediately below and select
1286 Insert a new formula at the current point.
1289 Move the cursor to the next active formula in the buffer.
1292 Move the cursor to the previous active formula in the buffer.
1295 Update (i.e., as if by the @kbd{=} key) the formula at the current point.
1298 Edit (as if by @code{calc-edit}) the formula at the current point.
1305 Miscellaneous commands:
1309 Run the Emacs Info system to read the Calc manual.
1310 (This is the same as @kbd{h i} inside of Calc.)
1313 Run the Emacs Info system to read the Calc Tutorial.
1316 Run the Emacs Info system to read the Calc Summary.
1319 Load Calc entirely into memory. (Normally the various parts
1320 are loaded only as they are needed.)
1323 Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
1324 and record them as the current keyboard macro.
1327 (This is the ``zero'' digit key.) Reset the Calculator to
1328 its default state: Empty stack, and default mode settings.
1329 With any prefix argument, reset everything but the stack.
1332 @node History and Acknowledgements, , Using Calc, Getting Started
1333 @section History and Acknowledgements
1336 Calc was originally started as a two-week project to occupy a lull
1337 in the author's schedule. Basically, a friend asked if I remembered
1339 @texline @math{2^{32}}.
1340 @infoline @expr{2^32}.
1341 I didn't offhand, but I said, ``that's easy, just call up an
1342 @code{xcalc}.'' @code{Xcalc} duly reported that the answer to our
1343 question was @samp{4.294967e+09}---with no way to see the full ten
1344 digits even though we knew they were there in the program's memory! I
1345 was so annoyed, I vowed to write a calculator of my own, once and for
1348 I chose Emacs Lisp, a) because I had always been curious about it
1349 and b) because, being only a text editor extension language after
1350 all, Emacs Lisp would surely reach its limits long before the project
1351 got too far out of hand.
1353 To make a long story short, Emacs Lisp turned out to be a distressingly
1354 solid implementation of Lisp, and the humble task of calculating
1355 turned out to be more open-ended than one might have expected.
1357 Emacs Lisp doesn't have built-in floating point math, so it had to be
1358 simulated in software. In fact, Emacs integers will only comfortably
1359 fit six decimal digits or so---not enough for a decent calculator. So
1360 I had to write my own high-precision integer code as well, and once I had
1361 this I figured that arbitrary-size integers were just as easy as large
1362 integers. Arbitrary floating-point precision was the logical next step.
1363 Also, since the large integer arithmetic was there anyway it seemed only
1364 fair to give the user direct access to it, which in turn made it practical
1365 to support fractions as well as floats. All these features inspired me
1366 to look around for other data types that might be worth having.
1368 Around this time, my friend Rick Koshi showed me his nifty new HP-28
1369 calculator. It allowed the user to manipulate formulas as well as
1370 numerical quantities, and it could also operate on matrices. I decided
1371 that these would be good for Calc to have, too. And once things had
1372 gone this far, I figured I might as well take a look at serious algebra
1373 systems like Mathematica, Macsyma, and Maple for further ideas. Since
1374 these systems did far more than I could ever hope to implement, I decided
1375 to focus on rewrite rules and other programming features so that users
1376 could implement what they needed for themselves.
1378 Rick complained that matrices were hard to read, so I put in code to
1379 format them in a 2D style. Once these routines were in place, Big mode
1380 was obligatory. Gee, what other language modes would be useful?
1382 Scott Hemphill and Allen Knutson, two friends with a strong mathematical
1383 bent, contributed ideas and algorithms for a number of Calc features
1384 including modulo forms, primality testing, and float-to-fraction conversion.
1386 Units were added at the eager insistence of Mass Sivilotti. Later,
1387 Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
1388 expert assistance with the units table. As far as I can remember, the
1389 idea of using algebraic formulas and variables to represent units dates
1390 back to an ancient article in Byte magazine about muMath, an early
1391 algebra system for microcomputers.
1393 Many people have contributed to Calc by reporting bugs and suggesting
1394 features, large and small. A few deserve special mention: Tim Peters,
1395 who helped develop the ideas that led to the selection commands, rewrite
1396 rules, and many other algebra features;
1397 @texline Fran\c cois
1399 Pinard, who contributed an early prototype of the Calc Summary appendix
1400 as well as providing valuable suggestions in many other areas of Calc;
1401 Carl Witty, whose eagle eyes discovered many typographical and factual
1402 errors in the Calc manual; Tim Kay, who drove the development of
1403 Embedded mode; Ove Ewerlid, who made many suggestions relating to the
1404 algebra commands and contributed some code for polynomial operations;
1405 Randal Schwartz, who suggested the @code{calc-eval} function; Robert
1406 J. Chassell, who suggested the Calc Tutorial and exercises; and Juha
1407 Sarlin, who first worked out how to split Calc into quickly-loading
1408 parts. Bob Weiner helped immensely with the Lucid Emacs port.
1410 @cindex Bibliography
1411 @cindex Knuth, Art of Computer Programming
1412 @cindex Numerical Recipes
1413 @c Should these be expanded into more complete references?
1414 Among the books used in the development of Calc were Knuth's @emph{Art
1415 of Computer Programming} (especially volume II, @emph{Seminumerical
1416 Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
1417 and Vetterling; Bevington's @emph{Data Reduction and Error Analysis for
1418 the Physical Sciences}; @emph{Concrete Mathematics} by Graham, Knuth,
1419 and Patashnik; Steele's @emph{Common Lisp, the Language}; the @emph{CRC
1420 Standard Math Tables} (William H. Beyer, ed.); and Abramowitz and
1421 Stegun's venerable @emph{Handbook of Mathematical Functions}. I
1422 consulted the user's manuals for the HP-28 and HP-48 calculators, as
1423 well as for the programs Mathematica, SMP, Macsyma, Maple, MathCAD,
1424 Gnuplot, and others. Also, of course, Calc could not have been written
1425 without the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil
1426 Lewis and Dan LaLiberte.
1428 Final thanks go to Richard Stallman, without whose fine implementations
1429 of the Emacs editor, language, and environment, Calc would have been
1430 finished in two weeks.
1435 @c This node is accessed by the `M-# t' command.
1436 @node Interactive Tutorial, , , Top
1440 Some brief instructions on using the Emacs Info system for this tutorial:
1442 Press the space bar and Delete keys to go forward and backward in a
1443 section by screenfuls (or use the regular Emacs scrolling commands
1446 Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
1447 If the section has a @dfn{menu}, press a digit key like @kbd{1}
1448 or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to
1449 go back up from a sub-section to the menu it is part of.
1451 Exercises in the tutorial all have cross-references to the
1452 appropriate page of the ``answers'' section. Press @kbd{f}, then
1453 the exercise number, to see the answer to an exercise. After
1454 you have followed a cross-reference, you can press the letter
1455 @kbd{l} to return to where you were before.
1457 You can press @kbd{?} at any time for a brief summary of Info commands.
1459 Press @kbd{1} now to enter the first section of the Tutorial.
1466 @node Tutorial, Introduction, Getting Started, Top
1470 This chapter explains how to use Calc and its many features, in
1471 a step-by-step, tutorial way. You are encouraged to run Calc and
1472 work along with the examples as you read (@pxref{Starting Calc}).
1473 If you are already familiar with advanced calculators, you may wish
1475 to skip on to the rest of this manual.
1477 @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
1479 @c [fix-ref Embedded Mode]
1480 This tutorial describes the standard user interface of Calc only.
1481 The Quick mode and Keypad mode interfaces are fairly
1482 self-explanatory. @xref{Embedded Mode}, for a description of
1483 the Embedded mode interface.
1486 The easiest way to read this tutorial on-line is to have two windows on
1487 your Emacs screen, one with Calc and one with the Info system. (If you
1488 have a printed copy of the manual you can use that instead.) Press
1489 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1490 press @kbd{M-# i} to start the Info system or to switch into its window.
1491 Or, you may prefer to use the tutorial in printed form.
1494 The easiest way to read this tutorial on-line is to have two windows on
1495 your Emacs screen, one with Calc and one with the Info system. (If you
1496 have a printed copy of the manual you can use that instead.) Press
1497 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1498 press @kbd{M-# i} to start the Info system or to switch into its window.
1501 This tutorial is designed to be done in sequence. But the rest of this
1502 manual does not assume you have gone through the tutorial. The tutorial
1503 does not cover everything in the Calculator, but it touches on most
1507 You may wish to print out a copy of the Calc Summary and keep notes on
1508 it as you learn Calc. @xref{Installation}, to see how to make a printed
1509 summary. @xref{Summary}.
1512 The Calc Summary at the end of the reference manual includes some blank
1513 space for your own use. You may wish to keep notes there as you learn
1519 * Arithmetic Tutorial::
1520 * Vector/Matrix Tutorial::
1522 * Algebra Tutorial::
1523 * Programming Tutorial::
1525 * Answers to Exercises::
1528 @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
1529 @section Basic Tutorial
1532 In this section, we learn how RPN and algebraic-style calculations
1533 work, how to undo and redo an operation done by mistake, and how
1534 to control various modes of the Calculator.
1537 * RPN Tutorial:: Basic operations with the stack.
1538 * Algebraic Tutorial:: Algebraic entry; variables.
1539 * Undo Tutorial:: If you make a mistake: Undo and the trail.
1540 * Modes Tutorial:: Common mode-setting commands.
1543 @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
1544 @subsection RPN Calculations and the Stack
1546 @cindex RPN notation
1549 Calc normally uses RPN notation. You may be familiar with the RPN
1550 system from Hewlett-Packard calculators, FORTH, or PostScript.
1551 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1556 Calc normally uses RPN notation. You may be familiar with the RPN
1557 system from Hewlett-Packard calculators, FORTH, or PostScript.
1558 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1562 The central component of an RPN calculator is the @dfn{stack}. A
1563 calculator stack is like a stack of dishes. New dishes (numbers) are
1564 added at the top of the stack, and numbers are normally only removed
1565 from the top of the stack.
1569 In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands}
1570 and the @expr{+} is the @dfn{operator}. In an RPN calculator you always
1571 enter the operands first, then the operator. Each time you type a
1572 number, Calc adds or @dfn{pushes} it onto the top of the Stack.
1573 When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
1574 number of operands from the stack and pushes back the result.
1576 Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
1577 @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to
1578 the @key{ENTER} key on traditional RPN calculators.) Try this now if
1579 you wish; type @kbd{M-# c} to switch into the Calc window (you can type
1580 @kbd{M-# c} again or @kbd{M-# o} to switch back to the Tutorial window).
1581 The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
1582 The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
1583 and pushes the result (5) back onto the stack. Here's how the stack
1584 will look at various points throughout the calculation:
1592 M-# c 2 @key{RET} 3 @key{RET} + @key{DEL}
1596 The @samp{.} symbol is a marker that represents the top of the stack.
1597 Note that the ``top'' of the stack is really shown at the bottom of
1598 the Stack window. This may seem backwards, but it turns out to be
1599 less distracting in regular use.
1601 @cindex Stack levels
1602 @cindex Levels of stack
1603 The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
1604 numbers}. Old RPN calculators always had four stack levels called
1605 @expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow
1606 as large as you like, so it uses numbers instead of letters. Some
1607 stack-manipulation commands accept a numeric argument that says
1608 which stack level to work on. Normal commands like @kbd{+} always
1609 work on the top few levels of the stack.
1611 @c [fix-ref Truncating the Stack]
1612 The Stack buffer is just an Emacs buffer, and you can move around in
1613 it using the regular Emacs motion commands. But no matter where the
1614 cursor is, even if you have scrolled the @samp{.} marker out of
1615 view, most Calc commands always move the cursor back down to level 1
1616 before doing anything. It is possible to move the @samp{.} marker
1617 upwards through the stack, temporarily ``hiding'' some numbers from
1618 commands like @kbd{+}. This is called @dfn{stack truncation} and
1619 we will not cover it in this tutorial; @pxref{Truncating the Stack},
1620 if you are interested.
1622 You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
1623 @key{RET} +}. That's because if you type any operator name or
1624 other non-numeric key when you are entering a number, the Calculator
1625 automatically enters that number and then does the requested command.
1626 Thus @kbd{2 @key{RET} 3 +} will work just as well.
1628 Examples in this tutorial will often omit @key{RET} even when the
1629 stack displays shown would only happen if you did press @key{RET}:
1642 Here, after pressing @kbd{3} the stack would really show @samp{1: 2}
1643 with @samp{Calc:@: 3} in the minibuffer. In these situations, you can
1644 press the optional @key{RET} to see the stack as the figure shows.
1646 (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises
1647 at various points. Try them if you wish. Answers to all the exercises
1648 are located at the end of the Tutorial chapter. Each exercise will
1649 include a cross-reference to its particular answer. If you are
1650 reading with the Emacs Info system, press @kbd{f} and the
1651 exercise number to go to the answer, then the letter @kbd{l} to
1652 return to where you were.)
1655 Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2
1656 @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for
1657 multiplication.) Figure it out by hand, then try it with Calc to see
1658 if you're right. @xref{RPN Answer 1, 1}. (@bullet{})
1660 (@bullet{}) @strong{Exercise 2.} Compute
1661 @texline @math{(2\times4) + (7\times9.4) + {5\over4}}
1662 @infoline @expr{2*4 + 7*9.5 + 5/4}
1663 using the stack. @xref{RPN Answer 2, 2}. (@bullet{})
1665 The @key{DEL} key is called Backspace on some keyboards. It is
1666 whatever key you would use to correct a simple typing error when
1667 regularly using Emacs. The @key{DEL} key pops and throws away the
1668 top value on the stack. (You can still get that value back from
1669 the Trail if you should need it later on.) There are many places
1670 in this tutorial where we assume you have used @key{DEL} to erase the
1671 results of the previous example at the beginning of a new example.
1672 In the few places where it is really important to use @key{DEL} to
1673 clear away old results, the text will remind you to do so.
1675 (It won't hurt to let things accumulate on the stack, except that
1676 whenever you give a display-mode-changing command Calc will have to
1677 spend a long time reformatting such a large stack.)
1679 Since the @kbd{-} key is also an operator (it subtracts the top two
1680 stack elements), how does one enter a negative number? Calc uses
1681 the @kbd{_} (underscore) key to act like the minus sign in a number.
1682 So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
1683 will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
1685 You can also press @kbd{n}, which means ``change sign.'' It changes
1686 the number at the top of the stack (or the number being entered)
1687 from positive to negative or vice-versa: @kbd{5 n @key{RET}}.
1689 @cindex Duplicating a stack entry
1690 If you press @key{RET} when you're not entering a number, the effect
1691 is to duplicate the top number on the stack. Consider this calculation:
1695 1: 3 2: 3 1: 9 2: 9 1: 81
1699 3 @key{RET} @key{RET} * @key{RET} *
1704 (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
1705 to raise 3 to the fourth power.)
1707 The space-bar key (denoted @key{SPC} here) performs the same function
1708 as @key{RET}; you could replace all three occurrences of @key{RET} in
1709 the above example with @key{SPC} and the effect would be the same.
1711 @cindex Exchanging stack entries
1712 Another stack manipulation key is @key{TAB}. This exchanges the top
1713 two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +}
1714 to get 5, and then you realize what you really wanted to compute
1715 was @expr{20 / (2+3)}.
1719 1: 5 2: 5 2: 20 1: 4
1723 2 @key{RET} 3 + 20 @key{TAB} /
1728 Planning ahead, the calculation would have gone like this:
1732 1: 20 2: 20 3: 20 2: 20 1: 4
1737 20 @key{RET} 2 @key{RET} 3 + /
1741 A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
1742 @key{TAB}). It rotates the top three elements of the stack upward,
1743 bringing the object in level 3 to the top.
1747 1: 10 2: 10 3: 10 3: 20 3: 30
1748 . 1: 20 2: 20 2: 30 2: 10
1752 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB}
1756 (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
1757 on the stack. Figure out how to add one to the number in level 2
1758 without affecting the rest of the stack. Also figure out how to add
1759 one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{})
1761 Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
1762 arguments from the stack and push a result. Operations like @kbd{n} and
1763 @kbd{Q} (square root) pop a single number and push the result. You can
1764 think of them as simply operating on the top element of the stack.
1768 1: 3 1: 9 2: 9 1: 25 1: 5
1772 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q
1777 (Note that capital @kbd{Q} means to hold down the Shift key while
1778 typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.)
1780 @cindex Pythagorean Theorem
1781 Here we've used the Pythagorean Theorem to determine the hypotenuse of a
1782 right triangle. Calc actually has a built-in command for that called
1783 @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
1784 We can still enter it by its full name using @kbd{M-x} notation:
1792 3 @key{RET} 4 @key{RET} M-x calc-hypot
1796 All Calculator commands begin with the word @samp{calc-}. Since it
1797 gets tiring to type this, Calc provides an @kbd{x} key which is just
1798 like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
1807 3 @key{RET} 4 @key{RET} x hypot
1811 What happens if you take the square root of a negative number?
1815 1: 4 1: -4 1: (0, 2)
1823 The notation @expr{(a, b)} represents a complex number.
1824 Complex numbers are more traditionally written @expr{a + b i};
1825 Calc can display in this format, too, but for now we'll stick to the
1826 @expr{(a, b)} notation.
1828 If you don't know how complex numbers work, you can safely ignore this
1829 feature. Complex numbers only arise from operations that would be
1830 errors in a calculator that didn't have complex numbers. (For example,
1831 taking the square root or logarithm of a negative number produces a
1834 Complex numbers are entered in the notation shown. The @kbd{(} and
1835 @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
1839 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3)
1847 You can perform calculations while entering parts of incomplete objects.
1848 However, an incomplete object cannot actually participate in a calculation:
1852 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ...
1862 Adding 5 to an incomplete object makes no sense, so the last command
1863 produces an error message and leaves the stack the same.
1865 Incomplete objects can't participate in arithmetic, but they can be
1866 moved around by the regular stack commands.
1870 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3)
1871 1: 3 2: 3 2: ( ... 2 .
1875 2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} )
1880 Note that the @kbd{,} (comma) key did not have to be used here.
1881 When you press @kbd{)} all the stack entries between the incomplete
1882 entry and the top are collected, so there's never really a reason
1883 to use the comma. It's up to you.
1885 (@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)},
1886 your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened?
1887 (Joe thought of a clever way to correct his mistake in only two
1888 keystrokes, but it didn't quite work. Try it to find out why.)
1889 @xref{RPN Answer 4, 4}. (@bullet{})
1891 Vectors are entered the same way as complex numbers, but with square
1892 brackets in place of parentheses. We'll meet vectors again later in
1895 Any Emacs command can be given a @dfn{numeric prefix argument} by
1896 typing a series of @key{META}-digits beforehand. If @key{META} is
1897 awkward for you, you can instead type @kbd{C-u} followed by the
1898 necessary digits. Numeric prefix arguments can be negative, as in
1899 @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric
1900 prefix arguments in a variety of ways. For example, a numeric prefix
1901 on the @kbd{+} operator adds any number of stack entries at once:
1905 1: 10 2: 10 3: 10 3: 10 1: 60
1906 . 1: 20 2: 20 2: 20 .
1910 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 +
1914 For stack manipulation commands like @key{RET}, a positive numeric
1915 prefix argument operates on the top @var{n} stack entries at once. A
1916 negative argument operates on the entry in level @var{n} only. An
1917 argument of zero operates on the entire stack. In this example, we copy
1918 the second-to-top element of the stack:
1922 1: 10 2: 10 3: 10 3: 10 4: 10
1923 . 1: 20 2: 20 2: 20 3: 20
1928 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET}
1932 @cindex Clearing the stack
1933 @cindex Emptying the stack
1934 Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
1935 (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
1938 @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
1939 @subsection Algebraic-Style Calculations
1942 If you are not used to RPN notation, you may prefer to operate the
1943 Calculator in Algebraic mode, which is closer to the way
1944 non-RPN calculators work. In Algebraic mode, you enter formulas
1945 in traditional @expr{2+3} notation.
1947 You don't really need any special ``mode'' to enter algebraic formulas.
1948 You can enter a formula at any time by pressing the apostrophe (@kbd{'})
1949 key. Answer the prompt with the desired formula, then press @key{RET}.
1950 The formula is evaluated and the result is pushed onto the RPN stack.
1951 If you don't want to think in RPN at all, you can enter your whole
1952 computation as a formula, read the result from the stack, then press
1953 @key{DEL} to delete it from the stack.
1955 Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
1956 The result should be the number 9.
1958 Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
1959 @samp{/}, and @samp{^}. You can use parentheses to make the order
1960 of evaluation clear. In the absence of parentheses, @samp{^} is
1961 evaluated first, then @samp{*}, then @samp{/}, then finally
1962 @samp{+} and @samp{-}. For example, the expression
1965 2 + 3*4*5 / 6*7^8 - 9
1972 2 + ((3*4*5) / (6*(7^8)) - 9
1976 or, in large mathematical notation,
1991 $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
1996 The result of this expression will be the number @mathit{-6.99999826533}.
1998 Calc's order of evaluation is the same as for most computer languages,
1999 except that @samp{*} binds more strongly than @samp{/}, as the above
2000 example shows. As in normal mathematical notation, the @samp{*} symbol
2001 can often be omitted: @samp{2 a} is the same as @samp{2*a}.
2003 Operators at the same level are evaluated from left to right, except
2004 that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is
2005 equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent
2006 to @samp{2^(3^4)} (a very large integer; try it!).
2008 If you tire of typing the apostrophe all the time, there is
2009 Algebraic mode, where Calc automatically senses
2010 when you are about to type an algebraic expression. To enter this
2011 mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator
2012 should appear in the Calc window's mode line.)
2014 Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
2016 In Algebraic mode, when you press any key that would normally begin
2017 entering a number (such as a digit, a decimal point, or the @kbd{_}
2018 key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
2021 Functions which do not have operator symbols like @samp{+} and @samp{*}
2022 must be entered in formulas using function-call notation. For example,
2023 the function name corresponding to the square-root key @kbd{Q} is
2024 @code{sqrt}. To compute a square root in a formula, you would use
2025 the notation @samp{sqrt(@var{x})}.
2027 Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should
2028 be @expr{0.16227766017}.
2030 Note that if the formula begins with a function name, you need to use
2031 the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin}
2032 out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
2033 command, and the @kbd{csin} will be taken as the name of the rewrite
2036 Some people prefer to enter complex numbers and vectors in algebraic
2037 form because they find RPN entry with incomplete objects to be too
2038 distracting, even though they otherwise use Calc as an RPN calculator.
2040 Still in Algebraic mode, type:
2044 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1)
2045 . 1: (1, -2) . 1: 1 .
2048 (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} +
2052 Algebraic mode allows us to enter complex numbers without pressing
2053 an apostrophe first, but it also means we need to press @key{RET}
2054 after every entry, even for a simple number like @expr{1}.
2056 (You can type @kbd{C-u m a} to enable a special Incomplete Algebraic
2057 mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even
2058 though regular numeric keys still use RPN numeric entry. There is also
2059 Total Algebraic mode, started by typing @kbd{m t}, in which all
2060 normal keys begin algebraic entry. You must then use the @key{META} key
2061 to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic
2062 mode, @kbd{M-q} to quit, etc.)
2064 If you're still in Algebraic mode, press @kbd{m a} again to turn it off.
2066 Actual non-RPN calculators use a mixture of algebraic and RPN styles.
2067 In general, operators of two numbers (like @kbd{+} and @kbd{*})
2068 use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
2069 use RPN form. Also, a non-RPN calculator allows you to see the
2070 intermediate results of a calculation as you go along. You can
2071 accomplish this in Calc by performing your calculation as a series
2072 of algebraic entries, using the @kbd{$} sign to tie them together.
2073 In an algebraic formula, @kbd{$} represents the number on the top
2074 of the stack. Here, we perform the calculation
2075 @texline @math{\sqrt{2\times4+1}},
2076 @infoline @expr{sqrt(2*4+1)},
2077 which on a traditional calculator would be done by pressing
2078 @kbd{2 * 4 + 1 =} and then the square-root key.
2085 ' 2*4 @key{RET} $+1 @key{RET} Q
2090 Notice that we didn't need to press an apostrophe for the @kbd{$+1},
2091 because the dollar sign always begins an algebraic entry.
2093 (@bullet{}) @strong{Exercise 1.} How could you get the same effect as
2094 pressing @kbd{Q} but using an algebraic entry instead? How about
2095 if the @kbd{Q} key on your keyboard were broken?
2096 @xref{Algebraic Answer 1, 1}. (@bullet{})
2098 The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
2099 entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
2101 Algebraic formulas can include @dfn{variables}. To store in a
2102 variable, press @kbd{s s}, then type the variable name, then press
2103 @key{RET}. (There are actually two flavors of store command:
2104 @kbd{s s} stores a number in a variable but also leaves the number
2105 on the stack, while @w{@kbd{s t}} removes a number from the stack and
2106 stores it in the variable.) A variable name should consist of one
2107 or more letters or digits, beginning with a letter.
2111 1: 17 . 1: a + a^2 1: 306
2114 17 s t a @key{RET} ' a+a^2 @key{RET} =
2119 The @kbd{=} key @dfn{evaluates} a formula by replacing all its
2120 variables by the values that were stored in them.
2122 For RPN calculations, you can recall a variable's value on the
2123 stack either by entering its name as a formula and pressing @kbd{=},
2124 or by using the @kbd{s r} command.
2128 1: 17 2: 17 3: 17 2: 17 1: 306
2129 . 1: 17 2: 17 1: 289 .
2133 s r a @key{RET} ' a @key{RET} = 2 ^ +
2137 If you press a single digit for a variable name (as in @kbd{s t 3}, you
2138 get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
2139 They are ``quick'' simply because you don't have to type the letter
2140 @code{q} or the @key{RET} after their names. In fact, you can type
2141 simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
2142 @kbd{t 3} and @w{@kbd{r 3}}.
2144 Any variables in an algebraic formula for which you have not stored
2145 values are left alone, even when you evaluate the formula.
2149 1: 2 a + 2 b 1: 34 + 2 b
2156 Calls to function names which are undefined in Calc are also left
2157 alone, as are calls for which the value is undefined.
2161 1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
2164 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
2169 In this example, the first call to @code{log10} works, but the other
2170 calls are not evaluated. In the second call, the logarithm is
2171 undefined for that value of the argument; in the third, the argument
2172 is symbolic, and in the fourth, there are too many arguments. In the
2173 fifth case, there is no function called @code{foo}. You will see a
2174 ``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
2175 Press the @kbd{w} (``why'') key to see any other messages that may
2176 have arisen from the last calculation. In this case you will get
2177 ``logarithm of zero,'' then ``number expected: @code{x}''. Calc
2178 automatically displays the first message only if the message is
2179 sufficiently important; for example, Calc considers ``wrong number
2180 of arguments'' and ``logarithm of zero'' to be important enough to
2181 report automatically, while a message like ``number expected: @code{x}''
2182 will only show up if you explicitly press the @kbd{w} key.
2184 (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y},
2185 stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
2186 @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)},
2187 expecting @samp{10 (1+y)}, but it didn't work. Why not?
2188 @xref{Algebraic Answer 2, 2}. (@bullet{})
2190 (@bullet{}) @strong{Exercise 3.} What result would you expect
2191 @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}?
2192 @xref{Algebraic Answer 3, 3}. (@bullet{})
2194 One interesting way to work with variables is to use the
2195 @dfn{evaluates-to} (@samp{=>}) operator. It works like this:
2196 Enter a formula algebraically in the usual way, but follow
2197 the formula with an @samp{=>} symbol. (There is also an @kbd{s =}
2198 command which builds an @samp{=>} formula using the stack.) On
2199 the stack, you will see two copies of the formula with an @samp{=>}
2200 between them. The lefthand formula is exactly like you typed it;
2201 the righthand formula has been evaluated as if by typing @kbd{=}.
2205 2: 2 + 3 => 5 2: 2 + 3 => 5
2206 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b
2209 ' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET}
2214 Notice that the instant we stored a new value in @code{a}, all
2215 @samp{=>} operators already on the stack that referred to @expr{a}
2216 were updated to use the new value. With @samp{=>}, you can push a
2217 set of formulas on the stack, then change the variables experimentally
2218 to see the effects on the formulas' values.
2220 You can also ``unstore'' a variable when you are through with it:
2225 1: 2 a + 2 b => 2 a + 2 b
2232 We will encounter formulas involving variables and functions again
2233 when we discuss the algebra and calculus features of the Calculator.
2235 @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
2236 @subsection Undo and Redo
2239 If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
2240 the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
2241 and restart Calc (@kbd{M-# M-# M-# M-#}) to make sure things start off
2242 with a clean slate. Now:
2246 1: 2 2: 2 1: 8 2: 2 1: 6
2254 You can undo any number of times. Calc keeps a complete record of
2255 all you have done since you last opened the Calc window. After the
2256 above example, you could type:
2268 You can also type @kbd{D} to ``redo'' a command that you have undone
2273 . 1: 2 2: 2 1: 6 1: 6
2282 It was not possible to redo past the @expr{6}, since that was placed there
2283 by something other than an undo command.
2286 You can think of undo and redo as a sort of ``time machine.'' Press
2287 @kbd{U} to go backward in time, @kbd{D} to go forward. If you go
2288 backward and do something (like @kbd{*}) then, as any science fiction
2289 reader knows, you have changed your future and you cannot go forward
2290 again. Thus, the inability to redo past the @expr{6} even though there
2291 was an earlier undo command.
2293 You can always recall an earlier result using the Trail. We've ignored
2294 the trail so far, but it has been faithfully recording everything we
2295 did since we loaded the Calculator. If the Trail is not displayed,
2296 press @kbd{t d} now to turn it on.
2298 Let's try grabbing an earlier result. The @expr{8} we computed was
2299 undone by a @kbd{U} command, and was lost even to Redo when we pressed
2300 @kbd{*}, but it's still there in the trail. There should be a little
2301 @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
2302 entry. If there isn't, press @kbd{t ]} to reset the trail pointer.
2303 Now, press @w{@kbd{t p}} to move the arrow onto the line containing
2304 @expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
2307 If you press @kbd{t ]} again, you will see that even our Yank command
2308 went into the trail.
2310 Let's go further back in time. Earlier in the tutorial we computed
2311 a huge integer using the formula @samp{2^3^4}. We don't remember
2312 what it was, but the first digits were ``241''. Press @kbd{t r}
2313 (which stands for trail-search-reverse), then type @kbd{241}.
2314 The trail cursor will jump back to the next previous occurrence of
2315 the string ``241'' in the trail. This is just a regular Emacs
2316 incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
2317 continue the search forwards or backwards as you like.
2319 To finish the search, press @key{RET}. This halts the incremental
2320 search and leaves the trail pointer at the thing we found. Now we
2321 can type @kbd{t y} to yank that number onto the stack. If we hadn't
2322 remembered the ``241'', we could simply have searched for @kbd{2^3^4},
2323 then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
2325 You may have noticed that all the trail-related commands begin with
2326 the letter @kbd{t}. (The store-and-recall commands, on the other hand,
2327 all began with @kbd{s}.) Calc has so many commands that there aren't
2328 enough keys for all of them, so various commands are grouped into
2329 two-letter sequences where the first letter is called the @dfn{prefix}
2330 key. If you type a prefix key by accident, you can press @kbd{C-g}
2331 to cancel it. (In fact, you can press @kbd{C-g} to cancel almost
2332 anything in Emacs.) To get help on a prefix key, press that key
2333 followed by @kbd{?}. Some prefixes have several lines of help,
2334 so you need to press @kbd{?} repeatedly to see them all.
2335 You can also type @kbd{h h} to see all the help at once.
2337 Try pressing @kbd{t ?} now. You will see a line of the form,
2340 trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t-
2344 The word ``trail'' indicates that the @kbd{t} prefix key contains
2345 trail-related commands. Each entry on the line shows one command,
2346 with a single capital letter showing which letter you press to get
2347 that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
2348 @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?}
2349 again to see more @kbd{t}-prefix commands. Notice that the commands
2350 are roughly divided (by semicolons) into related groups.
2352 When you are in the help display for a prefix key, the prefix is
2353 still active. If you press another key, like @kbd{y} for example,
2354 it will be interpreted as a @kbd{t y} command. If all you wanted
2355 was to look at the help messages, press @kbd{C-g} afterwards to cancel
2358 One more way to correct an error is by editing the stack entries.
2359 The actual Stack buffer is marked read-only and must not be edited
2360 directly, but you can press @kbd{`} (the backquote or accent grave)
2361 to edit a stack entry.
2363 Try entering @samp{3.141439} now. If this is supposed to represent
2364 @cpi{}, it's got several errors. Press @kbd{`} to edit this number.
2365 Now use the normal Emacs cursor motion and editing keys to change
2366 the second 4 to a 5, and to transpose the 3 and the 9. When you
2367 press @key{RET}, the number on the stack will be replaced by your
2368 new number. This works for formulas, vectors, and all other types
2369 of values you can put on the stack. The @kbd{`} key also works
2370 during entry of a number or algebraic formula.
2372 @node Modes Tutorial, , Undo Tutorial, Basic Tutorial
2373 @subsection Mode-Setting Commands
2376 Calc has many types of @dfn{modes} that affect the way it interprets
2377 your commands or the way it displays data. We have already seen one
2378 mode, namely Algebraic mode. There are many others, too; we'll
2379 try some of the most common ones here.
2381 Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
2382 Notice the @samp{12} on the Calc window's mode line:
2385 --%%-Calc: 12 Deg (Calculator)----All------
2389 Most of the symbols there are Emacs things you don't need to worry
2390 about, but the @samp{12} and the @samp{Deg} are mode indicators.
2391 The @samp{12} means that calculations should always be carried to
2392 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /},
2393 we get @expr{0.142857142857} with exactly 12 digits, not counting
2394 leading and trailing zeros.
2396 You can set the precision to anything you like by pressing @kbd{p},
2397 then entering a suitable number. Try pressing @kbd{p 30 @key{RET}},
2398 then doing @kbd{1 @key{RET} 7 /} again:
2403 2: 0.142857142857142857142857142857
2408 Although the precision can be set arbitrarily high, Calc always
2409 has to have @emph{some} value for the current precision. After
2410 all, the true value @expr{1/7} is an infinitely repeating decimal;
2411 Calc has to stop somewhere.
2413 Of course, calculations are slower the more digits you request.
2414 Press @w{@kbd{p 12}} now to set the precision back down to the default.
2416 Calculations always use the current precision. For example, even
2417 though we have a 30-digit value for @expr{1/7} on the stack, if
2418 we use it in a calculation in 12-digit mode it will be rounded
2419 down to 12 digits before it is used. Try it; press @key{RET} to
2420 duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET}
2421 key didn't round the number, because it doesn't do any calculation.
2422 But the instant we pressed @kbd{+}, the number was rounded down.
2427 2: 0.142857142857142857142857142857
2434 In fact, since we added a digit on the left, we had to lose one
2435 digit on the right from even the 12-digit value of @expr{1/7}.
2437 How did we get more than 12 digits when we computed @samp{2^3^4}? The
2438 answer is that Calc makes a distinction between @dfn{integers} and
2439 @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number
2440 that does not contain a decimal point. There is no such thing as an
2441 ``infinitely repeating fraction integer,'' so Calc doesn't have to limit
2442 itself. If you asked for @samp{2^10000} (don't try this!), you would
2443 have to wait a long time but you would eventually get an exact answer.
2444 If you ask for @samp{2.^10000}, you will quickly get an answer which is
2445 correct only to 12 places. The decimal point tells Calc that it should
2446 use floating-point arithmetic to get the answer, not exact integer
2449 You can use the @kbd{F} (@code{calc-floor}) command to convert a
2450 floating-point value to an integer, and @kbd{c f} (@code{calc-float})
2451 to convert an integer to floating-point form.
2453 Let's try entering that last calculation:
2457 1: 2. 2: 2. 1: 1.99506311689e3010
2461 2.0 @key{RET} 10000 @key{RET} ^
2466 @cindex Scientific notation, entry of
2467 Notice the letter @samp{e} in there. It represents ``times ten to the
2468 power of,'' and is used by Calc automatically whenever writing the
2469 number out fully would introduce more extra zeros than you probably
2470 want to see. You can enter numbers in this notation, too.
2474 1: 2. 2: 2. 1: 1.99506311678e3010
2478 2.0 @key{RET} 1e4 @key{RET} ^
2482 @cindex Round-off errors
2484 Hey, the answer is different! Look closely at the middle columns
2485 of the two examples. In the first, the stack contained the
2486 exact integer @expr{10000}, but in the second it contained
2487 a floating-point value with a decimal point. When you raise a
2488 number to an integer power, Calc uses repeated squaring and
2489 multiplication to get the answer. When you use a floating-point
2490 power, Calc uses logarithms and exponentials. As you can see,
2491 a slight error crept in during one of these methods. Which
2492 one should we trust? Let's raise the precision a bit and find
2497 . 1: 2. 2: 2. 1: 1.995063116880828e3010
2501 p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET}
2506 @cindex Guard digits
2507 Presumably, it doesn't matter whether we do this higher-precision
2508 calculation using an integer or floating-point power, since we
2509 have added enough ``guard digits'' to trust the first 12 digits
2510 no matter what. And the verdict is@dots{} Integer powers were more
2511 accurate; in fact, the result was only off by one unit in the
2514 @cindex Guard digits
2515 Calc does many of its internal calculations to a slightly higher
2516 precision, but it doesn't always bump the precision up enough.
2517 In each case, Calc added about two digits of precision during
2518 its calculation and then rounded back down to 12 digits
2519 afterward. In one case, it was enough; in the other, it
2520 wasn't. If you really need @var{x} digits of precision, it
2521 never hurts to do the calculation with a few extra guard digits.
2523 What if we want guard digits but don't want to look at them?
2524 We can set the @dfn{float format}. Calc supports four major
2525 formats for floating-point numbers, called @dfn{normal},
2526 @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
2527 notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f},
2528 @kbd{d s}, and @kbd{d e}, respectively. In each case, you can
2529 supply a numeric prefix argument which says how many digits
2530 should be displayed. As an example, let's put a few numbers
2531 onto the stack and try some different display modes. First,
2532 use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
2537 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2538 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000
2539 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450
2540 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345
2543 d n M-3 d n d s M-3 d s M-3 d f
2548 Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
2549 to three significant digits, but then when we typed @kbd{d s} all
2550 five significant figures reappeared. The float format does not
2551 affect how numbers are stored, it only affects how they are
2552 displayed. Only the current precision governs the actual rounding
2553 of numbers in the Calculator's memory.
2555 Engineering notation, not shown here, is like scientific notation
2556 except the exponent (the power-of-ten part) is always adjusted to be
2557 a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result
2558 there will be one, two, or three digits before the decimal point.
2560 Whenever you change a display-related mode, Calc redraws everything
2561 in the stack. This may be slow if there are many things on the stack,
2562 so Calc allows you to type shift-@kbd{H} before any mode command to
2563 prevent it from updating the stack. Anything Calc displays after the
2564 mode-changing command will appear in the new format.
2568 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2569 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345.
2570 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45
2571 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345
2574 H d s @key{DEL} U @key{TAB} d @key{SPC} d n
2579 Here the @kbd{H d s} command changes to scientific notation but without
2580 updating the screen. Deleting the top stack entry and undoing it back
2581 causes it to show up in the new format; swapping the top two stack
2582 entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the
2583 whole stack. The @kbd{d n} command changes back to the normal float
2584 format; since it doesn't have an @kbd{H} prefix, it also updates all
2585 the stack entries to be in @kbd{d n} format.
2587 Notice that the integer @expr{12345} was not affected by any
2588 of the float formats. Integers are integers, and are always
2591 @cindex Large numbers, readability
2592 Large integers have their own problems. Let's look back at
2593 the result of @kbd{2^3^4}.
2596 2417851639229258349412352
2600 Quick---how many digits does this have? Try typing @kbd{d g}:
2603 2,417,851,639,229,258,349,412,352
2607 Now how many digits does this have? It's much easier to tell!
2608 We can actually group digits into clumps of any size. Some
2609 people prefer @kbd{M-5 d g}:
2612 24178,51639,22925,83494,12352
2615 Let's see what happens to floating-point numbers when they are grouped.
2616 First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
2617 to get ourselves into trouble. Now, type @kbd{1e13 /}:
2620 24,17851,63922.9258349412352
2624 The integer part is grouped but the fractional part isn't. Now try
2625 @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
2628 24,17851,63922.92583,49412,352
2631 If you find it hard to tell the decimal point from the commas, try
2632 changing the grouping character to a space with @kbd{d , @key{SPC}}:
2635 24 17851 63922.92583 49412 352
2638 Type @kbd{d , ,} to restore the normal grouping character, then
2639 @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to
2640 restore the default precision.
2642 Press @kbd{U} enough times to get the original big integer back.
2643 (Notice that @kbd{U} does not undo each mode-setting command; if
2644 you want to undo a mode-setting command, you have to do it yourself.)
2645 Now, type @kbd{d r 16 @key{RET}}:
2648 16#200000000000000000000
2652 The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
2653 Suddenly it looks pretty simple; this should be no surprise, since we
2654 got this number by computing a power of two, and 16 is a power of 2.
2655 In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
2659 2#1000000000000000000000000000000000000000000000000000000 @dots{}
2663 We don't have enough space here to show all the zeros! They won't
2664 fit on a typical screen, either, so you will have to use horizontal
2665 scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the
2666 stack window left and right by half its width. Another way to view
2667 something large is to press @kbd{`} (back-quote) to edit the top of
2668 stack in a separate window. (Press @kbd{C-c C-c} when you are done.)
2670 You can enter non-decimal numbers using the @kbd{#} symbol, too.
2671 Let's see what the hexadecimal number @samp{5FE} looks like in
2672 binary. Type @kbd{16#5FE} (the letters can be typed in upper or
2673 lower case; they will always appear in upper case). It will also
2674 help to turn grouping on with @kbd{d g}:
2680 Notice that @kbd{d g} groups by fours by default if the display radix
2681 is binary or hexadecimal, but by threes if it is decimal, octal, or any
2684 Now let's see that number in decimal; type @kbd{d r 10}:
2690 Numbers are not @emph{stored} with any particular radix attached. They're
2691 just numbers; they can be entered in any radix, and are always displayed
2692 in whatever radix you've chosen with @kbd{d r}. The current radix applies
2693 to integers, fractions, and floats.
2695 @cindex Roundoff errors, in non-decimal numbers
2696 (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third
2697 as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got
2698 @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied
2699 that by three, he got @samp{3#0.222222...} instead of the expected
2700 @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief,
2701 saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got
2702 @samp{3#0.10000001} (some zeros omitted). What's going on here?
2703 @xref{Modes Answer 1, 1}. (@bullet{})
2705 @cindex Scientific notation, in non-decimal numbers
2706 (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal
2707 modes in the natural way (the exponent is a power of the radix instead of
2708 a power of ten, although the exponent itself is always written in decimal).
2709 Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number
2710 @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}.
2711 What is wrong with this picture? What could we write instead that would
2712 work better? @xref{Modes Answer 2, 2}. (@bullet{})
2714 The @kbd{m} prefix key has another set of modes, relating to the way
2715 Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix
2716 modes generally affect the way things look, @kbd{m}-prefix modes affect
2717 the way they are actually computed.
2719 The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice
2720 the @samp{Deg} indicator in the mode line. This means that if you use
2721 a command that interprets a number as an angle, it will assume the
2722 angle is measured in degrees. For example,
2726 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5
2734 The shift-@kbd{S} command computes the sine of an angle. The sine
2736 @texline @math{\sqrt{2}/2};
2737 @infoline @expr{sqrt(2)/2};
2738 squaring this yields @expr{2/4 = 0.5}. However, there has been a slight
2739 roundoff error because the representation of
2740 @texline @math{\sqrt{2}/2}
2741 @infoline @expr{sqrt(2)/2}
2742 wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers
2743 in this case; it temporarily reduces the precision by one digit while it
2744 re-rounds the number on the top of the stack.
2746 @cindex Roundoff errors, examples
2747 (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine
2748 of 45 degrees as shown above, then, hoping to avoid an inexact
2749 result, he increased the precision to 16 digits before squaring.
2750 What happened? @xref{Modes Answer 3, 3}. (@bullet{})
2752 To do this calculation in radians, we would type @kbd{m r} first.
2753 (The indicator changes to @samp{Rad}.) 45 degrees corresponds to
2754 @cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once
2755 again, this is a shifted capital @kbd{P}. Remember, unshifted
2756 @kbd{p} sets the precision.)
2760 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187
2767 Likewise, inverse trigonometric functions generate results in
2768 either radians or degrees, depending on the current angular mode.
2772 1: 0.707106781187 1: 0.785398163398 1: 45.
2775 .5 Q m r I S m d U I S
2780 Here we compute the Inverse Sine of
2781 @texline @math{\sqrt{0.5}},
2782 @infoline @expr{sqrt(0.5)},
2783 first in radians, then in degrees.
2785 Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
2790 1: 45 1: 0.785398163397 1: 45.
2797 Another interesting mode is @dfn{Fraction mode}. Normally,
2798 dividing two integers produces a floating-point result if the
2799 quotient can't be expressed as an exact integer. Fraction mode
2800 causes integer division to produce a fraction, i.e., a rational
2805 2: 12 1: 1.33333333333 1: 4:3
2809 12 @key{RET} 9 / m f U / m f
2814 In the first case, we get an approximate floating-point result.
2815 In the second case, we get an exact fractional result (four-thirds).
2817 You can enter a fraction at any time using @kbd{:} notation.
2818 (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
2819 because @kbd{/} is already used to divide the top two stack
2820 elements.) Calculations involving fractions will always
2821 produce exact fractional results; Fraction mode only says
2822 what to do when dividing two integers.
2824 @cindex Fractions vs. floats
2825 @cindex Floats vs. fractions
2826 (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact,
2827 why would you ever use floating-point numbers instead?
2828 @xref{Modes Answer 4, 4}. (@bullet{})
2830 Typing @kbd{m f} doesn't change any existing values in the stack.
2831 In the above example, we had to Undo the division and do it over
2832 again when we changed to Fraction mode. But if you use the
2833 evaluates-to operator you can get commands like @kbd{m f} to
2838 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3
2841 ' 12/9 => @key{RET} p 4 @key{RET} m f
2846 In this example, the righthand side of the @samp{=>} operator
2847 on the stack is recomputed when we change the precision, then
2848 again when we change to Fraction mode. All @samp{=>} expressions
2849 on the stack are recomputed every time you change any mode that
2850 might affect their values.
2852 @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
2853 @section Arithmetic Tutorial
2856 In this section, we explore the arithmetic and scientific functions
2857 available in the Calculator.
2859 The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
2860 and @kbd{^}. Each normally takes two numbers from the top of the stack
2861 and pushes back a result. The @kbd{n} and @kbd{&} keys perform
2862 change-sign and reciprocal operations, respectively.
2866 1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
2873 @cindex Binary operators
2874 You can apply a ``binary operator'' like @kbd{+} across any number of
2875 stack entries by giving it a numeric prefix. You can also apply it
2876 pairwise to several stack elements along with the top one if you use
2881 3: 2 1: 9 3: 2 4: 2 3: 12
2882 2: 3 . 2: 3 3: 3 2: 13
2883 1: 4 1: 4 2: 4 1: 14
2887 2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 +
2891 @cindex Unary operators
2892 You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
2893 stack entries with a numeric prefix, too.
2898 2: 3 2: 0.333333333333 2: 3.
2902 2 @key{RET} 3 @key{RET} 4 M-3 & M-2 &
2906 Notice that the results here are left in floating-point form.
2907 We can convert them back to integers by pressing @kbd{F}, the
2908 ``floor'' function. This function rounds down to the next lower
2909 integer. There is also @kbd{R}, which rounds to the nearest
2927 Since dividing-and-flooring (i.e., ``integer quotient'') is such a
2928 common operation, Calc provides a special command for that purpose, the
2929 backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which
2930 computes the remainder that would arise from a @kbd{\} operation, i.e.,
2931 the ``modulo'' of two numbers. For example,
2935 2: 1234 1: 12 2: 1234 1: 34
2939 1234 @key{RET} 100 \ U %
2943 These commands actually work for any real numbers, not just integers.
2947 2: 3.1415 1: 3 2: 3.1415 1: 0.1415
2951 3.1415 @key{RET} 1 \ U %
2955 (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a
2956 frill, since you could always do the same thing with @kbd{/ F}. Think
2957 of a situation where this is not true---@kbd{/ F} would be inadequate.
2958 Now think of a way you could get around the problem if Calc didn't
2959 provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{})
2961 We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
2962 commands. Other commands along those lines are @kbd{C} (cosine),
2963 @kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural
2964 logarithm). These can be modified by the @kbd{I} (inverse) and
2965 @kbd{H} (hyperbolic) prefix keys.
2967 Let's compute the sine and cosine of an angle, and verify the
2969 @texline @math{\sin^2x + \cos^2x = 1}.
2970 @infoline @expr{sin(x)^2 + cos(x)^2 = 1}.
2971 We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}.
2972 With the angular mode set to degrees (type @w{@kbd{m d}}), do:
2976 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
2977 1: -64 1: -0.89879 1: -64 1: 0.43837 .
2980 64 n @key{RET} @key{RET} S @key{TAB} C f h
2985 (For brevity, we're showing only five digits of the results here.
2986 You can of course do these calculations to any precision you like.)
2988 Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
2989 of squares, command.
2992 @texline @math{\displaystyle\tan x = {\sin x \over \cos x}}.
2993 @infoline @expr{tan(x) = sin(x) / cos(x)}.
2997 2: -0.89879 1: -2.0503 1: -64.
3005 A physical interpretation of this calculation is that if you move
3006 @expr{0.89879} units downward and @expr{0.43837} units to the right,
3007 your direction of motion is @mathit{-64} degrees from horizontal. Suppose
3008 we move in the opposite direction, up and to the left:
3012 2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
3013 1: 0.43837 1: -0.43837 . .
3021 How can the angle be the same? The answer is that the @kbd{/} operation
3022 loses information about the signs of its inputs. Because the quotient
3023 is negative, we know exactly one of the inputs was negative, but we
3024 can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which
3025 computes the inverse tangent of the quotient of a pair of numbers.
3026 Since you feed it the two original numbers, it has enough information
3027 to give you a full 360-degree answer.
3031 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
3032 1: -0.43837 . 2: -0.89879 1: -64. .
3036 U U f T M-@key{RET} M-2 n f T -
3041 The resulting angles differ by 180 degrees; in other words, they
3042 point in opposite directions, just as we would expect.
3044 The @key{META}-@key{RET} we used in the third step is the
3045 ``last-arguments'' command. It is sort of like Undo, except that it
3046 restores the arguments of the last command to the stack without removing
3047 the command's result. It is useful in situations like this one,
3048 where we need to do several operations on the same inputs. We could
3049 have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
3050 the top two stack elements right after the @kbd{U U}, then a pair of
3051 @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
3053 A similar identity is supposed to hold for hyperbolic sines and cosines,
3054 except that it is the @emph{difference}
3055 @texline @math{\cosh^2x - \sinh^2x}
3056 @infoline @expr{cosh(x)^2 - sinh(x)^2}
3057 that always equals one. Let's try to verify this identity.
3061 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
3062 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
3065 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^
3070 @cindex Roundoff errors, examples
3071 Something's obviously wrong, because when we subtract these numbers
3072 the answer will clearly be zero! But if you think about it, if these
3073 numbers @emph{did} differ by one, it would be in the 55th decimal
3074 place. The difference we seek has been lost entirely to roundoff
3077 We could verify this hypothesis by doing the actual calculation with,
3078 say, 60 decimal places of precision. This will be slow, but not
3079 enormously so. Try it if you wish; sure enough, the answer is
3080 0.99999, reasonably close to 1.
3082 Of course, a more reasonable way to verify the identity is to use
3083 a more reasonable value for @expr{x}!
3085 @cindex Common logarithm
3086 Some Calculator commands use the Hyperbolic prefix for other purposes.
3087 The logarithm and exponential functions, for example, work to the base
3088 @expr{e} normally but use base-10 instead if you use the Hyperbolic
3093 1: 1000 1: 6.9077 1: 1000 1: 3
3101 First, we mistakenly compute a natural logarithm. Then we undo
3102 and compute a common logarithm instead.
3104 The @kbd{B} key computes a general base-@var{b} logarithm for any
3109 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
3110 1: 10 . . 1: 2.71828 .
3113 1000 @key{RET} 10 B H E H P B
3118 Here we first use @kbd{B} to compute the base-10 logarithm, then use
3119 the ``hyperbolic'' exponential as a cheap hack to recover the number
3120 1000, then use @kbd{B} again to compute the natural logarithm. Note
3121 that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e}
3124 You may have noticed that both times we took the base-10 logarithm
3125 of 1000, we got an exact integer result. Calc always tries to give
3126 an exact rational result for calculations involving rational numbers
3127 where possible. But when we used @kbd{H E}, the result was a
3128 floating-point number for no apparent reason. In fact, if we had
3129 computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
3130 exact integer 1000. But the @kbd{H E} command is rigged to generate
3131 a floating-point result all of the time so that @kbd{1000 H E} will
3132 not waste time computing a thousand-digit integer when all you
3133 probably wanted was @samp{1e1000}.
3135 (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to
3136 the @kbd{B} command for which Calc could find an exact rational
3137 result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{})
3139 The Calculator also has a set of functions relating to combinatorics
3140 and statistics. You may be familiar with the @dfn{factorial} function,
3141 which computes the product of all the integers up to a given number.
3145 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
3153 Recall, the @kbd{c f} command converts the integer or fraction at the
3154 top of the stack to floating-point format. If you take the factorial
3155 of a floating-point number, you get a floating-point result
3156 accurate to the current precision. But if you give @kbd{!} an
3157 exact integer, you get an exact integer result (158 digits long
3160 If you take the factorial of a non-integer, Calc uses a generalized
3161 factorial function defined in terms of Euler's Gamma function
3162 @texline @math{\Gamma(n)}
3163 @infoline @expr{gamma(n)}
3164 (which is itself available as the @kbd{f g} command).
3168 3: 4. 3: 24. 1: 5.5 1: 52.342777847
3169 2: 4.5 2: 52.3427777847 . .
3173 M-3 ! M-0 @key{DEL} 5.5 f g
3178 Here we verify the identity
3179 @texline @math{n! = \Gamma(n+1)}.
3180 @infoline @expr{@var{n}!@: = gamma(@var{n}+1)}.
3182 The binomial coefficient @var{n}-choose-@var{m}
3183 @texline or @math{\displaystyle {n \choose m}}
3185 @texline @math{\displaystyle {n! \over m! \, (n-m)!}}
3186 @infoline @expr{n!@: / m!@: (n-m)!}
3187 for all reals @expr{n} and @expr{m}. The intermediate results in this
3188 formula can become quite large even if the final result is small; the
3189 @kbd{k c} command computes a binomial coefficient in a way that avoids
3190 large intermediate values.
3192 The @kbd{k} prefix key defines several common functions out of
3193 combinatorics and number theory. Here we compute the binomial
3194 coefficient 30-choose-20, then determine its prime factorization.
3198 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
3202 30 @key{RET} 20 k c k f
3207 You can verify these prime factors by using @kbd{v u} to ``unpack''
3208 this vector into 8 separate stack entries, then @kbd{M-8 *} to
3209 multiply them back together. The result is the original number,
3213 Suppose a program you are writing needs a hash table with at least
3214 10000 entries. It's best to use a prime number as the actual size
3215 of a hash table. Calc can compute the next prime number after 10000:
3219 1: 10000 1: 10007 1: 9973
3227 Just for kicks we've also computed the next prime @emph{less} than
3230 @c [fix-ref Financial Functions]
3231 @xref{Financial Functions}, for a description of the Calculator
3232 commands that deal with business and financial calculations (functions
3233 like @code{pv}, @code{rate}, and @code{sln}).
3235 @c [fix-ref Binary Number Functions]
3236 @xref{Binary Functions}, to read about the commands for operating
3237 on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
3239 @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
3240 @section Vector/Matrix Tutorial
3243 A @dfn{vector} is a list of numbers or other Calc data objects.
3244 Calc provides a large set of commands that operate on vectors. Some
3245 are familiar operations from vector analysis. Others simply treat
3246 a vector as a list of objects.
3249 * Vector Analysis Tutorial::
3254 @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
3255 @subsection Vector Analysis
3258 If you add two vectors, the result is a vector of the sums of the
3259 elements, taken pairwise.
3263 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3]
3267 [1,2,3] s 1 [7 6 0] s 2 +
3272 Note that we can separate the vector elements with either commas or
3273 spaces. This is true whether we are using incomplete vectors or
3274 algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these
3275 vectors so we can easily reuse them later.
3277 If you multiply two vectors, the result is the sum of the products
3278 of the elements taken pairwise. This is called the @dfn{dot product}
3292 The dot product of two vectors is equal to the product of their
3293 lengths times the cosine of the angle between them. (Here the vector
3294 is interpreted as a line from the origin @expr{(0,0,0)} to the
3295 specified point in three-dimensional space.) The @kbd{A}
3296 (absolute value) command can be used to compute the length of a
3301 3: 19 3: 19 1: 0.550782 1: 56.579
3302 2: [1, 2, 3] 2: 3.741657 . .
3303 1: [7, 6, 0] 1: 9.219544
3306 M-@key{RET} M-2 A * / I C
3311 First we recall the arguments to the dot product command, then
3312 we compute the absolute values of the top two stack entries to
3313 obtain the lengths of the vectors, then we divide the dot product
3314 by the product of the lengths to get the cosine of the angle.
3315 The inverse cosine finds that the angle between the vectors
3316 is about 56 degrees.
3318 @cindex Cross product
3319 @cindex Perpendicular vectors
3320 The @dfn{cross product} of two vectors is a vector whose length
3321 is the product of the lengths of the inputs times the sine of the
3322 angle between them, and whose direction is perpendicular to both
3323 input vectors. Unlike the dot product, the cross product is
3324 defined only for three-dimensional vectors. Let's double-check
3325 our computation of the angle using the cross product.
3329 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579
3330 1: [7, 6, 0] 2: [1, 2, 3] . .
3334 r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S
3339 First we recall the original vectors and compute their cross product,
3340 which we also store for later reference. Now we divide the vector
3341 by the product of the lengths of the original vectors. The length of
3342 this vector should be the sine of the angle; sure enough, it is!
3344 @c [fix-ref General Mode Commands]
3345 Vector-related commands generally begin with the @kbd{v} prefix key.
3346 Some are uppercase letters and some are lowercase. To make it easier
3347 to type these commands, the shift-@kbd{V} prefix key acts the same as
3348 the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all
3349 prefix keys have this property.)
3351 If we take the dot product of two perpendicular vectors we expect
3352 to get zero, since the cosine of 90 degrees is zero. Let's check
3353 that the cross product is indeed perpendicular to both inputs:
3357 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0
3358 1: [-18, 21, -8] . 1: [-18, 21, -8] .
3361 r 1 r 3 * @key{DEL} r 2 r 3 *
3365 @cindex Normalizing a vector
3366 @cindex Unit vectors
3367 (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the
3368 stack, what keystrokes would you use to @dfn{normalize} the
3369 vector, i.e., to reduce its length to one without changing its
3370 direction? @xref{Vector Answer 1, 1}. (@bullet{})
3372 (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be
3373 at any of several positions along a ruler. You have a list of
3374 those positions in the form of a vector, and another list of the
3375 probabilities for the particle to be at the corresponding positions.
3376 Find the average position of the particle.
3377 @xref{Vector Answer 2, 2}. (@bullet{})
3379 @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
3380 @subsection Matrices
3383 A @dfn{matrix} is just a vector of vectors, all the same length.
3384 This means you can enter a matrix using nested brackets. You can
3385 also use the semicolon character to enter a matrix. We'll show
3390 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3391 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3394 [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET}
3399 We'll be using this matrix again, so type @kbd{s 4} to save it now.
3401 Note that semicolons work with incomplete vectors, but they work
3402 better in algebraic entry. That's why we use the apostrophe in
3405 When two matrices are multiplied, the lefthand matrix must have
3406 the same number of columns as the righthand matrix has rows.
3407 Row @expr{i}, column @expr{j} of the result is effectively the
3408 dot product of row @expr{i} of the left matrix by column @expr{j}
3409 of the right matrix.
3411 If we try to duplicate this matrix and multiply it by itself,
3412 the dimensions are wrong and the multiplication cannot take place:
3416 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ]
3417 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3425 Though rather hard to read, this is a formula which shows the product
3426 of two matrices. The @samp{*} function, having invalid arguments, has
3427 been left in symbolic form.
3429 We can multiply the matrices if we @dfn{transpose} one of them first.
3433 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ]
3434 [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ]
3435 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ]
3440 U v t * U @key{TAB} *
3444 Matrix multiplication is not commutative; indeed, switching the
3445 order of the operands can even change the dimensions of the result
3446 matrix, as happened here!
3448 If you multiply a plain vector by a matrix, it is treated as a
3449 single row or column depending on which side of the matrix it is
3450 on. The result is a plain vector which should also be interpreted
3451 as a row or column as appropriate.
3455 2: [ [ 1, 2, 3 ] 1: [14, 32]
3464 Multiplying in the other order wouldn't work because the number of
3465 rows in the matrix is different from the number of elements in the
3468 (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows
3470 @texline @math{2\times3}
3472 matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns
3473 to get @expr{[5, 7, 9]}.
3474 @xref{Matrix Answer 1, 1}. (@bullet{})
3476 @cindex Identity matrix
3477 An @dfn{identity matrix} is a square matrix with ones along the
3478 diagonal and zeros elsewhere. It has the property that multiplication
3479 by an identity matrix, on the left or on the right, always produces
3480 the original matrix.
3484 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3485 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3486 . 1: [ [ 1, 0, 0 ] .
3491 r 4 v i 3 @key{RET} *
3495 If a matrix is square, it is often possible to find its @dfn{inverse},
3496 that is, a matrix which, when multiplied by the original matrix, yields
3497 an identity matrix. The @kbd{&} (reciprocal) key also computes the
3498 inverse of a matrix.
3502 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ]
3503 [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ]
3504 [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ]
3512 The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
3513 matrices together. Here we have used it to add a new row onto
3514 our matrix to make it square.
3516 We can multiply these two matrices in either order to get an identity.
3520 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ]
3521 [ 0., 1., 0. ] [ 0., 1., 0. ]
3522 [ 0., 0., 1. ] ] [ 0., 0., 1. ] ]
3525 M-@key{RET} * U @key{TAB} *
3529 @cindex Systems of linear equations
3530 @cindex Linear equations, systems of
3531 Matrix inverses are related to systems of linear equations in algebra.
3532 Suppose we had the following set of equations:
3546 $$ \openup1\jot \tabskip=0pt plus1fil
3547 \halign to\displaywidth{\tabskip=0pt
3548 $\hfil#$&$\hfil{}#{}$&
3549 $\hfil#$&$\hfil{}#{}$&
3550 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3559 This can be cast into the matrix equation,
3564 [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ]
3565 [ 4, 5, 6 ] * [ b ] = [ 2 ]
3566 [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ]
3573 $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
3575 \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
3580 We can solve this system of equations by multiplying both sides by the
3581 inverse of the matrix. Calc can do this all in one step:
3585 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333]
3596 The result is the @expr{[a, b, c]} vector that solves the equations.
3597 (Dividing by a square matrix is equivalent to multiplying by its
3600 Let's verify this solution:
3604 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.]
3607 1: [-12.6, 15.2, -3.93333]
3615 Note that we had to be careful about the order in which we multiplied
3616 the matrix and vector. If we multiplied in the other order, Calc would
3617 assume the vector was a row vector in order to make the dimensions
3618 come out right, and the answer would be incorrect. If you
3619 don't feel safe letting Calc take either interpretation of your
3620 vectors, use explicit
3621 @texline @math{N\times1}
3624 @texline @math{1\times N}
3626 matrices instead. In this case, you would enter the original column
3627 vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
3629 (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make
3630 vectors and matrices that include variables. Solve the following
3631 system of equations to get expressions for @expr{x} and @expr{y}
3632 in terms of @expr{a} and @expr{b}.
3645 $$ \eqalign{ x &+ a y = 6 \cr
3652 @xref{Matrix Answer 2, 2}. (@bullet{})
3654 @cindex Least-squares for over-determined systems
3655 @cindex Over-determined systems of equations
3656 (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined''
3657 if it has more equations than variables. It is often the case that
3658 there are no values for the variables that will satisfy all the
3659 equations at once, but it is still useful to find a set of values
3660 which ``nearly'' satisfy all the equations. In terms of matrix equations,
3661 you can't solve @expr{A X = B} directly because the matrix @expr{A}
3662 is not square for an over-determined system. Matrix inversion works
3663 only for square matrices. One common trick is to multiply both sides
3664 on the left by the transpose of @expr{A}:
3666 @samp{trn(A)*A*X = trn(A)*B}.
3670 $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
3673 @texline @math{A^T A}
3674 @infoline @expr{trn(A)*A}
3675 is a square matrix so a solution is possible. It turns out that the
3676 @expr{X} vector you compute in this way will be a ``least-squares''
3677 solution, which can be regarded as the ``closest'' solution to the set
3678 of equations. Use Calc to solve the following over-determined
3694 $$ \openup1\jot \tabskip=0pt plus1fil
3695 \halign to\displaywidth{\tabskip=0pt
3696 $\hfil#$&$\hfil{}#{}$&
3697 $\hfil#$&$\hfil{}#{}$&
3698 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3702 2a&+&4b&+&6c&=11 \cr}
3708 @xref{Matrix Answer 3, 3}. (@bullet{})
3710 @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
3711 @subsection Vectors as Lists
3715 Although Calc has a number of features for manipulating vectors and
3716 matrices as mathematical objects, you can also treat vectors as
3717 simple lists of values. For example, we saw that the @kbd{k f}
3718 command returns a vector which is a list of the prime factors of a
3721 You can pack and unpack stack entries into vectors:
3725 3: 10 1: [10, 20, 30] 3: 10
3734 You can also build vectors out of consecutive integers, or out
3735 of many copies of a given value:
3739 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4]
3740 . 1: 17 1: [17, 17, 17, 17]
3743 v x 4 @key{RET} 17 v b 4 @key{RET}
3747 You can apply an operator to every element of a vector using the
3752 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68]
3760 In the first step, we multiply the vector of integers by the vector
3761 of 17's elementwise. In the second step, we raise each element to
3762 the power two. (The general rule is that both operands must be
3763 vectors of the same length, or else one must be a vector and the
3764 other a plain number.) In the final step, we take the square root
3767 (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two
3769 @texline @math{2^{-4}}
3770 @infoline @expr{2^-4}
3771 to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{})
3773 You can also @dfn{reduce} a binary operator across a vector.
3774 For example, reducing @samp{*} computes the product of all the
3775 elements in the vector:
3779 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123
3787 In this example, we decompose 123123 into its prime factors, then
3788 multiply those factors together again to yield the original number.
3790 We could compute a dot product ``by hand'' using mapping and
3795 2: [1, 2, 3] 1: [7, 12, 0] 1: 19
3804 Recalling two vectors from the previous section, we compute the
3805 sum of pairwise products of the elements to get the same answer
3806 for the dot product as before.
3808 A slight variant of vector reduction is the @dfn{accumulate} operation,
3809 @kbd{V U}. This produces a vector of the intermediate results from
3810 a corresponding reduction. Here we compute a table of factorials:
3814 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720]
3817 v x 6 @key{RET} V U *
3821 Calc allows vectors to grow as large as you like, although it gets
3822 rather slow if vectors have more than about a hundred elements.
3823 Actually, most of the time is spent formatting these large vectors
3824 for display, not calculating on them. Try the following experiment
3825 (if your computer is very fast you may need to substitute a larger
3830 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ...
3833 v x 500 @key{RET} 1 V M +
3837 Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
3838 experiment again. In @kbd{v .} mode, long vectors are displayed
3839 ``abbreviated'' like this:
3843 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501]
3846 v x 500 @key{RET} 1 V M +
3851 (where now the @samp{...} is actually part of the Calc display).
3852 You will find both operations are now much faster. But notice that
3853 even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
3854 Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
3855 experiment one more time. Operations on long vectors are now quite
3856 fast! (But of course if you use @kbd{t .} you will lose the ability
3857 to get old vectors back using the @kbd{t y} command.)
3859 An easy way to view a full vector when @kbd{v .} mode is active is
3860 to press @kbd{`} (back-quote) to edit the vector; editing always works
3861 with the full, unabbreviated value.
3863 @cindex Least-squares for fitting a straight line
3864 @cindex Fitting data to a line
3865 @cindex Line, fitting data to
3866 @cindex Data, extracting from buffers
3867 @cindex Columns of data, extracting
3868 As a larger example, let's try to fit a straight line to some data,
3869 using the method of least squares. (Calc has a built-in command for
3870 least-squares curve fitting, but we'll do it by hand here just to
3871 practice working with vectors.) Suppose we have the following list
3872 of values in a file we have loaded into Emacs:
3899 If you are reading this tutorial in printed form, you will find it
3900 easiest to press @kbd{M-# i} to enter the on-line Info version of
3901 the manual and find this table there. (Press @kbd{g}, then type
3902 @kbd{List Tutorial}, to jump straight to this section.)
3904 Position the cursor at the upper-left corner of this table, just
3905 to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark.
3906 (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
3907 Now position the cursor to the lower-right, just after the @expr{1.354}.
3908 You have now defined this region as an Emacs ``rectangle.'' Still
3909 in the Info buffer, type @kbd{M-# r}. This command
3910 (@code{calc-grab-rectangle}) will pop you back into the Calculator, with
3911 the contents of the rectangle you specified in the form of a matrix.
3915 1: [ [ 1.34, 0.234 ]
3922 (You may wish to use @kbd{v .} mode to abbreviate the display of this
3925 We want to treat this as a pair of lists. The first step is to
3926 transpose this matrix into a pair of rows. Remember, a matrix is
3927 just a vector of vectors. So we can unpack the matrix into a pair
3928 of row vectors on the stack.
3932 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ]
3933 [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ]
3941 Let's store these in quick variables 1 and 2, respectively.
3945 1: [1.34, 1.41, 1.49, ... ] .
3953 (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
3954 stored value from the stack.)
3956 In a least squares fit, the slope @expr{m} is given by the formula
3960 m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
3966 $$ m = {N \sum x y - \sum x \sum y \over
3967 N \sum x^2 - \left( \sum x \right)^2} $$
3973 @texline @math{\sum x}
3974 @infoline @expr{sum(x)}
3975 represents the sum of all the values of @expr{x}. While there is an
3976 actual @code{sum} function in Calc, it's easier to sum a vector using a
3977 simple reduction. First, let's compute the four different sums that
3985 r 1 V R + t 3 r 1 2 V M ^ V R + t 4
3992 1: 13.613 1: 33.36554
3995 r 2 V R + t 5 r 1 r 2 V M * V R + t 6
4001 These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
4002 respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and
4007 These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
4008 respectively. (We could have used \kbd{*} to compute $\sum x^2$ and
4012 Finally, we also need @expr{N}, the number of data points. This is just
4013 the length of either of our lists.
4025 (That's @kbd{v} followed by a lower-case @kbd{l}.)
4027 Now we grind through the formula:
4031 1: 633.94526 2: 633.94526 1: 67.23607
4035 r 7 r 6 * r 3 r 5 * -
4042 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679
4043 1: 1862.0057 2: 1862.0057 1: 128.9488 .
4047 r 7 r 4 * r 3 2 ^ - / t 8
4051 That gives us the slope @expr{m}. The y-intercept @expr{b} can now
4052 be found with the simple formula,
4056 b = (sum(y) - m sum(x)) / N
4062 $$ b = {\sum y - m \sum x \over N} $$
4069 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978
4073 r 5 r 8 r 3 * - r 7 / t 9
4077 Let's ``plot'' this straight line approximation,
4078 @texline @math{y \approx m x + b},
4079 @infoline @expr{m x + b},
4080 and compare it with the original data.
4084 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ]
4092 Notice that multiplying a vector by a constant, and adding a constant
4093 to a vector, can be done without mapping commands since these are
4094 common operations from vector algebra. As far as Calc is concerned,
4095 we've just been doing geometry in 19-dimensional space!
4097 We can subtract this vector from our original @expr{y} vector to get
4098 a feel for the error of our fit. Let's find the maximum error:
4102 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897
4110 First we compute a vector of differences, then we take the absolute
4111 values of these differences, then we reduce the @code{max} function
4112 across the vector. (The @code{max} function is on the two-key sequence
4113 @kbd{f x}; because it is so common to use @code{max} in a vector
4114 operation, the letters @kbd{X} and @kbd{N} are also accepted for
4115 @code{max} and @code{min} in this context. In general, you answer
4116 the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
4117 invokes the function you want. You could have typed @kbd{V R f x} or
4118 even @kbd{V R x max @key{RET}} if you had preferred.)
4120 If your system has the GNUPLOT program, you can see graphs of your
4121 data and your straight line to see how well they match. (If you have
4122 GNUPLOT 3.0, the following instructions will work regardless of the
4123 kind of display you have. Some GNUPLOT 2.0, non-X-windows systems
4124 may require additional steps to view the graphs.)
4126 Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}''
4127 vectors onto the stack and press @kbd{g f}. This ``fast'' graphing
4128 command does everything you need to do for simple, straightforward
4133 2: [1.34, 1.41, 1.49, ... ]
4134 1: [0.234, 0.298, 0.402, ... ]
4141 If all goes well, you will shortly get a new window containing a graph
4142 of the data. (If not, contact your GNUPLOT or Calc installer to find
4143 out what went wrong.) In the X window system, this will be a separate
4144 graphics window. For other kinds of displays, the default is to
4145 display the graph in Emacs itself using rough character graphics.
4146 Press @kbd{q} when you are done viewing the character graphics.
4148 Next, let's add the line we got from our least-squares fit.
4150 (If you are reading this tutorial on-line while running Calc, typing
4151 @kbd{g a} may cause the tutorial to disappear from its window and be
4152 replaced by a buffer named @samp{*Gnuplot Commands*}. The tutorial
4153 will reappear when you terminate GNUPLOT by typing @kbd{g q}.)
4158 2: [1.34, 1.41, 1.49, ... ]
4159 1: [0.273, 0.309, 0.351, ... ]
4162 @key{DEL} r 0 g a g p
4166 It's not very useful to get symbols to mark the data points on this
4167 second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q}
4168 when you are done to remove the X graphics window and terminate GNUPLOT.
4170 (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do
4171 least squares fitting to a general system of equations. Our 19 data
4172 points are really 19 equations of the form @expr{y_i = m x_i + b} for
4173 different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method
4174 to solve for @expr{m} and @expr{b}, duplicating the above result.
4175 @xref{List Answer 2, 2}. (@bullet{})
4177 @cindex Geometric mean
4178 (@bullet{}) @strong{Exercise 3.} If the input data do not form a
4179 rectangle, you can use @w{@kbd{M-# g}} (@code{calc-grab-region})
4180 to grab the data the way Emacs normally works with regions---it reads
4181 left-to-right, top-to-bottom, treating line breaks the same as spaces.
4182 Use this command to find the geometric mean of the following numbers.
4183 (The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
4192 The @kbd{M-# g} command accepts numbers separated by spaces or commas,
4193 with or without surrounding vector brackets.
4194 @xref{List Answer 3, 3}. (@bullet{})
4197 As another example, a theorem about binomial coefficients tells
4198 us that the alternating sum of binomial coefficients
4199 @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
4200 on up to @var{n}-choose-@var{n},
4201 always comes out to zero. Let's verify this
4205 As another example, a theorem about binomial coefficients tells
4206 us that the alternating sum of binomial coefficients
4207 ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
4208 always comes out to zero. Let's verify this
4214 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6]
4224 1: [1, -6, 15, -20, 15, -6, 1] 1: 0
4227 V M ' (-1)^$ choose(6,$) @key{RET} V R +
4231 The @kbd{V M '} command prompts you to enter any algebraic expression
4232 to define the function to map over the vector. The symbol @samp{$}
4233 inside this expression represents the argument to the function.
4234 The Calculator applies this formula to each element of the vector,
4235 substituting each element's value for the @samp{$} sign(s) in turn.
4237 To define a two-argument function, use @samp{$$} for the first
4238 argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is
4239 equivalent to @kbd{V M -}. This is analogous to regular algebraic
4240 entry, where @samp{$$} would refer to the next-to-top stack entry
4241 and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
4242 would act exactly like @kbd{-}.
4244 Notice that the @kbd{V M '} command has recorded two things in the
4245 trail: The result, as usual, and also a funny-looking thing marked
4246 @samp{oper} that represents the operator function you typed in.
4247 The function is enclosed in @samp{< >} brackets, and the argument is
4248 denoted by a @samp{#} sign. If there were several arguments, they
4249 would be shown as @samp{#1}, @samp{#2}, and so on. (For example,
4250 @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
4251 trail.) This object is a ``nameless function''; you can use nameless
4252 @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
4253 Nameless function notation has the interesting, occasionally useful
4254 property that a nameless function is not actually evaluated until
4255 it is used. For example, @kbd{V M ' $+random(2.0)} evaluates
4256 @samp{random(2.0)} once and adds that random number to all elements
4257 of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
4258 @samp{random(2.0)} separately for each vector element.
4260 Another group of operators that are often useful with @kbd{V M} are
4261 the relational operators: @kbd{a =}, for example, compares two numbers
4262 and gives the result 1 if they are equal, or 0 if not. Similarly,
4263 @w{@kbd{a <}} checks for one number being less than another.
4265 Other useful vector operations include @kbd{v v}, to reverse a
4266 vector end-for-end; @kbd{V S}, to sort the elements of a vector
4267 into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
4268 one row or column of a matrix, or (in both cases) to extract one
4269 element of a plain vector. With a negative argument, @kbd{v r}
4270 and @kbd{v c} instead delete one row, column, or vector element.
4272 @cindex Divisor functions
4273 (@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function}
4277 is the sum of the @expr{k}th powers of all the divisors of an
4278 integer @expr{n}. Figure out a method for computing the divisor
4279 function for reasonably small values of @expr{n}. As a test,
4280 the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
4281 @xref{List Answer 4, 4}. (@bullet{})
4283 @cindex Square-free numbers
4284 @cindex Duplicate values in a list
4285 (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a
4286 list of prime factors for a number. Sometimes it is important to
4287 know that a number is @dfn{square-free}, i.e., that no prime occurs
4288 more than once in its list of prime factors. Find a sequence of
4289 keystrokes to tell if a number is square-free; your method should
4290 leave 1 on the stack if it is, or 0 if it isn't.
4291 @xref{List Answer 5, 5}. (@bullet{})
4293 @cindex Triangular lists
4294 (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks
4295 like the following diagram. (You may wish to use the @kbd{v /}
4296 command to enable multi-line display of vectors.)
4305 [1, 2, 3, 4, 5, 6] ]
4310 @xref{List Answer 6, 6}. (@bullet{})
4312 (@bullet{}) @strong{Exercise 7.} Build the following list of lists.
4320 [10, 11, 12, 13, 14],
4321 [15, 16, 17, 18, 19, 20] ]
4326 @xref{List Answer 7, 7}. (@bullet{})
4328 @cindex Maximizing a function over a list of values
4329 @c [fix-ref Numerical Solutions]
4330 (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's
4331 @texline @math{J_1(x)}
4333 function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25.
4334 Find the value of @expr{x} (from among the above set of values) for
4335 which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method,
4336 i.e., just reading along the list by hand to find the largest value
4337 is not allowed! (There is an @kbd{a X} command which does this kind
4338 of thing automatically; @pxref{Numerical Solutions}.)
4339 @xref{List Answer 8, 8}. (@bullet{})
4341 @cindex Digits, vectors of
4342 (@bullet{}) @strong{Exercise 9.} You are given an integer in the range
4343 @texline @math{0 \le N < 10^m}
4344 @infoline @expr{0 <= N < 10^m}
4345 for @expr{m=12} (i.e., an integer of less than
4346 twelve digits). Convert this integer into a vector of @expr{m}
4347 digits, each in the range from 0 to 9. In vector-of-digits notation,
4348 add one to this integer to produce a vector of @expr{m+1} digits
4349 (since there could be a carry out of the most significant digit).
4350 Convert this vector back into a regular integer. A good integer
4351 to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{})
4353 (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use
4354 @kbd{V R a =} to test if all numbers in a list were equal. What
4355 happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{})
4357 (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one
4358 is @cpi{}. The area of the
4359 @texline @math{2\times2}
4361 square that encloses that circle is 4. So if we throw @var{n} darts at
4362 random points in the square, about @cpiover{4} of them will land inside
4363 the circle. This gives us an entertaining way to estimate the value of
4364 @cpi{}. The @w{@kbd{k r}}
4365 command picks a random number between zero and the value on the stack.
4366 We could get a random floating-point number between @mathit{-1} and 1 by typing
4367 @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in
4368 this square, then use vector mapping and reduction to count how many
4369 points lie inside the unit circle. Hint: Use the @kbd{v b} command.
4370 @xref{List Answer 11, 11}. (@bullet{})
4372 @cindex Matchstick problem
4373 (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides
4374 another way to calculate @cpi{}. Say you have an infinite field
4375 of vertical lines with a spacing of one inch. Toss a one-inch matchstick
4376 onto the field. The probability that the matchstick will land crossing
4377 a line turns out to be
4378 @texline @math{2/\pi}.
4379 @infoline @expr{2/pi}.
4380 Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun,
4381 the probability that the GCD (@w{@kbd{k g}}) of two large integers is
4383 @texline @math{6/\pi^2}.
4384 @infoline @expr{6/pi^2}.
4385 That provides yet another way to estimate @cpi{}.)
4386 @xref{List Answer 12, 12}. (@bullet{})
4388 (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in
4389 double-quote marks, @samp{"hello"}, creates a vector of the numerical
4390 (ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}).
4391 Sometimes it is convenient to compute a @dfn{hash code} of a string,
4392 which is just an integer that represents the value of that string.
4393 Two equal strings have the same hash code; two different strings
4394 @dfn{probably} have different hash codes. (For example, Calc has
4395 over 400 function names, but Emacs can quickly find the definition for
4396 any given name because it has sorted the functions into ``buckets'' by
4397 their hash codes. Sometimes a few names will hash into the same bucket,
4398 but it is easier to search among a few names than among all the names.)
4399 One popular hash function is computed as follows: First set @expr{h = 0}.
4400 Then, for each character from the string in turn, set @expr{h = 3h + c_i}
4401 where @expr{c_i} is the character's ASCII code. If we have 511 buckets,
4402 we then take the hash code modulo 511 to get the bucket number. Develop a
4403 simple command or commands for converting string vectors into hash codes.
4404 The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
4405 511 is 121. @xref{List Answer 13, 13}. (@bullet{})
4407 (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U}
4408 commands do nested function evaluations. @kbd{H V U} takes a starting
4409 value and a number of steps @var{n} from the stack; it then applies the
4410 function you give to the starting value 0, 1, 2, up to @var{n} times
4411 and returns a vector of the results. Use this command to create a
4412 ``random walk'' of 50 steps. Start with the two-dimensional point
4413 @expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1
4414 in both @expr{x} and @expr{y}; then take another step, and so on. Use the
4415 @kbd{g f} command to display this random walk. Now modify your random
4416 walk to walk a unit distance, but in a random direction, at each step.
4417 (Hint: The @code{sincos} function returns a vector of the cosine and
4418 sine of an angle.) @xref{List Answer 14, 14}. (@bullet{})
4420 @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
4421 @section Types Tutorial
4424 Calc understands a variety of data types as well as simple numbers.
4425 In this section, we'll experiment with each of these types in turn.
4427 The numbers we've been using so far have mainly been either @dfn{integers}
4428 or @dfn{floats}. We saw that floats are usually a good approximation to
4429 the mathematical concept of real numbers, but they are only approximations
4430 and are susceptible to roundoff error. Calc also supports @dfn{fractions},
4431 which can exactly represent any rational number.
4435 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414
4439 10 ! 49 @key{RET} : 2 + &
4444 The @kbd{:} command divides two integers to get a fraction; @kbd{/}
4445 would normally divide integers to get a floating-point result.
4446 Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
4447 since the @kbd{:} would otherwise be interpreted as part of a
4448 fraction beginning with 49.
4450 You can convert between floating-point and fractional format using
4451 @kbd{c f} and @kbd{c F}:
4455 1: 1.35027217629e-5 1: 7:518414
4462 The @kbd{c F} command replaces a floating-point number with the
4463 ``simplest'' fraction whose floating-point representation is the
4464 same, to within the current precision.
4468 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113
4471 P c F @key{DEL} p 5 @key{RET} P c F
4475 (@bullet{}) @strong{Exercise 1.} A calculation has produced the
4476 result 1.26508260337. You suspect it is the square root of the
4477 product of @cpi{} and some rational number. Is it? (Be sure
4478 to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{})
4480 @dfn{Complex numbers} can be stored in both rectangular and polar form.
4484 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.)
4492 The square root of @mathit{-9} is by default rendered in rectangular form
4493 (@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a
4494 phase angle of 90 degrees). All the usual arithmetic and scientific
4495 operations are defined on both types of complex numbers.
4497 Another generalized kind of number is @dfn{infinity}. Infinity
4498 isn't really a number, but it can sometimes be treated like one.
4499 Calc uses the symbol @code{inf} to represent positive infinity,
4500 i.e., a value greater than any real number. Naturally, you can
4501 also write @samp{-inf} for minus infinity, a value less than any
4502 real number. The word @code{inf} can only be input using
4507 2: inf 2: -inf 2: -inf 2: -inf 1: nan
4508 1: -17 1: -inf 1: -inf 1: inf .
4511 ' inf @key{RET} 17 n * @key{RET} 72 + A +
4516 Since infinity is infinitely large, multiplying it by any finite
4517 number (like @mathit{-17}) has no effect, except that since @mathit{-17}
4518 is negative, it changes a plus infinity to a minus infinity.
4519 (``A huge positive number, multiplied by @mathit{-17}, yields a huge
4520 negative number.'') Adding any finite number to infinity also
4521 leaves it unchanged. Taking an absolute value gives us plus
4522 infinity again. Finally, we add this plus infinity to the minus
4523 infinity we had earlier. If you work it out, you might expect
4524 the answer to be @mathit{-72} for this. But the 72 has been completely
4525 lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
4526 the finite difference between them, if any, is undetectable.
4527 So we say the result is @dfn{indeterminate}, which Calc writes
4528 with the symbol @code{nan} (for Not A Number).
4530 Dividing by zero is normally treated as an error, but you can get
4531 Calc to write an answer in terms of infinity by pressing @kbd{m i}
4532 to turn on Infinite mode.
4536 3: nan 2: nan 2: nan 2: nan 1: nan
4537 2: 1 1: 1 / 0 1: uinf 1: uinf .
4541 1 @key{RET} 0 / m i U / 17 n * +
4546 Dividing by zero normally is left unevaluated, but after @kbd{m i}
4547 it instead gives an infinite result. The answer is actually
4548 @code{uinf}, ``undirected infinity.'' If you look at a graph of
4549 @expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward
4550 plus infinity as you approach zero from above, but toward minus
4551 infinity as you approach from below. Since we said only @expr{1 / 0},
4552 Calc knows that the answer is infinite but not in which direction.
4553 That's what @code{uinf} means. Notice that multiplying @code{uinf}
4554 by a negative number still leaves plain @code{uinf}; there's no
4555 point in saying @samp{-uinf} because the sign of @code{uinf} is
4556 unknown anyway. Finally, we add @code{uinf} to our @code{nan},
4557 yielding @code{nan} again. It's easy to see that, because
4558 @code{nan} means ``totally unknown'' while @code{uinf} means
4559 ``unknown sign but known to be infinite,'' the more mysterious
4560 @code{nan} wins out when it is combined with @code{uinf}, or, for
4561 that matter, with anything else.
4563 (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer
4564 for each of these formulas: @samp{inf / inf}, @samp{exp(inf)},
4565 @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
4566 @samp{abs(uinf)}, @samp{ln(0)}.
4567 @xref{Types Answer 2, 2}. (@bullet{})
4569 (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan},
4570 which stands for an unknown value. Can @code{nan} stand for
4571 a complex number? Can it stand for infinity?
4572 @xref{Types Answer 3, 3}. (@bullet{})
4574 @dfn{HMS forms} represent a value in terms of hours, minutes, and
4579 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2.
4580 . . 1: 1@@ 45' 0." .
4583 2@@ 30' @key{RET} 1 + @key{RET} 2 / /
4587 HMS forms can also be used to hold angles in degrees, minutes, and
4592 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721
4600 First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
4601 form, then we take the sine of that angle. Note that the trigonometric
4602 functions will accept HMS forms directly as input.
4605 (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is
4606 47 minutes and 26 seconds long, and contains 17 songs. What is the
4607 average length of a song on @emph{Abbey Road}? If the Extended Disco
4608 Version of @emph{Abbey Road} added 20 seconds to the length of each
4609 song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{})
4611 A @dfn{date form} represents a date, or a date and time. Dates must
4612 be entered using algebraic entry. Date forms are surrounded by
4613 @samp{< >} symbols; most standard formats for dates are recognized.
4617 2: <Sun Jan 13, 1991> 1: 2.25
4618 1: <6:00pm Thu Jan 10, 1991> .
4621 ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} -
4626 In this example, we enter two dates, then subtract to find the
4627 number of days between them. It is also possible to add an
4628 HMS form or a number (of days) to a date form to get another
4633 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991>
4640 @c [fix-ref Date Arithmetic]
4642 The @kbd{t N} (``now'') command pushes the current date and time on the
4643 stack; then we add two days, ten hours and five minutes to the date and
4644 time. Other date-and-time related commands include @kbd{t J}, which
4645 does Julian day conversions, @kbd{t W}, which finds the beginning of
4646 the week in which a date form lies, and @kbd{t I}, which increments a
4647 date by one or several months. @xref{Date Arithmetic}, for more.
4649 (@bullet{}) @strong{Exercise 5.} How many days until the next
4650 Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{})
4652 (@bullet{}) @strong{Exercise 6.} How many leap years will there be
4653 between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{})
4655 @cindex Slope and angle of a line
4656 @cindex Angle and slope of a line
4657 An @dfn{error form} represents a mean value with an attached standard
4658 deviation, or error estimate. Suppose our measurements indicate that
4659 a certain telephone pole is about 30 meters away, with an estimated
4660 error of 1 meter, and 8 meters tall, with an estimated error of 0.2
4661 meters. What is the slope of a line from here to the top of the
4662 pole, and what is the equivalent angle in degrees?
4666 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594
4670 8 p .2 @key{RET} 30 p 1 / I T
4675 This means that the angle is about 15 degrees, and, assuming our
4676 original error estimates were valid standard deviations, there is about
4677 a 60% chance that the result is correct within 0.59 degrees.
4679 @cindex Torus, volume of
4680 (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is
4681 @texline @math{2 \pi^2 R r^2}
4682 @infoline @w{@expr{2 pi^2 R r^2}}
4683 where @expr{R} is the radius of the circle that
4684 defines the center of the tube and @expr{r} is the radius of the tube
4685 itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to
4686 within 5 percent. What is the volume and the relative uncertainty of
4687 the volume? @xref{Types Answer 7, 7}. (@bullet{})
4689 An @dfn{interval form} represents a range of values. While an
4690 error form is best for making statistical estimates, intervals give
4691 you exact bounds on an answer. Suppose we additionally know that
4692 our telephone pole is definitely between 28 and 31 meters away,
4693 and that it is between 7.7 and 8.1 meters tall.
4697 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1]
4701 [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T
4706 If our bounds were correct, then the angle to the top of the pole
4707 is sure to lie in the range shown.
4709 The square brackets around these intervals indicate that the endpoints
4710 themselves are allowable values. In other words, the distance to the
4711 telephone pole is between 28 and 31, @emph{inclusive}. You can also
4712 make an interval that is exclusive of its endpoints by writing
4713 parentheses instead of square brackets. You can even make an interval
4714 which is inclusive (``closed'') on one end and exclusive (``open'') on
4719 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3)
4723 [ 1 .. 10 ) & [ 2 .. 3 ) *
4728 The Calculator automatically keeps track of which end values should
4729 be open and which should be closed. You can also make infinite or
4730 semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
4733 (@bullet{}) @strong{Exercise 8.} What answer would you expect from
4734 @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What
4735 about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
4736 zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}?
4737 @xref{Types Answer 8, 8}. (@bullet{})
4739 (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number
4740 are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same
4741 answer. Would you expect this still to hold true for interval forms?
4742 If not, which of these will result in a larger interval?
4743 @xref{Types Answer 9, 9}. (@bullet{})
4745 A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
4746 For example, arithmetic involving time is generally done modulo 12
4751 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24
4754 17 M 24 @key{RET} 10 + n 5 /
4759 In this last step, Calc has divided by 5 modulo 24; i.e., it has found a
4760 new number which, when multiplied by 5 modulo 24, produces the original
4761 number, 21. If @var{m} is prime and the divisor is not a multiple of
4762 @var{m}, it is always possible to find such a number. For non-prime
4763 @var{m} like 24, it is only sometimes possible.
4767 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16
4770 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 %
4775 These two calculations get the same answer, but the first one is
4776 much more efficient because it avoids the huge intermediate value
4777 that arises in the second one.
4779 @cindex Fermat, primality test of
4780 (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat
4782 @texline @w{@math{x^{n-1} \bmod n = 1}}
4783 @infoline @expr{x^(n-1) mod n = 1}
4784 if @expr{n} is a prime number and @expr{x} is an integer less than
4785 @expr{n}. If @expr{n} is @emph{not} a prime number, this will
4786 @emph{not} be true for most values of @expr{x}. Thus we can test
4787 informally if a number is prime by trying this formula for several
4788 values of @expr{x}. Use this test to tell whether the following numbers
4789 are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{})
4791 It is possible to use HMS forms as parts of error forms, intervals,
4792 modulo forms, or as the phase part of a polar complex number.
4793 For example, the @code{calc-time} command pushes the current time
4794 of day on the stack as an HMS/modulo form.
4798 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0"
4806 This calculation tells me it is six hours and 22 minutes until midnight.
4808 (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year
4810 @texline @math{\pi \times 10^7}
4811 @infoline @w{@expr{pi * 10^7}}
4812 seconds. What time will it be that many seconds from right now?
4813 @xref{Types Answer 11, 11}. (@bullet{})
4815 (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging
4816 for the CD release of the Extended Disco Version of @emph{Abbey Road}.
4817 You are told that the songs will actually be anywhere from 20 to 60
4818 seconds longer than the originals. One CD can hold about 75 minutes
4819 of music. Should you order single or double packages?
4820 @xref{Types Answer 12, 12}. (@bullet{})
4822 Another kind of data the Calculator can manipulate is numbers with
4823 @dfn{units}. This isn't strictly a new data type; it's simply an
4824 application of algebraic expressions, where we use variables with
4825 suggestive names like @samp{cm} and @samp{in} to represent units
4826 like centimeters and inches.
4830 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m
4833 ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b
4838 We enter the quantity ``2 inches'' (actually an algebraic expression
4839 which means two times the variable @samp{in}), then we convert it
4840 first to centimeters, then to fathoms, then finally to ``base'' units,
4841 which in this case means meters.
4845 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm
4848 ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET}
4855 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2
4863 Since units expressions are really just formulas, taking the square
4864 root of @samp{acre} is undefined. After all, @code{acre} might be an
4865 algebraic variable that you will someday assign a value. We use the
4866 ``units-simplify'' command to simplify the expression with variables
4867 being interpreted as unit names.
4869 In the final step, we have converted not to a particular unit, but to a
4870 units system. The ``cgs'' system uses centimeters instead of meters
4871 as its standard unit of length.
4873 There is a wide variety of units defined in the Calculator.
4877 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c
4880 ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET}
4885 We express a speed first in miles per hour, then in kilometers per
4886 hour, then again using a slightly more explicit notation, then
4887 finally in terms of fractions of the speed of light.
4889 Temperature conversions are a bit more tricky. There are two ways to
4890 interpret ``20 degrees Fahrenheit''---it could mean an actual
4891 temperature, or it could mean a change in temperature. For normal
4892 units there is no difference, but temperature units have an offset
4893 as well as a scale factor and so there must be two explicit commands
4898 1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC
4901 ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} c f
4906 First we convert a change of 20 degrees Fahrenheit into an equivalent
4907 change in degrees Celsius (or Centigrade). Then, we convert the
4908 absolute temperature 20 degrees Fahrenheit into Celsius. Since
4909 this comes out as an exact fraction, we then convert to floating-point
4910 for easier comparison with the other result.
4912 For simple unit conversions, you can put a plain number on the stack.
4913 Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
4914 When you use this method, you're responsible for remembering which
4915 numbers are in which units:
4919 1: 55 1: 88.5139 1: 8.201407e-8
4922 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET}
4926 To see a complete list of built-in units, type @kbd{u v}. Press
4927 @w{@kbd{M-# c}} again to re-enter the Calculator when you're done looking
4930 (@bullet{}) @strong{Exercise 13.} How many seconds are there really
4931 in a year? @xref{Types Answer 13, 13}. (@bullet{})
4933 @cindex Speed of light
4934 (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by
4935 the speed of light (and of electricity, which is nearly as fast).
4936 Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
4937 cabinet is one meter across. Is speed of light going to be a
4938 significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{})
4940 (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about
4941 five yards in an hour. He has obtained a supply of Power Pills; each
4942 Power Pill he eats doubles his speed. How many Power Pills can he
4943 swallow and still travel legally on most US highways?
4944 @xref{Types Answer 15, 15}. (@bullet{})
4946 @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
4947 @section Algebra and Calculus Tutorial
4950 This section shows how to use Calc's algebra facilities to solve
4951 equations, do simple calculus problems, and manipulate algebraic
4955 * Basic Algebra Tutorial::
4956 * Rewrites Tutorial::
4959 @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
4960 @subsection Basic Algebra
4963 If you enter a formula in Algebraic mode that refers to variables,
4964 the formula itself is pushed onto the stack. You can manipulate
4965 formulas as regular data objects.
4969 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y)
4972 ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} *
4976 (@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and
4977 @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
4978 Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{})
4980 There are also commands for doing common algebraic operations on
4981 formulas. Continuing with the formula from the last example,
4985 1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y
4993 First we ``expand'' using the distributive law, then we ``collect''
4994 terms involving like powers of @expr{x}.
4996 Let's find the value of this expression when @expr{x} is 2 and @expr{y}
5001 1: 17 x^2 - 6 x^4 + 3 1: -25
5004 1:2 s l y @key{RET} 2 s l x @key{RET}
5009 The @kbd{s l} command means ``let''; it takes a number from the top of
5010 the stack and temporarily assigns it as the value of the variable
5011 you specify. It then evaluates (as if by the @kbd{=} key) the
5012 next expression on the stack. After this command, the variable goes
5013 back to its original value, if any.
5015 (An earlier exercise in this tutorial involved storing a value in the
5016 variable @code{x}; if this value is still there, you will have to
5017 unstore it with @kbd{s u x @key{RET}} before the above example will work
5020 @cindex Maximum of a function using Calculus
5021 Let's find the maximum value of our original expression when @expr{y}
5022 is one-half and @expr{x} ranges over all possible values. We can
5023 do this by taking the derivative with respect to @expr{x} and examining
5024 values of @expr{x} for which the derivative is zero. If the second
5025 derivative of the function at that value of @expr{x} is negative,
5026 the function has a local maximum there.
5030 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3
5033 U @key{DEL} s 1 a d x @key{RET} s 2
5038 Well, the derivative is clearly zero when @expr{x} is zero. To find
5039 the other root(s), let's divide through by @expr{x} and then solve:
5043 1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2
5046 ' x @key{RET} / a x a s
5053 1: 34 - 24 x^2 = 0 1: x = 1.19023
5056 0 a = s 3 a S x @key{RET}
5061 Notice the use of @kbd{a s} to ``simplify'' the formula. When the
5062 default algebraic simplifications don't do enough, you can use
5063 @kbd{a s} to tell Calc to spend more time on the job.
5065 Now we compute the second derivative and plug in our values of @expr{x}:
5069 1: 1.19023 2: 1.19023 2: 1.19023
5070 . 1: 34 x - 24 x^3 1: 34 - 72 x^2
5073 a . r 2 a d x @key{RET} s 4
5078 (The @kbd{a .} command extracts just the righthand side of an equation.
5079 Another method would have been to use @kbd{v u} to unpack the equation
5080 @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
5081 to delete the @samp{x}.)
5085 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34
5089 @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET}
5094 The first of these second derivatives is negative, so we know the function
5095 has a maximum value at @expr{x = 1.19023}. (The function also has a
5096 local @emph{minimum} at @expr{x = 0}.)
5098 When we solved for @expr{x}, we got only one value even though
5099 @expr{34 - 24 x^2 = 0} is a quadratic equation that ought to have
5100 two solutions. The reason is that @w{@kbd{a S}} normally returns a
5101 single ``principal'' solution. If it needs to come up with an
5102 arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}.
5103 If it needs an arbitrary integer, it picks zero. We can get a full
5104 solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
5108 1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023
5111 r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET}
5116 Calc has invented the variable @samp{s1} to represent an unknown sign;
5117 it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used
5118 the ``let'' command to evaluate the expression when the sign is negative.
5119 If we plugged this into our second derivative we would get the same,
5120 negative, answer, so @expr{x = -1.19023} is also a maximum.
5122 To find the actual maximum value, we must plug our two values of @expr{x}
5123 into the original formula.
5127 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3
5131 r 1 r 5 s l @key{RET}
5136 (Here we see another way to use @kbd{s l}; if its input is an equation
5137 with a variable on the lefthand side, then @kbd{s l} treats the equation
5138 like an assignment to that variable if you don't give a variable name.)
5140 It's clear that this will have the same value for either sign of
5141 @code{s1}, but let's work it out anyway, just for the exercise:
5145 2: [-1, 1] 1: [15.04166, 15.04166]
5146 1: 24.08333 s1^2 ... .
5149 [ 1 n , 1 ] @key{TAB} V M $ @key{RET}
5154 Here we have used a vector mapping operation to evaluate the function
5155 at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '}
5156 except that it takes the formula from the top of the stack. The
5157 formula is interpreted as a function to apply across the vector at the
5158 next-to-top stack level. Since a formula on the stack can't contain
5159 @samp{$} signs, Calc assumes the variables in the formula stand for
5160 different arguments. It prompts you for an @dfn{argument list}, giving
5161 the list of all variables in the formula in alphabetical order as the
5162 default list. In this case the default is @samp{(s1)}, which is just
5163 what we want so we simply press @key{RET} at the prompt.
5165 If there had been several different values, we could have used
5166 @w{@kbd{V R X}} to find the global maximum.
5168 Calc has a built-in @kbd{a P} command that solves an equation using
5169 @w{@kbd{H a S}} and returns a vector of all the solutions. It simply
5170 automates the job we just did by hand. Applied to our original
5171 cubic polynomial, it would produce the vector of solutions
5172 @expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command
5173 which finds a local maximum of a function. It uses a numerical search
5174 method rather than examining the derivatives, and thus requires you
5175 to provide some kind of initial guess to show it where to look.)
5177 (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a
5178 polynomial (such as the output of an @kbd{a P} command), what
5179 sequence of commands would you use to reconstruct the original
5180 polynomial? (The answer will be unique to within a constant
5181 multiple; choose the solution where the leading coefficient is one.)
5182 @xref{Algebra Answer 2, 2}. (@bullet{})
5184 The @kbd{m s} command enables Symbolic mode, in which formulas
5185 like @samp{sqrt(5)} that can't be evaluated exactly are left in
5186 symbolic form rather than giving a floating-point approximate answer.
5187 Fraction mode (@kbd{m f}) is also useful when doing algebra.
5191 2: 34 x - 24 x^3 2: 34 x - 24 x^3
5192 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0]
5195 r 2 @key{RET} m s m f a P x @key{RET}
5199 One more mode that makes reading formulas easier is Big mode.
5208 1: [-----, -----, 0]
5217 Here things like powers, square roots, and quotients and fractions
5218 are displayed in a two-dimensional pictorial form. Calc has other
5219 language modes as well, such as C mode, FORTRAN mode, and @TeX{} mode.
5223 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3
5224 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/
5235 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
5236 1: @{2 \over 3@} \sqrt@{5@}
5239 d T ' 2 \sqrt@{5@} \over 3 @key{RET}
5244 As you can see, language modes affect both entry and display of
5245 formulas. They affect such things as the names used for built-in
5246 functions, the set of arithmetic operators and their precedences,
5247 and notations for vectors and matrices.
5249 Notice that @samp{sqrt(51)} may cause problems with older
5250 implementations of C and FORTRAN, which would require something more
5251 like @samp{sqrt(51.0)}. It is always wise to check over the formulas
5252 produced by the various language modes to make sure they are fully
5255 Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You
5256 may prefer to remain in Big mode, but all the examples in the tutorial
5257 are shown in normal mode.)
5259 @cindex Area under a curve
5260 What is the area under the portion of this curve from @expr{x = 1} to @expr{2}?
5261 This is simply the integral of the function:
5265 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x
5273 We want to evaluate this at our two values for @expr{x} and subtract.
5274 One way to do it is again with vector mapping and reduction:
5278 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666
5279 1: 5.6666 x^3 ... . .
5281 [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5285 (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y}
5287 @texline @math{x \sin \pi x}
5288 @infoline @w{@expr{x sin(pi x)}}
5289 (where the sine is calculated in radians). Find the values of the
5290 integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3,
5293 Calc's integrator can do many simple integrals symbolically, but many
5294 others are beyond its capabilities. Suppose we wish to find the area
5296 @texline @math{\sin x \ln x}
5297 @infoline @expr{sin(x) ln(x)}
5298 over the same range of @expr{x}. If you entered this formula and typed
5299 @kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a
5300 long time but would be unable to find a solution. In fact, there is no
5301 closed-form solution to this integral. Now what do we do?
5303 @cindex Integration, numerical
5304 @cindex Numerical integration
5305 One approach would be to do the integral numerically. It is not hard
5306 to do this by hand using vector mapping and reduction. It is rather
5307 slow, though, since the sine and logarithm functions take a long time.
5308 We can save some time by reducing the working precision.
5312 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9]
5317 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
5322 (Note that we have used the extended version of @kbd{v x}; we could
5323 also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.)
5327 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ]
5331 ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET}
5346 (If you got wildly different results, did you remember to switch
5349 Here we have divided the curve into ten segments of equal width;
5350 approximating these segments as rectangular boxes (i.e., assuming
5351 the curve is nearly flat at that resolution), we compute the areas
5352 of the boxes (height times width), then sum the areas. (It is
5353 faster to sum first, then multiply by the width, since the width
5354 is the same for every box.)
5356 The true value of this integral turns out to be about 0.374, so
5357 we're not doing too well. Let's try another approach.
5361 1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
5364 r 1 a t x=1 @key{RET} 4 @key{RET}
5369 Here we have computed the Taylor series expansion of the function
5370 about the point @expr{x=1}. We can now integrate this polynomial
5371 approximation, since polynomials are easy to integrate.
5375 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761
5378 a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5383 Better! By increasing the precision and/or asking for more terms
5384 in the Taylor series, we can get a result as accurate as we like.
5385 (Taylor series converge better away from singularities in the
5386 function such as the one at @code{ln(0)}, so it would also help to
5387 expand the series about the points @expr{x=2} or @expr{x=1.5} instead
5390 @cindex Simpson's rule
5391 @cindex Integration by Simpson's rule
5392 (@bullet{}) @strong{Exercise 4.} Our first method approximated the
5393 curve by stairsteps of width 0.1; the total area was then the sum
5394 of the areas of the rectangles under these stairsteps. Our second
5395 method approximated the function by a polynomial, which turned out
5396 to be a better approximation than stairsteps. A third method is
5397 @dfn{Simpson's rule}, which is like the stairstep method except
5398 that the steps are not required to be flat. Simpson's rule boils
5399 down to the formula,
5403 (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
5404 + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
5411 \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
5412 \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
5418 where @expr{n} (which must be even) is the number of slices and @expr{h}
5419 is the width of each slice. These are 10 and 0.1 in our example.
5420 For reference, here is the corresponding formula for the stairstep
5425 h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
5426 + f(a+(n-2)*h) + f(a+(n-1)*h))
5432 $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
5433 + f(a+(n-2)h) + f(a+(n-1)h)) $$
5437 Compute the integral from 1 to 2 of
5438 @texline @math{\sin x \ln x}
5439 @infoline @expr{sin(x) ln(x)}
5440 using Simpson's rule with 10 slices.
5441 @xref{Algebra Answer 4, 4}. (@bullet{})
5443 Calc has a built-in @kbd{a I} command for doing numerical integration.
5444 It uses @dfn{Romberg's method}, which is a more sophisticated cousin
5445 of Simpson's rule. In particular, it knows how to keep refining the
5446 result until the current precision is satisfied.
5448 @c [fix-ref Selecting Sub-Formulas]
5449 Aside from the commands we've seen so far, Calc also provides a
5450 large set of commands for operating on parts of formulas. You
5451 indicate the desired sub-formula by placing the cursor on any part
5452 of the formula before giving a @dfn{selection} command. Selections won't
5453 be covered in the tutorial; @pxref{Selecting Subformulas}, for
5454 details and examples.
5456 @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
5457 @c to 2^((n-1)*(r-1)).
5459 @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
5460 @subsection Rewrite Rules
5463 No matter how many built-in commands Calc provided for doing algebra,
5464 there would always be something you wanted to do that Calc didn't have
5465 in its repertoire. So Calc also provides a @dfn{rewrite rule} system
5466 that you can use to define your own algebraic manipulations.
5468 Suppose we want to simplify this trigonometric formula:
5472 1: 1 / cos(x) - sin(x) tan(x)
5475 ' 1/cos(x) - sin(x) tan(x) @key{RET} s 1
5480 If we were simplifying this by hand, we'd probably replace the
5481 @samp{tan} with a @samp{sin/cos} first, then combine over a common
5482 denominator. There is no Calc command to do the former; the @kbd{a n}
5483 algebra command will do the latter but we'll do both with rewrite
5484 rules just for practice.
5486 Rewrite rules are written with the @samp{:=} symbol.
5490 1: 1 / cos(x) - sin(x)^2 / cos(x)
5493 a r tan(a) := sin(a)/cos(a) @key{RET}
5498 (The ``assignment operator'' @samp{:=} has several uses in Calc. All
5499 by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
5500 but when it is given to the @kbd{a r} command, that command interprets
5501 it as a rewrite rule.)
5503 The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
5504 rewrite rule. Calc searches the formula on the stack for parts that
5505 match the pattern. Variables in a rewrite pattern are called
5506 @dfn{meta-variables}, and when matching the pattern each meta-variable
5507 can match any sub-formula. Here, the meta-variable @samp{a} matched
5508 the actual variable @samp{x}.
5510 When the pattern part of a rewrite rule matches a part of the formula,
5511 that part is replaced by the righthand side with all the meta-variables
5512 substituted with the things they matched. So the result is
5513 @samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then
5514 mix this in with the rest of the original formula.
5516 To merge over a common denominator, we can use another simple rule:
5520 1: (1 - sin(x)^2) / cos(x)
5523 a r a/x + b/x := (a+b)/x @key{RET}
5527 This rule points out several interesting features of rewrite patterns.
5528 First, if a meta-variable appears several times in a pattern, it must
5529 match the same thing everywhere. This rule detects common denominators
5530 because the same meta-variable @samp{x} is used in both of the
5533 Second, meta-variable names are independent from variables in the
5534 target formula. Notice that the meta-variable @samp{x} here matches
5535 the subformula @samp{cos(x)}; Calc never confuses the two meanings of
5538 And third, rewrite patterns know a little bit about the algebraic
5539 properties of formulas. The pattern called for a sum of two quotients;
5540 Calc was able to match a difference of two quotients by matching
5541 @samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}.
5543 @c [fix-ref Algebraic Properties of Rewrite Rules]
5544 We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
5545 the rule. It would have worked just the same in all cases. (If we
5546 really wanted the rule to apply only to @samp{+} or only to @samp{-},
5547 we could have used the @code{plain} symbol. @xref{Algebraic Properties
5548 of Rewrite Rules}, for some examples of this.)
5550 One more rewrite will complete the job. We want to use the identity
5551 @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
5552 the identity in a way that matches our formula. The obvious rule
5553 would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows
5554 that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The
5555 latter rule has a more general pattern so it will work in many other
5560 1: (1 + cos(x)^2 - 1) / cos(x) 1: cos(x)
5563 a r sin(x)^2 := 1 - cos(x)^2 @key{RET} a s
5567 You may ask, what's the point of using the most general rule if you
5568 have to type it in every time anyway? The answer is that Calc allows
5569 you to store a rewrite rule in a variable, then give the variable
5570 name in the @kbd{a r} command. In fact, this is the preferred way to
5571 use rewrites. For one, if you need a rule once you'll most likely
5572 need it again later. Also, if the rule doesn't work quite right you
5573 can simply Undo, edit the variable, and run the rule again without
5574 having to retype it.
5578 ' tan(x) := sin(x)/cos(x) @key{RET} s t tsc @key{RET}
5579 ' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET}
5580 ' sin(x)^2 := 1 - cos(x)^2 @key{RET} s t sinsqr @key{RET}
5582 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5585 r 1 a r tsc @key{RET} a r merge @key{RET} a r sinsqr @key{RET} a s
5589 To edit a variable, type @kbd{s e} and the variable name, use regular
5590 Emacs editing commands as necessary, then type @kbd{C-c C-c} to store
5591 the edited value back into the variable.
5592 You can also use @w{@kbd{s e}} to create a new variable if you wish.
5594 Notice that the first time you use each rule, Calc puts up a ``compiling''
5595 message briefly. The pattern matcher converts rules into a special
5596 optimized pattern-matching language rather than using them directly.
5597 This allows @kbd{a r} to apply even rather complicated rules very
5598 efficiently. If the rule is stored in a variable, Calc compiles it
5599 only once and stores the compiled form along with the variable. That's
5600 another good reason to store your rules in variables rather than
5601 entering them on the fly.
5603 (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic
5604 mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
5605 Using a rewrite rule, simplify this formula by multiplying both
5606 sides by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have
5607 to be expanded by the distributive law; do this with another
5608 rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{})
5610 The @kbd{a r} command can also accept a vector of rewrite rules, or
5611 a variable containing a vector of rules.
5615 1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ]
5618 ' [tsc,merge,sinsqr] @key{RET} =
5625 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5628 s t trig @key{RET} r 1 a r trig @key{RET} a s
5632 @c [fix-ref Nested Formulas with Rewrite Rules]
5633 Calc tries all the rules you give against all parts of the formula,
5634 repeating until no further change is possible. (The exact order in
5635 which things are tried is rather complex, but for simple rules like
5636 the ones we've used here the order doesn't really matter.
5637 @xref{Nested Formulas with Rewrite Rules}.)
5639 Calc actually repeats only up to 100 times, just in case your rule set
5640 has gotten into an infinite loop. You can give a numeric prefix argument
5641 to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does
5642 only one rewrite at a time.
5646 1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x)
5649 r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET}
5653 You can type @kbd{M-0 a r} if you want no limit at all on the number
5654 of rewrites that occur.
5656 Rewrite rules can also be @dfn{conditional}. Simply follow the rule
5657 with a @samp{::} symbol and the desired condition. For example,
5661 1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
5664 ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET}
5671 1: 1 + exp(3 pi i) + 1
5674 a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET}
5679 (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
5680 which will be zero only when @samp{k} is an even integer.)
5682 An interesting point is that the variables @samp{pi} and @samp{i}
5683 were matched literally rather than acting as meta-variables.
5684 This is because they are special-constant variables. The special
5685 constants @samp{e}, @samp{phi}, and so on also match literally.
5686 A common error with rewrite
5687 rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
5688 to match any @samp{f} with five arguments but in fact matching
5689 only when the fifth argument is literally @samp{e}!
5691 @cindex Fibonacci numbers
5696 Rewrite rules provide an interesting way to define your own functions.
5697 Suppose we want to define @samp{fib(n)} to produce the @var{n}th
5698 Fibonacci number. The first two Fibonacci numbers are each 1;
5699 later numbers are formed by summing the two preceding numbers in
5700 the sequence. This is easy to express in a set of three rules:
5704 ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib
5709 ' fib(7) @key{RET} a r fib @key{RET}
5713 One thing that is guaranteed about the order that rewrites are tried
5714 is that, for any given subformula, earlier rules in the rule set will
5715 be tried for that subformula before later ones. So even though the
5716 first and third rules both match @samp{fib(1)}, we know the first will
5717 be used preferentially.
5719 This rule set has one dangerous bug: Suppose we apply it to the
5720 formula @samp{fib(x)}? (Don't actually try this.) The third rule
5721 will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
5722 Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
5723 fib(x-4)}, and so on, expanding forever. What we really want is to apply
5724 the third rule only when @samp{n} is an integer greater than two. Type
5725 @w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
5728 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
5736 1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0)
5739 ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET}
5744 We've created a new function, @code{fib}, and a new command,
5745 @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
5746 this formula.'' To make things easier still, we can tell Calc to
5747 apply these rules automatically by storing them in the special
5748 variable @code{EvalRules}.
5752 1: [fib(1) := ...] . 1: [8, 13]
5755 s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET}
5759 It turns out that this rule set has the problem that it does far
5760 more work than it needs to when @samp{n} is large. Consider the
5761 first few steps of the computation of @samp{fib(6)}:
5767 fib(4) + fib(3) + fib(3) + fib(2) =
5768 fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
5773 Note that @samp{fib(3)} appears three times here. Unless Calc's
5774 algebraic simplifier notices the multiple @samp{fib(3)}s and combines
5775 them (and, as it happens, it doesn't), this rule set does lots of
5776 needless recomputation. To cure the problem, type @code{s e EvalRules}
5777 to edit the rules (or just @kbd{s E}, a shorthand command for editing
5778 @code{EvalRules}) and add another condition:
5781 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
5785 If a @samp{:: remember} condition appears anywhere in a rule, then if
5786 that rule succeeds Calc will add another rule that describes that match
5787 to the front of the rule set. (Remembering works in any rule set, but
5788 for technical reasons it is most effective in @code{EvalRules}.) For
5789 example, if the rule rewrites @samp{fib(7)} to something that evaluates
5790 to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
5792 Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
5793 type @kbd{s E} again to see what has happened to the rule set.
5795 With the @code{remember} feature, our rule set can now compute
5796 @samp{fib(@var{n})} in just @var{n} steps. In the process it builds
5797 up a table of all Fibonacci numbers up to @var{n}. After we have
5798 computed the result for a particular @var{n}, we can get it back
5799 (and the results for all smaller @var{n}) later in just one step.
5801 All Calc operations will run somewhat slower whenever @code{EvalRules}
5802 contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to
5803 un-store the variable.
5805 (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate
5806 a problem to reduce the amount of recursion necessary to solve it.
5807 Create a rule that, in about @var{n} simple steps and without recourse
5808 to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
5809 @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
5810 @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is
5811 rather clunky to use, so add a couple more rules to make the ``user
5812 interface'' the same as for our first version: enter @samp{fib(@var{n})},
5813 get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{})
5815 There are many more things that rewrites can do. For example, there
5816 are @samp{&&&} and @samp{|||} pattern operators that create ``and''
5817 and ``or'' combinations of rules. As one really simple example, we
5818 could combine our first two Fibonacci rules thusly:
5821 [fib(1 ||| 2) := 1, fib(n) := ... ]
5825 That means ``@code{fib} of something matching either 1 or 2 rewrites
5828 You can also make meta-variables optional by enclosing them in @code{opt}.
5829 For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
5830 @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x}
5831 matches all of these forms, filling in a default of zero for @samp{a}
5832 and one for @samp{b}.
5834 (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x}
5835 on the stack and tried to use the rule
5836 @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened?
5837 @xref{Rewrites Answer 3, 3}. (@bullet{})
5839 (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a},
5840 divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}.
5841 Now repeat this step over and over. A famous unproved conjecture
5842 is that for any starting @expr{a}, the sequence always eventually
5843 reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of
5844 rules that convert this into @samp{seq(1, @var{n})} where @var{n}
5845 is the number of steps it took the sequence to reach the value 1.
5846 Now enhance the rules to accept @samp{seq(@var{a})} as a starting
5847 configuration, and to stop with just the number @var{n} by itself.
5848 Now make the result be a vector of values in the sequence, from @var{a}
5849 to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
5850 and @var{y}.) For example, rewriting @samp{seq(6)} should yield the
5851 vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
5852 @xref{Rewrites Answer 4, 4}. (@bullet{})
5854 (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function
5855 @samp{nterms(@var{x})} that returns the number of terms in the sum
5856 @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes
5857 is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
5858 so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.)
5859 @xref{Rewrites Answer 5, 5}. (@bullet{})
5861 (@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an
5862 infinite series that exactly equals the value of that function at
5863 values of @expr{x} near zero.
5867 cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
5873 $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
5877 The @kbd{a t} command produces a @dfn{truncated Taylor series} which
5878 is obtained by dropping all the terms higher than, say, @expr{x^2}.
5879 Calc represents the truncated Taylor series as a polynomial in @expr{x}.
5880 Mathematicians often write a truncated series using a ``big-O'' notation
5881 that records what was the lowest term that was truncated.
5885 cos(x) = 1 - x^2 / 2! + O(x^3)
5891 $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
5896 The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small
5897 if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.''
5899 The exercise is to create rewrite rules that simplify sums and products of
5900 power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
5901 For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
5902 on the stack, we want to be able to type @kbd{*} and get the result
5903 @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are
5904 rearranged or if @kbd{a s} needs to be typed after rewriting. (This one
5905 is rather tricky; the solution at the end of this chapter uses 6 rewrite
5906 rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is
5907 a number.) @xref{Rewrites Answer 6, 6}. (@bullet{})
5909 Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
5910 What happens? (Be sure to remove this rule afterward, or you might get
5911 a nasty surprise when you use Calc to balance your checkbook!)
5913 @xref{Rewrite Rules}, for the whole story on rewrite rules.
5915 @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
5916 @section Programming Tutorial
5919 The Calculator is written entirely in Emacs Lisp, a highly extensible
5920 language. If you know Lisp, you can program the Calculator to do
5921 anything you like. Rewrite rules also work as a powerful programming
5922 system. But Lisp and rewrite rules take a while to master, and often
5923 all you want to do is define a new function or repeat a command a few
5924 times. Calc has features that allow you to do these things easily.
5926 One very limited form of programming is defining your own functions.
5927 Calc's @kbd{Z F} command allows you to define a function name and
5928 key sequence to correspond to any formula. Programming commands use
5929 the shift-@kbd{Z} prefix; the user commands they create use the lower
5930 case @kbd{z} prefix.
5934 1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6
5937 ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y
5941 This polynomial is a Taylor series approximation to @samp{exp(x)}.
5942 The @kbd{Z F} command asks a number of questions. The above answers
5943 say that the key sequence for our function should be @kbd{z e}; the
5944 @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
5945 function in algebraic formulas should also be @code{myexp}; the
5946 default argument list @samp{(x)} is acceptable; and finally @kbd{y}
5947 answers the question ``leave it in symbolic form for non-constant
5952 1: 1.3495 2: 1.3495 3: 1.3495
5953 . 1: 1.34986 2: 1.34986
5957 .3 z e .3 E ' a+1 @key{RET} z e
5962 First we call our new @code{exp} approximation with 0.3 as an
5963 argument, and compare it with the true @code{exp} function. Then
5964 we note that, as requested, if we try to give @kbd{z e} an
5965 argument that isn't a plain number, it leaves the @code{myexp}
5966 function call in symbolic form. If we had answered @kbd{n} to the
5967 final question, @samp{myexp(a + 1)} would have evaluated by plugging
5968 in @samp{a + 1} for @samp{x} in the defining formula.
5970 @cindex Sine integral Si(x)
5975 (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function
5976 @texline @math{{\rm Si}(x)}
5977 @infoline @expr{Si(x)}
5978 is defined as the integral of @samp{sin(t)/t} for
5979 @expr{t = 0} to @expr{x} in radians. (It was invented because this
5980 integral has no solution in terms of basic functions; if you give it
5981 to Calc's @kbd{a i} command, it will ponder it for a long time and then
5982 give up.) We can use the numerical integration command, however,
5983 which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
5984 with any integrand @samp{f(t)}. Define a @kbd{z s} command and
5985 @code{Si} function that implement this. You will need to edit the
5986 default argument list a bit. As a test, @samp{Si(1)} should return
5987 0.946083. (If you don't get this answer, you might want to check that
5988 Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if
5989 you reduce the precision to, say, six digits beforehand.)
5990 @xref{Programming Answer 1, 1}. (@bullet{})
5992 The simplest way to do real ``programming'' of Emacs is to define a
5993 @dfn{keyboard macro}. A keyboard macro is simply a sequence of
5994 keystrokes which Emacs has stored away and can play back on demand.
5995 For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
5996 you may wish to program a keyboard macro to type this for you.
6000 1: y = sqrt(x) 1: x = y^2
6003 ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x )
6005 1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1
6008 ' y=cos(x) @key{RET} X
6013 When you type @kbd{C-x (}, Emacs begins recording. But it is also
6014 still ready to execute your keystrokes, so you're really ``training''
6015 Emacs by walking it through the procedure once. When you type
6016 @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to
6017 re-execute the same keystrokes.
6019 You can give a name to your macro by typing @kbd{Z K}.
6023 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y))
6026 Z K x @key{RET} ' y=x^4 @key{RET} z x
6031 Notice that we use shift-@kbd{Z} to define the command, and lower-case
6032 @kbd{z} to call it up.
6034 Keyboard macros can call other macros.
6038 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y
6041 ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X
6045 (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate
6046 the item in level 3 of the stack, without disturbing the rest of
6047 the stack. @xref{Programming Answer 2, 2}. (@bullet{})
6049 (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute
6050 the following functions:
6055 @texline @math{\displaystyle{\sin x \over x}},
6056 @infoline @expr{sin(x) / x},
6057 where @expr{x} is the number on the top of the stack.
6060 Compute the base-@expr{b} logarithm, just like the @kbd{B} key except
6061 the arguments are taken in the opposite order.
6064 Produce a vector of integers from 1 to the integer on the top of
6068 @xref{Programming Answer 3, 3}. (@bullet{})
6070 (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute
6071 the average (mean) value of a list of numbers.
6072 @xref{Programming Answer 4, 4}. (@bullet{})
6074 In many programs, some of the steps must execute several times.
6075 Calc has @dfn{looping} commands that allow this. Loops are useful
6076 inside keyboard macros, but actually work at any time.
6080 1: x^6 2: x^6 1: 360 x^2
6084 ' x^6 @key{RET} 4 Z < a d x @key{RET} Z >
6089 Here we have computed the fourth derivative of @expr{x^6} by
6090 enclosing a derivative command in a ``repeat loop'' structure.
6091 This structure pops a repeat count from the stack, then
6092 executes the body of the loop that many times.
6094 If you make a mistake while entering the body of the loop,
6095 type @w{@kbd{Z C-g}} to cancel the loop command.
6097 @cindex Fibonacci numbers
6098 Here's another example:
6107 1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z >
6112 The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
6113 numbers, respectively. (To see what's going on, try a few repetitions
6114 of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
6115 key if you have one, makes a copy of the number in level 2.)
6117 @cindex Golden ratio
6118 @cindex Phi, golden ratio
6119 A fascinating property of the Fibonacci numbers is that the @expr{n}th
6120 Fibonacci number can be found directly by computing
6121 @texline @math{\phi^n / \sqrt{5}}
6122 @infoline @expr{phi^n / sqrt(5)}
6123 and then rounding to the nearest integer, where
6124 @texline @math{\phi} (``phi''),
6125 @infoline @expr{phi},
6126 the ``golden ratio,'' is
6127 @texline @math{(1 + \sqrt{5}) / 2}.
6128 @infoline @expr{(1 + sqrt(5)) / 2}.
6129 (For convenience, this constant is available from the @code{phi}
6130 variable, or the @kbd{I H P} command.)
6134 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946
6141 @cindex Continued fractions
6142 (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction}
6144 @texline @math{\phi}
6145 @infoline @expr{phi}
6147 @texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}.
6148 @infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
6149 We can compute an approximate value by carrying this however far
6150 and then replacing the innermost
6151 @texline @math{1/( \ldots )}
6152 @infoline @expr{1/( ...@: )}
6154 @texline @math{\phi}
6155 @infoline @expr{phi}
6156 using a twenty-term continued fraction.
6157 @xref{Programming Answer 5, 5}. (@bullet{})
6159 (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for
6160 Fibonacci numbers can be expressed in terms of matrices. Given a
6161 vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this
6162 vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and
6163 @expr{c} are three successive Fibonacci numbers. Now write a program
6164 that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number
6165 using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{})
6167 @cindex Harmonic numbers
6168 A more sophisticated kind of loop is the @dfn{for} loop. Suppose
6169 we wish to compute the 20th ``harmonic'' number, which is equal to
6170 the sum of the reciprocals of the integers from 1 to 20.
6179 0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z )
6184 The ``for'' loop pops two numbers, the lower and upper limits, then
6185 repeats the body of the loop as an internal counter increases from
6186 the lower limit to the upper one. Just before executing the loop
6187 body, it pushes the current loop counter. When the loop body
6188 finishes, it pops the ``step,'' i.e., the amount by which to
6189 increment the loop counter. As you can see, our loop always
6192 This harmonic number function uses the stack to hold the running
6193 total as well as for the various loop housekeeping functions. If
6194 you find this disorienting, you can sum in a variable instead:
6198 1: 0 2: 1 . 1: 3.597739
6202 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7
6207 The @kbd{s +} command adds the top-of-stack into the value in a
6208 variable (and removes that value from the stack).
6210 It's worth noting that many jobs that call for a ``for'' loop can
6211 also be done more easily by Calc's high-level operations. Two
6212 other ways to compute harmonic numbers are to use vector mapping
6213 and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
6214 or to use the summation command @kbd{a +}. Both of these are
6215 probably easier than using loops. However, there are some
6216 situations where loops really are the way to go:
6218 (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first
6219 harmonic number which is greater than 4.0.
6220 @xref{Programming Answer 7, 7}. (@bullet{})
6222 Of course, if we're going to be using variables in our programs,
6223 we have to worry about the programs clobbering values that the
6224 caller was keeping in those same variables. This is easy to
6229 . 1: 0.6667 1: 0.6667 3: 0.6667
6234 Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET}
6239 When we type @kbd{Z `} (that's a back-quote character), Calc saves
6240 its mode settings and the contents of the ten ``quick variables''
6241 for later reference. When we type @kbd{Z '} (that's an apostrophe
6242 now), Calc restores those saved values. Thus the @kbd{p 4} and
6243 @kbd{s 7} commands have no effect outside this sequence. Wrapping
6244 this around the body of a keyboard macro ensures that it doesn't
6245 interfere with what the user of the macro was doing. Notice that
6246 the contents of the stack, and the values of named variables,
6247 survive past the @kbd{Z '} command.
6249 @cindex Bernoulli numbers, approximate
6250 The @dfn{Bernoulli numbers} are a sequence with the interesting
6251 property that all of the odd Bernoulli numbers are zero, and the
6252 even ones, while difficult to compute, can be roughly approximated
6254 @texline @math{\displaystyle{2 n! \over (2 \pi)^n}}.
6255 @infoline @expr{2 n!@: / (2 pi)^n}.
6256 Let's write a keyboard macro to compute (approximate) Bernoulli numbers.
6257 (Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but
6258 this command is very slow for large @expr{n} since the higher Bernoulli
6259 numbers are very large fractions.)
6266 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
6271 You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
6272 @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if''
6273 command. For the purposes of @w{@kbd{Z [}}, the condition is ``true''
6274 if the value it pops from the stack is a nonzero number, or ``false''
6275 if it pops zero or something that is not a number (like a formula).
6276 Here we take our integer argument modulo 2; this will be nonzero
6277 if we're asking for an odd Bernoulli number.
6279 The actual tenth Bernoulli number is @expr{5/66}.
6283 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659
6288 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
6292 Just to exercise loops a bit more, let's compute a table of even
6297 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...]
6302 [ ] 2 @key{RET} 30 Z ( X | 2 Z )
6307 The vertical-bar @kbd{|} is the vector-concatenation command. When
6308 we execute it, the list we are building will be in stack level 2
6309 (initially this is an empty list), and the next Bernoulli number
6310 will be in level 1. The effect is to append the Bernoulli number
6311 onto the end of the list. (To create a table of exact fractional
6312 Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
6313 sequence of keystrokes.)
6315 With loops and conditionals, you can program essentially anything
6316 in Calc. One other command that makes looping easier is @kbd{Z /},
6317 which takes a condition from the stack and breaks out of the enclosing
6318 loop if the condition is true (non-zero). You can use this to make
6319 ``while'' and ``until'' style loops.
6321 If you make a mistake when entering a keyboard macro, you can edit
6322 it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}.
6323 One technique is to enter a throwaway dummy definition for the macro,
6324 then enter the real one in the edit command.
6328 1: 3 1: 3 Calc Macro Edit Mode.
6329 . . Original keys: 1 <return> 2 +
6336 C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h
6341 A keyboard macro is stored as a pure keystroke sequence. The
6342 @file{edmacro} package (invoked by @kbd{Z E}) scans along the
6343 macro and tries to decode it back into human-readable steps.
6344 Descriptions of the keystrokes are given as comments, which begin with
6345 @samp{;;}, and which are ignored when the edited macro is saved.
6346 Spaces and line breaks are also ignored when the edited macro is saved.
6347 To enter a space into the macro, type @code{SPC}. All the special
6348 characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL},
6349 and @code{NUL} must be written in all uppercase, as must the prefixes
6350 @code{C-} and @code{M-}.
6352 Let's edit in a new definition, for computing harmonic numbers.
6353 First, erase the four lines of the old definition. Then, type
6354 in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
6355 to copy it from this page of the Info file; you can of course skip
6356 typing the comments, which begin with @samp{;;}).
6359 Z` ;; calc-kbd-push (Save local values)
6360 0 ;; calc digits (Push a zero onto the stack)
6361 st ;; calc-store-into (Store it in the following variable)
6362 1 ;; calc quick variable (Quick variable q1)
6363 1 ;; calc digits (Initial value for the loop)
6364 TAB ;; calc-roll-down (Swap initial and final)
6365 Z( ;; calc-kbd-for (Begin the "for" loop)
6366 & ;; calc-inv (Take the reciprocal)
6367 s+ ;; calc-store-plus (Add to the following variable)
6368 1 ;; calc quick variable (Quick variable q1)
6369 1 ;; calc digits (The loop step is 1)
6370 Z) ;; calc-kbd-end-for (End the "for" loop)
6371 sr ;; calc-recall (Recall the final accumulated value)
6372 1 ;; calc quick variable (Quick variable q1)
6373 Z' ;; calc-kbd-pop (Restore values)
6377 Press @kbd{C-c C-c} to finish editing and return to the Calculator.
6388 The @file{edmacro} package defines a handy @code{read-kbd-macro} command
6389 which reads the current region of the current buffer as a sequence of
6390 keystroke names, and defines that sequence on the @kbd{X}
6391 (and @kbd{C-x e}) key. Because this is so useful, Calc puts this
6392 command on the @kbd{M-# m} key. Try reading in this macro in the
6393 following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
6394 one end of the text below, then type @kbd{M-# m} at the other.
6406 (@bullet{}) @strong{Exercise 8.} A general algorithm for solving
6407 equations numerically is @dfn{Newton's Method}. Given the equation
6408 @expr{f(x) = 0} for any function @expr{f}, and an initial guess
6409 @expr{x_0} which is reasonably close to the desired solution, apply
6410 this formula over and over:
6414 new_x = x - f(x)/f'(x)
6419 $$ x_{\rm new} = x - {f(x) \over f'(x)} $$
6424 where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x}
6425 values will quickly converge to a solution, i.e., eventually
6426 @texline @math{x_{\rm new}}
6427 @infoline @expr{new_x}
6428 and @expr{x} will be equal to within the limits
6429 of the current precision. Write a program which takes a formula
6430 involving the variable @expr{x}, and an initial guess @expr{x_0},
6431 on the stack, and produces a value of @expr{x} for which the formula
6432 is zero. Use it to find a solution of
6433 @texline @math{\sin(\cos x) = 0.5}
6434 @infoline @expr{sin(cos(x)) = 0.5}
6435 near @expr{x = 4.5}. (Use angles measured in radians.) Note that
6436 the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
6437 method when it is able. @xref{Programming Answer 8, 8}. (@bullet{})
6439 @cindex Digamma function
6440 @cindex Gamma constant, Euler's
6441 @cindex Euler's gamma constant
6442 (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function
6443 @texline @math{\psi(z) (``psi'')}
6444 @infoline @expr{psi(z)}
6445 is defined as the derivative of
6446 @texline @math{\ln \Gamma(z)}.
6447 @infoline @expr{ln(gamma(z))}.
6448 For large values of @expr{z}, it can be approximated by the infinite sum
6452 psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
6457 $$ \psi(z) \approx \ln z - {1\over2z} -
6458 \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
6465 @texline @math{\sum}
6466 @infoline @expr{sum}
6467 represents the sum over @expr{n} from 1 to infinity
6468 (or to some limit high enough to give the desired accuracy), and
6469 the @code{bern} function produces (exact) Bernoulli numbers.
6470 While this sum is not guaranteed to converge, in practice it is safe.
6471 An interesting mathematical constant is Euler's gamma, which is equal
6472 to about 0.5772. One way to compute it is by the formula,
6473 @texline @math{\gamma = -\psi(1)}.
6474 @infoline @expr{gamma = -psi(1)}.
6475 Unfortunately, 1 isn't a large enough argument
6476 for the above formula to work (5 is a much safer value for @expr{z}).
6477 Fortunately, we can compute
6478 @texline @math{\psi(1)}
6479 @infoline @expr{psi(1)}
6481 @texline @math{\psi(5)}
6482 @infoline @expr{psi(5)}
6483 using the recurrence
6484 @texline @math{\psi(z+1) = \psi(z) + {1 \over z}}.
6485 @infoline @expr{psi(z+1) = psi(z) + 1/z}.
6486 Your task: Develop a program to compute
6487 @texline @math{\psi(z)};
6488 @infoline @expr{psi(z)};
6489 it should ``pump up'' @expr{z}
6490 if necessary to be greater than 5, then use the above summation
6491 formula. Use looping commands to compute the sum. Use your function
6493 @texline @math{\gamma}
6494 @infoline @expr{gamma}
6495 to twelve decimal places. (Calc has a built-in command
6496 for Euler's constant, @kbd{I P}, which you can use to check your answer.)
6497 @xref{Programming Answer 9, 9}. (@bullet{})
6499 @cindex Polynomial, list of coefficients
6500 (@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and
6501 a number @expr{m} on the stack, where the polynomial is of degree
6502 @expr{m} or less (i.e., does not have any terms higher than @expr{x^m}),
6503 write a program to convert the polynomial into a list-of-coefficients
6504 notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6}
6505 should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop
6506 a way to convert from this form back to the standard algebraic form.
6507 @xref{Programming Answer 10, 10}. (@bullet{})
6510 (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the
6511 first kind} are defined by the recurrences,
6515 s(n,n) = 1 for n >= 0,
6516 s(n,0) = 0 for n > 0,
6517 s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1.
6523 $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr
6524 s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr
6525 s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
6526 \hbox{for } n \ge m \ge 1.}
6530 (These numbers are also sometimes written $\displaystyle{n \brack m}$.)
6533 This can be implemented using a @dfn{recursive} program in Calc; the
6534 program must invoke itself in order to calculate the two righthand
6535 terms in the general formula. Since it always invokes itself with
6536 ``simpler'' arguments, it's easy to see that it must eventually finish
6537 the computation. Recursion is a little difficult with Emacs keyboard
6538 macros since the macro is executed before its definition is complete.
6539 So here's the recommended strategy: Create a ``dummy macro'' and assign
6540 it to a key with, e.g., @kbd{Z K s}. Now enter the true definition,
6541 using the @kbd{z s} command to call itself recursively, then assign it
6542 to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run
6543 the complete recursive program. (Another way is to use @w{@kbd{Z E}}
6544 or @kbd{M-# m} (@code{read-kbd-macro}) to read the whole macro at once,
6545 thus avoiding the ``training'' phase.) The task: Write a program
6546 that computes Stirling numbers of the first kind, given @expr{n} and
6547 @expr{m} on the stack. Test it with @emph{small} inputs like
6548 @expr{s(4,2)}. (There is a built-in command for Stirling numbers,
6549 @kbd{k s}, which you can use to check your answers.)
6550 @xref{Programming Answer 11, 11}. (@bullet{})
6552 The programming commands we've seen in this part of the tutorial
6553 are low-level, general-purpose operations. Often you will find
6554 that a higher-level function, such as vector mapping or rewrite
6555 rules, will do the job much more easily than a detailed, step-by-step
6558 (@bullet{}) @strong{Exercise 12.} Write another program for
6559 computing Stirling numbers of the first kind, this time using
6560 rewrite rules. Once again, @expr{n} and @expr{m} should be taken
6561 from the stack. @xref{Programming Answer 12, 12}. (@bullet{})
6566 This ends the tutorial section of the Calc manual. Now you know enough
6567 about Calc to use it effectively for many kinds of calculations. But
6568 Calc has many features that were not even touched upon in this tutorial.
6570 The rest of this manual tells the whole story.
6572 @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
6575 @node Answers to Exercises, , Programming Tutorial, Tutorial
6576 @section Answers to Exercises
6579 This section includes answers to all the exercises in the Calc tutorial.
6582 * RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
6583 * RPN Answer 2:: 2*4 + 7*9.5 + 5/4
6584 * RPN Answer 3:: Operating on levels 2 and 3
6585 * RPN Answer 4:: Joe's complex problems
6586 * Algebraic Answer 1:: Simulating Q command
6587 * Algebraic Answer 2:: Joe's algebraic woes
6588 * Algebraic Answer 3:: 1 / 0
6589 * Modes Answer 1:: 3#0.1 = 3#0.0222222?
6590 * Modes Answer 2:: 16#f.e8fe15
6591 * Modes Answer 3:: Joe's rounding bug
6592 * Modes Answer 4:: Why floating point?
6593 * Arithmetic Answer 1:: Why the \ command?
6594 * Arithmetic Answer 2:: Tripping up the B command
6595 * Vector Answer 1:: Normalizing a vector
6596 * Vector Answer 2:: Average position
6597 * Matrix Answer 1:: Row and column sums
6598 * Matrix Answer 2:: Symbolic system of equations
6599 * Matrix Answer 3:: Over-determined system
6600 * List Answer 1:: Powers of two
6601 * List Answer 2:: Least-squares fit with matrices
6602 * List Answer 3:: Geometric mean
6603 * List Answer 4:: Divisor function
6604 * List Answer 5:: Duplicate factors
6605 * List Answer 6:: Triangular list
6606 * List Answer 7:: Another triangular list
6607 * List Answer 8:: Maximum of Bessel function
6608 * List Answer 9:: Integers the hard way
6609 * List Answer 10:: All elements equal
6610 * List Answer 11:: Estimating pi with darts
6611 * List Answer 12:: Estimating pi with matchsticks
6612 * List Answer 13:: Hash codes
6613 * List Answer 14:: Random walk
6614 * Types Answer 1:: Square root of pi times rational
6615 * Types Answer 2:: Infinities
6616 * Types Answer 3:: What can "nan" be?
6617 * Types Answer 4:: Abbey Road
6618 * Types Answer 5:: Friday the 13th
6619 * Types Answer 6:: Leap years
6620 * Types Answer 7:: Erroneous donut
6621 * Types Answer 8:: Dividing intervals
6622 * Types Answer 9:: Squaring intervals
6623 * Types Answer 10:: Fermat's primality test
6624 * Types Answer 11:: pi * 10^7 seconds
6625 * Types Answer 12:: Abbey Road on CD
6626 * Types Answer 13:: Not quite pi * 10^7 seconds
6627 * Types Answer 14:: Supercomputers and c
6628 * Types Answer 15:: Sam the Slug
6629 * Algebra Answer 1:: Squares and square roots
6630 * Algebra Answer 2:: Building polynomial from roots
6631 * Algebra Answer 3:: Integral of x sin(pi x)
6632 * Algebra Answer 4:: Simpson's rule
6633 * Rewrites Answer 1:: Multiplying by conjugate
6634 * Rewrites Answer 2:: Alternative fib rule
6635 * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x
6636 * Rewrites Answer 4:: Sequence of integers
6637 * Rewrites Answer 5:: Number of terms in sum
6638 * Rewrites Answer 6:: Truncated Taylor series
6639 * Programming Answer 1:: Fresnel's C(x)
6640 * Programming Answer 2:: Negate third stack element
6641 * Programming Answer 3:: Compute sin(x) / x, etc.
6642 * Programming Answer 4:: Average value of a list
6643 * Programming Answer 5:: Continued fraction phi
6644 * Programming Answer 6:: Matrix Fibonacci numbers
6645 * Programming Answer 7:: Harmonic number greater than 4
6646 * Programming Answer 8:: Newton's method
6647 * Programming Answer 9:: Digamma function
6648 * Programming Answer 10:: Unpacking a polynomial
6649 * Programming Answer 11:: Recursive Stirling numbers
6650 * Programming Answer 12:: Stirling numbers with rewrites
6653 @c The following kludgery prevents the individual answers from
6654 @c being entered on the table of contents.
6656 \global\let\oldwrite=\write
6657 \gdef\skipwrite#1#2{\let\write=\oldwrite}
6658 \global\let\oldchapternofonts=\chapternofonts
6659 \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
6662 @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
6663 @subsection RPN Tutorial Exercise 1
6666 @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
6669 @texline @math{1 - (2 \times (3 + 4)) = -13}.
6670 @infoline @expr{1 - (2 * (3 + 4)) = -13}.
6672 @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
6673 @subsection RPN Tutorial Exercise 2
6676 @texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75}
6677 @infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75}
6679 After computing the intermediate term
6680 @texline @math{2\times4 = 8},
6681 @infoline @expr{2*4 = 8},
6682 you can leave that result on the stack while you compute the second
6683 term. With both of these results waiting on the stack you can then
6684 compute the final term, then press @kbd{+ +} to add everything up.
6693 2 @key{RET} 4 * 7 @key{RET} 9.5 *
6700 4: 8 3: 8 2: 8 1: 75.75
6701 3: 66.5 2: 66.5 1: 67.75 .
6710 Alternatively, you could add the first two terms before going on
6711 with the third term.
6715 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75
6716 1: 66.5 . 2: 5 1: 1.25 .
6720 ... + 5 @key{RET} 4 / +
6724 On an old-style RPN calculator this second method would have the
6725 advantage of using only three stack levels. But since Calc's stack
6726 can grow arbitrarily large this isn't really an issue. Which method
6727 you choose is purely a matter of taste.
6729 @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
6730 @subsection RPN Tutorial Exercise 3
6733 The @key{TAB} key provides a way to operate on the number in level 2.
6737 3: 10 3: 10 4: 10 3: 10 3: 10
6738 2: 20 2: 30 3: 30 2: 30 2: 21
6739 1: 30 1: 20 2: 20 1: 21 1: 30
6743 @key{TAB} 1 + @key{TAB}
6747 Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
6751 3: 10 3: 21 3: 21 3: 30 3: 11
6752 2: 21 2: 30 2: 30 2: 11 2: 21
6753 1: 30 1: 10 1: 11 1: 21 1: 30
6756 M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB}
6760 @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
6761 @subsection RPN Tutorial Exercise 4
6764 Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
6765 but using both the comma and the space at once yields:
6769 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ...
6770 . 1: 2 . 1: (2, ... 1: (2, 3)
6777 Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
6778 extra incomplete object to the top of the stack and delete it.
6779 But a feature of Calc is that @key{DEL} on an incomplete object
6780 deletes just one component out of that object, so he had to press
6781 @key{DEL} twice to finish the job.
6785 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3)
6786 1: (2, 3) 1: (2, ... 1: ( ... .
6789 @key{TAB} @key{DEL} @key{DEL}
6793 (As it turns out, deleting the second-to-top stack entry happens often
6794 enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
6795 @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
6796 the ``feature'' that tripped poor Joe.)
6798 @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
6799 @subsection Algebraic Entry Tutorial Exercise 1
6802 Type @kbd{' sqrt($) @key{RET}}.
6804 If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
6805 Or, RPN style, @kbd{0.5 ^}.
6807 (Actually, @samp{$^1:2}, using the fraction one-half as the power, is
6808 a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas
6809 @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.)
6811 @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
6812 @subsection Algebraic Entry Tutorial Exercise 2
6815 In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
6816 name with @samp{1+y} as its argument. Assigning a value to a variable
6817 has no relation to a function by the same name. Joe needed to use an
6818 explicit @samp{*} symbol here: @samp{2 x*(1+y)}.
6820 @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
6821 @subsection Algebraic Entry Tutorial Exercise 3
6824 The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}.
6825 The ``function'' @samp{/} cannot be evaluated when its second argument
6826 is zero, so it is left in symbolic form. When you now type @kbd{0 *},
6827 the result will be zero because Calc uses the general rule that ``zero
6828 times anything is zero.''
6830 @c [fix-ref Infinities]
6831 The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0}
6832 results in a special symbol that represents ``infinity.'' If you
6833 multiply infinity by zero, Calc uses another special new symbol to
6834 show that the answer is ``indeterminate.'' @xref{Infinities}, for
6835 further discussion of infinite and indeterminate values.
6837 @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
6838 @subsection Modes Tutorial Exercise 1
6841 Calc always stores its numbers in decimal, so even though one-third has
6842 an exact base-3 representation (@samp{3#0.1}), it is still stored as
6843 0.3333333 (chopped off after 12 or however many decimal digits) inside
6844 the calculator's memory. When this inexact number is converted back
6845 to base 3 for display, it may still be slightly inexact. When we
6846 multiply this number by 3, we get 0.999999, also an inexact value.
6848 When Calc displays a number in base 3, it has to decide how many digits
6849 to show. If the current precision is 12 (decimal) digits, that corresponds
6850 to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an
6851 exact integer, Calc shows only 25 digits, with the result that stored
6852 numbers carry a little bit of extra information that may not show up on
6853 the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666
6854 happened to round to a pleasing value when it lost that last 0.15 of a
6855 digit, but it was still inexact in Calc's memory. When he divided by 2,
6856 he still got the dreaded inexact value 0.333333. (Actually, he divided
6857 0.666667 by 2 to get 0.333334, which is why he got something a little
6858 higher than @code{3#0.1} instead of a little lower.)
6860 If Joe didn't want to be bothered with all this, he could have typed
6861 @kbd{M-24 d n} to display with one less digit than the default. (If
6862 you give @kbd{d n} a negative argument, it uses default-minus-that,
6863 so @kbd{M-- d n} would be an easier way to get the same effect.) Those
6864 inexact results would still be lurking there, but they would now be
6865 rounded to nice, natural-looking values for display purposes. (Remember,
6866 @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
6867 off one digit will round the number up to @samp{0.1}.) Depending on the
6868 nature of your work, this hiding of the inexactness may be a benefit or
6869 a danger. With the @kbd{d n} command, Calc gives you the choice.
6871 Incidentally, another consequence of all this is that if you type
6872 @kbd{M-30 d n} to display more digits than are ``really there,''
6873 you'll see garbage digits at the end of the number. (In decimal
6874 display mode, with decimally-stored numbers, these garbage digits are
6875 always zero so they vanish and you don't notice them.) Because Calc
6876 rounds off that 0.15 digit, there is the danger that two numbers could
6877 be slightly different internally but still look the same. If you feel
6878 uneasy about this, set the @kbd{d n} precision to be a little higher
6879 than normal; you'll get ugly garbage digits, but you'll always be able
6880 to tell two distinct numbers apart.
6882 An interesting side note is that most computers store their
6883 floating-point numbers in binary, and convert to decimal for display.
6884 Thus everyday programs have the same problem: Decimal 0.1 cannot be
6885 represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
6886 comes out as an inexact approximation to 1 on some machines (though
6887 they generally arrange to hide it from you by rounding off one digit as
6888 we did above). Because Calc works in decimal instead of binary, you can
6889 be sure that numbers that look exact @emph{are} exact as long as you stay
6890 in decimal display mode.
6892 It's not hard to show that any number that can be represented exactly
6893 in binary, octal, or hexadecimal is also exact in decimal, so the kinds
6894 of problems we saw in this exercise are likely to be severe only when
6895 you use a relatively unusual radix like 3.
6897 @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
6898 @subsection Modes Tutorial Exercise 2
6900 If the radix is 15 or higher, we can't use the letter @samp{e} to mark
6901 the exponent because @samp{e} is interpreted as a digit. When Calc
6902 needs to display scientific notation in a high radix, it writes
6903 @samp{16#F.E8F*16.^15}. You can enter a number like this as an
6904 algebraic entry. Also, pressing @kbd{e} without any digits before it
6905 normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
6906 puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
6907 way to enter this number.
6909 The reason Calc puts a decimal point in the @samp{16.^} is to prevent
6910 huge integers from being generated if the exponent is large (consider
6911 @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
6912 exact integer and then throw away most of the digits when we multiply
6913 it by the floating-point @samp{16#1.23}). While this wouldn't normally
6914 matter for display purposes, it could give you a nasty surprise if you
6915 copied that number into a file and later moved it back into Calc.
6917 @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
6918 @subsection Modes Tutorial Exercise 3
6921 The answer he got was @expr{0.5000000000006399}.
6923 The problem is not that the square operation is inexact, but that the
6924 sine of 45 that was already on the stack was accurate to only 12 places.
6925 Arbitrary-precision calculations still only give answers as good as
6928 The real problem is that there is no 12-digit number which, when
6929 squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]}
6930 commands decrease or increase a number by one unit in the last
6931 place (according to the current precision). They are useful for
6932 determining facts like this.
6936 1: 0.707106781187 1: 0.500000000001
6946 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999
6953 A high-precision calculation must be carried out in high precision
6954 all the way. The only number in the original problem which was known
6955 exactly was the quantity 45 degrees, so the precision must be raised
6956 before anything is done after the number 45 has been entered in order
6957 for the higher precision to be meaningful.
6959 @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
6960 @subsection Modes Tutorial Exercise 4
6963 Many calculations involve real-world quantities, like the width and
6964 height of a piece of wood or the volume of a jar. Such quantities
6965 can't be measured exactly anyway, and if the data that is input to
6966 a calculation is inexact, doing exact arithmetic on it is a waste
6969 Fractions become unwieldy after too many calculations have been
6970 done with them. For example, the sum of the reciprocals of the
6971 integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is
6972 9304682830147:2329089562800. After a point it will take a long
6973 time to add even one more term to this sum, but a floating-point
6974 calculation of the sum will not have this problem.
6976 Also, rational numbers cannot express the results of all calculations.
6977 There is no fractional form for the square root of two, so if you type
6978 @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
6980 @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
6981 @subsection Arithmetic Tutorial Exercise 1
6984 Dividing two integers that are larger than the current precision may
6985 give a floating-point result that is inaccurate even when rounded
6986 down to an integer. Consider @expr{123456789 / 2} when the current
6987 precision is 6 digits. The true answer is @expr{61728394.5}, but
6988 with a precision of 6 this will be rounded to
6989 @texline @math{12345700.0/2.0 = 61728500.0}.
6990 @infoline @expr{12345700.@: / 2.@: = 61728500.}.
6991 The result, when converted to an integer, will be off by 106.
6993 Here are two solutions: Raise the precision enough that the
6994 floating-point round-off error is strictly to the right of the
6995 decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2}
6996 produces the exact fraction @expr{123456789:2}, which can be rounded
6997 down by the @kbd{F} command without ever switching to floating-point
7000 @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
7001 @subsection Arithmetic Tutorial Exercise 2
7004 @kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it
7005 does a floating-point calculation instead and produces @expr{1.5}.
7007 Calc will find an exact result for a logarithm if the result is an integer
7008 or (when in Fraction mode) the reciprocal of an integer. But there is
7009 no efficient way to search the space of all possible rational numbers
7010 for an exact answer, so Calc doesn't try.
7012 @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
7013 @subsection Vector Tutorial Exercise 1
7016 Duplicate the vector, compute its length, then divide the vector
7017 by its length: @kbd{@key{RET} A /}.
7021 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1.
7022 . 1: 3.74165738677 . .
7029 The final @kbd{A} command shows that the normalized vector does
7030 indeed have unit length.
7032 @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
7033 @subsection Vector Tutorial Exercise 2
7036 The average position is equal to the sum of the products of the
7037 positions times their corresponding probabilities. This is the
7038 definition of the dot product operation. So all you need to do
7039 is to put the two vectors on the stack and press @kbd{*}.
7041 @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
7042 @subsection Matrix Tutorial Exercise 1
7045 The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to
7046 get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
7048 @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
7049 @subsection Matrix Tutorial Exercise 2
7062 $$ \eqalign{ x &+ a y = 6 \cr
7068 Just enter the righthand side vector, then divide by the lefthand side
7073 1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ]
7078 ' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} /
7082 This can be made more readable using @kbd{d B} to enable Big display
7088 1: [6 - -----, -----]
7093 Type @kbd{d N} to return to Normal display mode afterwards.
7095 @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
7096 @subsection Matrix Tutorial Exercise 3
7100 @texline @math{A^T A \, X = A^T B},
7101 @infoline @expr{trn(A) * A * X = trn(A) * B},
7103 @texline @math{A' = A^T A}
7104 @infoline @expr{A2 = trn(A) * A}
7106 @texline @math{B' = A^T B};
7107 @infoline @expr{B2 = trn(A) * B};
7108 now, we have a system
7109 @texline @math{A' X = B'}
7110 @infoline @expr{A2 * X = B2}
7111 which we can solve using Calc's @samp{/} command.
7126 $$ \openup1\jot \tabskip=0pt plus1fil
7127 \halign to\displaywidth{\tabskip=0pt
7128 $\hfil#$&$\hfil{}#{}$&
7129 $\hfil#$&$\hfil{}#{}$&
7130 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
7134 2a&+&4b&+&6c&=11 \cr}
7139 The first step is to enter the coefficient matrix. We'll store it in
7140 quick variable number 7 for later reference. Next, we compute the
7147 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96]
7148 [ 4, 5, 6 ] [ 2, 5, 6, 4 ] .
7149 [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ]
7150 [ 2, 4, 6 ] ] 1: [6, 2, 3, 11]
7153 ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] *
7158 Now we compute the matrix
7165 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64]
7166 1: [ [ 70, 72, 39 ] .
7176 (The actual computed answer will be slightly inexact due to
7179 Notice that the answers are similar to those for the
7180 @texline @math{3\times3}
7182 system solved in the text. That's because the fourth equation that was
7183 added to the system is almost identical to the first one multiplied
7184 by two. (If it were identical, we would have gotten the exact same
7186 @texline @math{4\times3}
7188 system would be equivalent to the original
7189 @texline @math{3\times3}
7193 Since the first and fourth equations aren't quite equivalent, they
7194 can't both be satisfied at once. Let's plug our answers back into
7195 the original system of equations to see how well they match.
7199 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2]
7211 This is reasonably close to our original @expr{B} vector,
7212 @expr{[6, 2, 3, 11]}.
7214 @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
7215 @subsection List Tutorial Exercise 1
7218 We can use @kbd{v x} to build a vector of integers. This needs to be
7219 adjusted to get the range of integers we desire. Mapping @samp{-}
7220 across the vector will accomplish this, although it turns out the
7221 plain @samp{-} key will work just as well.
7226 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4]
7229 2 v x 9 @key{RET} 5 V M - or 5 -
7234 Now we use @kbd{V M ^} to map the exponentiation operator across the
7239 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
7246 @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
7247 @subsection List Tutorial Exercise 2
7250 Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before,
7251 the first job is to form the matrix that describes the problem.
7261 $$ m \times x + b \times 1 = y $$
7266 @texline @math{19\times2}
7268 matrix with our @expr{x} vector as one column and
7269 ones as the other column. So, first we build the column of ones, then
7270 we combine the two columns to form our @expr{A} matrix.
7274 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ]
7275 1: [1, 1, 1, ...] [ 1.41, 1 ]
7279 r 1 1 v b 19 @key{RET} M-2 v p v t s 3
7285 @texline @math{A^T y}
7286 @infoline @expr{trn(A) * y}
7288 @texline @math{A^T A}
7289 @infoline @expr{trn(A) * A}
7294 1: [33.36554, 13.613] 2: [33.36554, 13.613]
7295 . 1: [ [ 98.0003, 41.63 ]
7299 v t r 2 * r 3 v t r 3 *
7304 (Hey, those numbers look familiar!)
7308 1: [0.52141679, -0.425978]
7315 Since we were solving equations of the form
7316 @texline @math{m \times x + b \times 1 = y},
7317 @infoline @expr{m*x + b*1 = y},
7318 these numbers should be @expr{m} and @expr{b}, respectively. Sure
7319 enough, they agree exactly with the result computed using @kbd{V M} and
7322 The moral of this story: @kbd{V M} and @kbd{V R} will probably solve
7323 your problem, but there is often an easier way using the higher-level
7324 arithmetic functions!
7326 @c [fix-ref Curve Fitting]
7327 In fact, there is a built-in @kbd{a F} command that does least-squares
7328 fits. @xref{Curve Fitting}.
7330 @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
7331 @subsection List Tutorial Exercise 3
7334 Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
7335 whatever) to set the mark, then move to the other end of the list
7336 and type @w{@kbd{M-# g}}.
7340 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
7345 To make things interesting, let's assume we don't know at a glance
7346 how many numbers are in this list. Then we could type:
7350 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ]
7351 1: [2.3, 6, 22, ... ] 1: 126356422.5
7361 2: 126356422.5 2: 126356422.5 1: 7.94652913734
7362 1: [2.3, 6, 22, ... ] 1: 9 .
7370 (The @kbd{I ^} command computes the @var{n}th root of a number.
7371 You could also type @kbd{& ^} to take the reciprocal of 9 and
7372 then raise the number to that power.)
7374 @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
7375 @subsection List Tutorial Exercise 4
7378 A number @expr{j} is a divisor of @expr{n} if
7379 @texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}.
7380 @infoline @samp{n % j = 0}.
7381 The first step is to get a vector that identifies the divisors.
7385 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...]
7386 1: [1, 2, 3, 4, ...] 1: 0 .
7389 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2
7394 This vector has 1's marking divisors of 30 and 0's marking non-divisors.
7396 The zeroth divisor function is just the total number of divisors.
7397 The first divisor function is the sum of the divisors.
7402 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72
7403 1: [1, 1, 1, 0, ...] . .
7406 V R + r 1 r 2 V M * V R +
7411 Once again, the last two steps just compute a dot product for which
7412 a simple @kbd{*} would have worked equally well.
7414 @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
7415 @subsection List Tutorial Exercise 5
7418 The obvious first step is to obtain the list of factors with @kbd{k f}.
7419 This list will always be in sorted order, so if there are duplicates
7420 they will be right next to each other. A suitable method is to compare
7421 the list with a copy of itself shifted over by one.
7425 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0]
7426 . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19]
7429 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} |
7436 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0
7444 Note that we have to arrange for both vectors to have the same length
7445 so that the mapping operation works; no prime factor will ever be
7446 zero, so adding zeros on the left and right is safe. From then on
7447 the job is pretty straightforward.
7449 Incidentally, Calc provides the
7450 @texline @dfn{M@"obius} @math{\mu}
7451 @infoline @dfn{Moebius mu}
7452 function which is zero if and only if its argument is square-free. It
7453 would be a much more convenient way to do the above test in practice.
7455 @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
7456 @subsection List Tutorial Exercise 6
7459 First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
7460 to get a list of lists of integers!
7462 @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
7463 @subsection List Tutorial Exercise 7
7466 Here's one solution. First, compute the triangular list from the previous
7467 exercise and type @kbd{1 -} to subtract one from all the elements.
7480 The numbers down the lefthand edge of the list we desire are called
7481 the ``triangular numbers'' (now you know why!). The @expr{n}th
7482 triangular number is the sum of the integers from 1 to @expr{n}, and
7483 can be computed directly by the formula
7484 @texline @math{n (n+1) \over 2}.
7485 @infoline @expr{n * (n+1) / 2}.
7489 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7490 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15]
7493 v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET}
7498 Adding this list to the above list of lists produces the desired
7507 [10, 11, 12, 13, 14],
7508 [15, 16, 17, 18, 19, 20] ]
7515 If we did not know the formula for triangular numbers, we could have
7516 computed them using a @kbd{V U +} command. We could also have
7517 gotten them the hard way by mapping a reduction across the original
7522 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7523 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15]
7531 (This means ``map a @kbd{V R +} command across the vector,'' and
7532 since each element of the main vector is itself a small vector,
7533 @kbd{V R +} computes the sum of its elements.)
7535 @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
7536 @subsection List Tutorial Exercise 8
7539 The first step is to build a list of values of @expr{x}.
7543 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5]
7546 v x 21 @key{RET} 1 - 4 / s 1
7550 Next, we compute the Bessel function values.
7554 1: [0., 0.124, 0.242, ..., -0.328]
7557 V M ' besJ(1,$) @key{RET}
7562 (Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
7564 A way to isolate the maximum value is to compute the maximum using
7565 @kbd{V R X}, then compare all the Bessel values with that maximum.
7569 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ]
7573 @key{RET} V R X V M a = @key{RET} V R + @key{DEL}
7578 It's a good idea to verify, as in the last step above, that only
7579 one value is equal to the maximum. (After all, a plot of
7580 @texline @math{\sin x}
7581 @infoline @expr{sin(x)}
7582 might have many points all equal to the maximum value, 1.)
7584 The vector we have now has a single 1 in the position that indicates
7585 the maximum value of @expr{x}. Now it is a simple matter to convert
7586 this back into the corresponding value itself.
7590 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75
7591 1: [0, 0.25, 0.5, ... ] . .
7598 If @kbd{a =} had produced more than one @expr{1} value, this method
7599 would have given the sum of all maximum @expr{x} values; not very
7600 useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector})
7601 instead. This command deletes all elements of a ``data'' vector that
7602 correspond to zeros in a ``mask'' vector, leaving us with, in this
7603 example, a vector of maximum @expr{x} values.
7605 The built-in @kbd{a X} command maximizes a function using more
7606 efficient methods. Just for illustration, let's use @kbd{a X}
7607 to maximize @samp{besJ(1,x)} over this same interval.
7611 2: besJ(1, x) 1: [1.84115, 0.581865]
7615 ' besJ(1,x), [0..5] @key{RET} a X x @key{RET}
7620 The output from @kbd{a X} is a vector containing the value of @expr{x}
7621 that maximizes the function, and the function's value at that maximum.
7622 As you can see, our simple search got quite close to the right answer.
7624 @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
7625 @subsection List Tutorial Exercise 9
7628 Step one is to convert our integer into vector notation.
7632 1: 25129925999 3: 25129925999
7634 1: [11, 10, 9, ..., 1, 0]
7637 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
7644 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ]
7645 2: [100000000000, ... ] .
7653 (Recall, the @kbd{\} command computes an integer quotient.)
7657 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
7664 Next we must increment this number. This involves adding one to
7665 the last digit, plus handling carries. There is a carry to the
7666 left out of a digit if that digit is a nine and all the digits to
7667 the right of it are nines.
7671 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ]
7681 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
7689 Accumulating @kbd{*} across a vector of ones and zeros will preserve
7690 only the initial run of ones. These are the carries into all digits
7691 except the rightmost digit. Concatenating a one on the right takes
7692 care of aligning the carries properly, and also adding one to the
7697 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
7698 1: [0, 0, 2, 5, ... ] .
7701 0 r 2 | V M + 10 V M %
7706 Here we have concatenated 0 to the @emph{left} of the original number;
7707 this takes care of shifting the carries by one with respect to the
7708 digits that generated them.
7710 Finally, we must convert this list back into an integer.
7714 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ]
7715 2: 1000000000000 1: [1000000000000, 100000000000, ... ]
7716 1: [100000000000, ... ] .
7719 10 @key{RET} 12 ^ r 1 |
7726 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000
7734 Another way to do this final step would be to reduce the formula
7735 @w{@samp{10 $$ + $}} across the vector of digits.
7739 1: [0, 0, 2, 5, ... ] 1: 25129926000
7742 V R ' 10 $$ + $ @key{RET}
7746 @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
7747 @subsection List Tutorial Exercise 10
7750 For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d},
7751 which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is
7752 then compared with @expr{c} to produce another 1 or 0, which is then
7753 compared with @expr{d}. This is not at all what Joe wanted.
7755 Here's a more correct method:
7759 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7]
7763 ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET}
7770 1: [1, 1, 1, 0, 1] 1: 0
7777 @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
7778 @subsection List Tutorial Exercise 11
7781 The circle of unit radius consists of those points @expr{(x,y)} for which
7782 @expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2}
7783 and a vector of @expr{y^2}.
7785 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7790 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.]
7791 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81]
7794 v . t . 2. v b 100 @key{RET} @key{RET} V M k r
7801 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036]
7802 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094]
7805 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^
7809 Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to
7810 get a vector of 1/0 truth values, then sum the truth values.
7814 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84
7822 The ratio @expr{84/100} should approximate the ratio @cpiover{4}.
7826 1: 0.84 1: 3.36 2: 3.36 1: 1.0695
7834 Our estimate, 3.36, is off by about 7%. We could get a better estimate
7835 by taking more points (say, 1000), but it's clear that this method is
7838 (Naturally, since this example uses random numbers your own answer
7839 will be slightly different from the one shown here!)
7841 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7842 return to full-sized display of vectors.
7844 @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
7845 @subsection List Tutorial Exercise 12
7848 This problem can be made a lot easier by taking advantage of some
7849 symmetries. First of all, after some thought it's clear that the
7850 @expr{y} axis can be ignored altogether. Just pick a random @expr{x}
7851 component for one end of the match, pick a random direction
7852 @texline @math{\theta},
7853 @infoline @expr{theta},
7854 and see if @expr{x} and
7855 @texline @math{x + \cos \theta}
7856 @infoline @expr{x + cos(theta)}
7857 (which is the @expr{x} coordinate of the other endpoint) cross a line.
7858 The lines are at integer coordinates, so this happens when the two
7859 numbers surround an integer.
7861 Since the two endpoints are equivalent, we may as well choose the leftmost
7862 of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing
7863 to the right, in the range -90 to 90 degrees. (We could use radians, but
7864 it would feel like cheating to refer to @cpiover{2} radians while trying
7865 to estimate @cpi{}!)
7867 In fact, since the field of lines is infinite we can choose the
7868 coordinates 0 and 1 for the lines on either side of the leftmost
7869 endpoint. The rightmost endpoint will be between 0 and 1 if the
7870 match does not cross a line, or between 1 and 2 if it does. So:
7871 Pick random @expr{x} and
7872 @texline @math{\theta},
7873 @infoline @expr{theta},
7875 @texline @math{x + \cos \theta},
7876 @infoline @expr{x + cos(theta)},
7877 and count how many of the results are greater than one. Simple!
7879 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7884 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72]
7885 . 1: [78.4, 64.5, ..., -42.9]
7888 v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 -
7893 (The next step may be slow, depending on the speed of your computer.)
7897 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45]
7898 1: [0.20, 0.43, ..., 0.73] .
7908 1: [0, 1, ..., 1] 1: 0.64 1: 3.125
7911 1 V M a > V R + 100 / 2 @key{TAB} /
7915 Let's try the third method, too. We'll use random integers up to
7916 one million. The @kbd{k r} command with an integer argument picks
7921 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975]
7922 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450]
7925 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r
7932 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56
7935 V M k g 1 V M a = V R + 100 /
7949 For a proof of this property of the GCD function, see section 4.5.2,
7950 exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
7952 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7953 return to full-sized display of vectors.
7955 @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
7956 @subsection List Tutorial Exercise 13
7959 First, we put the string on the stack as a vector of ASCII codes.
7963 1: [84, 101, 115, ..., 51]
7966 "Testing, 1, 2, 3 @key{RET}
7971 Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
7972 there was no need to type an apostrophe. Also, Calc didn't mind that
7973 we omitted the closing @kbd{"}. (The same goes for all closing delimiters
7974 like @kbd{)} and @kbd{]} at the end of a formula.
7976 We'll show two different approaches here. In the first, we note that
7977 if the input vector is @expr{[a, b, c, d]}, then the hash code is
7978 @expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words,
7979 it's a sum of descending powers of three times the ASCII codes.
7983 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51]
7984 1: 16 1: [15, 14, 13, ..., 0]
7987 @key{RET} v l v x 16 @key{RET} -
7994 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121
7995 1: [14348907, ..., 1] . .
7998 3 @key{TAB} V M ^ * 511 %
8003 Once again, @kbd{*} elegantly summarizes most of the computation.
8004 But there's an even more elegant approach: Reduce the formula
8005 @kbd{3 $$ + $} across the vector. Recall that this represents a
8006 function of two arguments that computes its first argument times three
8007 plus its second argument.
8011 1: [84, 101, 115, ..., 51] 1: 1960915098
8014 "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET}
8019 If you did the decimal arithmetic exercise, this will be familiar.
8020 Basically, we're turning a base-3 vector of digits into an integer,
8021 except that our ``digits'' are much larger than real digits.
8023 Instead of typing @kbd{511 %} again to reduce the result, we can be
8024 cleverer still and notice that rather than computing a huge integer
8025 and taking the modulo at the end, we can take the modulo at each step
8026 without affecting the result. While this means there are more
8027 arithmetic operations, the numbers we operate on remain small so
8028 the operations are faster.
8032 1: [84, 101, 115, ..., 51] 1: 121
8035 "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET}
8039 Why does this work? Think about a two-step computation:
8040 @w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means
8041 subtracting off enough 511's to put the result in the desired range.
8042 So the result when we take the modulo after every step is,
8046 3 (3 a + b - 511 m) + c - 511 n
8052 $$ 3 (3 a + b - 511 m) + c - 511 n $$
8057 for some suitable integers @expr{m} and @expr{n}. Expanding out by
8058 the distributive law yields
8062 9 a + 3 b + c - 511*3 m - 511 n
8068 $$ 9 a + 3 b + c - 511\times3 m - 511 n $$
8073 The @expr{m} term in the latter formula is redundant because any
8074 contribution it makes could just as easily be made by the @expr{n}
8075 term. So we can take it out to get an equivalent formula with
8080 9 a + 3 b + c - 511 n'
8086 $$ 9 a + 3 b + c - 511 n' $$
8091 which is just the formula for taking the modulo only at the end of
8092 the calculation. Therefore the two methods are essentially the same.
8094 Later in the tutorial we will encounter @dfn{modulo forms}, which
8095 basically automate the idea of reducing every intermediate result
8096 modulo some value @var{m}.
8098 @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
8099 @subsection List Tutorial Exercise 14
8101 We want to use @kbd{H V U} to nest a function which adds a random
8102 step to an @expr{(x,y)} coordinate. The function is a bit long, but
8103 otherwise the problem is quite straightforward.
8107 2: [0, 0] 1: [ [ 0, 0 ]
8108 1: 50 [ 0.4288, -0.1695 ]
8109 . [ -0.4787, -0.9027 ]
8112 [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
8116 Just as the text recommended, we used @samp{< >} nameless function
8117 notation to keep the two @code{random} calls from being evaluated
8118 before nesting even begins.
8120 We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's
8121 rules acts like a matrix. We can transpose this matrix and unpack
8122 to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing.
8126 2: [ 0, 0.4288, -0.4787, ... ]
8127 1: [ 0, -0.1696, -0.9027, ... ]
8134 Incidentally, because the @expr{x} and @expr{y} are completely
8135 independent in this case, we could have done two separate commands
8136 to create our @expr{x} and @expr{y} vectors of numbers directly.
8138 To make a random walk of unit steps, we note that @code{sincos} of
8139 a random direction exactly gives us an @expr{[x, y]} step of unit
8140 length; in fact, the new nesting function is even briefer, though
8141 we might want to lower the precision a bit for it.
8145 2: [0, 0] 1: [ [ 0, 0 ]
8146 1: 50 [ 0.1318, 0.9912 ]
8147 . [ -0.5965, 0.3061 ]
8150 [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET}
8154 Another @kbd{v t v u g f} sequence will graph this new random walk.
8156 An interesting twist on these random walk functions would be to use
8157 complex numbers instead of 2-vectors to represent points on the plane.
8158 In the first example, we'd use something like @samp{random + random*(0,1)},
8159 and in the second we could use polar complex numbers with random phase
8160 angles. (This exercise was first suggested in this form by Randal
8163 @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
8164 @subsection Types Tutorial Exercise 1
8167 If the number is the square root of @cpi{} times a rational number,
8168 then its square, divided by @cpi{}, should be a rational number.
8172 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627
8180 Technically speaking this is a rational number, but not one that is
8181 likely to have arisen in the original problem. More likely, it just
8182 happens to be the fraction which most closely represents some
8183 irrational number to within 12 digits.
8185 But perhaps our result was not quite exact. Let's reduce the
8186 precision slightly and try again:
8190 1: 0.509433962268 1: 27:53
8193 U p 10 @key{RET} c F
8198 Aha! It's unlikely that an irrational number would equal a fraction
8199 this simple to within ten digits, so our original number was probably
8200 @texline @math{\sqrt{27 \pi / 53}}.
8201 @infoline @expr{sqrt(27 pi / 53)}.
8203 Notice that we didn't need to re-round the number when we reduced the
8204 precision. Remember, arithmetic operations always round their inputs
8205 to the current precision before they begin.
8207 @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
8208 @subsection Types Tutorial Exercise 2
8211 @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer.
8212 But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
8214 @samp{exp(inf) = inf}. It's tempting to say that the exponential
8215 of infinity must be ``bigger'' than ``regular'' infinity, but as
8216 far as Calc is concerned all infinities are as just as big.
8217 In other words, as @expr{x} goes to infinity, @expr{e^x} also goes
8218 to infinity, but the fact the @expr{e^x} grows much faster than
8219 @expr{x} is not relevant here.
8221 @samp{exp(-inf) = 0}. Here we have a finite answer even though
8222 the input is infinite.
8224 @samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)}
8225 represents the imaginary number @expr{i}. Here's a derivation:
8226 @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
8227 The first part is, by definition, @expr{i}; the second is @code{inf}
8228 because, once again, all infinities are the same size.
8230 @samp{sqrt(uinf) = uinf}. In fact, we do know something about the
8231 direction because @code{sqrt} is defined to return a value in the
8232 right half of the complex plane. But Calc has no notation for this,
8233 so it settles for the conservative answer @code{uinf}.
8235 @samp{abs(uinf) = inf}. No matter which direction @expr{x} points,
8236 @samp{abs(x)} always points along the positive real axis.
8238 @samp{ln(0) = -inf}. Here we have an infinite answer to a finite
8239 input. As in the @expr{1 / 0} case, Calc will only use infinities
8240 here if you have turned on Infinite mode. Otherwise, it will
8241 treat @samp{ln(0)} as an error.
8243 @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
8244 @subsection Types Tutorial Exercise 3
8247 We can make @samp{inf - inf} be any real number we like, say,
8248 @expr{a}, just by claiming that we added @expr{a} to the first
8249 infinity but not to the second. This is just as true for complex
8250 values of @expr{a}, so @code{nan} can stand for a complex number.
8251 (And, similarly, @code{uinf} can stand for an infinity that points
8252 in any direction in the complex plane, such as @samp{(0, 1) inf}).
8254 In fact, we can multiply the first @code{inf} by two. Surely
8255 @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
8256 So @code{nan} can even stand for infinity. Obviously it's just
8257 as easy to make it stand for minus infinity as for plus infinity.
8259 The moral of this story is that ``infinity'' is a slippery fish
8260 indeed, and Calc tries to handle it by having a very simple model
8261 for infinities (only the direction counts, not the ``size''); but
8262 Calc is careful to write @code{nan} any time this simple model is
8263 unable to tell what the true answer is.
8265 @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
8266 @subsection Types Tutorial Exercise 4
8270 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765"
8274 0@@ 47' 26" @key{RET} 17 /
8279 The average song length is two minutes and 47.4 seconds.
8283 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005"
8292 The album would be 53 minutes and 6 seconds long.
8294 @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
8295 @subsection Types Tutorial Exercise 5
8298 Let's suppose it's January 14, 1991. The easiest thing to do is
8299 to keep trying 13ths of months until Calc reports a Friday.
8300 We can do this by manually entering dates, or by using @kbd{t I}:
8304 1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991>
8307 ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I
8312 (Calc assumes the current year if you don't say otherwise.)
8314 This is getting tedious---we can keep advancing the date by typing
8315 @kbd{t I} over and over again, but let's automate the job by using
8316 vector mapping. The @kbd{t I} command actually takes a second
8317 ``how-many-months'' argument, which defaults to one. This
8318 argument is exactly what we want to map over:
8322 2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
8323 1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
8324 . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
8327 v x 6 @key{RET} V M t I
8332 Et voil@`a, September 13, 1991 is a Friday.
8339 ' <sep 13> - <jan 14> @key{RET}
8344 And the answer to our original question: 242 days to go.
8346 @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
8347 @subsection Types Tutorial Exercise 6
8350 The full rule for leap years is that they occur in every year divisible
8351 by four, except that they don't occur in years divisible by 100, except
8352 that they @emph{do} in years divisible by 400. We could work out the
8353 answer by carefully counting the years divisible by four and the
8354 exceptions, but there is a much simpler way that works even if we
8355 don't know the leap year rule.
8357 Let's assume the present year is 1991. Years have 365 days, except
8358 that leap years (whenever they occur) have 366 days. So let's count
8359 the number of days between now and then, and compare that to the
8360 number of years times 365. The number of extra days we find must be
8361 equal to the number of leap years there were.
8365 1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593
8366 . 1: <Tue Jan 1, 1991> .
8369 ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} -
8376 3: 2925593 2: 2925593 2: 2925593 1: 1943
8377 2: 10001 1: 8010 1: 2923650 .
8381 10001 @key{RET} 1991 - 365 * -
8385 @c [fix-ref Date Forms]
8387 There will be 1943 leap years before the year 10001. (Assuming,
8388 of course, that the algorithm for computing leap years remains
8389 unchanged for that long. @xref{Date Forms}, for some interesting
8390 background information in that regard.)
8392 @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
8393 @subsection Types Tutorial Exercise 7
8396 The relative errors must be converted to absolute errors so that
8397 @samp{+/-} notation may be used.
8405 20 @key{RET} .05 * 4 @key{RET} .05 *
8409 Now we simply chug through the formula.
8413 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21
8416 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ *
8420 It turns out the @kbd{v u} command will unpack an error form as
8421 well as a vector. This saves us some retyping of numbers.
8425 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21
8430 @key{RET} v u @key{TAB} /
8435 Thus the volume is 6316 cubic centimeters, within about 11 percent.
8437 @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
8438 @subsection Types Tutorial Exercise 8
8441 The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}.
8442 Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
8443 close to zero, its reciprocal can get arbitrarily large, so the answer
8444 is an interval that effectively means, ``any number greater than 0.1''
8445 but with no upper bound.
8447 The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
8449 Calc normally treats division by zero as an error, so that the formula
8450 @w{@samp{1 / 0}} is left unsimplified. Our third problem,
8451 @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
8452 is now a member of the interval. So Calc leaves this one unevaluated, too.
8454 If you turn on Infinite mode by pressing @kbd{m i}, you will
8455 instead get the answer @samp{[0.1 .. inf]}, which includes infinity
8456 as a possible value.
8458 The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
8459 Zero is buried inside the interval, but it's still a possible value.
8460 It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
8461 will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus
8462 the interval goes from minus infinity to plus infinity, with a ``hole''
8463 in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to
8464 represent this, so it just reports @samp{[-inf .. inf]} as the answer.
8465 It may be disappointing to hear ``the answer lies somewhere between
8466 minus infinity and plus infinity, inclusive,'' but that's the best
8467 that interval arithmetic can do in this case.
8469 @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
8470 @subsection Types Tutorial Exercise 9
8474 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9]
8475 . 1: [0 .. 9] 1: [-9 .. 9]
8478 [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} *
8483 In the first case the result says, ``if a number is between @mathit{-3} and
8484 3, its square is between 0 and 9.'' The second case says, ``the product
8485 of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.''
8487 An interval form is not a number; it is a symbol that can stand for
8488 many different numbers. Two identical-looking interval forms can stand
8489 for different numbers.
8491 The same issue arises when you try to square an error form.
8493 @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
8494 @subsection Types Tutorial Exercise 10
8497 Testing the first number, we might arbitrarily choose 17 for @expr{x}.
8501 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613
8505 17 M 811749613 @key{RET} 811749612 ^
8510 Since 533694123 is (considerably) different from 1, the number 811749613
8513 It's awkward to type the number in twice as we did above. There are
8514 various ways to avoid this, and algebraic entry is one. In fact, using
8515 a vector mapping operation we can perform several tests at once. Let's
8516 use this method to test the second number.
8520 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ]
8524 [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET}
8529 The result is three ones (modulo @expr{n}), so it's very probable that
8530 15485863 is prime. (In fact, this number is the millionth prime.)
8532 Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
8533 would have been hopelessly inefficient, since they would have calculated
8534 the power using full integer arithmetic.
8536 Calc has a @kbd{k p} command that does primality testing. For small
8537 numbers it does an exact test; for large numbers it uses a variant
8538 of the Fermat test we used here. You can use @kbd{k p} repeatedly
8539 to prove that a large integer is prime with any desired probability.
8541 @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
8542 @subsection Types Tutorial Exercise 11
8545 There are several ways to insert a calculated number into an HMS form.
8546 One way to convert a number of seconds to an HMS form is simply to
8547 multiply the number by an HMS form representing one second:
8551 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359"
8562 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0"
8563 1: 15@@ 27' 16" mod 24@@ 0' 0" .
8571 It will be just after six in the morning.
8573 The algebraic @code{hms} function can also be used to build an
8578 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359"
8581 ' hms(0, 0, 1e7 pi) @key{RET} =
8586 The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
8587 the actual number 3.14159...
8589 @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
8590 @subsection Types Tutorial Exercise 12
8593 As we recall, there are 17 songs of about 2 minutes and 47 seconds
8598 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"]
8599 1: [0@@ 0' 20" .. 0@@ 1' 0"] .
8602 [ 0@@ 20" .. 0@@ 1' ] +
8609 1: [0@@ 52' 59." .. 1@@ 4' 19."]
8617 No matter how long it is, the album will fit nicely on one CD.
8619 @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
8620 @subsection Types Tutorial Exercise 13
8623 Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds.
8625 @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
8626 @subsection Types Tutorial Exercise 14
8629 How long will it take for a signal to get from one end of the computer
8634 1: m / c 1: 3.3356 ns
8637 ' 1 m / c @key{RET} u c ns @key{RET}
8642 (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
8646 1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356
8650 ' 4.1 ns @key{RET} / u s
8655 Thus a signal could take up to 81 percent of a clock cycle just to
8656 go from one place to another inside the computer, assuming the signal
8657 could actually attain the full speed of light. Pretty tight!
8659 @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
8660 @subsection Types Tutorial Exercise 15
8663 The speed limit is 55 miles per hour on most highways. We want to
8664 find the ratio of Sam's speed to the US speed limit.
8668 1: 55 mph 2: 55 mph 3: 11 hr mph / yd
8672 ' 55 mph @key{RET} ' 5 yd/hr @key{RET} /
8676 The @kbd{u s} command cancels out these units to get a plain
8677 number. Now we take the logarithm base two to find the final
8678 answer, assuming that each successive pill doubles his speed.
8682 1: 19360. 2: 19360. 1: 14.24
8691 Thus Sam can take up to 14 pills without a worry.
8693 @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
8694 @subsection Algebra Tutorial Exercise 1
8697 @c [fix-ref Declarations]
8698 The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the
8699 Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens
8700 if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be
8701 simplified to @samp{abs(x)}, but for general complex arguments even
8702 that is not safe. (@xref{Declarations}, for a way to tell Calc
8703 that @expr{x} is known to be real.)
8705 @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
8706 @subsection Algebra Tutorial Exercise 2
8709 Suppose our roots are @expr{[a, b, c]}. We want a polynomial which
8710 is zero when @expr{x} is any of these values. The trivial polynomial
8711 @expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)}
8712 will do the job. We can use @kbd{a c x} to write this in a more
8717 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0]
8727 1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x
8730 V M ' x-$ @key{RET} V R *
8737 1: x^3 - 1.41666 x 1: 34 x - 24 x^3
8740 a c x @key{RET} 24 n * a x
8745 Sure enough, our answer (multiplied by a suitable constant) is the
8746 same as the original polynomial.
8748 @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
8749 @subsection Algebra Tutorial Exercise 3
8753 1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2
8756 ' x sin(pi x) @key{RET} m r a i x @key{RET}
8764 2: (sin(pi x) - pi x cos(pi x)) / pi^2
8767 ' [y,1] @key{RET} @key{TAB}
8774 1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
8784 1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
8794 1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
8804 1: [0., -0.95493, 0.63662, -1.5915, 1.2732]
8807 v x 5 @key{RET} @key{TAB} V M $ @key{RET}
8811 @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
8812 @subsection Algebra Tutorial Exercise 4
8815 The hard part is that @kbd{V R +} is no longer sufficient to add up all
8816 the contributions from the slices, since the slices have varying
8817 coefficients. So first we must come up with a vector of these
8818 coefficients. Here's one way:
8822 2: -1 2: 3 1: [4, 2, ..., 4]
8823 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] .
8826 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} -
8833 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1]
8841 Now we compute the function values. Note that for this method we need
8842 eleven values, including both endpoints of the desired interval.
8846 2: [1, 4, 2, ..., 4, 1]
8847 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.]
8850 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
8857 2: [1, 4, 2, ..., 4, 1]
8858 1: [0., 0.084941, 0.16993, ... ]
8861 ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET}
8866 Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
8871 1: 11.22 1: 1.122 1: 0.374
8879 Wow! That's even better than the result from the Taylor series method.
8881 @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
8882 @subsection Rewrites Tutorial Exercise 1
8885 We'll use Big mode to make the formulas more readable.
8891 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: --------
8897 ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B
8902 Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}.
8907 1: (2 + V 2 ) (V 2 - 1)
8910 a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
8918 1: 2 + V 2 - 2 1: V 2
8921 a r a*(b+c) := a*b + a*c a s
8926 (We could have used @kbd{a x} instead of a rewrite rule for the
8929 The multiply-by-conjugate rule turns out to be useful in many
8930 different circumstances, such as when the denominator involves
8931 sines and cosines or the imaginary constant @code{i}.
8933 @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
8934 @subsection Rewrites Tutorial Exercise 2
8937 Here is the rule set:
8941 [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
8943 fib(n, x, y) := fib(n-1, y, x+y) ]
8948 The first rule turns a one-argument @code{fib} that people like to write
8949 into a three-argument @code{fib} that makes computation easier. The
8950 second rule converts back from three-argument form once the computation
8951 is done. The third rule does the computation itself. It basically
8952 says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers,
8953 then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci
8956 Notice that because the number @expr{n} was ``validated'' by the
8957 conditions on the first rule, there is no need to put conditions on
8958 the other rules because the rule set would never get that far unless
8959 the input were valid. That further speeds computation, since no
8960 extra conditions need to be checked at every step.
8962 Actually, a user with a nasty sense of humor could enter a bad
8963 three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
8964 which would get the rules into an infinite loop. One thing that would
8965 help keep this from happening by accident would be to use something like
8966 @samp{ZzFib} instead of @code{fib} as the name of the three-argument
8969 @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
8970 @subsection Rewrites Tutorial Exercise 3
8973 He got an infinite loop. First, Calc did as expected and rewrote
8974 @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to
8975 apply the rule again, and found that @samp{f(2, 3, x)} looks like
8976 @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
8977 @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)}
8978 around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r}
8979 to make sure the rule applied only once.
8981 (Actually, even the first step didn't work as he expected. What Calc
8982 really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
8983 treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
8984 to it. While this may seem odd, it's just as valid a solution as the
8985 ``obvious'' one. One way to fix this would be to add the condition
8986 @samp{:: variable(x)} to the rule, to make sure the thing that matches
8987 @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
8988 on the lefthand side, so that the rule matches the actual variable
8989 @samp{x} rather than letting @samp{x} stand for something else.)
8991 @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
8992 @subsection Rewrites Tutorial Exercise 4
8999 Here is a suitable set of rules to solve the first part of the problem:
9003 [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0,
9004 seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
9008 Given the initial formula @samp{seq(6, 0)}, application of these
9009 rules produces the following sequence of formulas:
9023 whereupon neither of the rules match, and rewriting stops.
9025 We can pretty this up a bit with a couple more rules:
9029 [ seq(n) := seq(n, 0),
9036 Now, given @samp{seq(6)} as the starting configuration, we get 8
9039 The change to return a vector is quite simple:
9043 [ seq(n) := seq(n, []) :: integer(n) :: n > 0,
9045 seq(n, v) := seq(n/2, v | n) :: n%2 = 0,
9046 seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
9051 Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
9053 Notice that the @expr{n > 1} guard is no longer necessary on the last
9054 rule since the @expr{n = 1} case is now detected by another rule.
9055 But a guard has been added to the initial rule to make sure the
9056 initial value is suitable before the computation begins.
9058 While still a good idea, this guard is not as vitally important as it
9059 was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
9060 will not get into an infinite loop. Calc will not be able to prove
9061 the symbol @samp{x} is either even or odd, so none of the rules will
9062 apply and the rewrites will stop right away.
9064 @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
9065 @subsection Rewrites Tutorial Exercise 5
9072 If @expr{x} is the sum @expr{a + b}, then `@t{nterms(}@var{x}@t{)}' must
9073 be `@t{nterms(}@var{a}@t{)}' plus `@t{nterms(}@var{b}@t{)}'. If @expr{x}
9074 is not a sum, then `@t{nterms(}@var{x}@t{)}' = 1.
9078 [ nterms(a + b) := nterms(a) + nterms(b),
9084 Here we have taken advantage of the fact that earlier rules always
9085 match before later rules; @samp{nterms(x)} will only be tried if we
9086 already know that @samp{x} is not a sum.
9088 @node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises
9089 @subsection Rewrites Tutorial Exercise 6
9092 Here is a rule set that will do the job:
9096 [ a*(b + c) := a*b + a*c,
9097 opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
9098 :: constant(a) :: constant(b),
9099 opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
9100 :: constant(a) :: constant(b),
9101 a O(x^n) := O(x^n) :: constant(a),
9102 x^opt(m) O(x^n) := O(x^(n+m)),
9103 O(x^n) O(x^m) := O(x^(n+m)) ]
9107 If we really want the @kbd{+} and @kbd{*} keys to operate naturally
9108 on power series, we should put these rules in @code{EvalRules}. For
9109 testing purposes, it is better to put them in a different variable,
9110 say, @code{O}, first.
9112 The first rule just expands products of sums so that the rest of the
9113 rules can assume they have an expanded-out polynomial to work with.
9114 Note that this rule does not mention @samp{O} at all, so it will
9115 apply to any product-of-sum it encounters---this rule may surprise
9116 you if you put it into @code{EvalRules}!
9118 In the second rule, the sum of two O's is changed to the smaller O.
9119 The optional constant coefficients are there mostly so that
9120 @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
9121 as well as @samp{O(x^2) + O(x^3)}.
9123 The third rule absorbs higher powers of @samp{x} into O's.
9125 The fourth rule says that a constant times a negligible quantity
9126 is still negligible. (This rule will also match @samp{O(x^3) / 4},
9127 with @samp{a = 1/4}.)
9129 The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
9130 (It is easy to see that if one of these forms is negligible, the other
9131 is, too.) Notice the @samp{x^opt(m)} to pick up terms like
9132 @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1}
9133 but not 1 as @samp{x^0}. This turns out to be exactly what we want here.
9135 The sixth rule is the corresponding rule for products of two O's.
9137 Another way to solve this problem would be to create a new ``data type''
9138 that represents truncated power series. We might represent these as
9139 function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
9140 a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so
9141 on. Rules would exist for sums and products of such @code{series}
9142 objects, and as an optional convenience could also know how to combine a
9143 @code{series} object with a normal polynomial. (With this, and with a
9144 rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
9145 you could still enter power series in exactly the same notation as
9146 before.) Operations on such objects would probably be more efficient,
9147 although the objects would be a bit harder to read.
9149 @c [fix-ref Compositions]
9150 Some other symbolic math programs provide a power series data type
9151 similar to this. Mathematica, for example, has an object that looks
9152 like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
9153 @var{nmax}, @var{den}]}, where @var{x0} is the point about which the
9154 power series is taken (we've been assuming this was always zero),
9155 and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
9156 with fractional or negative powers. Also, the @code{PowerSeries}
9157 objects have a special display format that makes them look like
9158 @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions},
9159 for a way to do this in Calc, although for something as involved as
9160 this it would probably be better to write the formatting routine
9163 @node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises
9164 @subsection Programming Tutorial Exercise 1
9167 Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
9168 @kbd{Z F}, and answer the questions. Since this formula contains two
9169 variables, the default argument list will be @samp{(t x)}. We want to
9170 change this to @samp{(x)} since @expr{t} is really a dummy variable
9171 to be used within @code{ninteg}.
9173 The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
9174 (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
9176 @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
9177 @subsection Programming Tutorial Exercise 2
9180 One way is to move the number to the top of the stack, operate on
9181 it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
9183 Another way is to negate the top three stack entries, then negate
9184 again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}.
9186 Finally, it turns out that a negative prefix argument causes a
9187 command like @kbd{n} to operate on the specified stack entry only,
9188 which is just what we want: @kbd{C-x ( M-- 3 n C-x )}.
9190 Just for kicks, let's also do it algebraically:
9191 @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
9193 @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
9194 @subsection Programming Tutorial Exercise 3
9197 Each of these functions can be computed using the stack, or using
9198 algebraic entry, whichever way you prefer:
9202 @texline @math{\displaystyle{\sin x \over x}}:
9203 @infoline @expr{sin(x) / x}:
9205 Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}.
9207 Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}.
9210 Computing the logarithm:
9212 Using the stack: @kbd{C-x ( @key{TAB} B C-x )}
9214 Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}.
9217 Computing the vector of integers:
9219 Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that
9220 @kbd{C-u v x} takes the vector size, starting value, and increment
9223 Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a
9224 number from the stack and uses it as the prefix argument for the
9227 Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}.
9229 @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
9230 @subsection Programming Tutorial Exercise 4
9233 Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
9235 @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
9236 @subsection Programming Tutorial Exercise 5
9240 2: 1 1: 1.61803398502 2: 1.61803398502
9241 1: 20 . 1: 1.61803398875
9244 1 @key{RET} 20 Z < & 1 + Z > I H P
9249 This answer is quite accurate.
9251 @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
9252 @subsection Programming Tutorial Exercise 6
9258 [ [ 0, 1 ] * [a, b] = [b, a + b]
9263 Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1}
9264 and @expr{n+2}. Here's one program that does the job:
9267 C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
9271 This program is quite efficient because Calc knows how to raise a
9272 matrix (or other value) to the power @expr{n} in only
9273 @texline @math{\log_2 n}
9274 @infoline @expr{log(n,2)}
9275 steps. For example, this program can compute the 1000th Fibonacci
9276 number (a 209-digit integer!) in about 10 steps; even though the
9277 @kbd{Z < ... Z >} solution had much simpler steps, it would have
9278 required so many steps that it would not have been practical.
9280 @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
9281 @subsection Programming Tutorial Exercise 7
9284 The trick here is to compute the harmonic numbers differently, so that
9285 the loop counter itself accumulates the sum of reciprocals. We use
9286 a separate variable to hold the integer counter.
9294 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z )
9299 The body of the loop goes as follows: First save the harmonic sum
9300 so far in variable 2. Then delete it from the stack; the for loop
9301 itself will take care of remembering it for us. Next, recall the
9302 count from variable 1, add one to it, and feed its reciprocal to
9303 the for loop to use as the step value. The for loop will increase
9304 the ``loop counter'' by that amount and keep going until the
9305 loop counter exceeds 4.
9310 1: 3.99498713092 2: 3.99498713092
9314 r 1 r 2 @key{RET} 31 & +
9318 Thus we find that the 30th harmonic number is 3.99, and the 31st
9319 harmonic number is 4.02.
9321 @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
9322 @subsection Programming Tutorial Exercise 8
9325 The first step is to compute the derivative @expr{f'(x)} and thus
9327 @texline @math{\displaystyle{x - {f(x) \over f'(x)}}}.
9328 @infoline @expr{x - f(x)/f'(x)}.
9330 (Because this definition is long, it will be repeated in concise form
9331 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9332 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9333 keystrokes without executing them. In the following diagrams we'll
9334 pretend Calc actually executed the keystrokes as you typed them,
9335 just for purposes of illustration.)
9339 2: sin(cos(x)) - 0.5 3: 4.5
9340 1: 4.5 2: sin(cos(x)) - 0.5
9341 . 1: -(sin(x) cos(cos(x)))
9344 ' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET}
9352 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
9355 / ' x @key{RET} @key{TAB} - t 1
9359 Now, we enter the loop. We'll use a repeat loop with a 20-repetition
9360 limit just in case the method fails to converge for some reason.
9361 (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
9362 repetitions are done.)
9366 1: 4.5 3: 4.5 2: 4.5
9367 . 2: x + (sin(cos(x)) ... 1: 5.24196456928
9371 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9375 This is the new guess for @expr{x}. Now we compare it with the
9376 old one to see if we've converged.
9380 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348
9385 @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x )
9389 The loop converges in just a few steps to this value. To check
9390 the result, we can simply substitute it back into the equation.
9398 @key{RET} ' sin(cos($)) @key{RET}
9402 Let's test the new definition again:
9410 ' x^2-9 @key{RET} 1 X
9414 Once again, here's the full Newton's Method definition:
9418 C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1
9419 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9420 @key{RET} M-@key{TAB} a = Z /
9427 @c [fix-ref Nesting and Fixed Points]
9428 It turns out that Calc has a built-in command for applying a formula
9429 repeatedly until it converges to a number. @xref{Nesting and Fixed Points},
9430 to see how to use it.
9432 @c [fix-ref Root Finding]
9433 Also, of course, @kbd{a R} is a built-in command that uses Newton's
9434 method (among others) to look for numerical solutions to any equation.
9435 @xref{Root Finding}.
9437 @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
9438 @subsection Programming Tutorial Exercise 9
9441 The first step is to adjust @expr{z} to be greater than 5. A simple
9442 ``for'' loop will do the job here. If @expr{z} is less than 5, we
9443 reduce the problem using
9444 @texline @math{\psi(z) = \psi(z+1) - 1/z}.
9445 @infoline @expr{psi(z) = psi(z+1) - 1/z}. We go
9447 @texline @math{\psi(z+1)},
9448 @infoline @expr{psi(z+1)},
9449 and remember to add back a factor of @expr{-1/z} when we're done. This
9450 step is repeated until @expr{z > 5}.
9452 (Because this definition is long, it will be repeated in concise form
9453 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9454 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9455 keystrokes without executing them. In the following diagrams we'll
9456 pretend Calc actually executed the keystrokes as you typed them,
9457 just for purposes of illustration.)
9464 1.0 @key{RET} C-x ( Z ` s 1 0 t 2
9468 Here, variable 1 holds @expr{z} and variable 2 holds the adjustment
9469 factor. If @expr{z < 5}, we use a loop to increase it.
9471 (By the way, we started with @samp{1.0} instead of the integer 1 because
9472 otherwise the calculation below will try to do exact fractional arithmetic,
9473 and will never converge because fractions compare equal only if they
9474 are exactly equal, not just equal to within the current precision.)
9483 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9487 Now we compute the initial part of the sum:
9488 @texline @math{\ln z - {1 \over 2z}}
9489 @infoline @expr{ln(z) - 1/2z}
9490 minus the adjustment factor.
9494 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743
9495 1: 0.0833333333333 1: 2.28333333333 .
9502 Now we evaluate the series. We'll use another ``for'' loop counting
9503 up the value of @expr{2 n}. (Calc does have a summation command,
9504 @kbd{a +}, but we'll use loops just to get more practice with them.)
9508 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749
9509 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3
9514 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9521 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892
9522 2: -0.5749 2: -0.5772 1: 0 .
9523 1: 2.3148e-3 1: -0.5749 .
9526 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x )
9530 This is the value of
9531 @texline @math{-\gamma},
9532 @infoline @expr{- gamma},
9533 with a slight bit of roundoff error. To get a full 12 digits, let's use
9538 2: -0.577215664892 2: -0.577215664892
9539 1: 1. 1: -0.577215664901532
9541 1. @key{RET} p 16 @key{RET} X
9545 Here's the complete sequence of keystrokes:
9550 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9552 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9553 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
9560 @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
9561 @subsection Programming Tutorial Exercise 10
9564 Taking the derivative of a term of the form @expr{x^n} will produce
9566 @texline @math{n x^{n-1}}.
9567 @infoline @expr{n x^(n-1)}.
9568 Taking the derivative of a constant
9569 produces zero. From this it is easy to see that the @expr{n}th
9570 derivative of a polynomial, evaluated at @expr{x = 0}, will equal the
9571 coefficient on the @expr{x^n} term times @expr{n!}.
9573 (Because this definition is long, it will be repeated in concise form
9574 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9575 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9576 keystrokes without executing them. In the following diagrams we'll
9577 pretend Calc actually executed the keystrokes as you typed them,
9578 just for purposes of illustration.)
9582 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2
9587 ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB}
9592 Variable 1 will accumulate the vector of coefficients.
9596 2: 0 3: 0 2: 5 x^4 + ...
9597 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1
9601 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9606 Note that @kbd{s | 1} appends the top-of-stack value to the vector
9607 in a variable; it is completely analogous to @kbd{s + 1}. We could
9608 have written instead, @kbd{r 1 @key{TAB} | t 1}.
9612 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0]
9615 a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x )
9619 To convert back, a simple method is just to map the coefficients
9620 against a table of powers of @expr{x}.
9624 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0]
9625 1: 6 1: [0, 1, 2, 3, 4, 5, 6]
9628 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x
9635 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4
9636 1: [1, x, x^2, x^3, ... ] .
9639 ' x @key{RET} @key{TAB} V M ^ *
9643 Once again, here are the whole polynomial to/from vector programs:
9647 C-x ( Z ` [ ] t 1 0 @key{TAB}
9648 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9654 C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x )
9658 @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
9659 @subsection Programming Tutorial Exercise 11
9662 First we define a dummy program to go on the @kbd{z s} key. The true
9663 @w{@kbd{z s}} key is supposed to take two numbers from the stack and
9664 return one number, so @key{DEL} as a dummy definition will make
9665 sure the stack comes out right.
9673 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2
9677 The last step replaces the 2 that was eaten during the creation
9678 of the dummy @kbd{z s} command. Now we move on to the real
9679 definition. The recurrence needs to be rewritten slightly,
9680 to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
9682 (Because this definition is long, it will be repeated in concise form
9683 below. You can use @kbd{M-# m} to load it from there.)
9693 C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z :
9700 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3
9701 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2
9702 2: 2 . . 2: 3 2: 3 1: 3
9706 @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9711 (Note that the value 3 that our dummy @kbd{z s} produces is not correct;
9712 it is merely a placeholder that will do just as well for now.)
9716 3: 3 4: 3 3: 3 2: 3 1: -6
9717 2: 3 3: 3 2: 3 1: 9 .
9722 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9729 1: -6 2: 4 1: 11 2: 11
9733 Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s
9737 Even though the result that we got during the definition was highly
9738 bogus, once the definition is complete the @kbd{z s} command gets
9741 Here's the full program once again:
9745 C-x ( M-2 @key{RET} a =
9746 Z [ @key{DEL} @key{DEL} 1
9748 Z [ @key{DEL} @key{DEL} 0
9749 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9750 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9757 You can read this definition using @kbd{M-# m} (@code{read-kbd-macro})
9758 followed by @kbd{Z K s}, without having to make a dummy definition
9759 first, because @code{read-kbd-macro} doesn't need to execute the
9760 definition as it reads it in. For this reason, @code{M-# m} is often
9761 the easiest way to create recursive programs in Calc.
9763 @node Programming Answer 12, , Programming Answer 11, Answers to Exercises
9764 @subsection Programming Tutorial Exercise 12
9767 This turns out to be a much easier way to solve the problem. Let's
9768 denote Stirling numbers as calls of the function @samp{s}.
9770 First, we store the rewrite rules corresponding to the definition of
9771 Stirling numbers in a convenient variable:
9774 s e StirlingRules @key{RET}
9775 [ s(n,n) := 1 :: n >= 0,
9776 s(n,0) := 0 :: n > 0,
9777 s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
9781 Now, it's just a matter of applying the rules:
9785 2: 4 1: s(4, 2) 1: 11
9789 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x )
9793 As in the case of the @code{fib} rules, it would be useful to put these
9794 rules in @code{EvalRules} and to add a @samp{:: remember} condition to
9797 @c This ends the table-of-contents kludge from above:
9799 \global\let\chapternofonts=\oldchapternofonts
9804 @node Introduction, Data Types, Tutorial, Top
9805 @chapter Introduction
9808 This chapter is the beginning of the Calc reference manual.
9809 It covers basic concepts such as the stack, algebraic and
9810 numeric entry, undo, numeric prefix arguments, etc.
9813 @c (Chapter 2, the Tutorial, has been printed in a separate volume.)
9821 * Quick Calculator::
9823 * Prefix Arguments::
9826 * Multiple Calculators::
9827 * Troubleshooting Commands::
9830 @node Basic Commands, Help Commands, Introduction, Introduction
9831 @section Basic Commands
9836 @cindex Starting the Calculator
9837 @cindex Running the Calculator
9838 To start the Calculator in its standard interface, type @kbd{M-x calc}.
9839 By default this creates a pair of small windows, @samp{*Calculator*}
9840 and @samp{*Calc Trail*}. The former displays the contents of the
9841 Calculator stack and is manipulated exclusively through Calc commands.
9842 It is possible (though not usually necessary) to create several Calc
9843 mode buffers each of which has an independent stack, undo list, and
9844 mode settings. There is exactly one Calc Trail buffer; it records a
9845 list of the results of all calculations that have been done. The
9846 Calc Trail buffer uses a variant of Calc mode, so Calculator commands
9847 still work when the trail buffer's window is selected. It is possible
9848 to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
9849 still exists and is updated silently. @xref{Trail Commands}.
9857 In most installations, the @kbd{M-# c} key sequence is a more
9858 convenient way to start the Calculator. Also, @kbd{M-# M-#} and
9859 @kbd{M-# #} are synonyms for @kbd{M-# c} unless you last used Calc
9864 @pindex calc-execute-extended-command
9865 Most Calc commands use one or two keystrokes. Lower- and upper-case
9866 letters are distinct. Commands may also be entered in full @kbd{M-x} form;
9867 for some commands this is the only form. As a convenience, the @kbd{x}
9868 key (@code{calc-execute-extended-command})
9869 is like @kbd{M-x} except that it enters the initial string @samp{calc-}
9870 for you. For example, the following key sequences are equivalent:
9871 @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.
9873 @cindex Extensions module
9874 @cindex @file{calc-ext} module
9875 The Calculator exists in many parts. When you type @kbd{M-# c}, the
9876 Emacs ``auto-load'' mechanism will bring in only the first part, which
9877 contains the basic arithmetic functions. The other parts will be
9878 auto-loaded the first time you use the more advanced commands like trig
9879 functions or matrix operations. This is done to improve the response time
9880 of the Calculator in the common case when all you need to do is a
9881 little arithmetic. If for some reason the Calculator fails to load an
9882 extension module automatically, you can force it to load all the
9883 extensions by using the @kbd{M-# L} (@code{calc-load-everything})
9884 command. @xref{Mode Settings}.
9886 If you type @kbd{M-x calc} or @kbd{M-# c} with any numeric prefix argument,
9887 the Calculator is loaded if necessary, but it is not actually started.
9888 If the argument is positive, the @file{calc-ext} extensions are also
9889 loaded if necessary. User-written Lisp code that wishes to make use
9890 of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
9891 to auto-load the Calculator.
9895 If you type @kbd{M-# b}, then next time you use @kbd{M-# c} you
9896 will get a Calculator that uses the full height of the Emacs screen.
9897 When full-screen mode is on, @kbd{M-# c} runs the @code{full-calc}
9898 command instead of @code{calc}. From the Unix shell you can type
9899 @samp{emacs -f full-calc} to start a new Emacs specifically for use
9900 as a calculator. When Calc is started from the Emacs command line
9901 like this, Calc's normal ``quit'' commands actually quit Emacs itself.
9904 @pindex calc-other-window
9905 The @kbd{M-# o} command is like @kbd{M-# c} except that the Calc
9906 window is not actually selected. If you are already in the Calc
9907 window, @kbd{M-# o} switches you out of it. (The regular Emacs
9908 @kbd{C-x o} command would also work for this, but it has a
9909 tendency to drop you into the Calc Trail window instead, which
9910 @kbd{M-# o} takes care not to do.)
9915 For one quick calculation, you can type @kbd{M-# q} (@code{quick-calc})
9916 which prompts you for a formula (like @samp{2+3/4}). The result is
9917 displayed at the bottom of the Emacs screen without ever creating
9918 any special Calculator windows. @xref{Quick Calculator}.
9923 Finally, if you are using the X window system you may want to try
9924 @kbd{M-# k} (@code{calc-keypad}) which runs Calc with a
9925 ``calculator keypad'' picture as well as a stack display. Click on
9926 the keys with the mouse to operate the calculator. @xref{Keypad Mode}.
9930 @cindex Quitting the Calculator
9931 @cindex Exiting the Calculator
9932 The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the
9933 Calculator's window(s). It does not delete the Calculator buffers.
9934 If you type @kbd{M-x calc} again, the Calculator will reappear with the
9935 contents of the stack intact. Typing @kbd{M-# c} or @kbd{M-# M-#}
9936 again from inside the Calculator buffer is equivalent to executing
9937 @code{calc-quit}; you can think of @kbd{M-# M-#} as toggling the
9938 Calculator on and off.
9941 The @kbd{M-# x} command also turns the Calculator off, no matter which
9942 user interface (standard, Keypad, or Embedded) is currently active.
9943 It also cancels @code{calc-edit} mode if used from there.
9946 @pindex calc-refresh
9947 @cindex Refreshing a garbled display
9948 @cindex Garbled displays, refreshing
9949 The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
9950 of the Calculator buffer from memory. Use this if the contents of the
9951 buffer have been damaged somehow.
9956 The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
9957 ``home'' position at the bottom of the Calculator buffer.
9961 @pindex calc-scroll-left
9962 @pindex calc-scroll-right
9963 @cindex Horizontal scrolling
9965 @cindex Wide text, scrolling
9966 The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
9967 @code{calc-scroll-right}. These are just like the normal horizontal
9968 scrolling commands except that they scroll one half-screen at a time by
9969 default. (Calc formats its output to fit within the bounds of the
9970 window whenever it can.)
9974 @pindex calc-scroll-down
9975 @pindex calc-scroll-up
9976 @cindex Vertical scrolling
9977 The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
9978 and @code{calc-scroll-up}. They scroll up or down by one-half the
9979 height of the Calc window.
9983 The @kbd{M-# 0} command (@code{calc-reset}; that's @kbd{M-#} followed
9984 by a zero) resets the Calculator to its default state. This clears
9985 the stack, resets all the modes, clears the caches (@pxref{Caches}),
9986 and so on. (It does @emph{not} erase the values of any variables.)
9987 With a numeric prefix argument, @kbd{M-# 0} preserves the contents
9988 of the stack but resets everything else.
9990 @pindex calc-version
9991 The @kbd{M-x calc-version} command displays the current version number
9992 of Calc and the name of the person who installed it on your system.
9993 (This information is also present in the @samp{*Calc Trail*} buffer,
9994 and in the output of the @kbd{h h} command.)
9996 @node Help Commands, Stack Basics, Basic Commands, Introduction
9997 @section Help Commands
10000 @cindex Help commands
10003 The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
10004 Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
10005 @key{ESC} and @kbd{C-x} prefixes. You can type
10006 @kbd{?} after a prefix to see a list of commands beginning with that
10007 prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again
10008 to see additional commands for that prefix.)
10011 @pindex calc-full-help
10012 The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
10013 responses at once. When printed, this makes a nice, compact (three pages)
10014 summary of Calc keystrokes.
10016 In general, the @kbd{h} key prefix introduces various commands that
10017 provide help within Calc. Many of the @kbd{h} key functions are
10018 Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
10024 The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
10025 to read this manual on-line. This is basically the same as typing
10026 @kbd{C-h i} (the regular way to run the Info system), then, if Info
10027 is not already in the Calc manual, selecting the beginning of the
10028 manual. The @kbd{M-# i} command is another way to read the Calc
10029 manual; it is different from @kbd{h i} in that it works any time,
10030 not just inside Calc. The plain @kbd{i} key is also equivalent to
10031 @kbd{h i}, though this key is obsolete and may be replaced with a
10032 different command in a future version of Calc.
10036 @pindex calc-tutorial
10037 The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
10038 the Tutorial section of the Calc manual. It is like @kbd{h i},
10039 except that it selects the starting node of the tutorial rather
10040 than the beginning of the whole manual. (It actually selects the
10041 node ``Interactive Tutorial'' which tells a few things about
10042 using the Info system before going on to the actual tutorial.)
10043 The @kbd{M-# t} key is equivalent to @kbd{h t} (but it works at
10048 @pindex calc-info-summary
10049 The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
10050 on the Summary node of the Calc manual. @xref{Summary}. The @kbd{M-# s}
10051 key is equivalent to @kbd{h s}.
10054 @pindex calc-describe-key
10055 The @kbd{h k} (@code{calc-describe-key}) command looks up a key
10056 sequence in the Calc manual. For example, @kbd{h k H a S} looks
10057 up the documentation on the @kbd{H a S} (@code{calc-solve-for})
10058 command. This works by looking up the textual description of
10059 the key(s) in the Key Index of the manual, then jumping to the
10060 node indicated by the index.
10062 Most Calc commands do not have traditional Emacs documentation
10063 strings, since the @kbd{h k} command is both more convenient and
10064 more instructive. This means the regular Emacs @kbd{C-h k}
10065 (@code{describe-key}) command will not be useful for Calc keystrokes.
10068 @pindex calc-describe-key-briefly
10069 The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
10070 key sequence and displays a brief one-line description of it at
10071 the bottom of the screen. It looks for the key sequence in the
10072 Summary node of the Calc manual; if it doesn't find the sequence
10073 there, it acts just like its regular Emacs counterpart @kbd{C-h c}
10074 (@code{describe-key-briefly}). For example, @kbd{h c H a S}
10075 gives the description:
10078 H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes)
10082 which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
10083 takes a value @expr{a} from the stack, prompts for a value @expr{v},
10084 then applies the algebraic function @code{fsolve} to these values.
10085 The @samp{?=notes} message means you can now type @kbd{?} to see
10086 additional notes from the summary that apply to this command.
10089 @pindex calc-describe-function
10090 The @kbd{h f} (@code{calc-describe-function}) command looks up an
10091 algebraic function or a command name in the Calc manual. Enter an
10092 algebraic function name to look up that function in the Function
10093 Index or enter a command name beginning with @samp{calc-} to look it
10094 up in the Command Index. This command will also look up operator
10095 symbols that can appear in algebraic formulas, like @samp{%} and
10099 @pindex calc-describe-variable
10100 The @kbd{h v} (@code{calc-describe-variable}) command looks up a
10101 variable in the Calc manual. Enter a variable name like @code{pi} or
10102 @code{PlotRejects}.
10105 @pindex describe-bindings
10106 The @kbd{h b} (@code{calc-describe-bindings}) command is just like
10107 @kbd{C-h b}, except that only local (Calc-related) key bindings are
10111 The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
10112 the ``news'' or change history of Calc. This is kept in the file
10113 @file{README}, which Calc looks for in the same directory as the Calc
10119 The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
10120 distribution, and warranty information about Calc. These work by
10121 pulling up the appropriate parts of the ``Copying'' or ``Reporting
10122 Bugs'' sections of the manual.
10124 @node Stack Basics, Numeric Entry, Help Commands, Introduction
10125 @section Stack Basics
10128 @cindex Stack basics
10129 @c [fix-tut RPN Calculations and the Stack]
10130 Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN
10133 To add the numbers 1 and 2 in Calc you would type the keys:
10134 @kbd{1 @key{RET} 2 +}.
10135 (@key{RET} corresponds to the @key{ENTER} key on most calculators.)
10136 The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The
10137 @kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
10138 and pushes the result (3) back onto the stack. This number is ready for
10139 further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the
10140 3 and 5, subtracts them, and pushes the result (@mathit{-2}).
10142 Note that the ``top'' of the stack actually appears at the @emph{bottom}
10143 of the buffer. A line containing a single @samp{.} character signifies
10144 the end of the buffer; Calculator commands operate on the number(s)
10145 directly above this line. The @kbd{d t} (@code{calc-truncate-stack})
10146 command allows you to move the @samp{.} marker up and down in the stack;
10147 @pxref{Truncating the Stack}.
10150 @pindex calc-line-numbering
10151 Stack elements are numbered consecutively, with number 1 being the top of
10152 the stack. These line numbers are ordinarily displayed on the lefthand side
10153 of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls
10154 whether these numbers appear. (Line numbers may be turned off since they
10155 slow the Calculator down a bit and also clutter the display.)
10158 @pindex calc-realign
10159 The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
10160 the cursor to its top-of-stack ``home'' position. It also undoes any
10161 horizontal scrolling in the window. If you give it a numeric prefix
10162 argument, it instead moves the cursor to the specified stack element.
10164 The @key{RET} (or equivalent @key{SPC}) key is only required to separate
10165 two consecutive numbers.
10166 (After all, if you typed @kbd{1 2} by themselves the Calculator
10167 would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not}
10168 right after typing a number, the key duplicates the number on the top of
10169 the stack. @kbd{@key{RET} *} is thus a handy way to square a number.
10171 The @key{DEL} key pops and throws away the top number on the stack.
10172 The @key{TAB} key swaps the top two objects on the stack.
10173 @xref{Stack and Trail}, for descriptions of these and other stack-related
10176 @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
10177 @section Numeric Entry
10183 @cindex Numeric entry
10184 @cindex Entering numbers
10185 Pressing a digit or other numeric key begins numeric entry using the
10186 minibuffer. The number is pushed on the stack when you press the @key{RET}
10187 or @key{SPC} keys. If you press any other non-numeric key, the number is
10188 pushed onto the stack and the appropriate operation is performed. If
10189 you press a numeric key which is not valid, the key is ignored.
10191 @cindex Minus signs
10192 @cindex Negative numbers, entering
10194 There are three different concepts corresponding to the word ``minus,''
10195 typified by @expr{a-b} (subtraction), @expr{-x}
10196 (change-sign), and @expr{-5} (negative number). Calc uses three
10197 different keys for these operations, respectively:
10198 @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts
10199 the two numbers on the top of the stack. The @kbd{n} key changes the sign
10200 of the number on the top of the stack or the number currently being entered.
10201 The @kbd{_} key begins entry of a negative number or changes the sign of
10202 the number currently being entered. The following sequences all enter the
10203 number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
10204 @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.
10206 Some other keys are active during numeric entry, such as @kbd{#} for
10207 non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
10208 These notations are described later in this manual with the corresponding
10209 data types. @xref{Data Types}.
10211 During numeric entry, the only editing key available is @key{DEL}.
10213 @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
10214 @section Algebraic Entry
10218 @pindex calc-algebraic-entry
10219 @cindex Algebraic notation
10220 @cindex Formulas, entering
10221 Calculations can also be entered in algebraic form. This is accomplished
10222 by typing the apostrophe key, @kbd{'}, followed by the expression in
10223 standard format: @kbd{@key{'} 2+3*4 @key{RET}} computes
10224 @texline @math{2+(3\times4) = 14}
10225 @infoline @expr{2+(3*4) = 14}
10226 and pushes that on the stack. If you wish you can
10227 ignore the RPN aspect of Calc altogether and simply enter algebraic
10228 expressions in this way. You may want to use @key{DEL} every so often to
10229 clear previous results off the stack.
10231 You can press the apostrophe key during normal numeric entry to switch
10232 the half-entered number into Algebraic entry mode. One reason to do this
10233 would be to use the full Emacs cursor motion and editing keys, which are
10234 available during algebraic entry but not during numeric entry.
10236 In the same vein, during either numeric or algebraic entry you can
10237 press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
10238 you complete your half-finished entry in a separate buffer.
10239 @xref{Editing Stack Entries}.
10242 @pindex calc-algebraic-mode
10243 @cindex Algebraic Mode
10244 If you prefer algebraic entry, you can use the command @kbd{m a}
10245 (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode,
10246 digits and other keys that would normally start numeric entry instead
10247 start full algebraic entry; as long as your formula begins with a digit
10248 you can omit the apostrophe. Open parentheses and square brackets also
10249 begin algebraic entry. You can still do RPN calculations in this mode,
10250 but you will have to press @key{RET} to terminate every number:
10251 @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
10252 thing as @kbd{2*3+4 @key{RET}}.
10254 @cindex Incomplete Algebraic Mode
10255 If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
10256 command, it enables Incomplete Algebraic mode; this is like regular
10257 Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
10258 only. Numeric keys still begin a numeric entry in this mode.
10261 @pindex calc-total-algebraic-mode
10262 @cindex Total Algebraic Mode
10263 The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
10264 stronger algebraic-entry mode, in which @emph{all} regular letter and
10265 punctuation keys begin algebraic entry. Use this if you prefer typing
10266 @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
10267 @kbd{a f}, and so on. To type regular Calc commands when you are in
10268 Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q}
10269 is the command to quit Calc, @kbd{M-p} sets the precision, and
10270 @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic
10271 mode back off again. Meta keys also terminate algebraic entry, so
10272 that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol
10273 @samp{Alg*} will appear in the mode line whenever you are in this mode.
10275 Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
10276 algebraic formula. You can then use the normal Emacs editing keys to
10277 modify this formula to your liking before pressing @key{RET}.
10280 @cindex Formulas, referring to stack
10281 Within a formula entered from the keyboard, the symbol @kbd{$}
10282 represents the number on the top of the stack. If an entered formula
10283 contains any @kbd{$} characters, the Calculator replaces the top of
10284 stack with that formula rather than simply pushing the formula onto the
10285 stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
10286 @key{RET}} replaces it with 6. Note that the @kbd{$} key always
10287 initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
10288 first character in the new formula.
10290 Higher stack elements can be accessed from an entered formula with the
10291 symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements
10292 removed (to be replaced by the entered values) equals the number of dollar
10293 signs in the longest such symbol in the formula. For example, @samp{$$+$$$}
10294 adds the second and third stack elements, replacing the top three elements
10295 with the answer. (All information about the top stack element is thus lost
10296 since no single @samp{$} appears in this formula.)
10298 A slightly different way to refer to stack elements is with a dollar
10299 sign followed by a number: @samp{$1}, @samp{$2}, and so on are much
10300 like @samp{$}, @samp{$$}, etc., except that stack entries referred
10301 to numerically are not replaced by the algebraic entry. That is, while
10302 @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
10303 on the stack and pushes an additional 6.
10305 If a sequence of formulas are entered separated by commas, each formula
10306 is pushed onto the stack in turn. For example, @samp{1,2,3} pushes
10307 those three numbers onto the stack (leaving the 3 at the top), and
10308 @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also,
10309 @samp{$,$$} exchanges the top two elements of the stack, just like the
10312 You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
10313 of @key{RET}. This uses @kbd{=} to evaluate the variables in each
10314 formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes
10315 the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
10317 If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
10318 instead of @key{RET}, Calc disables the default simplifications
10319 (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
10320 is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3
10321 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2};
10322 you might then press @kbd{=} when it is time to evaluate this formula.
10324 @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
10325 @section ``Quick Calculator'' Mode
10330 @cindex Quick Calculator
10331 There is another way to invoke the Calculator if all you need to do
10332 is make one or two quick calculations. Type @kbd{M-# q} (or
10333 @kbd{M-x quick-calc}), then type any formula as an algebraic entry.
10334 The Calculator will compute the result and display it in the echo
10335 area, without ever actually putting up a Calc window.
10337 You can use the @kbd{$} character in a Quick Calculator formula to
10338 refer to the previous Quick Calculator result. Older results are
10339 not retained; the Quick Calculator has no effect on the full
10340 Calculator's stack or trail. If you compute a result and then
10341 forget what it was, just run @code{M-# q} again and enter
10342 @samp{$} as the formula.
10344 If this is the first time you have used the Calculator in this Emacs
10345 session, the @kbd{M-# q} command will create the @code{*Calculator*}
10346 buffer and perform all the usual initializations; it simply will
10347 refrain from putting that buffer up in a new window. The Quick
10348 Calculator refers to the @code{*Calculator*} buffer for all mode
10349 settings. Thus, for example, to set the precision that the Quick
10350 Calculator uses, simply run the full Calculator momentarily and use
10351 the regular @kbd{p} command.
10353 If you use @code{M-# q} from inside the Calculator buffer, the
10354 effect is the same as pressing the apostrophe key (algebraic entry).
10356 The result of a Quick calculation is placed in the Emacs ``kill ring''
10357 as well as being displayed. A subsequent @kbd{C-y} command will
10358 yank the result into the editing buffer. You can also use this
10359 to yank the result into the next @kbd{M-# q} input line as a more
10360 explicit alternative to @kbd{$} notation, or to yank the result
10361 into the Calculator stack after typing @kbd{M-# c}.
10363 If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
10364 of @key{RET}, the result is inserted immediately into the current
10365 buffer rather than going into the kill ring.
10367 Quick Calculator results are actually evaluated as if by the @kbd{=}
10368 key (which replaces variable names by their stored values, if any).
10369 If the formula you enter is an assignment to a variable using the
10370 @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
10371 then the result of the evaluation is stored in that Calc variable.
10372 @xref{Store and Recall}.
10374 If the result is an integer and the current display radix is decimal,
10375 the number will also be displayed in hex and octal formats. If the
10376 integer is in the range from 1 to 126, it will also be displayed as
10377 an ASCII character.
10379 For example, the quoted character @samp{"x"} produces the vector
10380 result @samp{[120]} (because 120 is the ASCII code of the lower-case
10381 `x'; @pxref{Strings}). Since this is a vector, not an integer, it
10382 is displayed only according to the current mode settings. But
10383 running Quick Calc again and entering @samp{120} will produce the
10384 result @samp{120 (16#78, 8#170, x)} which shows the number in its
10385 decimal, hexadecimal, octal, and ASCII forms.
10387 Please note that the Quick Calculator is not any faster at loading
10388 or computing the answer than the full Calculator; the name ``quick''
10389 merely refers to the fact that it's much less hassle to use for
10390 small calculations.
10392 @node Prefix Arguments, Undo, Quick Calculator, Introduction
10393 @section Numeric Prefix Arguments
10396 Many Calculator commands use numeric prefix arguments. Some, such as
10397 @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
10398 the prefix argument or use a default if you don't use a prefix.
10399 Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
10400 and prompt for a number if you don't give one as a prefix.
10402 As a rule, stack-manipulation commands accept a numeric prefix argument
10403 which is interpreted as an index into the stack. A positive argument
10404 operates on the top @var{n} stack entries; a negative argument operates
10405 on the @var{n}th stack entry in isolation; and a zero argument operates
10406 on the entire stack.
10408 Most commands that perform computations (such as the arithmetic and
10409 scientific functions) accept a numeric prefix argument that allows the
10410 operation to be applied across many stack elements. For unary operations
10411 (that is, functions of one argument like absolute value or complex
10412 conjugate), a positive prefix argument applies that function to the top
10413 @var{n} stack entries simultaneously, and a negative argument applies it
10414 to the @var{n}th stack entry only. For binary operations (functions of
10415 two arguments like addition, GCD, and vector concatenation), a positive
10416 prefix argument ``reduces'' the function across the top @var{n}
10417 stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
10418 @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
10419 @var{n} stack elements with the top stack element as a second argument
10420 (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
10421 This feature is not available for operations which use the numeric prefix
10422 argument for some other purpose.
10424 Numeric prefixes are specified the same way as always in Emacs: Press
10425 a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
10426 or press @kbd{C-u} followed by digits. Some commands treat plain
10427 @kbd{C-u} (without any actual digits) specially.
10430 @pindex calc-num-prefix
10431 You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
10432 top of the stack and enter it as the numeric prefix for the next command.
10433 For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
10434 (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
10435 to the fourth power and set the precision to that value.
10437 Conversely, if you have typed a numeric prefix argument the @kbd{~} key
10438 pushes it onto the stack in the form of an integer.
10440 @node Undo, Error Messages, Prefix Arguments, Introduction
10441 @section Undoing Mistakes
10447 @cindex Mistakes, undoing
10448 @cindex Undoing mistakes
10449 @cindex Errors, undoing
10450 The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
10451 If that operation added or dropped objects from the stack, those objects
10452 are removed or restored. If it was a ``store'' operation, you are
10453 queried whether or not to restore the variable to its original value.
10454 The @kbd{U} key may be pressed any number of times to undo successively
10455 farther back in time; with a numeric prefix argument it undoes a
10456 specified number of operations. The undo history is cleared only by the
10457 @kbd{q} (@code{calc-quit}) command. (Recall that @kbd{M-# c} is
10458 synonymous with @code{calc-quit} while inside the Calculator; this
10459 also clears the undo history.)
10461 Currently the mode-setting commands (like @code{calc-precision}) are not
10462 undoable. You can undo past a point where you changed a mode, but you
10463 will need to reset the mode yourself.
10467 @cindex Redoing after an Undo
10468 The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
10469 mistakenly undone. Pressing @kbd{U} with a negative prefix argument is
10470 equivalent to executing @code{calc-redo}. You can redo any number of
10471 times, up to the number of recent consecutive undo commands. Redo
10472 information is cleared whenever you give any command that adds new undo
10473 information, i.e., if you undo, then enter a number on the stack or make
10474 any other change, then it will be too late to redo.
10476 @kindex M-@key{RET}
10477 @pindex calc-last-args
10478 @cindex Last-arguments feature
10479 @cindex Arguments, restoring
10480 The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
10481 it restores the arguments of the most recent command onto the stack;
10482 however, it does not remove the result of that command. Given a numeric
10483 prefix argument, this command applies to the @expr{n}th most recent
10484 command which removed items from the stack; it pushes those items back
10487 The @kbd{K} (@code{calc-keep-args}) command provides a related function
10488 to @kbd{M-@key{RET}}. @xref{Stack and Trail}.
10490 It is also possible to recall previous results or inputs using the trail.
10491 @xref{Trail Commands}.
10493 The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
10495 @node Error Messages, Multiple Calculators, Undo, Introduction
10496 @section Error Messages
10501 @cindex Errors, messages
10502 @cindex Why did an error occur?
10503 Many situations that would produce an error message in other calculators
10504 simply create unsimplified formulas in the Emacs Calculator. For example,
10505 @kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes
10506 the formula @samp{ln(0)}. Floating-point overflow and underflow are also
10507 reasons for this to happen.
10509 When a function call must be left in symbolic form, Calc usually
10510 produces a message explaining why. Messages that are probably
10511 surprising or indicative of user errors are displayed automatically.
10512 Other messages are simply kept in Calc's memory and are displayed only
10513 if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if
10514 the same computation results in several messages. (The first message
10515 will end with @samp{[w=more]} in this case.)
10518 @pindex calc-auto-why
10519 The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
10520 are displayed automatically. (Calc effectively presses @kbd{w} for you
10521 after your computation finishes.) By default, this occurs only for
10522 ``important'' messages. The other possible modes are to report
10523 @emph{all} messages automatically, or to report none automatically (so
10524 that you must always press @kbd{w} yourself to see the messages).
10526 @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
10527 @section Multiple Calculators
10530 @pindex another-calc
10531 It is possible to have any number of Calc mode buffers at once.
10532 Usually this is done by executing @kbd{M-x another-calc}, which
10533 is similar to @kbd{M-# c} except that if a @samp{*Calculator*}
10534 buffer already exists, a new, independent one with a name of the
10535 form @samp{*Calculator*<@var{n}>} is created. You can also use the
10536 command @code{calc-mode} to put any buffer into Calculator mode, but
10537 this would ordinarily never be done.
10539 The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
10540 it only closes its window. Use @kbd{M-x kill-buffer} to destroy a
10543 Each Calculator buffer keeps its own stack, undo list, and mode settings
10544 such as precision, angular mode, and display formats. In Emacs terms,
10545 variables such as @code{calc-stack} are buffer-local variables. The
10546 global default values of these variables are used only when a new
10547 Calculator buffer is created. The @code{calc-quit} command saves
10548 the stack and mode settings of the buffer being quit as the new defaults.
10550 There is only one trail buffer, @samp{*Calc Trail*}, used by all
10551 Calculator buffers.
10553 @node Troubleshooting Commands, , Multiple Calculators, Introduction
10554 @section Troubleshooting Commands
10557 This section describes commands you can use in case a computation
10558 incorrectly fails or gives the wrong answer.
10560 @xref{Reporting Bugs}, if you find a problem that appears to be due
10561 to a bug or deficiency in Calc.
10564 * Autoloading Problems::
10565 * Recursion Depth::
10570 @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
10571 @subsection Autoloading Problems
10574 The Calc program is split into many component files; components are
10575 loaded automatically as you use various commands that require them.
10576 Occasionally Calc may lose track of when a certain component is
10577 necessary; typically this means you will type a command and it won't
10578 work because some function you've never heard of was undefined.
10581 @pindex calc-load-everything
10582 If this happens, the easiest workaround is to type @kbd{M-# L}
10583 (@code{calc-load-everything}) to force all the parts of Calc to be
10584 loaded right away. This will cause Emacs to take up a lot more
10585 memory than it would otherwise, but it's guaranteed to fix the problem.
10587 If you seem to run into this problem no matter what you do, or if
10588 even the @kbd{M-# L} command crashes, Calc may have been improperly
10589 installed. @xref{Installation}, for details of the installation
10592 @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
10593 @subsection Recursion Depth
10598 @pindex calc-more-recursion-depth
10599 @pindex calc-less-recursion-depth
10600 @cindex Recursion depth
10601 @cindex ``Computation got stuck'' message
10602 @cindex @code{max-lisp-eval-depth}
10603 @cindex @code{max-specpdl-size}
10604 Calc uses recursion in many of its calculations. Emacs Lisp keeps a
10605 variable @code{max-lisp-eval-depth} which limits the amount of recursion
10606 possible in an attempt to recover from program bugs. If a calculation
10607 ever halts incorrectly with the message ``Computation got stuck or
10608 ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
10609 to increase this limit. (Of course, this will not help if the
10610 calculation really did get stuck due to some problem inside Calc.)
10612 The limit is always increased (multiplied) by a factor of two. There
10613 is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
10614 decreases this limit by a factor of two, down to a minimum value of 200.
10615 The default value is 1000.
10617 These commands also double or halve @code{max-specpdl-size}, another
10618 internal Lisp recursion limit. The minimum value for this limit is 600.
10620 @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
10625 @cindex Flushing caches
10626 Calc saves certain values after they have been computed once. For
10627 example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
10628 constant @cpi{} to about 20 decimal places; if the current precision
10629 is greater than this, it will recompute @cpi{} using a series
10630 approximation. This value will not need to be recomputed ever again
10631 unless you raise the precision still further. Many operations such as
10632 logarithms and sines make use of similarly cached values such as
10634 @texline @math{\ln 2}.
10635 @infoline @expr{ln(2)}.
10636 The visible effect of caching is that
10637 high-precision computations may seem to do extra work the first time.
10638 Other things cached include powers of two (for the binary arithmetic
10639 functions), matrix inverses and determinants, symbolic integrals, and
10640 data points computed by the graphing commands.
10642 @pindex calc-flush-caches
10643 If you suspect a Calculator cache has become corrupt, you can use the
10644 @code{calc-flush-caches} command to reset all caches to the empty state.
10645 (This should only be necessary in the event of bugs in the Calculator.)
10646 The @kbd{M-# 0} (with the zero key) command also resets caches along
10647 with all other aspects of the Calculator's state.
10649 @node Debugging Calc, , Caches, Troubleshooting Commands
10650 @subsection Debugging Calc
10653 A few commands exist to help in the debugging of Calc commands.
10654 @xref{Programming}, to see the various ways that you can write
10655 your own Calc commands.
10658 @pindex calc-timing
10659 The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
10660 in which the timing of slow commands is reported in the Trail.
10661 Any Calc command that takes two seconds or longer writes a line
10662 to the Trail showing how many seconds it took. This value is
10663 accurate only to within one second.
10665 All steps of executing a command are included; in particular, time
10666 taken to format the result for display in the stack and trail is
10667 counted. Some prompts also count time taken waiting for them to
10668 be answered, while others do not; this depends on the exact
10669 implementation of the command. For best results, if you are timing
10670 a sequence that includes prompts or multiple commands, define a
10671 keyboard macro to run the whole sequence at once. Calc's @kbd{X}
10672 command (@pxref{Keyboard Macros}) will then report the time taken
10673 to execute the whole macro.
10675 Another advantage of the @kbd{X} command is that while it is
10676 executing, the stack and trail are not updated from step to step.
10677 So if you expect the output of your test sequence to leave a result
10678 that may take a long time to format and you don't wish to count
10679 this formatting time, end your sequence with a @key{DEL} keystroke
10680 to clear the result from the stack. When you run the sequence with
10681 @kbd{X}, Calc will never bother to format the large result.
10683 Another thing @kbd{Z T} does is to increase the Emacs variable
10684 @code{gc-cons-threshold} to a much higher value (two million; the
10685 usual default in Calc is 250,000) for the duration of each command.
10686 This generally prevents garbage collection during the timing of
10687 the command, though it may cause your Emacs process to grow
10688 abnormally large. (Garbage collection time is a major unpredictable
10689 factor in the timing of Emacs operations.)
10691 Another command that is useful when debugging your own Lisp
10692 extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
10693 the error handler that changes the ``@code{max-lisp-eval-depth}
10694 exceeded'' message to the much more friendly ``Computation got
10695 stuck or ran too long.'' This handler interferes with the Emacs
10696 Lisp debugger's @code{debug-on-error} mode. Errors are reported
10697 in the handler itself rather than at the true location of the
10698 error. After you have executed @code{calc-pass-errors}, Lisp
10699 errors will be reported correctly but the user-friendly message
10702 @node Data Types, Stack and Trail, Introduction, Top
10703 @chapter Data Types
10706 This chapter discusses the various types of objects that can be placed
10707 on the Calculator stack, how they are displayed, and how they are
10708 entered. (@xref{Data Type Formats}, for information on how these data
10709 types are represented as underlying Lisp objects.)
10711 Integers, fractions, and floats are various ways of describing real
10712 numbers. HMS forms also for many purposes act as real numbers. These
10713 types can be combined to form complex numbers, modulo forms, error forms,
10714 or interval forms. (But these last four types cannot be combined
10715 arbitrarily:@: error forms may not contain modulo forms, for example.)
10716 Finally, all these types of numbers may be combined into vectors,
10717 matrices, or algebraic formulas.
10720 * Integers:: The most basic data type.
10721 * Fractions:: This and above are called @dfn{rationals}.
10722 * Floats:: This and above are called @dfn{reals}.
10723 * Complex Numbers:: This and above are called @dfn{numbers}.
10725 * Vectors and Matrices::
10732 * Incomplete Objects::
10737 @node Integers, Fractions, Data Types, Data Types
10742 The Calculator stores integers to arbitrary precision. Addition,
10743 subtraction, and multiplication of integers always yields an exact
10744 integer result. (If the result of a division or exponentiation of
10745 integers is not an integer, it is expressed in fractional or
10746 floating-point form according to the current Fraction mode.
10747 @xref{Fraction Mode}.)
10749 A decimal integer is represented as an optional sign followed by a
10750 sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to
10751 insert a comma at every third digit for display purposes, but you
10752 must not type commas during the entry of numbers.
10755 A non-decimal integer is represented as an optional sign, a radix
10756 between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11
10757 and above, the letters A through Z (upper- or lower-case) count as
10758 digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how
10759 to set the default radix for display of integers. Numbers of any radix
10760 may be entered at any time. If you press @kbd{#} at the beginning of a
10761 number, the current display radix is used.
10763 @node Fractions, Floats, Integers, Data Types
10768 A @dfn{fraction} is a ratio of two integers. Fractions are traditionally
10769 written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key
10770 performs RPN division; the following two sequences push the number
10771 @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
10772 assuming Fraction mode has been enabled.)
10773 When the Calculator produces a fractional result it always reduces it to
10774 simplest form, which may in fact be an integer.
10776 Fractions may also be entered in a three-part form, where @samp{2:3:4}
10777 represents two-and-three-quarters. @xref{Fraction Formats}, for fraction
10780 Non-decimal fractions are entered and displayed as
10781 @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
10782 form). The numerator and denominator always use the same radix.
10784 @node Floats, Complex Numbers, Fractions, Data Types
10788 @cindex Floating-point numbers
10789 A floating-point number or @dfn{float} is a number stored in scientific
10790 notation. The number of significant digits in the fractional part is
10791 governed by the current floating precision (@pxref{Precision}). The
10792 range of acceptable values is from
10793 @texline @math{10^{-3999999}}
10794 @infoline @expr{10^-3999999}
10796 @texline @math{10^{4000000}}
10797 @infoline @expr{10^4000000}
10798 (exclusive), plus the corresponding negative values and zero.
10800 Calculations that would exceed the allowable range of values (such
10801 as @samp{exp(exp(20))}) are left in symbolic form by Calc. The
10802 messages ``floating-point overflow'' or ``floating-point underflow''
10803 indicate that during the calculation a number would have been produced
10804 that was too large or too close to zero, respectively, to be represented
10805 by Calc. This does not necessarily mean the final result would have
10806 overflowed, just that an overflow occurred while computing the result.
10807 (In fact, it could report an underflow even though the final result
10808 would have overflowed!)
10810 If a rational number and a float are mixed in a calculation, the result
10811 will in general be expressed as a float. Commands that require an integer
10812 value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
10813 floats, i.e., floating-point numbers with nothing after the decimal point.
10815 Floats are identified by the presence of a decimal point and/or an
10816 exponent. In general a float consists of an optional sign, digits
10817 including an optional decimal point, and an optional exponent consisting
10818 of an @samp{e}, an optional sign, and up to seven exponent digits.
10819 For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
10822 Floating-point numbers are normally displayed in decimal notation with
10823 all significant figures shown. Exceedingly large or small numbers are
10824 displayed in scientific notation. Various other display options are
10825 available. @xref{Float Formats}.
10827 @cindex Accuracy of calculations
10828 Floating-point numbers are stored in decimal, not binary. The result
10829 of each operation is rounded to the nearest value representable in the
10830 number of significant digits specified by the current precision,
10831 rounding away from zero in the case of a tie. Thus (in the default
10832 display mode) what you see is exactly what you get. Some operations such
10833 as square roots and transcendental functions are performed with several
10834 digits of extra precision and then rounded down, in an effort to make the
10835 final result accurate to the full requested precision. However,
10836 accuracy is not rigorously guaranteed. If you suspect the validity of a
10837 result, try doing the same calculation in a higher precision. The
10838 Calculator's arithmetic is not intended to be IEEE-conformant in any
10841 While floats are always @emph{stored} in decimal, they can be entered
10842 and displayed in any radix just like integers and fractions. The
10843 notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point
10844 number whose digits are in the specified radix. Note that the @samp{.}
10845 is more aptly referred to as a ``radix point'' than as a decimal
10846 point in this case. The number @samp{8#123.4567} is defined as
10847 @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can use
10848 @samp{e} notation to write a non-decimal number in scientific notation.
10849 The exponent is written in decimal, and is considered to be a power
10850 of the radix: @samp{8#1234567e-4}. If the radix is 15 or above, the
10851 letter @samp{e} is a digit, so scientific notation must be written
10852 out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the
10853 Modes Tutorial explore some of the properties of non-decimal floats.
10855 @node Complex Numbers, Infinities, Floats, Data Types
10856 @section Complex Numbers
10859 @cindex Complex numbers
10860 There are two supported formats for complex numbers: rectangular and
10861 polar. The default format is rectangular, displayed in the form
10862 @samp{(@var{real},@var{imag})} where @var{real} is the real part and
10863 @var{imag} is the imaginary part, each of which may be any real number.
10864 Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
10865 notation; @pxref{Complex Formats}.
10867 Polar complex numbers are displayed in the form
10868 @texline `@t{(}@var{r}@t{;}@math{\theta}@t{)}'
10869 @infoline `@t{(}@var{r}@t{;}@var{theta}@t{)}'
10870 where @var{r} is the nonnegative magnitude and
10871 @texline @math{\theta}
10872 @infoline @var{theta}
10873 is the argument or phase angle. The range of
10874 @texline @math{\theta}
10875 @infoline @var{theta}
10876 depends on the current angular mode (@pxref{Angular Modes}); it is
10877 generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range
10880 Complex numbers are entered in stages using incomplete objects.
10881 @xref{Incomplete Objects}.
10883 Operations on rectangular complex numbers yield rectangular complex
10884 results, and similarly for polar complex numbers. Where the two types
10885 are mixed, or where new complex numbers arise (as for the square root of
10886 a negative real), the current @dfn{Polar mode} is used to determine the
10887 type. @xref{Polar Mode}.
10889 A complex result in which the imaginary part is zero (or the phase angle
10890 is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real
10893 @node Infinities, Vectors and Matrices, Complex Numbers, Data Types
10894 @section Infinities
10898 @cindex @code{inf} variable
10899 @cindex @code{uinf} variable
10900 @cindex @code{nan} variable
10904 The word @code{inf} represents the mathematical concept of @dfn{infinity}.
10905 Calc actually has three slightly different infinity-like values:
10906 @code{inf}, @code{uinf}, and @code{nan}. These are just regular
10907 variable names (@pxref{Variables}); you should avoid using these
10908 names for your own variables because Calc gives them special
10909 treatment. Infinities, like all variable names, are normally
10910 entered using algebraic entry.
10912 Mathematically speaking, it is not rigorously correct to treat
10913 ``infinity'' as if it were a number, but mathematicians often do
10914 so informally. When they say that @samp{1 / inf = 0}, what they
10915 really mean is that @expr{1 / x}, as @expr{x} becomes larger and
10916 larger, becomes arbitrarily close to zero. So you can imagine
10917 that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x}
10918 would go all the way to zero. Similarly, when they say that
10919 @samp{exp(inf) = inf}, they mean that
10920 @texline @math{e^x}
10921 @infoline @expr{exp(x)}
10922 grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise
10923 stands for an infinitely negative real value; for example, we say that
10924 @samp{exp(-inf) = 0}. You can have an infinity pointing in any
10925 direction on the complex plane: @samp{sqrt(-inf) = i inf}.
10927 The same concept of limits can be used to define @expr{1 / 0}. We
10928 really want the value that @expr{1 / x} approaches as @expr{x}
10929 approaches zero. But if all we have is @expr{1 / 0}, we can't
10930 tell which direction @expr{x} was coming from. If @expr{x} was
10931 positive and decreasing toward zero, then we should say that
10932 @samp{1 / 0 = inf}. But if @expr{x} was negative and increasing
10933 toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x}
10934 could be an imaginary number, giving the answer @samp{i inf} or
10935 @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean
10936 @dfn{undirected infinity}, i.e., a value which is infinitely
10937 large but with an unknown sign (or direction on the complex plane).
10939 Calc actually has three modes that say how infinities are handled.
10940 Normally, infinities never arise from calculations that didn't
10941 already have them. Thus, @expr{1 / 0} is treated simply as an
10942 error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode})
10943 command (@pxref{Infinite Mode}) enables a mode in which
10944 @expr{1 / 0} evaluates to @code{uinf} instead. There is also
10945 an alternative type of infinite mode which says to treat zeros
10946 as if they were positive, so that @samp{1 / 0 = inf}. While this
10947 is less mathematically correct, it may be the answer you want in
10950 Since all infinities are ``as large'' as all others, Calc simplifies,
10951 e.g., @samp{5 inf} to @samp{inf}. Another example is
10952 @samp{5 - inf = -inf}, where the @samp{-inf} is so large that
10953 adding a finite number like five to it does not affect it.
10954 Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
10955 that variables like @code{a} always stand for finite quantities.
10956 Just to show that infinities really are all the same size,
10957 note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
10960 It's not so easy to define certain formulas like @samp{0 * inf} and
10961 @samp{inf / inf}. Depending on where these zeros and infinities
10962 came from, the answer could be literally anything. The latter
10963 formula could be the limit of @expr{x / x} (giving a result of one),
10964 or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}),
10965 or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan}
10966 to represent such an @dfn{indeterminate} value. (The name ``nan''
10967 comes from analogy with the ``NAN'' concept of IEEE standard
10968 arithmetic; it stands for ``Not A Number.'' This is somewhat of a
10969 misnomer, since @code{nan} @emph{does} stand for some number or
10970 infinity, it's just that @emph{which} number it stands for
10971 cannot be determined.) In Calc's notation, @samp{0 * inf = nan}
10972 and @samp{inf / inf = nan}. A few other common indeterminate
10973 expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also,
10974 @samp{0 / 0 = nan} if you have turned on Infinite mode
10975 (as described above).
10977 Infinities are especially useful as parts of @dfn{intervals}.
10978 @xref{Interval Forms}.
10980 @node Vectors and Matrices, Strings, Infinities, Data Types
10981 @section Vectors and Matrices
10985 @cindex Plain vectors
10987 The @dfn{vector} data type is flexible and general. A vector is simply a
10988 list of zero or more data objects. When these objects are numbers, the
10989 whole is a vector in the mathematical sense. When these objects are
10990 themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
10991 A vector which is not a matrix is referred to here as a @dfn{plain vector}.
10993 A vector is displayed as a list of values separated by commas and enclosed
10994 in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by
10995 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex
10996 numbers, are entered as incomplete objects. @xref{Incomplete Objects}.
10997 During algebraic entry, vectors are entered all at once in the usual
10998 brackets-and-commas form. Matrices may be entered algebraically as nested
10999 vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
11000 with rows separated by semicolons. The commas may usually be omitted
11001 when entering vectors: @samp{[1 2 3]}. Curly braces may be used in
11002 place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
11005 Traditional vector and matrix arithmetic is also supported;
11006 @pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
11007 Many other operations are applied to vectors element-wise. For example,
11008 the complex conjugate of a vector is a vector of the complex conjugates
11015 Algebraic functions for building vectors include @samp{vec(a, b, c)}
11016 to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an
11017 @texline @math{n\times m}
11018 @infoline @var{n}x@var{m}
11019 matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
11020 from 1 to @samp{n}.
11022 @node Strings, HMS Forms, Vectors and Matrices, Data Types
11028 @cindex Character strings
11029 Character strings are not a special data type in the Calculator.
11030 Rather, a string is represented simply as a vector all of whose
11031 elements are integers in the range 0 to 255 (ASCII codes). You can
11032 enter a string at any time by pressing the @kbd{"} key. Quotation
11033 marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
11034 inside strings. Other notations introduced by backslashes are:
11050 Finally, a backslash followed by three octal digits produces any
11051 character from its ASCII code.
11054 @pindex calc-display-strings
11055 Strings are normally displayed in vector-of-integers form. The
11056 @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
11057 which any vectors of small integers are displayed as quoted strings
11060 The backslash notations shown above are also used for displaying
11061 strings. Characters 128 and above are not translated by Calc; unless
11062 you have an Emacs modified for 8-bit fonts, these will show up in
11063 backslash-octal-digits notation. For characters below 32, and
11064 for character 127, Calc uses the backslash-letter combination if
11065 there is one, or otherwise uses a @samp{\^} sequence.
11067 The only Calc feature that uses strings is @dfn{compositions};
11068 @pxref{Compositions}. Strings also provide a convenient
11069 way to do conversions between ASCII characters and integers.
11075 There is a @code{string} function which provides a different display
11076 format for strings. Basically, @samp{string(@var{s})}, where @var{s}
11077 is a vector of integers in the proper range, is displayed as the
11078 corresponding string of characters with no surrounding quotation
11079 marks or other modifications. Thus @samp{string("ABC")} (or
11080 @samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
11081 This happens regardless of whether @w{@kbd{d "}} has been used. The
11082 only way to turn it off is to use @kbd{d U} (unformatted language
11083 mode) which will display @samp{string("ABC")} instead.
11085 Control characters are displayed somewhat differently by @code{string}.
11086 Characters below 32, and character 127, are shown using @samp{^} notation
11087 (same as shown above, but without the backslash). The quote and
11088 backslash characters are left alone, as are characters 128 and above.
11094 The @code{bstring} function is just like @code{string} except that
11095 the resulting string is breakable across multiple lines if it doesn't
11096 fit all on one line. Potential break points occur at every space
11097 character in the string.
11099 @node HMS Forms, Date Forms, Strings, Data Types
11103 @cindex Hours-minutes-seconds forms
11104 @cindex Degrees-minutes-seconds forms
11105 @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
11106 argument, the interpretation is Degrees-Minutes-Seconds. All functions
11107 that operate on angles accept HMS forms. These are interpreted as
11108 degrees regardless of the current angular mode. It is also possible to
11109 use HMS as the angular mode so that calculated angles are expressed in
11110 degrees, minutes, and seconds.
11116 @kindex ' (HMS forms)
11120 @kindex " (HMS forms)
11124 @kindex h (HMS forms)
11128 @kindex o (HMS forms)
11132 @kindex m (HMS forms)
11136 @kindex s (HMS forms)
11137 The default format for HMS values is
11138 @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters
11139 @samp{h} (for ``hours'') or
11140 @samp{o} (approximating the ``degrees'' symbol) are accepted as well as
11141 @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
11142 accepted in place of @samp{"}.
11143 The @var{hours} value is an integer (or integer-valued float).
11144 The @var{mins} value is an integer or integer-valued float between 0 and 59.
11145 The @var{secs} value is a real number between 0 (inclusive) and 60
11146 (exclusive). A positive HMS form is interpreted as @var{hours} +
11147 @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted
11148 as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600.
11149 Display format for HMS forms is quite flexible. @xref{HMS Formats}.
11151 HMS forms can be added and subtracted. When they are added to numbers,
11152 the numbers are interpreted according to the current angular mode. HMS
11153 forms can also be multiplied and divided by real numbers. Dividing
11154 two HMS forms produces a real-valued ratio of the two angles.
11157 @cindex Time of day
11158 Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
11159 the stack as an HMS form.
11161 @node Date Forms, Modulo Forms, HMS Forms, Data Types
11162 @section Date Forms
11166 A @dfn{date form} represents a date and possibly an associated time.
11167 Simple date arithmetic is supported: Adding a number to a date
11168 produces a new date shifted by that many days; adding an HMS form to
11169 a date shifts it by that many hours. Subtracting two date forms
11170 computes the number of days between them (represented as a simple
11171 number). Many other operations, such as multiplying two date forms,
11172 are nonsensical and are not allowed by Calc.
11174 Date forms are entered and displayed enclosed in @samp{< >} brackets.
11175 The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
11176 or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
11177 Input is flexible; date forms can be entered in any of the usual
11178 notations for dates and times. @xref{Date Formats}.
11180 Date forms are stored internally as numbers, specifically the number
11181 of days since midnight on the morning of January 1 of the year 1 AD.
11182 If the internal number is an integer, the form represents a date only;
11183 if the internal number is a fraction or float, the form represents
11184 a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>}
11185 is represented by the number 726842.25. The standard precision of
11186 12 decimal digits is enough to ensure that a (reasonable) date and
11187 time can be stored without roundoff error.
11189 If the current precision is greater than 12, date forms will keep
11190 additional digits in the seconds position. For example, if the
11191 precision is 15, the seconds will keep three digits after the
11192 decimal point. Decreasing the precision below 12 may cause the
11193 time part of a date form to become inaccurate. This can also happen
11194 if astronomically high years are used, though this will not be an
11195 issue in everyday (or even everymillennium) use. Note that date
11196 forms without times are stored as exact integers, so roundoff is
11197 never an issue for them.
11199 You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
11200 (@code{calc-unpack}) commands to get at the numerical representation
11201 of a date form. @xref{Packing and Unpacking}.
11203 Date forms can go arbitrarily far into the future or past. Negative
11204 year numbers represent years BC. Calc uses a combination of the
11205 Gregorian and Julian calendars, following the history of Great
11206 Britain and the British colonies. This is the same calendar that
11207 is used by the @code{cal} program in most Unix implementations.
11209 @cindex Julian calendar
11210 @cindex Gregorian calendar
11211 Some historical background: The Julian calendar was created by
11212 Julius Caesar in the year 46 BC as an attempt to fix the gradual
11213 drift caused by the lack of leap years in the calendar used
11214 until that time. The Julian calendar introduced an extra day in
11215 all years divisible by four. After some initial confusion, the
11216 calendar was adopted around the year we call 8 AD. Some centuries
11217 later it became apparent that the Julian year of 365.25 days was
11218 itself not quite right. In 1582 Pope Gregory XIII introduced the
11219 Gregorian calendar, which added the new rule that years divisible
11220 by 100, but not by 400, were not to be considered leap years
11221 despite being divisible by four. Many countries delayed adoption
11222 of the Gregorian calendar because of religious differences;
11223 in Britain it was put off until the year 1752, by which time
11224 the Julian calendar had fallen eleven days behind the true
11225 seasons. So the switch to the Gregorian calendar in early
11226 September 1752 introduced a discontinuity: The day after
11227 Sep 2, 1752 is Sep 14, 1752. Calc follows this convention.
11228 To take another example, Russia waited until 1918 before
11229 adopting the new calendar, and thus needed to remove thirteen
11230 days (between Feb 1, 1918 and Feb 14, 1918). This means that
11231 Calc's reckoning will be inconsistent with Russian history between
11232 1752 and 1918, and similarly for various other countries.
11234 Today's timekeepers introduce an occasional ``leap second'' as
11235 well, but Calc does not take these minor effects into account.
11236 (If it did, it would have to report a non-integer number of days
11237 between, say, @samp{<12:00am Mon Jan 1, 1900>} and
11238 @samp{<12:00am Sat Jan 1, 2000>}.)
11240 Calc uses the Julian calendar for all dates before the year 1752,
11241 including dates BC when the Julian calendar technically had not
11242 yet been invented. Thus the claim that day number @mathit{-10000} is
11243 called ``August 16, 28 BC'' should be taken with a grain of salt.
11245 Please note that there is no ``year 0''; the day before
11246 @samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}. These are
11247 days 0 and @mathit{-1} respectively in Calc's internal numbering scheme.
11249 @cindex Julian day counting
11250 Another day counting system in common use is, confusingly, also
11251 called ``Julian.'' It was invented in 1583 by Joseph Justus
11252 Scaliger, who named it in honor of his father Julius Caesar
11253 Scaliger. For obscure reasons he chose to start his day
11254 numbering on Jan 1, 4713 BC at noon, which in Calc's scheme
11255 is @mathit{-1721423.5} (recall that Calc starts at midnight instead
11256 of noon). Thus to convert a Calc date code obtained by
11257 unpacking a date form into a Julian day number, simply add
11258 1721423.5. The Julian code for @samp{6:00am Jan 9, 1991}
11259 is 2448265.75. The built-in @kbd{t J} command performs
11260 this conversion for you.
11262 @cindex Unix time format
11263 The Unix operating system measures time as an integer number of
11264 seconds since midnight, Jan 1, 1970. To convert a Calc date
11265 value into a Unix time stamp, first subtract 719164 (the code
11266 for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
11267 seconds in a day) and press @kbd{R} to round to the nearest
11268 integer. If you have a date form, you can simply subtract the
11269 day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
11270 719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
11271 to convert from Unix time to a Calc date form. (Note that
11272 Unix normally maintains the time in the GMT time zone; you may
11273 need to subtract five hours to get New York time, or eight hours
11274 for California time. The same is usually true of Julian day
11275 counts.) The built-in @kbd{t U} command performs these
11278 @node Modulo Forms, Error Forms, Date Forms, Data Types
11279 @section Modulo Forms
11282 @cindex Modulo forms
11283 A @dfn{modulo form} is a real number which is taken modulo (i.e., within
11284 an integer multiple of) some value @var{M}. Arithmetic modulo @var{M}
11285 often arises in number theory. Modulo forms are written
11286 `@var{a} @t{mod} @var{M}',
11287 where @var{a} and @var{M} are real numbers or HMS forms, and
11288 @texline @math{0 \le a < M}.
11289 @infoline @expr{0 <= a < @var{M}}.
11290 In many applications @expr{a} and @expr{M} will be
11291 integers but this is not required.
11293 Modulo forms are not to be confused with the modulo operator @samp{%}.
11294 The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
11295 the result 7. Further computations treat this 7 as just a regular integer.
11296 The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
11297 further computations with this value are again reduced modulo 10 so that
11298 the result always lies in the desired range.
11300 When two modulo forms with identical @expr{M}'s are added or multiplied,
11301 the Calculator simply adds or multiplies the values, then reduces modulo
11302 @expr{M}. If one argument is a modulo form and the other a plain number,
11303 the plain number is treated like a compatible modulo form. It is also
11304 possible to raise modulo forms to powers; the result is the value raised
11305 to the power, then reduced modulo @expr{M}. (When all values involved
11306 are integers, this calculation is done much more efficiently than
11307 actually computing the power and then reducing.)
11309 @cindex Modulo division
11310 Two modulo forms `@var{a} @t{mod} @var{M}' and `@var{b} @t{mod} @var{M}'
11311 can be divided if @expr{a}, @expr{b}, and @expr{M} are all
11312 integers. The result is the modulo form which, when multiplied by
11313 `@var{b} @t{mod} @var{M}', produces `@var{a} @t{mod} @var{M}'. If
11314 there is no solution to this equation (which can happen only when
11315 @expr{M} is non-prime), or if any of the arguments are non-integers, the
11316 division is left in symbolic form. Other operations, such as square
11317 roots, are not yet supported for modulo forms. (Note that, although
11318 @w{`@t{(}@var{a} @t{mod} @var{M}@t{)^.5}'} will compute a ``modulo square root''
11319 in the sense of reducing
11320 @texline @math{\sqrt a}
11321 @infoline @expr{sqrt(a)}
11322 modulo @expr{M}, this is not a useful definition from the
11323 number-theoretical point of view.)
11328 @kindex M (modulo forms)
11332 @tindex mod (operator)
11333 To create a modulo form during numeric entry, press the shift-@kbd{M}
11334 key to enter the word @samp{mod}. As a special convenience, pressing
11335 shift-@kbd{M} a second time automatically enters the value of @expr{M}
11336 that was most recently used before. During algebraic entry, either
11337 type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
11338 Once again, pressing this a second time enters the current modulo.
11340 You can also use @kbd{v p} and @kbd{%} to modify modulo forms.
11341 @xref{Building Vectors}. @xref{Basic Arithmetic}.
11343 It is possible to mix HMS forms and modulo forms. For example, an
11344 HMS form modulo 24 could be used to manipulate clock times; an HMS
11345 form modulo 360 would be suitable for angles. Making the modulo @expr{M}
11346 also be an HMS form eliminates troubles that would arise if the angular
11347 mode were inadvertently set to Radians, in which case
11348 @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
11351 Modulo forms cannot have variables or formulas for components. If you
11352 enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
11353 to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}.
11359 The algebraic function @samp{makemod(a, m)} builds the modulo form
11360 @w{@samp{a mod m}}.
11362 @node Error Forms, Interval Forms, Modulo Forms, Data Types
11363 @section Error Forms
11366 @cindex Error forms
11367 @cindex Standard deviations
11368 An @dfn{error form} is a number with an associated standard
11369 deviation, as in @samp{2.3 +/- 0.12}. The notation
11370 @texline `@var{x} @t{+/-} @math{\sigma}'
11371 @infoline `@var{x} @t{+/-} sigma'
11372 stands for an uncertain value which follows
11373 a normal or Gaussian distribution of mean @expr{x} and standard
11374 deviation or ``error''
11375 @texline @math{\sigma}.
11376 @infoline @expr{sigma}.
11377 Both the mean and the error can be either numbers or
11378 formulas. Generally these are real numbers but the mean may also be
11379 complex. If the error is negative or complex, it is changed to its
11380 absolute value. An error form with zero error is converted to a
11381 regular number by the Calculator.
11383 All arithmetic and transcendental functions accept error forms as input.
11384 Operations on the mean-value part work just like operations on regular
11385 numbers. The error part for any function @expr{f(x)} (such as
11386 @texline @math{\sin x}
11387 @infoline @expr{sin(x)})
11388 is defined by the error of @expr{x} times the derivative of @expr{f}
11389 evaluated at the mean value of @expr{x}. For a two-argument function
11390 @expr{f(x,y)} (such as addition) the error is the square root of the sum
11391 of the squares of the errors due to @expr{x} and @expr{y}.
11394 f(x \hbox{\code{ +/- }} \sigma)
11395 &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
11396 f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
11397 &= f(x,y) \hbox{\code{ +/- }}
11398 \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
11400 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
11401 \right| \right)^2 } \cr
11405 definition assumes the errors in @expr{x} and @expr{y} are uncorrelated.
11406 A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
11407 is not the same as @samp{(2 +/- 1)^2}; the former represents the product
11408 of two independent values which happen to have the same probability
11409 distributions, and the latter is the product of one random value with itself.
11410 The former will produce an answer with less error, since on the average
11411 the two independent errors can be expected to cancel out.
11413 Consult a good text on error analysis for a discussion of the proper use
11414 of standard deviations. Actual errors often are neither Gaussian-distributed
11415 nor uncorrelated, and the above formulas are valid only when errors
11416 are small. As an example, the error arising from
11417 @texline `@t{sin(}@var{x} @t{+/-} @math{\sigma}@t{)}'
11418 @infoline `@t{sin(}@var{x} @t{+/-} @var{sigma}@t{)}'
11420 @texline `@math{\sigma} @t{abs(cos(}@var{x}@t{))}'.
11421 @infoline `@var{sigma} @t{abs(cos(}@var{x}@t{))}'.
11422 When @expr{x} is close to zero,
11423 @texline @math{\cos x}
11424 @infoline @expr{cos(x)}
11425 is close to one so the error in the sine is close to
11426 @texline @math{\sigma};
11427 @infoline @expr{sigma};
11428 this makes sense, since
11429 @texline @math{\sin x}
11430 @infoline @expr{sin(x)}
11431 is approximately @expr{x} near zero, so a given error in @expr{x} will
11432 produce about the same error in the sine. Likewise, near 90 degrees
11433 @texline @math{\cos x}
11434 @infoline @expr{cos(x)}
11435 is nearly zero and so the computed error is
11436 small: The sine curve is nearly flat in that region, so an error in @expr{x}
11437 has relatively little effect on the value of
11438 @texline @math{\sin x}.
11439 @infoline @expr{sin(x)}.
11440 However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so
11441 Calc will report zero error! We get an obviously wrong result because
11442 we have violated the small-error approximation underlying the error
11443 analysis. If the error in @expr{x} had been small, the error in
11444 @texline @math{\sin x}
11445 @infoline @expr{sin(x)}
11446 would indeed have been negligible.
11451 @kindex p (error forms)
11453 To enter an error form during regular numeric entry, use the @kbd{p}
11454 (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually
11455 typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
11456 @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-p} to
11457 type the @samp{+/-} symbol, or type it out by hand.
11459 Error forms and complex numbers can be mixed; the formulas shown above
11460 are used for complex numbers, too; note that if the error part evaluates
11461 to a complex number its absolute value (or the square root of the sum of
11462 the squares of the absolute values of the two error contributions) is
11463 used. Mathematically, this corresponds to a radially symmetric Gaussian
11464 distribution of numbers on the complex plane. However, note that Calc
11465 considers an error form with real components to represent a real number,
11466 not a complex distribution around a real mean.
11468 Error forms may also be composed of HMS forms. For best results, both
11469 the mean and the error should be HMS forms if either one is.
11475 The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
11477 @node Interval Forms, Incomplete Objects, Error Forms, Data Types
11478 @section Interval Forms
11481 @cindex Interval forms
11482 An @dfn{interval} is a subset of consecutive real numbers. For example,
11483 the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
11484 inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you
11485 obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if
11486 you multiply some number in the range @samp{[2 ..@: 4]} by some other
11487 number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
11488 from 1 to 8. Interval arithmetic is used to get a worst-case estimate
11489 of the possible range of values a computation will produce, given the
11490 set of possible values of the input.
11493 Calc supports several varieties of intervals, including @dfn{closed}
11494 intervals of the type shown above, @dfn{open} intervals such as
11495 @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
11496 @emph{exclusive}, and @dfn{semi-open} intervals in which one end
11497 uses a round parenthesis and the other a square bracket. In mathematical
11499 @samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas
11500 @samp{[2 ..@: 4)} represents @expr{2 <= x < 4},
11501 @samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and
11502 @samp{(2 ..@: 4)} represents @expr{2 < x < 4}.
11505 Calc supports several varieties of intervals, including \dfn{closed}
11506 intervals of the type shown above, \dfn{open} intervals such as
11507 \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
11508 \emph{exclusive}, and \dfn{semi-open} intervals in which one end
11509 uses a round parenthesis and the other a square bracket. In mathematical
11512 [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr
11513 [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr
11514 (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr
11515 (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr
11519 The lower and upper limits of an interval must be either real numbers
11520 (or HMS or date forms), or symbolic expressions which are assumed to be
11521 real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit
11522 must be less than the upper limit. A closed interval containing only
11523 one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
11524 automatically. An interval containing no values at all (such as
11525 @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
11526 guaranteed to behave well when used in arithmetic. Note that the
11527 interval @samp{[3 .. inf)} represents all real numbers greater than
11528 or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
11529 In fact, @samp{[-inf .. inf]} represents all real numbers including
11530 the real infinities.
11532 Intervals are entered in the notation shown here, either as algebraic
11533 formulas, or using incomplete forms. (@xref{Incomplete Objects}.)
11534 In algebraic formulas, multiple periods in a row are collected from
11535 left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
11536 rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to
11537 get the other interpretation. If you omit the lower or upper limit,
11538 a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
11540 Infinite mode also affects operations on intervals
11541 (@pxref{Infinities}). Calc will always introduce an open infinity,
11542 as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities,
11543 @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode;
11544 otherwise they are left unevaluated. Note that the ``direction'' of
11545 a zero is not an issue in this case since the zero is always assumed
11546 to be continuous with the rest of the interval. For intervals that
11547 contain zero inside them Calc is forced to give the result,
11548 @samp{1 / (-2 .. 2) = [-inf .. inf]}.
11550 While it may seem that intervals and error forms are similar, they are
11551 based on entirely different concepts of inexact quantities. An error
11553 @texline `@var{x} @t{+/-} @math{\sigma}'
11554 @infoline `@var{x} @t{+/-} @var{sigma}'
11555 means a variable is random, and its value could
11556 be anything but is ``probably'' within one
11557 @texline @math{\sigma}
11558 @infoline @var{sigma}
11559 of the mean value @expr{x}. An interval
11560 `@t{[}@var{a} @t{..@:} @var{b}@t{]}' means a
11561 variable's value is unknown, but guaranteed to lie in the specified
11562 range. Error forms are statistical or ``average case'' approximations;
11563 interval arithmetic tends to produce ``worst case'' bounds on an
11566 Intervals may not contain complex numbers, but they may contain
11567 HMS forms or date forms.
11569 @xref{Set Operations}, for commands that interpret interval forms
11570 as subsets of the set of real numbers.
11576 The algebraic function @samp{intv(n, a, b)} builds an interval form
11577 from @samp{a} to @samp{b}; @samp{n} is an integer code which must
11578 be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
11581 Please note that in fully rigorous interval arithmetic, care would be
11582 taken to make sure that the computation of the lower bound rounds toward
11583 minus infinity, while upper bound computations round toward plus
11584 infinity. Calc's arithmetic always uses a round-to-nearest mode,
11585 which means that roundoff errors could creep into an interval
11586 calculation to produce intervals slightly smaller than they ought to
11587 be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
11588 should yield the interval @samp{[1..2]} again, but in fact it yields the
11589 (slightly too small) interval @samp{[1..1.9999999]} due to roundoff
11592 @node Incomplete Objects, Variables, Interval Forms, Data Types
11593 @section Incomplete Objects
11613 @cindex Incomplete vectors
11614 @cindex Incomplete complex numbers
11615 @cindex Incomplete interval forms
11616 When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
11617 vector, respectively, the effect is to push an @dfn{incomplete} complex
11618 number or vector onto the stack. The @kbd{,} key adds the value(s) at
11619 the top of the stack onto the current incomplete object. The @kbd{)}
11620 and @kbd{]} keys ``close'' the incomplete object after adding any values
11621 on the top of the stack in front of the incomplete object.
11623 As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
11624 pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )}
11625 pushes the complex number @samp{(1, 1.414)} (approximately).
11627 If several values lie on the stack in front of the incomplete object,
11628 all are collected and appended to the object. Thus the @kbd{,} key
11629 is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people
11630 prefer the equivalent @key{SPC} key to @key{RET}.
11632 As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
11633 @kbd{,} adds a zero or duplicates the preceding value in the list being
11634 formed. Typing @key{DEL} during incomplete entry removes the last item
11638 The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
11639 numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for
11640 creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
11641 equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
11645 Incomplete entry is also used to enter intervals. For example,
11646 @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type
11647 the first period, it will be interpreted as a decimal point, but when
11648 you type a second period immediately afterward, it is re-interpreted as
11649 part of the interval symbol. Typing @kbd{..} corresponds to executing
11650 the @code{calc-dots} command.
11652 If you find incomplete entry distracting, you may wish to enter vectors
11653 and complex numbers as algebraic formulas by pressing the apostrophe key.
11655 @node Variables, Formulas, Incomplete Objects, Data Types
11659 @cindex Variables, in formulas
11660 A @dfn{variable} is somewhere between a storage register on a conventional
11661 calculator, and a variable in a programming language. (In fact, a Calc
11662 variable is really just an Emacs Lisp variable that contains a Calc number
11663 or formula.) A variable's name is normally composed of letters and digits.
11664 Calc also allows apostrophes and @code{#} signs in variable names.
11665 (The Calc variable @code{foo} corresponds to the Emacs Lisp variable
11666 @code{var-foo}, but unless you access the variable from within Emacs
11667 Lisp, you don't need to worry about it. Variable names in algebraic
11668 formulas implicitly have @samp{var-} prefixed to their names. The
11669 @samp{#} character in variable names used in algebraic formulas
11670 corresponds to a dash @samp{-} in the Lisp variable name. If the name
11671 contains any dashes, the prefix @samp{var-} is @emph{not} automatically
11672 added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both
11673 refer to the same variable.)
11675 In a command that takes a variable name, you can either type the full
11676 name of a variable, or type a single digit to use one of the special
11677 convenience variables @code{q0} through @code{q9}. For example,
11678 @kbd{3 s s 2} stores the number 3 in variable @code{q2}, and
11679 @w{@kbd{3 s s foo @key{RET}}} stores that number in variable
11682 To push a variable itself (as opposed to the variable's value) on the
11683 stack, enter its name as an algebraic expression using the apostrophe
11687 @pindex calc-evaluate
11688 @cindex Evaluation of variables in a formula
11689 @cindex Variables, evaluation
11690 @cindex Formulas, evaluation
11691 The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
11692 replacing all variables in the formula which have been given values by a
11693 @code{calc-store} or @code{calc-let} command by their stored values.
11694 Other variables are left alone. Thus a variable that has not been
11695 stored acts like an abstract variable in algebra; a variable that has
11696 been stored acts more like a register in a traditional calculator.
11697 With a positive numeric prefix argument, @kbd{=} evaluates the top
11698 @var{n} stack entries; with a negative argument, @kbd{=} evaluates
11699 the @var{n}th stack entry.
11701 @cindex @code{e} variable
11702 @cindex @code{pi} variable
11703 @cindex @code{i} variable
11704 @cindex @code{phi} variable
11705 @cindex @code{gamma} variable
11711 A few variables are called @dfn{special constants}. Their names are
11712 @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
11713 (@xref{Scientific Functions}.) When they are evaluated with @kbd{=},
11714 their values are calculated if necessary according to the current precision
11715 or complex polar mode. If you wish to use these symbols for other purposes,
11716 simply undefine or redefine them using @code{calc-store}.
11718 The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
11719 infinite or indeterminate values. It's best not to use them as
11720 regular variables, since Calc uses special algebraic rules when
11721 it manipulates them. Calc displays a warning message if you store
11722 a value into any of these special variables.
11724 @xref{Store and Recall}, for a discussion of commands dealing with variables.
11726 @node Formulas, , Variables, Data Types
11731 @cindex Expressions
11732 @cindex Operators in formulas
11733 @cindex Precedence of operators
11734 When you press the apostrophe key you may enter any expression or formula
11735 in algebraic form. (Calc uses the terms ``expression'' and ``formula''
11736 interchangeably.) An expression is built up of numbers, variable names,
11737 and function calls, combined with various arithmetic operators.
11739 be used to indicate grouping. Spaces are ignored within formulas, except
11740 that spaces are not permitted within variable names or numbers.
11741 Arithmetic operators, in order from highest to lowest precedence, and
11742 with their equivalent function names, are:
11744 @samp{_} [@code{subscr}] (subscripts);
11746 postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
11748 prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x})
11749 and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
11751 @samp{+/-} [@code{sdev}] (the standard deviation symbol) and
11752 @samp{mod} [@code{makemod}] (the symbol for modulo forms);
11754 postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
11755 and postfix @samp{!!} [@code{dfact}] (double factorial);
11757 @samp{^} [@code{pow}] (raised-to-the-power-of);
11759 @samp{*} [@code{mul}];
11761 @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
11762 @samp{\} [@code{idiv}] (integer division);
11764 infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
11766 @samp{|} [@code{vconcat}] (vector concatenation);
11768 relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
11769 @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
11771 @samp{&&} [@code{land}] (logical ``and'');
11773 @samp{||} [@code{lor}] (logical ``or'');
11775 the C-style ``if'' operator @samp{a?b:c} [@code{if}];
11777 @samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
11779 @samp{&&&} [@code{pand}] (rewrite pattern ``and'');
11781 @samp{|||} [@code{por}] (rewrite pattern ``or'');
11783 @samp{:=} [@code{assign}] (for assignments and rewrite rules);
11785 @samp{::} [@code{condition}] (rewrite pattern condition);
11787 @samp{=>} [@code{evalto}].
11789 Note that, unlike in usual computer notation, multiplication binds more
11790 strongly than division: @samp{a*b/c*d} is equivalent to
11791 @texline @math{a b \over c d}.
11792 @infoline @expr{(a*b)/(c*d)}.
11794 @cindex Multiplication, implicit
11795 @cindex Implicit multiplication
11796 The multiplication sign @samp{*} may be omitted in many cases. In particular,
11797 if the righthand side is a number, variable name, or parenthesized
11798 expression, the @samp{*} may be omitted. Implicit multiplication has the
11799 same precedence as the explicit @samp{*} operator. The one exception to
11800 the rule is that a variable name followed by a parenthesized expression,
11802 is interpreted as a function call, not an implicit @samp{*}. In many
11803 cases you must use a space if you omit the @samp{*}: @samp{2a} is the
11804 same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
11805 is a variable called @code{ab}, @emph{not} the product of @samp{a} and
11806 @samp{b}! Also note that @samp{f (x)} is still a function call.
11808 @cindex Implicit comma in vectors
11809 The rules are slightly different for vectors written with square brackets.
11810 In vectors, the space character is interpreted (like the comma) as a
11811 separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is
11812 equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
11813 to @samp{2*a*b + c*d}.
11814 Note that spaces around the brackets, and around explicit commas, are
11815 ignored. To force spaces to be interpreted as multiplication you can
11816 enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
11817 interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted
11818 between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.
11820 Vectors that contain commas (not embedded within nested parentheses or
11821 brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector
11822 of two elements. Also, if it would be an error to treat spaces as
11823 separators, but not otherwise, then Calc will ignore spaces:
11824 @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
11825 a vector of two elements. Finally, vectors entered with curly braces
11826 instead of square brackets do not give spaces any special treatment.
11827 When Calc displays a vector that does not contain any commas, it will
11828 insert parentheses if necessary to make the meaning clear:
11829 @w{@samp{[(a b)]}}.
11831 The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
11832 or five modulo minus-two? Calc always interprets the leftmost symbol as
11833 an infix operator preferentially (modulo, in this case), so you would
11834 need to write @samp{(5%)-2} to get the former interpretation.
11836 @cindex Function call notation
11837 A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function
11838 @code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo},
11839 but unless you access the function from within Emacs Lisp, you don't
11840 need to worry about it.) Most mathematical Calculator commands like
11841 @code{calc-sin} have function equivalents like @code{sin}.
11842 If no Lisp function is defined for a function called by a formula, the
11843 call is left as it is during algebraic manipulation: @samp{f(x+y)} is
11844 left alone. Beware that many innocent-looking short names like @code{in}
11845 and @code{re} have predefined meanings which could surprise you; however,
11846 single letters or single letters followed by digits are always safe to
11847 use for your own function names. @xref{Function Index}.
11849 In the documentation for particular commands, the notation @kbd{H S}
11850 (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
11851 command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
11852 represent the same operation.
11854 Commands that interpret (``parse'') text as algebraic formulas include
11855 algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
11856 the contents of the editing buffer when you finish, the @kbd{M-# g}
11857 and @w{@kbd{M-# r}} commands, the @kbd{C-y} command, the X window system
11858 ``paste'' mouse operation, and Embedded mode. All of these operations
11859 use the same rules for parsing formulas; in particular, language modes
11860 (@pxref{Language Modes}) affect them all in the same way.
11862 When you read a large amount of text into the Calculator (say a vector
11863 which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
11864 you may wish to include comments in the text. Calc's formula parser
11865 ignores the symbol @samp{%%} and anything following it on a line:
11868 [ a + b, %% the sum of "a" and "b"
11870 %% last line is coming up:
11875 This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
11877 @xref{Syntax Tables}, for a way to create your own operators and other
11878 input notations. @xref{Compositions}, for a way to create new display
11881 @xref{Algebra}, for commands for manipulating formulas symbolically.
11883 @node Stack and Trail, Mode Settings, Data Types, Top
11884 @chapter Stack and Trail Commands
11887 This chapter describes the Calc commands for manipulating objects on the
11888 stack and in the trail buffer. (These commands operate on objects of any
11889 type, such as numbers, vectors, formulas, and incomplete objects.)
11892 * Stack Manipulation::
11893 * Editing Stack Entries::
11898 @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
11899 @section Stack Manipulation Commands
11905 @cindex Duplicating stack entries
11906 To duplicate the top object on the stack, press @key{RET} or @key{SPC}
11907 (two equivalent keys for the @code{calc-enter} command).
11908 Given a positive numeric prefix argument, these commands duplicate
11909 several elements at the top of the stack.
11910 Given a negative argument,
11911 these commands duplicate the specified element of the stack.
11912 Given an argument of zero, they duplicate the entire stack.
11913 For example, with @samp{10 20 30} on the stack,
11914 @key{RET} creates @samp{10 20 30 30},
11915 @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
11916 @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
11917 @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.
11921 The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
11922 have it, else on @kbd{C-j}) is like @code{calc-enter}
11923 except that the sign of the numeric prefix argument is interpreted
11924 oppositely. Also, with no prefix argument the default argument is 2.
11925 Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
11926 are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
11927 @samp{10 20 30 20}.
11932 @cindex Removing stack entries
11933 @cindex Deleting stack entries
11934 To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
11935 The @kbd{C-d} key is a synonym for @key{DEL}.
11936 (If the top element is an incomplete object with at least one element, the
11937 last element is removed from it.) Given a positive numeric prefix argument,
11938 several elements are removed. Given a negative argument, the specified
11939 element of the stack is deleted. Given an argument of zero, the entire
11941 For example, with @samp{10 20 30} on the stack,
11942 @key{DEL} leaves @samp{10 20},
11943 @kbd{C-u 2 @key{DEL}} leaves @samp{10},
11944 @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
11945 @kbd{C-u 0 @key{DEL}} leaves an empty stack.
11947 @kindex M-@key{DEL}
11948 @pindex calc-pop-above
11949 The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
11950 @key{LFD} is to @key{RET}: It interprets the sign of the numeric
11951 prefix argument in the opposite way, and the default argument is 2.
11952 Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
11953 leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
11954 the third stack element.
11957 @pindex calc-roll-down
11958 To exchange the top two elements of the stack, press @key{TAB}
11959 (@code{calc-roll-down}). Given a positive numeric prefix argument, the
11960 specified number of elements at the top of the stack are rotated downward.
11961 Given a negative argument, the entire stack is rotated downward the specified
11962 number of times. Given an argument of zero, the entire stack is reversed
11964 For example, with @samp{10 20 30 40 50} on the stack,
11965 @key{TAB} creates @samp{10 20 30 50 40},
11966 @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
11967 @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
11968 @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.
11970 @kindex M-@key{TAB}
11971 @pindex calc-roll-up
11972 The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
11973 except that it rotates upward instead of downward. Also, the default
11974 with no prefix argument is to rotate the top 3 elements.
11975 For example, with @samp{10 20 30 40 50} on the stack,
11976 @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
11977 @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
11978 @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
11979 @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.
11981 A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
11982 terms of moving a particular element to a new position in the stack.
11983 With a positive argument @var{n}, @key{TAB} moves the top stack
11984 element down to level @var{n}, making room for it by pulling all the
11985 intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the
11986 element at level @var{n} up to the top. (Compare with @key{LFD},
11987 which copies instead of moving the element in level @var{n}.)
11989 With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack
11990 to move the object in level @var{n} to the deepest place in the
11991 stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}}
11992 rotates the deepest stack element to be in level @mathit{n}, also
11993 putting the top stack element in level @mathit{@var{n}+1}.
11995 @xref{Selecting Subformulas}, for a way to apply these commands to
11996 any portion of a vector or formula on the stack.
11998 @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
11999 @section Editing Stack Entries
12004 @pindex calc-edit-finish
12005 @cindex Editing the stack with Emacs
12006 The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary
12007 buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using
12008 regular Emacs commands. With a numeric prefix argument, it edits the
12009 specified number of stack entries at once. (An argument of zero edits
12010 the entire stack; a negative argument edits one specific stack entry.)
12012 When you are done editing, press @kbd{C-c C-c} to finish and return
12013 to Calc. The @key{RET} and @key{LFD} keys also work to finish most
12014 sorts of editing, though in some cases Calc leaves @key{RET} with its
12015 usual meaning (``insert a newline'') if it's a situation where you
12016 might want to insert new lines into the editing buffer.
12018 When you finish editing, the Calculator parses the lines of text in
12019 the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
12020 original stack elements in the original buffer with these new values,
12021 then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer
12022 continues to exist during editing, but for best results you should be
12023 careful not to change it until you have finished the edit. You can
12024 also cancel the edit by killing the buffer with @kbd{C-x k}.
12026 The formula is normally reevaluated as it is put onto the stack.
12027 For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
12028 @kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to
12029 finish, Calc will put the result on the stack without evaluating it.
12031 If you give a prefix argument to @kbd{C-c C-c},
12032 Calc will not kill the @samp{*Calc Edit*} buffer. You can switch
12033 back to that buffer and continue editing if you wish. However, you
12034 should understand that if you initiated the edit with @kbd{`}, the
12035 @kbd{C-c C-c} operation will be programmed to replace the top of the
12036 stack with the new edited value, and it will do this even if you have
12037 rearranged the stack in the meanwhile. This is not so much of a problem
12038 with other editing commands, though, such as @kbd{s e}
12039 (@code{calc-edit-variable}; @pxref{Operations on Variables}).
12041 If the @code{calc-edit} command involves more than one stack entry,
12042 each line of the @samp{*Calc Edit*} buffer is interpreted as a
12043 separate formula. Otherwise, the entire buffer is interpreted as
12044 one formula, with line breaks ignored. (You can use @kbd{C-o} or
12045 @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
12047 The @kbd{`} key also works during numeric or algebraic entry. The
12048 text entered so far is moved to the @code{*Calc Edit*} buffer for
12049 more extensive editing than is convenient in the minibuffer.
12051 @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
12052 @section Trail Commands
12055 @cindex Trail buffer
12056 The commands for manipulating the Calc Trail buffer are two-key sequences
12057 beginning with the @kbd{t} prefix.
12060 @pindex calc-trail-display
12061 The @kbd{t d} (@code{calc-trail-display}) command turns display of the
12062 trail on and off. Normally the trail display is toggled on if it was off,
12063 off if it was on. With a numeric prefix of zero, this command always
12064 turns the trail off; with a prefix of one, it always turns the trail on.
12065 The other trail-manipulation commands described here automatically turn
12066 the trail on. Note that when the trail is off values are still recorded
12067 there; they are simply not displayed. To set Emacs to turn the trail
12068 off by default, type @kbd{t d} and then save the mode settings with
12069 @kbd{m m} (@code{calc-save-modes}).
12072 @pindex calc-trail-in
12074 @pindex calc-trail-out
12075 The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
12076 (@code{calc-trail-out}) commands switch the cursor into and out of the
12077 Calc Trail window. In practice they are rarely used, since the commands
12078 shown below are a more convenient way to move around in the
12079 trail, and they work ``by remote control'' when the cursor is still
12080 in the Calculator window.
12082 @cindex Trail pointer
12083 There is a @dfn{trail pointer} which selects some entry of the trail at
12084 any given time. The trail pointer looks like a @samp{>} symbol right
12085 before the selected number. The following commands operate on the
12086 trail pointer in various ways.
12089 @pindex calc-trail-yank
12090 @cindex Retrieving previous results
12091 The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
12092 the trail and pushes it onto the Calculator stack. It allows you to
12093 re-use any previously computed value without retyping. With a numeric
12094 prefix argument @var{n}, it yanks the value @var{n} lines above the current
12098 @pindex calc-trail-scroll-left
12100 @pindex calc-trail-scroll-right
12101 The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
12102 (@code{calc-trail-scroll-right}) commands horizontally scroll the trail
12103 window left or right by one half of its width.
12106 @pindex calc-trail-next
12108 @pindex calc-trail-previous
12110 @pindex calc-trail-forward
12112 @pindex calc-trail-backward
12113 The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
12114 (@code{calc-trail-previous)} commands move the trail pointer down or up
12115 one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
12116 (@code{calc-trail-backward}) commands move the trail pointer down or up
12117 one screenful at a time. All of these commands accept numeric prefix
12118 arguments to move several lines or screenfuls at a time.
12121 @pindex calc-trail-first
12123 @pindex calc-trail-last
12125 @pindex calc-trail-here
12126 The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
12127 (@code{calc-trail-last}) commands move the trail pointer to the first or
12128 last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command
12129 moves the trail pointer to the cursor position; unlike the other trail
12130 commands, @kbd{t h} works only when Calc Trail is the selected window.
12133 @pindex calc-trail-isearch-forward
12135 @pindex calc-trail-isearch-backward
12137 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12138 (@code{calc-trail-isearch-backward}) commands perform an incremental
12139 search forward or backward through the trail. You can press @key{RET}
12140 to terminate the search; the trail pointer moves to the current line.
12141 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12142 it was when the search began.
12145 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12146 (@code{calc-trail-isearch-backward}) com\-mands perform an incremental
12147 search forward or backward through the trail. You can press @key{RET}
12148 to terminate the search; the trail pointer moves to the current line.
12149 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12150 it was when the search began.
12154 @pindex calc-trail-marker
12155 The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
12156 line of text of your own choosing into the trail. The text is inserted
12157 after the line containing the trail pointer; this usually means it is
12158 added to the end of the trail. Trail markers are useful mainly as the
12159 targets for later incremental searches in the trail.
12162 @pindex calc-trail-kill
12163 The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
12164 from the trail. The line is saved in the Emacs kill ring suitable for
12165 yanking into another buffer, but it is not easy to yank the text back
12166 into the trail buffer. With a numeric prefix argument, this command
12167 kills the @var{n} lines below or above the selected one.
12169 The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
12170 elsewhere; @pxref{Vector and Matrix Formats}.
12172 @node Keep Arguments, , Trail Commands, Stack and Trail
12173 @section Keep Arguments
12177 @pindex calc-keep-args
12178 The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
12179 the following command. It prevents that command from removing its
12180 arguments from the stack. For example, after @kbd{2 @key{RET} 3 +},
12181 the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
12182 the stack contains the arguments and the result: @samp{2 3 5}.
12184 This works for all commands that take arguments off the stack. As
12185 another example, @kbd{K a s} simplifies a formula, pushing the
12186 simplified version of the formula onto the stack after the original
12187 formula (rather than replacing the original formula).
12189 Note that you could get the same effect by typing @kbd{@key{RET} a s},
12190 copying the formula and then simplifying the copy. One difference
12191 is that for a very large formula the time taken to format the
12192 intermediate copy in @kbd{@key{RET} a s} could be noticeable; @kbd{K a s}
12193 would avoid this extra work.
12195 Even stack manipulation commands are affected. @key{TAB} works by
12196 popping two values and pushing them back in the opposite order,
12197 so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
12199 A few Calc commands provide other ways of doing the same thing.
12200 For example, @kbd{' sin($)} replaces the number on the stack with
12201 its sine using algebraic entry; to push the sine and keep the
12202 original argument you could use either @kbd{' sin($1)} or
12203 @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s}
12204 command is effectively the same as @kbd{K s t}. @xref{Storing Variables}.
12206 Keyboard macros may interact surprisingly with the @kbd{K} prefix.
12207 If you have defined a keyboard macro to be, say, @samp{Q +} to add
12208 one number to the square root of another, then typing @kbd{K X} will
12209 execute @kbd{K Q +}, probably not what you expected. The @kbd{K}
12210 prefix will apply to just the first command in the macro rather than
12213 If you execute a command and then decide you really wanted to keep
12214 the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
12215 This command pushes the last arguments that were popped by any command
12216 onto the stack. Note that the order of things on the stack will be
12217 different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
12218 @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}.
12220 @node Mode Settings, Arithmetic, Stack and Trail, Top
12221 @chapter Mode Settings
12224 This chapter describes commands that set modes in the Calculator.
12225 They do not affect the contents of the stack, although they may change
12226 the @emph{appearance} or @emph{interpretation} of the stack's contents.
12229 * General Mode Commands::
12231 * Inverse and Hyperbolic::
12232 * Calculation Modes::
12233 * Simplification Modes::
12241 @node General Mode Commands, Precision, Mode Settings, Mode Settings
12242 @section General Mode Commands
12246 @pindex calc-save-modes
12247 @cindex Continuous memory
12248 @cindex Saving mode settings
12249 @cindex Permanent mode settings
12250 @cindex Calc init file, mode settings
12251 You can save all of the current mode settings in your Calc init file
12252 (the file given by the variable @code{calc-settings-file}, typically
12253 @file{~/.calc.el}) with the @kbd{m m} (@code{calc-save-modes}) command.
12254 This will cause Emacs to reestablish these modes each time it starts up.
12255 The modes saved in the file include everything controlled by the @kbd{m}
12256 and @kbd{d} prefix keys, the current precision and binary word size,
12257 whether or not the trail is displayed, the current height of the Calc
12258 window, and more. The current interface (used when you type @kbd{M-#
12259 M-#}) is also saved. If there were already saved mode settings in the
12260 file, they are replaced. Otherwise, the new mode information is
12261 appended to the end of the file.
12264 @pindex calc-mode-record-mode
12265 The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
12266 record the new mode settings (as if by pressing @kbd{m m}) every
12267 time a mode setting changes. If Embedded mode is enabled, other
12268 options are available; @pxref{Mode Settings in Embedded Mode}.
12271 @pindex calc-settings-file-name
12272 The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
12273 choose a different file than the current value of @code{calc-settings-file}
12274 for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information.
12275 You are prompted for a file name. All Calc modes are then reset to
12276 their default values, then settings from the file you named are loaded
12277 if this file exists, and this file becomes the one that Calc will
12278 use in the future for commands like @kbd{m m}. The default settings
12279 file name is @file{~/.calc.el}. You can see the current file name by
12280 giving a blank response to the @kbd{m F} prompt. See also the
12281 discussion of the @code{calc-settings-file} variable; @pxref{Installation}.
12283 If the file name you give is your user init file (typically
12284 @file{~/.emacs}), @kbd{m F} will not automatically load the new file. This
12285 is because your user init file may contain other things you don't want
12286 to reread. You can give
12287 a numeric prefix argument of 1 to @kbd{m F} to force it to read the
12288 file no matter what. Conversely, an argument of @mathit{-1} tells
12289 @kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2}
12290 tells @kbd{m F} not to reset the modes to their defaults beforehand,
12291 which is useful if you intend your new file to have a variant of the
12292 modes present in the file you were using before.
12295 @pindex calc-always-load-extensions
12296 The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
12297 in which the first use of Calc loads the entire program, including all
12298 extensions modules. Otherwise, the extensions modules will not be loaded
12299 until the various advanced Calc features are used. Since this mode only
12300 has effect when Calc is first loaded, @kbd{m x} is usually followed by
12301 @kbd{m m} to make the mode-setting permanent. To load all of Calc just
12302 once, rather than always in the future, you can press @kbd{M-# L}.
12305 @pindex calc-shift-prefix
12306 The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
12307 all of Calc's letter prefix keys may be typed shifted as well as unshifted.
12308 If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
12309 you might find it easier to turn this mode on so that you can type
12310 @kbd{A S} instead. When this mode is enabled, the commands that used to
12311 be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
12312 now be invoked by pressing the shifted letter twice: @kbd{A A}. Note
12313 that the @kbd{v} prefix key always works both shifted and unshifted, and
12314 the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h}
12315 prefix is not affected by this mode. Press @kbd{m S} again to disable
12316 shifted-prefix mode.
12318 @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
12323 @pindex calc-precision
12324 @cindex Precision of calculations
12325 The @kbd{p} (@code{calc-precision}) command controls the precision to
12326 which floating-point calculations are carried. The precision must be
12327 at least 3 digits and may be arbitrarily high, within the limits of
12328 memory and time. This affects only floats: Integer and rational
12329 calculations are always carried out with as many digits as necessary.
12331 The @kbd{p} key prompts for the current precision. If you wish you
12332 can instead give the precision as a numeric prefix argument.
12334 Many internal calculations are carried to one or two digits higher
12335 precision than normal. Results are rounded down afterward to the
12336 current precision. Unless a special display mode has been selected,
12337 floats are always displayed with their full stored precision, i.e.,
12338 what you see is what you get. Reducing the current precision does not
12339 round values already on the stack, but those values will be rounded
12340 down before being used in any calculation. The @kbd{c 0} through
12341 @kbd{c 9} commands (@pxref{Conversions}) can be used to round an
12342 existing value to a new precision.
12344 @cindex Accuracy of calculations
12345 It is important to distinguish the concepts of @dfn{precision} and
12346 @dfn{accuracy}. In the normal usage of these words, the number
12347 123.4567 has a precision of 7 digits but an accuracy of 4 digits.
12348 The precision is the total number of digits not counting leading
12349 or trailing zeros (regardless of the position of the decimal point).
12350 The accuracy is simply the number of digits after the decimal point
12351 (again not counting trailing zeros). In Calc you control the precision,
12352 not the accuracy of computations. If you were to set the accuracy
12353 instead, then calculations like @samp{exp(100)} would generate many
12354 more digits than you would typically need, while @samp{exp(-100)} would
12355 probably round to zero! In Calc, both these computations give you
12356 exactly 12 (or the requested number of) significant digits.
12358 The only Calc features that deal with accuracy instead of precision
12359 are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
12360 and the rounding functions like @code{floor} and @code{round}
12361 (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9}
12362 deal with both precision and accuracy depending on the magnitudes
12363 of the numbers involved.
12365 If you need to work with a particular fixed accuracy (say, dollars and
12366 cents with two digits after the decimal point), one solution is to work
12367 with integers and an ``implied'' decimal point. For example, $8.99
12368 divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
12369 (actually $1.49833 with our implied decimal point); pressing @kbd{R}
12370 would round this to 150 cents, i.e., $1.50.
12372 @xref{Floats}, for still more on floating-point precision and related
12375 @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
12376 @section Inverse and Hyperbolic Flags
12380 @pindex calc-inverse
12381 There is no single-key equivalent to the @code{calc-arcsin} function.
12382 Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
12383 the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
12384 The @kbd{I} key actually toggles the Inverse Flag. When this flag
12385 is set, the word @samp{Inv} appears in the mode line.
12388 @pindex calc-hyperbolic
12389 Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
12390 Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
12391 If both of these flags are set at once, the effect will be
12392 @code{calc-arcsinh}. (The Hyperbolic flag is also used by some
12393 non-trigonometric commands; for example @kbd{H L} computes a base-10,
12394 instead of base-@mathit{e}, logarithm.)
12396 Command names like @code{calc-arcsin} are provided for completeness, and
12397 may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to
12398 toggle the Inverse and/or Hyperbolic flags and then execute the
12399 corresponding base command (@code{calc-sin} in this case).
12401 The Inverse and Hyperbolic flags apply only to the next Calculator
12402 command, after which they are automatically cleared. (They are also
12403 cleared if the next keystroke is not a Calc command.) Digits you
12404 type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix
12405 arguments for the next command, not as numeric entries. The same
12406 is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to
12407 subtract and keep arguments).
12409 The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed
12410 elsewhere. @xref{Keep Arguments}.
12412 @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
12413 @section Calculation Modes
12416 The commands in this section are two-key sequences beginning with
12417 the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.)
12418 The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
12419 (@pxref{Algebraic Entry}).
12428 * Automatic Recomputation::
12429 * Working Message::
12432 @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
12433 @subsection Angular Modes
12436 @cindex Angular mode
12437 The Calculator supports three notations for angles: radians, degrees,
12438 and degrees-minutes-seconds. When a number is presented to a function
12439 like @code{sin} that requires an angle, the current angular mode is
12440 used to interpret the number as either radians or degrees. If an HMS
12441 form is presented to @code{sin}, it is always interpreted as
12442 degrees-minutes-seconds.
12444 Functions that compute angles produce a number in radians, a number in
12445 degrees, or an HMS form depending on the current angular mode. If the
12446 result is a complex number and the current mode is HMS, the number is
12447 instead expressed in degrees. (Complex-number calculations would
12448 normally be done in Radians mode, though. Complex numbers are converted
12449 to degrees by calculating the complex result in radians and then
12450 multiplying by 180 over @cpi{}.)
12453 @pindex calc-radians-mode
12455 @pindex calc-degrees-mode
12457 @pindex calc-hms-mode
12458 The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
12459 and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
12460 The current angular mode is displayed on the Emacs mode line.
12461 The default angular mode is Degrees.
12463 @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
12464 @subsection Polar Mode
12468 The Calculator normally ``prefers'' rectangular complex numbers in the
12469 sense that rectangular form is used when the proper form can not be
12470 decided from the input. This might happen by multiplying a rectangular
12471 number by a polar one, by taking the square root of a negative real
12472 number, or by entering @kbd{( 2 @key{SPC} 3 )}.
12475 @pindex calc-polar-mode
12476 The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
12477 preference between rectangular and polar forms. In Polar mode, all
12478 of the above example situations would produce polar complex numbers.
12480 @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
12481 @subsection Fraction Mode
12484 @cindex Fraction mode
12485 @cindex Division of integers
12486 Division of two integers normally yields a floating-point number if the
12487 result cannot be expressed as an integer. In some cases you would
12488 rather get an exact fractional answer. One way to accomplish this is
12489 to multiply fractions instead: @kbd{6 @key{RET} 1:4 *} produces @expr{3:2}
12490 even though @kbd{6 @key{RET} 4 /} produces @expr{1.5}.
12493 @pindex calc-frac-mode
12494 To set the Calculator to produce fractional results for normal integer
12495 divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
12496 For example, @expr{8/4} produces @expr{2} in either mode,
12497 but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in
12500 At any time you can use @kbd{c f} (@code{calc-float}) to convert a
12501 fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
12502 float to a fraction. @xref{Conversions}.
12504 @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
12505 @subsection Infinite Mode
12508 @cindex Infinite mode
12509 The Calculator normally treats results like @expr{1 / 0} as errors;
12510 formulas like this are left in unsimplified form. But Calc can be
12511 put into a mode where such calculations instead produce ``infinite''
12515 @pindex calc-infinite-mode
12516 The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
12517 on and off. When the mode is off, infinities do not arise except
12518 in calculations that already had infinities as inputs. (One exception
12519 is that infinite open intervals like @samp{[0 .. inf)} can be
12520 generated; however, intervals closed at infinity (@samp{[0 .. inf]})
12521 will not be generated when Infinite mode is off.)
12523 With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
12524 an undirected infinity. @xref{Infinities}, for a discussion of the
12525 difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0}
12526 evaluates to @code{nan}, the ``indeterminate'' symbol. Various other
12527 functions can also return infinities in this mode; for example,
12528 @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again,
12529 note that @samp{exp(inf) = inf} regardless of Infinite mode because
12530 this calculation has infinity as an input.
12532 @cindex Positive Infinite mode
12533 The @kbd{m i} command with a numeric prefix argument of zero,
12534 i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in
12535 which zero is treated as positive instead of being directionless.
12536 Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
12537 Note that zero never actually has a sign in Calc; there are no
12538 separate representations for @mathit{+0} and @mathit{-0}. Positive
12539 Infinite mode merely changes the interpretation given to the
12540 single symbol, @samp{0}. One consequence of this is that, while
12541 you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
12542 is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
12544 @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
12545 @subsection Symbolic Mode
12548 @cindex Symbolic mode
12549 @cindex Inexact results
12550 Calculations are normally performed numerically wherever possible.
12551 For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
12552 algebraic expression, produces a numeric answer if the argument is a
12553 number or a symbolic expression if the argument is an expression:
12554 @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
12557 @pindex calc-symbolic-mode
12558 In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
12559 command, functions which would produce inexact, irrational results are
12560 left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
12564 @pindex calc-eval-num
12565 The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
12566 the expression at the top of the stack, by temporarily disabling
12567 @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
12568 Given a numeric prefix argument, it also
12569 sets the floating-point precision to the specified value for the duration
12572 To evaluate a formula numerically without expanding the variables it
12573 contains, you can use the key sequence @kbd{m s a v m s} (this uses
12574 @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
12577 @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
12578 @subsection Matrix and Scalar Modes
12581 @cindex Matrix mode
12582 @cindex Scalar mode
12583 Calc sometimes makes assumptions during algebraic manipulation that
12584 are awkward or incorrect when vectors and matrices are involved.
12585 Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which
12586 modify its behavior around vectors in useful ways.
12589 @pindex calc-matrix-mode
12590 Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode.
12591 In this mode, all objects are assumed to be matrices unless provably
12592 otherwise. One major effect is that Calc will no longer consider
12593 multiplication to be commutative. (Recall that in matrix arithmetic,
12594 @samp{A*B} is not the same as @samp{B*A}.) This assumption affects
12595 rewrite rules and algebraic simplification. Another effect of this
12596 mode is that calculations that would normally produce constants like
12597 0 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now
12598 produce function calls that represent ``generic'' zero or identity
12599 matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function
12600 @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
12601 identity matrix; if @var{n} is omitted, it doesn't know what
12602 dimension to use and so the @code{idn} call remains in symbolic
12603 form. However, if this generic identity matrix is later combined
12604 with a matrix whose size is known, it will be converted into
12605 a true identity matrix of the appropriate size. On the other hand,
12606 if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
12607 will assume it really was a scalar after all and produce, e.g., 3.
12609 Press @kbd{m v} a second time to get Scalar mode. Here, objects are
12610 assumed @emph{not} to be vectors or matrices unless provably so.
12611 For example, normally adding a variable to a vector, as in
12612 @samp{[x, y, z] + a}, will leave the sum in symbolic form because
12613 as far as Calc knows, @samp{a} could represent either a number or
12614 another 3-vector. In Scalar mode, @samp{a} is assumed to be a
12615 non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
12617 Press @kbd{m v} a third time to return to the normal mode of operation.
12619 If you press @kbd{m v} with a numeric prefix argument @var{n}, you
12620 get a special ``dimensioned'' Matrix mode in which matrices of
12621 unknown size are assumed to be @var{n}x@var{n} square matrices.
12622 Then, the function call @samp{idn(1)} will expand into an actual
12623 matrix rather than representing a ``generic'' matrix.
12625 @cindex Declaring scalar variables
12626 Of course these modes are approximations to the true state of
12627 affairs, which is probably that some quantities will be matrices
12628 and others will be scalars. One solution is to ``declare''
12629 certain variables or functions to be scalar-valued.
12630 @xref{Declarations}, to see how to make declarations in Calc.
12632 There is nothing stopping you from declaring a variable to be
12633 scalar and then storing a matrix in it; however, if you do, the
12634 results you get from Calc may not be valid. Suppose you let Calc
12635 get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
12636 @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as
12637 for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
12638 your earlier promise to Calc that @samp{a} would be scalar.
12640 Another way to mix scalars and matrices is to use selections
12641 (@pxref{Selecting Subformulas}). Use Matrix mode when operating on
12642 your formula normally; then, to apply Scalar mode to a certain part
12643 of the formula without affecting the rest just select that part,
12644 change into Scalar mode and press @kbd{=} to resimplify the part
12645 under this mode, then change back to Matrix mode before deselecting.
12647 @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
12648 @subsection Automatic Recomputation
12651 The @dfn{evaluates-to} operator, @samp{=>}, has the special
12652 property that any @samp{=>} formulas on the stack are recomputed
12653 whenever variable values or mode settings that might affect them
12654 are changed. @xref{Evaluates-To Operator}.
12657 @pindex calc-auto-recompute
12658 The @kbd{m C} (@code{calc-auto-recompute}) command turns this
12659 automatic recomputation on and off. If you turn it off, Calc will
12660 not update @samp{=>} operators on the stack (nor those in the
12661 attached Embedded mode buffer, if there is one). They will not
12662 be updated unless you explicitly do so by pressing @kbd{=} or until
12663 you press @kbd{m C} to turn recomputation back on. (While automatic
12664 recomputation is off, you can think of @kbd{m C m C} as a command
12665 to update all @samp{=>} operators while leaving recomputation off.)
12667 To update @samp{=>} operators in an Embedded buffer while
12668 automatic recomputation is off, use @w{@kbd{M-# u}}.
12669 @xref{Embedded Mode}.
12671 @node Working Message, , Automatic Recomputation, Calculation Modes
12672 @subsection Working Messages
12675 @cindex Performance
12676 @cindex Working messages
12677 Since the Calculator is written entirely in Emacs Lisp, which is not
12678 designed for heavy numerical work, many operations are quite slow.
12679 The Calculator normally displays the message @samp{Working...} in the
12680 echo area during any command that may be slow. In addition, iterative
12681 operations such as square roots and trigonometric functions display the
12682 intermediate result at each step. Both of these types of messages can
12683 be disabled if you find them distracting.
12686 @pindex calc-working
12687 Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
12688 disable all ``working'' messages. Use a numeric prefix of 1 to enable
12689 only the plain @samp{Working...} message. Use a numeric prefix of 2 to
12690 see intermediate results as well. With no numeric prefix this displays
12693 While it may seem that the ``working'' messages will slow Calc down
12694 considerably, experiments have shown that their impact is actually
12695 quite small. But if your terminal is slow you may find that it helps
12696 to turn the messages off.
12698 @node Simplification Modes, Declarations, Calculation Modes, Mode Settings
12699 @section Simplification Modes
12702 The current @dfn{simplification mode} controls how numbers and formulas
12703 are ``normalized'' when being taken from or pushed onto the stack.
12704 Some normalizations are unavoidable, such as rounding floating-point
12705 results to the current precision, and reducing fractions to simplest
12706 form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}),
12707 are done by default but can be turned off when necessary.
12709 When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the
12710 stack, Calc pops these numbers, normalizes them, creates the formula
12711 @expr{2+3}, normalizes it, and pushes the result. Of course the standard
12712 rules for normalizing @expr{2+3} will produce the result @expr{5}.
12714 Simplification mode commands consist of the lower-case @kbd{m} prefix key
12715 followed by a shifted letter.
12718 @pindex calc-no-simplify-mode
12719 The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
12720 simplifications. These would leave a formula like @expr{2+3} alone. In
12721 fact, nothing except simple numbers are ever affected by normalization
12725 @pindex calc-num-simplify-mode
12726 The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
12727 of any formulas except those for which all arguments are constants. For
12728 example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is
12729 simplified to @expr{a+0} but no further, since one argument of the sum
12730 is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified
12731 because the top-level @samp{-} operator's arguments are not both
12732 constant numbers (one of them is the formula @expr{a+2}).
12733 A constant is a number or other numeric object (such as a constant
12734 error form or modulo form), or a vector all of whose
12735 elements are constant.
12738 @pindex calc-default-simplify-mode
12739 The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
12740 default simplifications for all formulas. This includes many easy and
12741 fast algebraic simplifications such as @expr{a+0} to @expr{a}, and
12742 @expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like
12743 @texline @t{deriv}@expr{(x^2,x)}
12744 @infoline @expr{@t{deriv}(x^2, x)}
12748 @pindex calc-bin-simplify-mode
12749 The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
12750 simplifications to a result and then, if the result is an integer,
12751 uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
12752 to the current binary word size. @xref{Binary Functions}. Real numbers
12753 are rounded to the nearest integer and then clipped; other kinds of
12754 results (after the default simplifications) are left alone.
12757 @pindex calc-alg-simplify-mode
12758 The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
12759 simplification; it applies all the default simplifications, and also
12760 the more powerful (and slower) simplifications made by @kbd{a s}
12761 (@code{calc-simplify}). @xref{Algebraic Simplifications}.
12764 @pindex calc-ext-simplify-mode
12765 The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
12766 algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
12767 command. @xref{Unsafe Simplifications}.
12770 @pindex calc-units-simplify-mode
12771 The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
12772 simplification; it applies the command @kbd{u s}
12773 (@code{calc-simplify-units}), which in turn
12774 is a superset of @kbd{a s}. In this mode, variable names which
12775 are identifiable as unit names (like @samp{mm} for ``millimeters'')
12776 are simplified with their unit definitions in mind.
12778 A common technique is to set the simplification mode down to the lowest
12779 amount of simplification you will allow to be applied automatically, then
12780 use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
12781 perform higher types of simplifications on demand. @xref{Algebraic
12782 Definitions}, for another sample use of No-Simplification mode.
12784 @node Declarations, Display Modes, Simplification Modes, Mode Settings
12785 @section Declarations
12788 A @dfn{declaration} is a statement you make that promises you will
12789 use a certain variable or function in a restricted way. This may
12790 give Calc the freedom to do things that it couldn't do if it had to
12791 take the fully general situation into account.
12794 * Declaration Basics::
12795 * Kinds of Declarations::
12796 * Functions for Declarations::
12799 @node Declaration Basics, Kinds of Declarations, Declarations, Declarations
12800 @subsection Declaration Basics
12804 @pindex calc-declare-variable
12805 The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
12806 way to make a declaration for a variable. This command prompts for
12807 the variable name, then prompts for the declaration. The default
12808 at the declaration prompt is the previous declaration, if any.
12809 You can edit this declaration, or press @kbd{C-k} to erase it and
12810 type a new declaration. (Or, erase it and press @key{RET} to clear
12811 the declaration, effectively ``undeclaring'' the variable.)
12813 A declaration is in general a vector of @dfn{type symbols} and
12814 @dfn{range} values. If there is only one type symbol or range value,
12815 you can write it directly rather than enclosing it in a vector.
12816 For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
12817 be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
12818 declares @code{bar} to be a constant integer between 1 and 6.
12819 (Actually, you can omit the outermost brackets and Calc will
12820 provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
12822 @cindex @code{Decls} variable
12824 Declarations in Calc are kept in a special variable called @code{Decls}.
12825 This variable encodes the set of all outstanding declarations in
12826 the form of a matrix. Each row has two elements: A variable or
12827 vector of variables declared by that row, and the declaration
12828 specifier as described above. You can use the @kbd{s D} command to
12829 edit this variable if you wish to see all the declarations at once.
12830 @xref{Operations on Variables}, for a description of this command
12831 and the @kbd{s p} command that allows you to save your declarations
12832 permanently if you wish.
12834 Items being declared can also be function calls. The arguments in
12835 the call are ignored; the effect is to say that this function returns
12836 values of the declared type for any valid arguments. The @kbd{s d}
12837 command declares only variables, so if you wish to make a function
12838 declaration you will have to edit the @code{Decls} matrix yourself.
12840 For example, the declaration matrix
12846 [ f(1,2,3), [0 .. inf) ] ]
12851 declares that @code{foo} represents a real number, @code{j}, @code{k}
12852 and @code{n} represent integers, and the function @code{f} always
12853 returns a real number in the interval shown.
12856 If there is a declaration for the variable @code{All}, then that
12857 declaration applies to all variables that are not otherwise declared.
12858 It does not apply to function names. For example, using the row
12859 @samp{[All, real]} says that all your variables are real unless they
12860 are explicitly declared without @code{real} in some other row.
12861 The @kbd{s d} command declares @code{All} if you give a blank
12862 response to the variable-name prompt.
12864 @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
12865 @subsection Kinds of Declarations
12868 The type-specifier part of a declaration (that is, the second prompt
12869 in the @kbd{s d} command) can be a type symbol, an interval, or a
12870 vector consisting of zero or more type symbols followed by zero or
12871 more intervals or numbers that represent the set of possible values
12876 [ [ a, [1, 2, 3, 4, 5] ]
12878 [ c, [int, 1 .. 5] ] ]
12882 Here @code{a} is declared to contain one of the five integers shown;
12883 @code{b} is any number in the interval from 1 to 5 (any real number
12884 since we haven't specified), and @code{c} is any integer in that
12885 interval. Thus the declarations for @code{a} and @code{c} are
12886 nearly equivalent (see below).
12888 The type-specifier can be the empty vector @samp{[]} to say that
12889 nothing is known about a given variable's value. This is the same
12890 as not declaring the variable at all except that it overrides any
12891 @code{All} declaration which would otherwise apply.
12893 The initial value of @code{Decls} is the empty vector @samp{[]}.
12894 If @code{Decls} has no stored value or if the value stored in it
12895 is not valid, it is ignored and there are no declarations as far
12896 as Calc is concerned. (The @kbd{s d} command will replace such a
12897 malformed value with a fresh empty matrix, @samp{[]}, before recording
12898 the new declaration.) Unrecognized type symbols are ignored.
12900 The following type symbols describe what sorts of numbers will be
12901 stored in a variable:
12907 Numerical integers. (Integers or integer-valued floats.)
12909 Fractions. (Rational numbers which are not integers.)
12911 Rational numbers. (Either integers or fractions.)
12913 Floating-point numbers.
12915 Real numbers. (Integers, fractions, or floats. Actually,
12916 intervals and error forms with real components also count as
12919 Positive real numbers. (Strictly greater than zero.)
12921 Nonnegative real numbers. (Greater than or equal to zero.)
12923 Numbers. (Real or complex.)
12926 Calc uses this information to determine when certain simplifications
12927 of formulas are safe. For example, @samp{(x^y)^z} cannot be
12928 simplified to @samp{x^(y z)} in general; for example,
12929 @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}.
12930 However, this simplification @emph{is} safe if @code{z} is known
12931 to be an integer, or if @code{x} is known to be a nonnegative
12932 real number. If you have given declarations that allow Calc to
12933 deduce either of these facts, Calc will perform this simplification
12936 Calc can apply a certain amount of logic when using declarations.
12937 For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
12938 has been declared @code{int}; Calc knows that an integer times an
12939 integer, plus an integer, must always be an integer. (In fact,
12940 Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
12941 it is able to determine that @samp{2n+1} must be an odd integer.)
12943 Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
12944 because Calc knows that the @code{abs} function always returns a
12945 nonnegative real. If you had a @code{myabs} function that also had
12946 this property, you could get Calc to recognize it by adding the row
12947 @samp{[myabs(), nonneg]} to the @code{Decls} matrix.
12949 One instance of this simplification is @samp{sqrt(x^2)} (since the
12950 @code{sqrt} function is effectively a one-half power). Normally
12951 Calc leaves this formula alone. After the command
12952 @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
12953 @samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
12954 simplify this formula all the way to @samp{x}.
12956 If there are any intervals or real numbers in the type specifier,
12957 they comprise the set of possible values that the variable or
12958 function being declared can have. In particular, the type symbol
12959 @code{real} is effectively the same as the range @samp{[-inf .. inf]}
12960 (note that infinity is included in the range of possible values);
12961 @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
12962 the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is
12963 redundant because the fact that the variable is real can be
12964 deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
12965 @samp{[rat, [-5 .. 5]]} are useful combinations.
12967 Note that the vector of intervals or numbers is in the same format
12968 used by Calc's set-manipulation commands. @xref{Set Operations}.
12970 The type specifier @samp{[1, 2, 3]} is equivalent to
12971 @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
12972 In other words, the range of possible values means only that
12973 the variable's value must be numerically equal to a number in
12974 that range, but not that it must be equal in type as well.
12975 Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
12976 and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
12978 If you use a conflicting combination of type specifiers, the
12979 results are unpredictable. An example is @samp{[pos, [0 .. 5]]},
12980 where the interval does not lie in the range described by the
12983 ``Real'' declarations mostly affect simplifications involving powers
12984 like the one described above. Another case where they are used
12985 is in the @kbd{a P} command which returns a list of all roots of a
12986 polynomial; if the variable has been declared real, only the real
12987 roots (if any) will be included in the list.
12989 ``Integer'' declarations are used for simplifications which are valid
12990 only when certain values are integers (such as @samp{(x^y)^z}
12993 Another command that makes use of declarations is @kbd{a s}, when
12994 simplifying equations and inequalities. It will cancel @code{x}
12995 from both sides of @samp{a x = b x} only if it is sure @code{x}
12996 is non-zero, say, because it has a @code{pos} declaration.
12997 To declare specifically that @code{x} is real and non-zero,
12998 use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
12999 current notation to say that @code{x} is nonzero but not necessarily
13000 real.) The @kbd{a e} command does ``unsafe'' simplifications,
13001 including cancelling @samp{x} from the equation when @samp{x} is
13002 not known to be nonzero.
13004 Another set of type symbols distinguish between scalars and vectors.
13008 The value is not a vector.
13010 The value is a vector.
13012 The value is a matrix (a rectangular vector of vectors).
13015 These type symbols can be combined with the other type symbols
13016 described above; @samp{[int, matrix]} describes an object which
13017 is a matrix of integers.
13019 Scalar/vector declarations are used to determine whether certain
13020 algebraic operations are safe. For example, @samp{[a, b, c] + x}
13021 is normally not simplified to @samp{[a + x, b + x, c + x]}, but
13022 it will be if @code{x} has been declared @code{scalar}. On the
13023 other hand, multiplication is usually assumed to be commutative,
13024 but the terms in @samp{x y} will never be exchanged if both @code{x}
13025 and @code{y} are known to be vectors or matrices. (Calc currently
13026 never distinguishes between @code{vector} and @code{matrix}
13029 @xref{Matrix Mode}, for a discussion of Matrix mode and
13030 Scalar mode, which are similar to declaring @samp{[All, matrix]}
13031 or @samp{[All, scalar]} but much more convenient.
13033 One more type symbol that is recognized is used with the @kbd{H a d}
13034 command for taking total derivatives of a formula. @xref{Calculus}.
13038 The value is a constant with respect to other variables.
13041 Calc does not check the declarations for a variable when you store
13042 a value in it. However, storing @mathit{-3.5} in a variable that has
13043 been declared @code{pos}, @code{int}, or @code{matrix} may have
13044 unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5}
13045 if it substitutes the value first, or to @expr{-3.5} if @code{x}
13046 was declared @code{pos} and the formula @samp{sqrt(x^2)} is
13047 simplified to @samp{x} before the value is substituted. Before
13048 using a variable for a new purpose, it is best to use @kbd{s d}
13049 or @kbd{s D} to check to make sure you don't still have an old
13050 declaration for the variable that will conflict with its new meaning.
13052 @node Functions for Declarations, , Kinds of Declarations, Declarations
13053 @subsection Functions for Declarations
13056 Calc has a set of functions for accessing the current declarations
13057 in a convenient manner. These functions return 1 if the argument
13058 can be shown to have the specified property, or 0 if the argument
13059 can be shown @emph{not} to have that property; otherwise they are
13060 left unevaluated. These functions are suitable for use with rewrite
13061 rules (@pxref{Conditional Rewrite Rules}) or programming constructs
13062 (@pxref{Conditionals in Macros}). They can be entered only using
13063 algebraic notation. @xref{Logical Operations}, for functions
13064 that perform other tests not related to declarations.
13066 For example, @samp{dint(17)} returns 1 because 17 is an integer, as
13067 do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
13068 @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
13069 Calc consults knowledge of its own built-in functions as well as your
13070 own declarations: @samp{dint(floor(x))} returns 1.
13084 The @code{dint} function checks if its argument is an integer.
13085 The @code{dnatnum} function checks if its argument is a natural
13086 number, i.e., a nonnegative integer. The @code{dnumint} function
13087 checks if its argument is numerically an integer, i.e., either an
13088 integer or an integer-valued float. Note that these and the other
13089 data type functions also accept vectors or matrices composed of
13090 suitable elements, and that real infinities @samp{inf} and @samp{-inf}
13091 are considered to be integers for the purposes of these functions.
13097 The @code{drat} function checks if its argument is rational, i.e.,
13098 an integer or fraction. Infinities count as rational, but intervals
13099 and error forms do not.
13105 The @code{dreal} function checks if its argument is real. This
13106 includes integers, fractions, floats, real error forms, and intervals.
13112 The @code{dimag} function checks if its argument is imaginary,
13113 i.e., is mathematically equal to a real number times @expr{i}.
13127 The @code{dpos} function checks for positive (but nonzero) reals.
13128 The @code{dneg} function checks for negative reals. The @code{dnonneg}
13129 function checks for nonnegative reals, i.e., reals greater than or
13130 equal to zero. Note that the @kbd{a s} command can simplify an
13131 expression like @expr{x > 0} to 1 or 0 using @code{dpos}, and that
13132 @kbd{a s} is effectively applied to all conditions in rewrite rules,
13133 so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
13134 are rarely necessary.
13140 The @code{dnonzero} function checks that its argument is nonzero.
13141 This includes all nonzero real or complex numbers, all intervals that
13142 do not include zero, all nonzero modulo forms, vectors all of whose
13143 elements are nonzero, and variables or formulas whose values can be
13144 deduced to be nonzero. It does not include error forms, since they
13145 represent values which could be anything including zero. (This is
13146 also the set of objects considered ``true'' in conditional contexts.)
13156 The @code{deven} function returns 1 if its argument is known to be
13157 an even integer (or integer-valued float); it returns 0 if its argument
13158 is known not to be even (because it is known to be odd or a non-integer).
13159 The @kbd{a s} command uses this to simplify a test of the form
13160 @samp{x % 2 = 0}. There is also an analogous @code{dodd} function.
13166 The @code{drange} function returns a set (an interval or a vector
13167 of intervals and/or numbers; @pxref{Set Operations}) that describes
13168 the set of possible values of its argument. If the argument is
13169 a variable or a function with a declaration, the range is copied
13170 from the declaration. Otherwise, the possible signs of the
13171 expression are determined using a method similar to @code{dpos},
13172 etc., and a suitable set like @samp{[0 .. inf]} is returned. If
13173 the expression is not provably real, the @code{drange} function
13174 remains unevaluated.
13180 The @code{dscalar} function returns 1 if its argument is provably
13181 scalar, or 0 if its argument is provably non-scalar. It is left
13182 unevaluated if this cannot be determined. (If Matrix mode or Scalar
13183 mode is in effect, this function returns 1 or 0, respectively,
13184 if it has no other information.) When Calc interprets a condition
13185 (say, in a rewrite rule) it considers an unevaluated formula to be
13186 ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
13187 provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
13188 is provably non-scalar; both are ``false'' if there is insufficient
13189 information to tell.
13191 @node Display Modes, Language Modes, Declarations, Mode Settings
13192 @section Display Modes
13195 The commands in this section are two-key sequences beginning with the
13196 @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
13197 (@code{calc-line-breaking}) commands are described elsewhere;
13198 @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
13199 Display formats for vectors and matrices are also covered elsewhere;
13200 @pxref{Vector and Matrix Formats}.
13202 One thing all display modes have in common is their treatment of the
13203 @kbd{H} prefix. This prefix causes any mode command that would normally
13204 refresh the stack to leave the stack display alone. The word ``Dirty''
13205 will appear in the mode line when Calc thinks the stack display may not
13206 reflect the latest mode settings.
13208 @kindex d @key{RET}
13209 @pindex calc-refresh-top
13210 The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
13211 top stack entry according to all the current modes. Positive prefix
13212 arguments reformat the top @var{n} entries; negative prefix arguments
13213 reformat the specified entry, and a prefix of zero is equivalent to
13214 @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
13215 For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
13216 but reformats only the top two stack entries in the new mode.
13218 The @kbd{I} prefix has another effect on the display modes. The mode
13219 is set only temporarily; the top stack entry is reformatted according
13220 to that mode, then the original mode setting is restored. In other
13221 words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
13225 * Grouping Digits::
13227 * Complex Formats::
13228 * Fraction Formats::
13231 * Truncating the Stack::
13236 @node Radix Modes, Grouping Digits, Display Modes, Display Modes
13237 @subsection Radix Modes
13240 @cindex Radix display
13241 @cindex Non-decimal numbers
13242 @cindex Decimal and non-decimal numbers
13243 Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
13244 notation. Calc can actually display in any radix from two (binary) to 36.
13245 When the radix is above 10, the letters @code{A} to @code{Z} are used as
13246 digits. When entering such a number, letter keys are interpreted as
13247 potential digits rather than terminating numeric entry mode.
13253 @cindex Hexadecimal integers
13254 @cindex Octal integers
13255 The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
13256 binary, octal, hexadecimal, and decimal as the current display radix,
13257 respectively. Numbers can always be entered in any radix, though the
13258 current radix is used as a default if you press @kbd{#} without any initial
13259 digits. A number entered without a @kbd{#} is @emph{always} interpreted
13264 To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
13265 an integer from 2 to 36. You can specify the radix as a numeric prefix
13266 argument; otherwise you will be prompted for it.
13269 @pindex calc-leading-zeros
13270 @cindex Leading zeros
13271 Integers normally are displayed with however many digits are necessary to
13272 represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros})
13273 command causes integers to be padded out with leading zeros according to the
13274 current binary word size. (@xref{Binary Functions}, for a discussion of
13275 word size.) If the absolute value of the word size is @expr{w}, all integers
13276 are displayed with at least enough digits to represent
13277 @texline @math{2^w-1}
13278 @infoline @expr{(2^w)-1}
13279 in the current radix. (Larger integers will still be displayed in their
13282 @node Grouping Digits, Float Formats, Radix Modes, Display Modes
13283 @subsection Grouping Digits
13287 @pindex calc-group-digits
13288 @cindex Grouping digits
13289 @cindex Digit grouping
13290 Long numbers can be hard to read if they have too many digits. For
13291 example, the factorial of 30 is 33 digits long! Press @kbd{d g}
13292 (@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits
13293 are displayed in clumps of 3 or 4 (depending on the current radix)
13294 separated by commas.
13296 The @kbd{d g} command toggles grouping on and off.
13297 With a numerix prefix of 0, this command displays the current state of
13298 the grouping flag; with an argument of minus one it disables grouping;
13299 with a positive argument @expr{N} it enables grouping on every @expr{N}
13300 digits. For floating-point numbers, grouping normally occurs only
13301 before the decimal point. A negative prefix argument @expr{-N} enables
13302 grouping every @expr{N} digits both before and after the decimal point.
13305 @pindex calc-group-char
13306 The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
13307 character as the grouping separator. The default is the comma character.
13308 If you find it difficult to read vectors of large integers grouped with
13309 commas, you may wish to use spaces or some other character instead.
13310 This command takes the next character you type, whatever it is, and
13311 uses it as the digit separator. As a special case, @kbd{d , \} selects
13312 @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
13314 Please note that grouped numbers will not generally be parsed correctly
13315 if re-read in textual form, say by the use of @kbd{M-# y} and @kbd{M-# g}.
13316 (@xref{Kill and Yank}, for details on these commands.) One exception is
13317 the @samp{\,} separator, which doesn't interfere with parsing because it
13318 is ignored by @TeX{} language mode.
13320 @node Float Formats, Complex Formats, Grouping Digits, Display Modes
13321 @subsection Float Formats
13324 Floating-point quantities are normally displayed in standard decimal
13325 form, with scientific notation used if the exponent is especially high
13326 or low. All significant digits are normally displayed. The commands
13327 in this section allow you to choose among several alternative display
13328 formats for floats.
13331 @pindex calc-normal-notation
13332 The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
13333 display format. All significant figures in a number are displayed.
13334 With a positive numeric prefix, numbers are rounded if necessary to
13335 that number of significant digits. With a negative numerix prefix,
13336 the specified number of significant digits less than the current
13337 precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the
13338 current precision is 12.)
13341 @pindex calc-fix-notation
13342 The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
13343 notation. The numeric argument is the number of digits after the
13344 decimal point, zero or more. This format will relax into scientific
13345 notation if a nonzero number would otherwise have been rounded all the
13346 way to zero. Specifying a negative number of digits is the same as
13347 for a positive number, except that small nonzero numbers will be rounded
13348 to zero rather than switching to scientific notation.
13351 @pindex calc-sci-notation
13352 @cindex Scientific notation, display of
13353 The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
13354 notation. A positive argument sets the number of significant figures
13355 displayed, of which one will be before and the rest after the decimal
13356 point. A negative argument works the same as for @kbd{d n} format.
13357 The default is to display all significant digits.
13360 @pindex calc-eng-notation
13361 @cindex Engineering notation, display of
13362 The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
13363 notation. This is similar to scientific notation except that the
13364 exponent is rounded down to a multiple of three, with from one to three
13365 digits before the decimal point. An optional numeric prefix sets the
13366 number of significant digits to display, as for @kbd{d s}.
13368 It is important to distinguish between the current @emph{precision} and
13369 the current @emph{display format}. After the commands @kbd{C-u 10 p}
13370 and @kbd{C-u 6 d n} the Calculator computes all results to ten
13371 significant figures but displays only six. (In fact, intermediate
13372 calculations are often carried to one or two more significant figures,
13373 but values placed on the stack will be rounded down to ten figures.)
13374 Numbers are never actually rounded to the display precision for storage,
13375 except by commands like @kbd{C-k} and @kbd{M-# y} which operate on the
13376 actual displayed text in the Calculator buffer.
13379 @pindex calc-point-char
13380 The @kbd{d .} (@code{calc-point-char}) command selects the character used
13381 as a decimal point. Normally this is a period; users in some countries
13382 may wish to change this to a comma. Note that this is only a display
13383 style; on entry, periods must always be used to denote floating-point
13384 numbers, and commas to separate elements in a list.
13386 @node Complex Formats, Fraction Formats, Float Formats, Display Modes
13387 @subsection Complex Formats
13391 @pindex calc-complex-notation
13392 There are three supported notations for complex numbers in rectangular
13393 form. The default is as a pair of real numbers enclosed in parentheses
13394 and separated by a comma: @samp{(a,b)}. The @kbd{d c}
13395 (@code{calc-complex-notation}) command selects this style.
13398 @pindex calc-i-notation
13400 @pindex calc-j-notation
13401 The other notations are @kbd{d i} (@code{calc-i-notation}), in which
13402 numbers are displayed in @samp{a+bi} form, and @kbd{d j}
13403 (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
13404 in some disciplines.
13406 @cindex @code{i} variable
13408 Complex numbers are normally entered in @samp{(a,b)} format.
13409 If you enter @samp{2+3i} as an algebraic formula, it will be stored as
13410 the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate
13411 this formula and you have not changed the variable @samp{i}, the @samp{i}
13412 will be interpreted as @samp{(0,1)} and the formula will be simplified
13413 to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not}
13414 interpret the formula @samp{2 + 3 * i} as a complex number.
13415 @xref{Variables}, under ``special constants.''
13417 @node Fraction Formats, HMS Formats, Complex Formats, Display Modes
13418 @subsection Fraction Formats
13422 @pindex calc-over-notation
13423 Display of fractional numbers is controlled by the @kbd{d o}
13424 (@code{calc-over-notation}) command. By default, a number like
13425 eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command
13426 prompts for a one- or two-character format. If you give one character,
13427 that character is used as the fraction separator. Common separators are
13428 @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be
13429 used regardless of the display format; in particular, the @kbd{/} is used
13430 for RPN-style division, @emph{not} for entering fractions.)
13432 If you give two characters, fractions use ``integer-plus-fractional-part''
13433 notation. For example, the format @samp{+/} would display eight thirds
13434 as @samp{2+2/3}. If two colons are present in a number being entered,
13435 the number is interpreted in this form (so that the entries @kbd{2:2:3}
13436 and @kbd{8:3} are equivalent).
13438 It is also possible to follow the one- or two-character format with
13439 a number. For example: @samp{:10} or @samp{+/3}. In this case,
13440 Calc adjusts all fractions that are displayed to have the specified
13441 denominator, if possible. Otherwise it adjusts the denominator to
13442 be a multiple of the specified value. For example, in @samp{:6} mode
13443 the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be
13444 displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6},
13445 and @expr{1:8} will be displayed as @expr{3:24}. Integers are also
13446 affected by this mode: 3 is displayed as @expr{18:6}. Note that the
13447 format @samp{:1} writes fractions the same as @samp{:}, but it writes
13448 integers as @expr{n:1}.
13450 The fraction format does not affect the way fractions or integers are
13451 stored, only the way they appear on the screen. The fraction format
13452 never affects floats.
13454 @node HMS Formats, Date Formats, Fraction Formats, Display Modes
13455 @subsection HMS Formats
13459 @pindex calc-hms-notation
13460 The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
13461 HMS (hours-minutes-seconds) forms. It prompts for a string which
13462 consists basically of an ``hours'' marker, optional punctuation, a
13463 ``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
13464 Punctuation is zero or more spaces, commas, or semicolons. The hours
13465 marker is one or more non-punctuation characters. The minutes and
13466 seconds markers must be single non-punctuation characters.
13468 The default HMS format is @samp{@@ ' "}, producing HMS values of the form
13469 @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same
13470 value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o}
13471 keys are recognized as synonyms for @kbd{@@} regardless of display format.
13472 The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
13473 @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
13474 already been typed; otherwise, they have their usual meanings
13475 (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
13476 @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
13477 The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
13478 @kbd{o}) has already been pressed; otherwise it means to switch to algebraic
13481 @node Date Formats, Truncating the Stack, HMS Formats, Display Modes
13482 @subsection Date Formats
13486 @pindex calc-date-notation
13487 The @kbd{d d} (@code{calc-date-notation}) command controls the display
13488 of date forms (@pxref{Date Forms}). It prompts for a string which
13489 contains letters that represent the various parts of a date and time.
13490 To show which parts should be omitted when the form represents a pure
13491 date with no time, parts of the string can be enclosed in @samp{< >}
13492 marks. If you don't include @samp{< >} markers in the format, Calc
13493 guesses at which parts, if any, should be omitted when formatting
13496 The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
13497 An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
13498 If you enter a blank format string, this default format is
13501 Calc uses @samp{< >} notation for nameless functions as well as for
13502 dates. @xref{Specifying Operators}. To avoid confusion with nameless
13503 functions, your date formats should avoid using the @samp{#} character.
13506 * Date Formatting Codes::
13507 * Free-Form Dates::
13508 * Standard Date Formats::
13511 @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
13512 @subsubsection Date Formatting Codes
13515 When displaying a date, the current date format is used. All
13516 characters except for letters and @samp{<} and @samp{>} are
13517 copied literally when dates are formatted. The portion between
13518 @samp{< >} markers is omitted for pure dates, or included for
13519 date/time forms. Letters are interpreted according to the table
13522 When dates are read in during algebraic entry, Calc first tries to
13523 match the input string to the current format either with or without
13524 the time part. The punctuation characters (including spaces) must
13525 match exactly; letter fields must correspond to suitable text in
13526 the input. If this doesn't work, Calc checks if the input is a
13527 simple number; if so, the number is interpreted as a number of days
13528 since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and
13529 flexible algorithm which is described in the next section.
13531 Weekday names are ignored during reading.
13533 Two-digit year numbers are interpreted as lying in the range
13534 from 1941 to 2039. Years outside that range are always
13535 entered and displayed in full. Year numbers with a leading
13536 @samp{+} sign are always interpreted exactly, allowing the
13537 entry and display of the years 1 through 99 AD.
13539 Here is a complete list of the formatting codes for dates:
13543 Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
13545 Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
13547 Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
13549 Year: ``1991'' for 1991, ``23'' for 23 AD.
13551 Year: ``1991'' for 1991, ``+23'' for 23 AD.
13553 Year: ``ad'' or blank.
13555 Year: ``AD'' or blank.
13557 Year: ``ad '' or blank. (Note trailing space.)
13559 Year: ``AD '' or blank.
13561 Year: ``a.d.'' or blank.
13563 Year: ``A.D.'' or blank.
13565 Year: ``bc'' or blank.
13567 Year: ``BC'' or blank.
13569 Year: `` bc'' or blank. (Note leading space.)
13571 Year: `` BC'' or blank.
13573 Year: ``b.c.'' or blank.
13575 Year: ``B.C.'' or blank.
13577 Month: ``8'' for August.
13579 Month: ``08'' for August.
13581 Month: `` 8'' for August.
13583 Month: ``AUG'' for August.
13585 Month: ``Aug'' for August.
13587 Month: ``aug'' for August.
13589 Month: ``AUGUST'' for August.
13591 Month: ``August'' for August.
13593 Day: ``7'' for 7th day of month.
13595 Day: ``07'' for 7th day of month.
13597 Day: `` 7'' for 7th day of month.
13599 Weekday: ``0'' for Sunday, ``6'' for Saturday.
13601 Weekday: ``SUN'' for Sunday.
13603 Weekday: ``Sun'' for Sunday.
13605 Weekday: ``sun'' for Sunday.
13607 Weekday: ``SUNDAY'' for Sunday.
13609 Weekday: ``Sunday'' for Sunday.
13611 Day of year: ``34'' for Feb. 3.
13613 Day of year: ``034'' for Feb. 3.
13615 Day of year: `` 34'' for Feb. 3.
13617 Hour: ``5'' for 5 AM; ``17'' for 5 PM.
13619 Hour: ``05'' for 5 AM; ``17'' for 5 PM.
13621 Hour: `` 5'' for 5 AM; ``17'' for 5 PM.
13623 Hour: ``5'' for 5 AM and 5 PM.
13625 Hour: ``05'' for 5 AM and 5 PM.
13627 Hour: `` 5'' for 5 AM and 5 PM.
13629 AM/PM: ``a'' or ``p''.
13631 AM/PM: ``A'' or ``P''.
13633 AM/PM: ``am'' or ``pm''.
13635 AM/PM: ``AM'' or ``PM''.
13637 AM/PM: ``a.m.'' or ``p.m.''.
13639 AM/PM: ``A.M.'' or ``P.M.''.
13641 Minutes: ``7'' for 7.
13643 Minutes: ``07'' for 7.
13645 Minutes: `` 7'' for 7.
13647 Seconds: ``7'' for 7; ``7.23'' for 7.23.
13649 Seconds: ``07'' for 7; ``07.23'' for 7.23.
13651 Seconds: `` 7'' for 7; `` 7.23'' for 7.23.
13653 Optional seconds: ``07'' for 7; blank for 0.
13655 Optional seconds: `` 7'' for 7; blank for 0.
13657 Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991.
13659 Numeric date: ``726842'' for any time on Wed Jan 9, 1991.
13661 Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991.
13663 Julian date: ``2448266'' for any time on Wed Jan 9, 1991.
13665 Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991.
13667 Brackets suppression. An ``X'' at the front of the format
13668 causes the surrounding @w{@samp{< >}} delimiters to be omitted
13669 when formatting dates. Note that the brackets are still
13670 required for algebraic entry.
13673 If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
13674 colon is also omitted if the seconds part is zero.
13676 If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
13677 appear in the format, then negative year numbers are displayed
13678 without a minus sign. Note that ``aa'' and ``bb'' are mutually
13679 exclusive. Some typical usages would be @samp{YYYY AABB};
13680 @samp{AAAYYYYBBB}; @samp{YYYYBBB}.
13682 The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
13683 ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
13684 reading unless several of these codes are strung together with no
13685 punctuation in between, in which case the input must have exactly as
13686 many digits as there are letters in the format.
13688 The ``j,'' ``J,'' and ``U'' formats do not make any time zone
13689 adjustment. They effectively use @samp{julian(x,0)} and
13690 @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
13692 @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
13693 @subsubsection Free-Form Dates
13696 When reading a date form during algebraic entry, Calc falls back
13697 on the algorithm described here if the input does not exactly
13698 match the current date format. This algorithm generally
13699 ``does the right thing'' and you don't have to worry about it,
13700 but it is described here in full detail for the curious.
13702 Calc does not distinguish between upper- and lower-case letters
13703 while interpreting dates.
13705 First, the time portion, if present, is located somewhere in the
13706 text and then removed. The remaining text is then interpreted as
13709 A time is of the form @samp{hh:mm:ss}, possibly with the seconds
13710 part omitted and possibly with an AM/PM indicator added to indicate
13711 12-hour time. If the AM/PM is present, the minutes may also be
13712 omitted. The AM/PM part may be any of the words @samp{am},
13713 @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
13714 abbreviated to one letter, and the alternate forms @samp{a.m.},
13715 @samp{p.m.}, and @samp{mid} are also understood. Obviously
13716 @samp{noon} and @samp{midnight} are allowed only on 12:00:00.
13717 The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
13718 recognized with no number attached.
13720 If there is no AM/PM indicator, the time is interpreted in 24-hour
13723 To read the date portion, all words and numbers are isolated
13724 from the string; other characters are ignored. All words must
13725 be either month names or day-of-week names (the latter of which
13726 are ignored). Names can be written in full or as three-letter
13729 Large numbers, or numbers with @samp{+} or @samp{-} signs,
13730 are interpreted as years. If one of the other numbers is
13731 greater than 12, then that must be the day and the remaining
13732 number in the input is therefore the month. Otherwise, Calc
13733 assumes the month, day and year are in the same order that they
13734 appear in the current date format. If the year is omitted, the
13735 current year is taken from the system clock.
13737 If there are too many or too few numbers, or any unrecognizable
13738 words, then the input is rejected.
13740 If there are any large numbers (of five digits or more) other than
13741 the year, they are ignored on the assumption that they are something
13742 like Julian dates that were included along with the traditional
13743 date components when the date was formatted.
13745 One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
13746 may optionally be used; the latter two are equivalent to a
13747 minus sign on the year value.
13749 If you always enter a four-digit year, and use a name instead
13750 of a number for the month, there is no danger of ambiguity.
13752 @node Standard Date Formats, , Free-Form Dates, Date Formats
13753 @subsubsection Standard Date Formats
13756 There are actually ten standard date formats, numbered 0 through 9.
13757 Entering a blank line at the @kbd{d d} command's prompt gives
13758 you format number 1, Calc's usual format. You can enter any digit
13759 to select the other formats.
13761 To create your own standard date formats, give a numeric prefix
13762 argument from 0 to 9 to the @w{@kbd{d d}} command. The format you
13763 enter will be recorded as the new standard format of that
13764 number, as well as becoming the new current date format.
13765 You can save your formats permanently with the @w{@kbd{m m}}
13766 command (@pxref{Mode Settings}).
13770 @samp{N} (Numerical format)
13772 @samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format)
13774 @samp{D Mmm YYYY<, h:mm:SS>} (European format)
13776 @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format)
13778 @samp{M/D/Y< H:mm:SSpp>} (American slashed format)
13780 @samp{D.M.Y< h:mm:SS>} (European dotted format)
13782 @samp{M-D-Y< H:mm:SSpp>} (American dashed format)
13784 @samp{D-M-Y< h:mm:SS>} (European dashed format)
13786 @samp{j<, h:mm:ss>} (Julian day plus time)
13788 @samp{YYddd< hh:mm:ss>} (Year-day format)
13791 @node Truncating the Stack, Justification, Date Formats, Display Modes
13792 @subsection Truncating the Stack
13796 @pindex calc-truncate-stack
13797 @cindex Truncating the stack
13798 @cindex Narrowing the stack
13799 The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
13800 line that marks the top-of-stack up or down in the Calculator buffer.
13801 The number right above that line is considered to the be at the top of
13802 the stack. Any numbers below that line are ``hidden'' from all stack
13803 operations. This is similar to the Emacs ``narrowing'' feature, except
13804 that the values below the @samp{.} are @emph{visible}, just temporarily
13805 frozen. This feature allows you to keep several independent calculations
13806 running at once in different parts of the stack, or to apply a certain
13807 command to an element buried deep in the stack.
13809 Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
13810 is on. Thus, this line and all those below it become hidden. To un-hide
13811 these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
13812 With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the
13813 bottom @expr{n} values in the buffer. With a negative argument, it hides
13814 all but the top @expr{n} values. With an argument of zero, it hides zero
13815 values, i.e., moves the @samp{.} all the way down to the bottom.
13818 @pindex calc-truncate-up
13820 @pindex calc-truncate-down
13821 The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
13822 (@code{calc-truncate-down}) commands move the @samp{.} up or down one
13823 line at a time (or several lines with a prefix argument).
13825 @node Justification, Labels, Truncating the Stack, Display Modes
13826 @subsection Justification
13830 @pindex calc-left-justify
13832 @pindex calc-center-justify
13834 @pindex calc-right-justify
13835 Values on the stack are normally left-justified in the window. You can
13836 control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
13837 @kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
13838 (@code{calc-center-justify}). For example, in Right-Justification mode,
13839 stack entries are displayed flush-right against the right edge of the
13842 If you change the width of the Calculator window you may have to type
13843 @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
13846 Right-justification is especially useful together with fixed-point
13847 notation (see @code{d f}; @code{calc-fix-notation}). With these modes
13848 together, the decimal points on numbers will always line up.
13850 With a numeric prefix argument, the justification commands give you
13851 a little extra control over the display. The argument specifies the
13852 horizontal ``origin'' of a display line. It is also possible to
13853 specify a maximum line width using the @kbd{d b} command (@pxref{Normal
13854 Language Modes}). For reference, the precise rules for formatting and
13855 breaking lines are given below. Notice that the interaction between
13856 origin and line width is slightly different in each justification
13859 In Left-Justified mode, the line is indented by a number of spaces
13860 given by the origin (default zero). If the result is longer than the
13861 maximum line width, if given, or too wide to fit in the Calc window
13862 otherwise, then it is broken into lines which will fit; each broken
13863 line is indented to the origin.
13865 In Right-Justified mode, lines are shifted right so that the rightmost
13866 character is just before the origin, or just before the current
13867 window width if no origin was specified. If the line is too long
13868 for this, then it is broken; the current line width is used, if
13869 specified, or else the origin is used as a width if that is
13870 specified, or else the line is broken to fit in the window.
13872 In Centering mode, the origin is the column number of the center of
13873 each stack entry. If a line width is specified, lines will not be
13874 allowed to go past that width; Calc will either indent less or
13875 break the lines if necessary. If no origin is specified, half the
13876 line width or Calc window width is used.
13878 Note that, in each case, if line numbering is enabled the display
13879 is indented an additional four spaces to make room for the line
13880 number. The width of the line number is taken into account when
13881 positioning according to the current Calc window width, but not
13882 when positioning by explicit origins and widths. In the latter
13883 case, the display is formatted as specified, and then uniformly
13884 shifted over four spaces to fit the line numbers.
13886 @node Labels, , Justification, Display Modes
13891 @pindex calc-left-label
13892 The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
13893 then displays that string to the left of every stack entry. If the
13894 entries are left-justified (@pxref{Justification}), then they will
13895 appear immediately after the label (unless you specified an origin
13896 greater than the length of the label). If the entries are centered
13897 or right-justified, the label appears on the far left and does not
13898 affect the horizontal position of the stack entry.
13900 Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
13903 @pindex calc-right-label
13904 The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
13905 label on the righthand side. It does not affect positioning of
13906 the stack entries unless they are right-justified. Also, if both
13907 a line width and an origin are given in Right-Justified mode, the
13908 stack entry is justified to the origin and the righthand label is
13909 justified to the line width.
13911 One application of labels would be to add equation numbers to
13912 formulas you are manipulating in Calc and then copying into a
13913 document (possibly using Embedded mode). The equations would
13914 typically be centered, and the equation numbers would be on the
13915 left or right as you prefer.
13917 @node Language Modes, Modes Variable, Display Modes, Mode Settings
13918 @section Language Modes
13921 The commands in this section change Calc to use a different notation for
13922 entry and display of formulas, corresponding to the conventions of some
13923 other common language such as Pascal or @TeX{}. Objects displayed on the
13924 stack or yanked from the Calculator to an editing buffer will be formatted
13925 in the current language; objects entered in algebraic entry or yanked from
13926 another buffer will be interpreted according to the current language.
13928 The current language has no effect on things written to or read from the
13929 trail buffer, nor does it affect numeric entry. Only algebraic entry is
13930 affected. You can make even algebraic entry ignore the current language
13931 and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
13933 For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
13934 program; elsewhere in the program you need the derivatives of this formula
13935 with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C}
13936 to switch to C notation. Now use @code{C-u M-# g} to grab the formula
13937 into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
13938 to the first variable, and @kbd{M-# y} to yank the formula for the derivative
13939 back into your C program. Press @kbd{U} to undo the differentiation and
13940 repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
13942 Without being switched into C mode first, Calc would have misinterpreted
13943 the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
13944 @code{atan} was equivalent to Calc's built-in @code{arctan} function,
13945 and would have written the formula back with notations (like implicit
13946 multiplication) which would not have been legal for a C program.
13948 As another example, suppose you are maintaining a C program and a @TeX{}
13949 document, each of which needs a copy of the same formula. You can grab the
13950 formula from the program in C mode, switch to @TeX{} mode, and yank the
13951 formula into the document in @TeX{} math-mode format.
13953 Language modes are selected by typing the letter @kbd{d} followed by a
13954 shifted letter key.
13957 * Normal Language Modes::
13958 * C FORTRAN Pascal::
13959 * TeX Language Mode::
13960 * Eqn Language Mode::
13961 * Mathematica Language Mode::
13962 * Maple Language Mode::
13967 @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
13968 @subsection Normal Language Modes
13972 @pindex calc-normal-language
13973 The @kbd{d N} (@code{calc-normal-language}) command selects the usual
13974 notation for Calc formulas, as described in the rest of this manual.
13975 Matrices are displayed in a multi-line tabular format, but all other
13976 objects are written in linear form, as they would be typed from the
13980 @pindex calc-flat-language
13981 @cindex Matrix display
13982 The @kbd{d O} (@code{calc-flat-language}) command selects a language
13983 identical with the normal one, except that matrices are written in
13984 one-line form along with everything else. In some applications this
13985 form may be more suitable for yanking data into other buffers.
13988 @pindex calc-line-breaking
13989 @cindex Line breaking
13990 @cindex Breaking up long lines
13991 Even in one-line mode, long formulas or vectors will still be split
13992 across multiple lines if they exceed the width of the Calculator window.
13993 The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
13994 feature on and off. (It works independently of the current language.)
13995 If you give a numeric prefix argument of five or greater to the @kbd{d b}
13996 command, that argument will specify the line width used when breaking
14000 @pindex calc-big-language
14001 The @kbd{d B} (@code{calc-big-language}) command selects a language
14002 which uses textual approximations to various mathematical notations,
14003 such as powers, quotients, and square roots:
14013 in place of @samp{sqrt((a+1)/b + c^2)}.
14015 Subscripts like @samp{a_i} are displayed as actual subscripts in Big
14016 mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
14017 are displayed as @samp{a} with subscripts separated by commas:
14018 @samp{i, j}. They must still be entered in the usual underscore
14021 One slight ambiguity of Big notation is that
14030 can represent either the negative rational number @expr{-3:4}, or the
14031 actual expression @samp{-(3/4)}; but the latter formula would normally
14032 never be displayed because it would immediately be evaluated to
14033 @expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in
14036 Non-decimal numbers are displayed with subscripts. Thus there is no
14037 way to tell the difference between @samp{16#C2} and @samp{C2_16},
14038 though generally you will know which interpretation is correct.
14039 Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
14042 In Big mode, stack entries often take up several lines. To aid
14043 readability, stack entries are separated by a blank line in this mode.
14044 You may find it useful to expand the Calc window's height using
14045 @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
14046 one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
14048 Long lines are currently not rearranged to fit the window width in
14049 Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
14050 to scroll across a wide formula. For really big formulas, you may
14051 even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
14054 @pindex calc-unformatted-language
14055 The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
14056 the use of operator notation in formulas. In this mode, the formula
14057 shown above would be displayed:
14060 sqrt(add(div(add(a, 1), b), pow(c, 2)))
14063 These four modes differ only in display format, not in the format
14064 expected for algebraic entry. The standard Calc operators work in
14065 all four modes, and unformatted notation works in any language mode
14066 (except that Mathematica mode expects square brackets instead of
14069 @node C FORTRAN Pascal, TeX Language Mode, Normal Language Modes, Language Modes
14070 @subsection C, FORTRAN, and Pascal Modes
14074 @pindex calc-c-language
14076 The @kbd{d C} (@code{calc-c-language}) command selects the conventions
14077 of the C language for display and entry of formulas. This differs from
14078 the normal language mode in a variety of (mostly minor) ways. In
14079 particular, C language operators and operator precedences are used in
14080 place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)}
14081 in C mode; a value raised to a power is written as a function call,
14084 In C mode, vectors and matrices use curly braces instead of brackets.
14085 Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
14086 rather than using the @samp{#} symbol. Array subscripting is
14087 translated into @code{subscr} calls, so that @samp{a[i]} in C
14088 mode is the same as @samp{a_i} in Normal mode. Assignments
14089 turn into the @code{assign} function, which Calc normally displays
14090 using the @samp{:=} symbol.
14092 The variables @code{pi} and @code{e} would be displayed @samp{pi}
14093 and @samp{e} in Normal mode, but in C mode they are displayed as
14094 @samp{M_PI} and @samp{M_E}, corresponding to the names of constants
14095 typically provided in the @file{<math.h>} header. Functions whose
14096 names are different in C are translated automatically for entry and
14097 display purposes. For example, entering @samp{asin(x)} will push the
14098 formula @samp{arcsin(x)} onto the stack; this formula will be displayed
14099 as @samp{asin(x)} as long as C mode is in effect.
14102 @pindex calc-pascal-language
14103 @cindex Pascal language
14104 The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
14105 conventions. Like C mode, Pascal mode interprets array brackets and uses
14106 a different table of operators. Hexadecimal numbers are entered and
14107 displayed with a preceding dollar sign. (Thus the regular meaning of
14108 @kbd{$2} during algebraic entry does not work in Pascal mode, though
14109 @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
14110 always.) No special provisions are made for other non-decimal numbers,
14111 vectors, and so on, since there is no universally accepted standard way
14112 of handling these in Pascal.
14115 @pindex calc-fortran-language
14116 @cindex FORTRAN language
14117 The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
14118 conventions. Various function names are transformed into FORTRAN
14119 equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be
14120 entered this way or using square brackets. Since FORTRAN uses round
14121 parentheses for both function calls and array subscripts, Calc displays
14122 both in the same way; @samp{a(i)} is interpreted as a function call
14123 upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
14124 Also, if the variable @code{a} has been declared to have type
14125 @code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
14126 subscript. (@xref{Declarations}.) Usually it doesn't matter, though;
14127 if you enter the subscript expression @samp{a(i)} and Calc interprets
14128 it as a function call, you'll never know the difference unless you
14129 switch to another language mode or replace @code{a} with an actual
14130 vector (or unless @code{a} happens to be the name of a built-in
14133 Underscores are allowed in variable and function names in all of these
14134 language modes. The underscore here is equivalent to the @samp{#} in
14135 Normal mode, or to hyphens in the underlying Emacs Lisp variable names.
14137 FORTRAN and Pascal modes normally do not adjust the case of letters in
14138 formulas. Most built-in Calc names use lower-case letters. If you use a
14139 positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
14140 modes will use upper-case letters exclusively for display, and will
14141 convert to lower-case on input. With a negative prefix, these modes
14142 convert to lower-case for display and input.
14144 @node TeX Language Mode, Eqn Language Mode, C FORTRAN Pascal, Language Modes
14145 @subsection @TeX{} Language Mode
14149 @pindex calc-tex-language
14150 @cindex TeX language
14151 The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
14152 of ``math mode'' in the @TeX{} typesetting language, by Donald Knuth.
14153 Formulas are entered
14154 and displayed in @TeX{} notation, as in @samp{\sin\left( a \over b \right)}.
14155 Math formulas are usually enclosed by @samp{$ $} signs in @TeX{}; these
14156 should be omitted when interfacing with Calc. To Calc, the @samp{$} sign
14157 has the same meaning it always does in algebraic formulas (a reference to
14158 an existing entry on the stack).
14160 Complex numbers are displayed as in @samp{3 + 4i}. Fractions and
14161 quotients are written using @code{\over};
14162 binomial coefficients are written with @code{\choose}.
14163 Interval forms are written with @code{\ldots}, and
14164 error forms are written with @code{\pm}.
14165 Absolute values are written as in @samp{|x + 1|}, and the floor and
14166 ceiling functions are written with @code{\lfloor}, @code{\rfloor}, etc.
14167 The words @code{\left} and @code{\right} are ignored when reading
14168 formulas in @TeX{} mode. Both @code{inf} and @code{uinf} are written
14169 as @code{\infty}; when read, @code{\infty} always translates to
14172 Function calls are written the usual way, with the function name followed
14173 by the arguments in parentheses. However, functions for which @TeX{} has
14174 special names (like @code{\sin}) will use curly braces instead of
14175 parentheses for very simple arguments. During input, curly braces and
14176 parentheses work equally well for grouping, but when the document is
14177 formatted the curly braces will be invisible. Thus the printed result is
14178 @texline @math{\sin{2 x}}
14179 @infoline @expr{sin 2x}
14181 @texline @math{\sin(2 + x)}.
14182 @infoline @expr{sin(2 + x)}.
14184 Function and variable names not treated specially by @TeX{} are simply
14185 written out as-is, which will cause them to come out in italic letters
14186 in the printed document. If you invoke @kbd{d T} with a positive numeric
14187 prefix argument, names of more than one character will instead be written
14188 @samp{\hbox@{@var{name}@}}. The @samp{\hbox@{ @}} notation is ignored
14189 during reading. If you use a negative prefix argument, such function
14190 names are written @samp{\@var{name}}, and function names that begin
14191 with @code{\} during reading have the @code{\} removed. (Note that
14192 in this mode, long variable names are still written with @code{\hbox}.
14193 However, you can always make an actual variable name like @code{\bar}
14194 in any @TeX{} mode.)
14196 During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
14197 by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and
14198 @code{\bmatrix}. The symbol @samp{&} is interpreted as a comma,
14199 and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
14200 During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
14201 format; you may need to edit this afterwards to change @code{\matrix}
14202 to @code{\pmatrix} or @code{\\} to @code{\cr}.
14204 Accents like @code{\tilde} and @code{\bar} translate into function
14205 calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline}
14206 sequence is treated as an accent. The @code{\vec} accent corresponds
14207 to the function name @code{Vec}, because @code{vec} is the name of
14208 a built-in Calc function. The following table shows the accents
14209 in Calc, @TeX{}, and @dfn{eqn} (described in the next section):
14213 @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes
14214 @let@calcindexersh=@calcindexernoshow
14279 dotdot \ddot dotdot
14285 under \underline under
14289 The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
14290 @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an
14291 alias for @code{\rightarrow}. However, if the @samp{=>} is the
14292 top-level expression being formatted, a slightly different notation
14293 is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto}
14294 word is ignored by Calc's input routines, and is undefined in @TeX{}.
14295 You will typically want to include one of the following definitions
14296 at the top of a @TeX{} file that uses @code{\evalto}:
14300 \def\evalto#1\to@{@}
14303 The first definition formats evaluates-to operators in the usual
14304 way. The second causes only the @var{b} part to appear in the
14305 printed document; the @var{a} part and the arrow are hidden.
14306 Another definition you may wish to use is @samp{\let\to=\Rightarrow}
14307 which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
14308 @xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
14310 The complete set of @TeX{} control sequences that are ignored during
14314 \hbox \mbox \text \left \right
14315 \, \> \: \; \! \quad \qquad \hfil \hfill
14316 \displaystyle \textstyle \dsize \tsize
14317 \scriptstyle \scriptscriptstyle \ssize \ssize
14318 \rm \bf \it \sl \roman \bold \italic \slanted
14319 \cal \mit \Cal \Bbb \frak \goth
14323 Note that, because these symbols are ignored, reading a @TeX{} formula
14324 into Calc and writing it back out may lose spacing and font information.
14326 Also, the ``discretionary multiplication sign'' @samp{\*} is read
14327 the same as @samp{*}.
14330 The @TeX{} version of this manual includes some printed examples at the
14331 end of this section.
14334 Here are some examples of how various Calc formulas are formatted in @TeX{}:
14339 \sin\left( {a^2 \over b_i} \right)
14343 $$ \sin\left( a^2 \over b_i \right) $$
14349 [(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
14350 [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
14355 $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
14361 [abs(a), abs(a / b), floor(a), ceil(a / b)]
14362 [|a|, \left| a \over b \right|,
14363 \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
14367 $$ [|a|, \left| a \over b \right|,
14368 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
14374 [sin(a), sin(2 a), sin(2 + a), sin(a / b)]
14375 [\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
14376 \sin\left( @{a \over b@} \right)]
14381 $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
14385 First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
14386 @kbd{C-u - d T} (using the example definition
14387 @samp{\def\foo#1@{\tilde F(#1)@}}:
14391 [f(a), foo(bar), sin(pi)]
14392 [f(a), foo(bar), \sin{\pi}]
14393 [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
14394 [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
14398 $$ [f(a), foo(bar), \sin{\pi}] $$
14399 $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
14400 $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
14404 First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
14409 \evalto 2 + 3 \to 5
14419 First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
14423 [2 + 3 => 5, a / 2 => (b + c) / 2]
14424 [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
14429 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
14430 {\let\to\Rightarrow
14431 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
14435 Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
14439 [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
14440 \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14441 \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14446 $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14447 $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14452 @node Eqn Language Mode, Mathematica Language Mode, TeX Language Mode, Language Modes
14453 @subsection Eqn Language Mode
14457 @pindex calc-eqn-language
14458 @dfn{Eqn} is another popular formatter for math formulas. It is
14459 designed for use with the TROFF text formatter, and comes standard
14460 with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language})
14461 command selects @dfn{eqn} notation.
14463 The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
14464 a significant part in the parsing of the language. For example,
14465 @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
14466 @code{sqrt} operator. @dfn{Eqn} also understands more conventional
14467 grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are
14468 required only when the argument contains spaces.
14470 In Calc's @dfn{eqn} mode, however, curly braces are required to
14471 delimit arguments of operators like @code{sqrt}. The first of the
14472 above examples would treat only the @samp{x} as the argument of
14473 @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
14474 @samp{sin * x + 1}, because @code{sin} is not a special operator
14475 in the @dfn{eqn} language. If you always surround the argument
14476 with curly braces, Calc will never misunderstand.
14478 Calc also understands parentheses as grouping characters. Another
14479 peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
14480 words with spaces from any surrounding characters that aren't curly
14481 braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
14482 (The spaces around @code{sin} are important to make @dfn{eqn}
14483 recognize that @code{sin} should be typeset in a roman font, and
14484 the spaces around @code{x} and @code{y} are a good idea just in
14485 case the @dfn{eqn} document has defined special meanings for these
14488 Powers and subscripts are written with the @code{sub} and @code{sup}
14489 operators, respectively. Note that the caret symbol @samp{^} is
14490 treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
14491 symbol (these are used to introduce spaces of various widths into
14492 the typeset output of @dfn{eqn}).
14494 As in @TeX{} mode, Calc's formatter omits parentheses around the
14495 arguments of functions like @code{ln} and @code{sin} if they are
14496 ``simple-looking''; in this case Calc surrounds the argument with
14497 braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
14499 Font change codes (like @samp{roman @var{x}}) and positioning codes
14500 (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
14501 @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right},
14502 @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input
14503 are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
14504 @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
14505 of quotes in @dfn{eqn}, but it is good enough for most uses.
14507 Accent codes (@samp{@var{x} dot}) are handled by treating them as
14508 function calls (@samp{dot(@var{x})}) internally. @xref{TeX Language
14509 Mode}, for a table of these accent functions. The @code{prime} accent
14510 is treated specially if it occurs on a variable or function name:
14511 @samp{f prime prime @w{( x prime )}} is stored internally as
14512 @samp{f'@w{'}(x')}. For example, taking the derivative of @samp{f(2 x)}
14513 with @kbd{a d x} will produce @samp{2 f'(2 x)}, which @dfn{eqn} mode
14514 will display as @samp{2 f prime ( 2 x )}.
14516 Assignments are written with the @samp{<-} (left-arrow) symbol,
14517 and @code{evalto} operators are written with @samp{->} or
14518 @samp{evalto ... ->} (@pxref{TeX Language Mode}, for a discussion
14519 of this). The regular Calc symbols @samp{:=} and @samp{=>} are also
14520 recognized for these operators during reading.
14522 Vectors in @dfn{eqn} mode use regular Calc square brackets, but
14523 matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
14524 The words @code{lcol} and @code{rcol} are recognized as synonyms
14525 for @code{ccol} during input, and are generated instead of @code{ccol}
14526 if the matrix justification mode so specifies.
14528 @node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
14529 @subsection Mathematica Language Mode
14533 @pindex calc-mathematica-language
14534 @cindex Mathematica language
14535 The @kbd{d M} (@code{calc-mathematica-language}) command selects the
14536 conventions of Mathematica, a powerful and popular mathematical tool
14537 from Wolfram Research, Inc. Notable differences in Mathematica mode
14538 are that the names of built-in functions are capitalized, and function
14539 calls use square brackets instead of parentheses. Thus the Calc
14540 formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
14543 Vectors and matrices use curly braces in Mathematica. Complex numbers
14544 are written @samp{3 + 4 I}. The standard special constants in Calc are
14545 written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
14546 @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
14548 Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point
14549 numbers in scientific notation are written @samp{1.23*10.^3}.
14550 Subscripts use double square brackets: @samp{a[[i]]}.
14552 @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
14553 @subsection Maple Language Mode
14557 @pindex calc-maple-language
14558 @cindex Maple language
14559 The @kbd{d W} (@code{calc-maple-language}) command selects the
14560 conventions of Maple, another mathematical tool from the University
14563 Maple's language is much like C. Underscores are allowed in symbol
14564 names; square brackets are used for subscripts; explicit @samp{*}s for
14565 multiplications are required. Use either @samp{^} or @samp{**} to
14568 Maple uses square brackets for lists and curly braces for sets. Calc
14569 interprets both notations as vectors, and displays vectors with square
14570 brackets. This means Maple sets will be converted to lists when they
14571 pass through Calc. As a special case, matrices are written as calls
14572 to the function @code{matrix}, given a list of lists as the argument,
14573 and can be read in this form or with all-capitals @code{MATRIX}.
14575 The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
14576 Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
14577 writes any kind of interval as @samp{2 .. 3}. This means you cannot
14578 see the difference between an open and a closed interval while in
14579 Maple display mode.
14581 Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
14582 are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
14583 @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
14584 Floating-point numbers are written @samp{1.23*10.^3}.
14586 Among things not currently handled by Calc's Maple mode are the
14587 various quote symbols, procedures and functional operators, and
14588 inert (@samp{&}) operators.
14590 @node Compositions, Syntax Tables, Maple Language Mode, Language Modes
14591 @subsection Compositions
14594 @cindex Compositions
14595 There are several @dfn{composition functions} which allow you to get
14596 displays in a variety of formats similar to those in Big language
14597 mode. Most of these functions do not evaluate to anything; they are
14598 placeholders which are left in symbolic form by Calc's evaluator but
14599 are recognized by Calc's display formatting routines.
14601 Two of these, @code{string} and @code{bstring}, are described elsewhere.
14602 @xref{Strings}. For example, @samp{string("ABC")} is displayed as
14603 @samp{ABC}. When viewed on the stack it will be indistinguishable from
14604 the variable @code{ABC}, but internally it will be stored as
14605 @samp{string([65, 66, 67])} and can still be manipulated this way; for
14606 example, the selection and vector commands @kbd{j 1 v v j u} would
14607 select the vector portion of this object and reverse the elements, then
14608 deselect to reveal a string whose characters had been reversed.
14610 The composition functions do the same thing in all language modes
14611 (although their components will of course be formatted in the current
14612 language mode). The one exception is Unformatted mode (@kbd{d U}),
14613 which does not give the composition functions any special treatment.
14614 The functions are discussed here because of their relationship to
14615 the language modes.
14618 * Composition Basics::
14619 * Horizontal Compositions::
14620 * Vertical Compositions::
14621 * Other Compositions::
14622 * Information about Compositions::
14623 * User-Defined Compositions::
14626 @node Composition Basics, Horizontal Compositions, Compositions, Compositions
14627 @subsubsection Composition Basics
14630 Compositions are generally formed by stacking formulas together
14631 horizontally or vertically in various ways. Those formulas are
14632 themselves compositions. @TeX{} users will find this analogous
14633 to @TeX{}'s ``boxes.'' Each multi-line composition has a
14634 @dfn{baseline}; horizontal compositions use the baselines to
14635 decide how formulas should be positioned relative to one another.
14636 For example, in the Big mode formula
14648 the second term of the sum is four lines tall and has line three as
14649 its baseline. Thus when the term is combined with 17, line three
14650 is placed on the same level as the baseline of 17.
14656 Another important composition concept is @dfn{precedence}. This is
14657 an integer that represents the binding strength of various operators.
14658 For example, @samp{*} has higher precedence (195) than @samp{+} (180),
14659 which means that @samp{(a * b) + c} will be formatted without the
14660 parentheses, but @samp{a * (b + c)} will keep the parentheses.
14662 The operator table used by normal and Big language modes has the
14663 following precedences:
14666 _ 1200 @r{(subscripts)}
14667 % 1100 @r{(as in n}%@r{)}
14668 - 1000 @r{(as in }-@r{n)}
14669 ! 1000 @r{(as in }!@r{n)}
14672 !! 210 @r{(as in n}!!@r{)}
14673 ! 210 @r{(as in n}!@r{)}
14675 * 195 @r{(or implicit multiplication)}
14677 + - 180 @r{(as in a}+@r{b)}
14679 < = 160 @r{(and other relations)}
14691 The general rule is that if an operator with precedence @expr{n}
14692 occurs as an argument to an operator with precedence @expr{m}, then
14693 the argument is enclosed in parentheses if @expr{n < m}. Top-level
14694 expressions and expressions which are function arguments, vector
14695 components, etc., are formatted with precedence zero (so that they
14696 normally never get additional parentheses).
14698 For binary left-associative operators like @samp{+}, the righthand
14699 argument is actually formatted with one-higher precedence than shown
14700 in the table. This makes sure @samp{(a + b) + c} omits the parentheses,
14701 but the unnatural form @samp{a + (b + c)} keeps its parentheses.
14702 Right-associative operators like @samp{^} format the lefthand argument
14703 with one-higher precedence.
14709 The @code{cprec} function formats an expression with an arbitrary
14710 precedence. For example, @samp{cprec(abc, 185)} will combine into
14711 sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because
14712 this @code{cprec} form has higher precedence than addition, but lower
14713 precedence than multiplication).
14719 A final composition issue is @dfn{line breaking}. Calc uses two
14720 different strategies for ``flat'' and ``non-flat'' compositions.
14721 A non-flat composition is anything that appears on multiple lines
14722 (not counting line breaking). Examples would be matrices and Big
14723 mode powers and quotients. Non-flat compositions are displayed
14724 exactly as specified. If they come out wider than the current
14725 window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
14728 Flat compositions, on the other hand, will be broken across several
14729 lines if they are too wide to fit the window. Certain points in a
14730 composition are noted internally as @dfn{break points}. Calc's
14731 general strategy is to fill each line as much as possible, then to
14732 move down to the next line starting at the first break point that
14733 didn't fit. However, the line breaker understands the hierarchical
14734 structure of formulas. It will not break an ``inner'' formula if
14735 it can use an earlier break point from an ``outer'' formula instead.
14736 For example, a vector of sums might be formatted as:
14740 [ a + b + c, d + e + f,
14741 g + h + i, j + k + l, m ]
14746 If the @samp{m} can fit, then so, it seems, could the @samp{g}.
14747 But Calc prefers to break at the comma since the comma is part
14748 of a ``more outer'' formula. Calc would break at a plus sign
14749 only if it had to, say, if the very first sum in the vector had
14750 itself been too large to fit.
14752 Of the composition functions described below, only @code{choriz}
14753 generates break points. The @code{bstring} function (@pxref{Strings})
14754 also generates breakable items: A break point is added after every
14755 space (or group of spaces) except for spaces at the very beginning or
14758 Composition functions themselves count as levels in the formula
14759 hierarchy, so a @code{choriz} that is a component of a larger
14760 @code{choriz} will be less likely to be broken. As a special case,
14761 if a @code{bstring} occurs as a component of a @code{choriz} or
14762 @code{choriz}-like object (such as a vector or a list of arguments
14763 in a function call), then the break points in that @code{bstring}
14764 will be on the same level as the break points of the surrounding
14767 @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
14768 @subsubsection Horizontal Compositions
14775 The @code{choriz} function takes a vector of objects and composes
14776 them horizontally. For example, @samp{choriz([17, a b/c, d])} formats
14777 as @w{@samp{17a b / cd}} in Normal language mode, or as
14788 in Big language mode. This is actually one case of the general
14789 function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
14790 either or both of @var{sep} and @var{prec} may be omitted.
14791 @var{Prec} gives the @dfn{precedence} to use when formatting
14792 each of the components of @var{vec}. The default precedence is
14793 the precedence from the surrounding environment.
14795 @var{Sep} is a string (i.e., a vector of character codes as might
14796 be entered with @code{" "} notation) which should separate components
14797 of the composition. Also, if @var{sep} is given, the line breaker
14798 will allow lines to be broken after each occurrence of @var{sep}.
14799 If @var{sep} is omitted, the composition will not be breakable
14800 (unless any of its component compositions are breakable).
14802 For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
14803 formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz}
14804 to have precedence 180 ``outwards'' as well as ``inwards,''
14805 enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)}
14806 formats as @samp{2 (a + b c + (d = e))}.
14808 The baseline of a horizontal composition is the same as the
14809 baselines of the component compositions, which are all aligned.
14811 @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
14812 @subsubsection Vertical Compositions
14819 The @code{cvert} function makes a vertical composition. Each
14820 component of the vector is centered in a column. The baseline of
14821 the result is by default the top line of the resulting composition.
14822 For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
14823 formats in Big mode as
14838 There are several special composition functions that work only as
14839 components of a vertical composition. The @code{cbase} function
14840 controls the baseline of the vertical composition; the baseline
14841 will be the same as the baseline of whatever component is enclosed
14842 in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]),
14843 cvert([a^2 + 1, cbase(b^2)]))} displays as
14863 There are also @code{ctbase} and @code{cbbase} functions which
14864 make the baseline of the vertical composition equal to the top
14865 or bottom line (rather than the baseline) of that component.
14866 Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
14867 cvert([cbbase(a / b)])} gives
14879 There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
14880 function in a given vertical composition. These functions can also
14881 be written with no arguments: @samp{ctbase()} is a zero-height object
14882 which means the baseline is the top line of the following item, and
14883 @samp{cbbase()} means the baseline is the bottom line of the preceding
14890 The @code{crule} function builds a ``rule,'' or horizontal line,
14891 across a vertical composition. By itself @samp{crule()} uses @samp{-}
14892 characters to build the rule. You can specify any other character,
14893 e.g., @samp{crule("=")}. The argument must be a character code or
14894 vector of exactly one character code. It is repeated to match the
14895 width of the widest item in the stack. For example, a quotient
14896 with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
14915 Finally, the functions @code{clvert} and @code{crvert} act exactly
14916 like @code{cvert} except that the items are left- or right-justified
14917 in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
14928 Like @code{choriz}, the vertical compositions accept a second argument
14929 which gives the precedence to use when formatting the components.
14930 Vertical compositions do not support separator strings.
14932 @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
14933 @subsubsection Other Compositions
14940 The @code{csup} function builds a superscripted expression. For
14941 example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
14942 language mode. This is essentially a horizontal composition of
14943 @samp{a} and @samp{b}, where @samp{b} is shifted up so that its
14944 bottom line is one above the baseline.
14950 Likewise, the @code{csub} function builds a subscripted expression.
14951 This shifts @samp{b} down so that its top line is one below the
14952 bottom line of @samp{a} (note that this is not quite analogous to
14953 @code{csup}). Other arrangements can be obtained by using
14954 @code{choriz} and @code{cvert} directly.
14960 The @code{cflat} function formats its argument in ``flat'' mode,
14961 as obtained by @samp{d O}, if the current language mode is normal
14962 or Big. It has no effect in other language modes. For example,
14963 @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
14964 to improve its readability.
14970 The @code{cspace} function creates horizontal space. For example,
14971 @samp{cspace(4)} is effectively the same as @samp{string(" ")}.
14972 A second string (i.e., vector of characters) argument is repeated
14973 instead of the space character. For example, @samp{cspace(4, "ab")}
14974 looks like @samp{abababab}. If the second argument is not a string,
14975 it is formatted in the normal way and then several copies of that
14976 are composed together: @samp{cspace(4, a^2)} yields
14986 If the number argument is zero, this is a zero-width object.
14992 The @code{cvspace} function creates vertical space, or a vertical
14993 stack of copies of a certain string or formatted object. The
14994 baseline is the center line of the resulting stack. A numerical
14995 argument of zero will produce an object which contributes zero
14996 height if used in a vertical composition.
15006 There are also @code{ctspace} and @code{cbspace} functions which
15007 create vertical space with the baseline the same as the baseline
15008 of the top or bottom copy, respectively, of the second argument.
15009 Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
15026 @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
15027 @subsubsection Information about Compositions
15030 The functions in this section are actual functions; they compose their
15031 arguments according to the current language and other display modes,
15032 then return a certain measurement of the composition as an integer.
15038 The @code{cwidth} function measures the width, in characters, of a
15039 composition. For example, @samp{cwidth(a + b)} is 5, and
15040 @samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in
15041 @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve
15042 the composition functions described in this section.
15048 The @code{cheight} function measures the height of a composition.
15049 This is the total number of lines in the argument's printed form.
15059 The functions @code{cascent} and @code{cdescent} measure the amount
15060 of the height that is above (and including) the baseline, or below
15061 the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
15062 always equals @samp{cheight(@var{x})}. For a one-line formula like
15063 @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
15064 For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
15065 returns 1. The only formula for which @code{cascent} will return zero
15066 is @samp{cvspace(0)} or equivalents.
15068 @node User-Defined Compositions, , Information about Compositions, Compositions
15069 @subsubsection User-Defined Compositions
15073 @pindex calc-user-define-composition
15074 The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
15075 define the display format for any algebraic function. You provide a
15076 formula containing a certain number of argument variables on the stack.
15077 Any time Calc formats a call to the specified function in the current
15078 language mode and with that number of arguments, Calc effectively
15079 replaces the function call with that formula with the arguments
15082 Calc builds the default argument list by sorting all the variable names
15083 that appear in the formula into alphabetical order. You can edit this
15084 argument list before pressing @key{RET} if you wish. Any variables in
15085 the formula that do not appear in the argument list will be displayed
15086 literally; any arguments that do not appear in the formula will not
15087 affect the display at all.
15089 You can define formats for built-in functions, for functions you have
15090 defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
15091 which have no definitions but are being used as purely syntactic objects.
15092 You can define different formats for each language mode, and for each
15093 number of arguments, using a succession of @kbd{Z C} commands. When
15094 Calc formats a function call, it first searches for a format defined
15095 for the current language mode (and number of arguments); if there is
15096 none, it uses the format defined for the Normal language mode. If
15097 neither format exists, Calc uses its built-in standard format for that
15098 function (usually just @samp{@var{func}(@var{args})}).
15100 If you execute @kbd{Z C} with the number 0 on the stack instead of a
15101 formula, any defined formats for the function in the current language
15102 mode will be removed. The function will revert to its standard format.
15104 For example, the default format for the binomial coefficient function
15105 @samp{choose(n, m)} in the Big language mode is
15116 You might prefer the notation,
15126 To define this notation, first make sure you are in Big mode,
15127 then put the formula
15130 choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
15134 on the stack and type @kbd{Z C}. Answer the first prompt with
15135 @code{choose}. The second prompt will be the default argument list
15136 of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press
15137 @key{RET}. Now, try it out: For example, turn simplification
15138 off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
15139 as an algebraic entry.
15148 As another example, let's define the usual notation for Stirling
15149 numbers of the first kind, @samp{stir1(n, m)}. This is just like
15150 the regular format for binomial coefficients but with square brackets
15151 instead of parentheses.
15154 choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
15157 Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
15158 @samp{(n m)}, and type @key{RET}.
15160 The formula provided to @kbd{Z C} usually will involve composition
15161 functions, but it doesn't have to. Putting the formula @samp{a + b + c}
15162 onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
15163 the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
15164 This ``sum'' will act exactly like a real sum for all formatting
15165 purposes (it will be parenthesized the same, and so on). However
15166 it will be computationally unrelated to a sum. For example, the
15167 formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
15168 Operator precedences have caused the ``sum'' to be written in
15169 parentheses, but the arguments have not actually been summed.
15170 (Generally a display format like this would be undesirable, since
15171 it can easily be confused with a real sum.)
15173 The special function @code{eval} can be used inside a @kbd{Z C}
15174 composition formula to cause all or part of the formula to be
15175 evaluated at display time. For example, if the formula is
15176 @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
15177 as @samp{1 + 5}. Evaluation will use the default simplifications,
15178 regardless of the current simplification mode. There are also
15179 @code{evalsimp} and @code{evalextsimp} which simplify as if by
15180 @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions''
15181 operate only in the context of composition formulas (and also in
15182 rewrite rules, where they serve a similar purpose; @pxref{Rewrite
15183 Rules}). On the stack, a call to @code{eval} will be left in
15186 It is not a good idea to use @code{eval} except as a last resort.
15187 It can cause the display of formulas to be extremely slow. For
15188 example, while @samp{eval(a + b)} might seem quite fast and simple,
15189 there are several situations where it could be slow. For example,
15190 @samp{a} and/or @samp{b} could be polar complex numbers, in which
15191 case doing the sum requires trigonometry. Or, @samp{a} could be
15192 the factorial @samp{fact(100)} which is unevaluated because you
15193 have typed @kbd{m O}; @code{eval} will evaluate it anyway to
15194 produce a large, unwieldy integer.
15196 You can save your display formats permanently using the @kbd{Z P}
15197 command (@pxref{Creating User Keys}).
15199 @node Syntax Tables, , Compositions, Language Modes
15200 @subsection Syntax Tables
15203 @cindex Syntax tables
15204 @cindex Parsing formulas, customized
15205 Syntax tables do for input what compositions do for output: They
15206 allow you to teach custom notations to Calc's formula parser.
15207 Calc keeps a separate syntax table for each language mode.
15209 (Note that the Calc ``syntax tables'' discussed here are completely
15210 unrelated to the syntax tables described in the Emacs manual.)
15213 @pindex calc-edit-user-syntax
15214 The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
15215 syntax table for the current language mode. If you want your
15216 syntax to work in any language, define it in the Normal language
15217 mode. Type @kbd{C-c C-c} to finish editing the syntax table, or
15218 @kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all
15219 the syntax tables along with the other mode settings;
15220 @pxref{General Mode Commands}.
15223 * Syntax Table Basics::
15224 * Precedence in Syntax Tables::
15225 * Advanced Syntax Patterns::
15226 * Conditional Syntax Rules::
15229 @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
15230 @subsubsection Syntax Table Basics
15233 @dfn{Parsing} is the process of converting a raw string of characters,
15234 such as you would type in during algebraic entry, into a Calc formula.
15235 Calc's parser works in two stages. First, the input is broken down
15236 into @dfn{tokens}, such as words, numbers, and punctuation symbols
15237 like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is
15238 ignored (except when it serves to separate adjacent words). Next,
15239 the parser matches this string of tokens against various built-in
15240 syntactic patterns, such as ``an expression followed by @samp{+}
15241 followed by another expression'' or ``a name followed by @samp{(},
15242 zero or more expressions separated by commas, and @samp{)}.''
15244 A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
15245 which allow you to specify new patterns to define your own
15246 favorite input notations. Calc's parser always checks the syntax
15247 table for the current language mode, then the table for the Normal
15248 language mode, before it uses its built-in rules to parse an
15249 algebraic formula you have entered. Each syntax rule should go on
15250 its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
15251 and a Calc formula with an optional @dfn{condition}. (Syntax rules
15252 resemble algebraic rewrite rules, but the notation for patterns is
15253 completely different.)
15255 A syntax pattern is a list of tokens, separated by spaces.
15256 Except for a few special symbols, tokens in syntax patterns are
15257 matched literally, from left to right. For example, the rule,
15264 would cause Calc to parse the formula @samp{4+foo()*5} as if it
15265 were @samp{4+(2+3)*5}. Notice that the parentheses were written
15266 as two separate tokens in the rule. As a result, the rule works
15267 for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written
15268 the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
15269 as a single, indivisible token, so that @w{@samp{foo( )}} would
15270 not be recognized by the rule. (It would be parsed as a regular
15271 zero-argument function call instead.) In fact, this rule would
15272 also make trouble for the rest of Calc's parser: An unrelated
15273 formula like @samp{bar()} would now be tokenized into @samp{bar ()}
15274 instead of @samp{bar ( )}, so that the standard parser for function
15275 calls would no longer recognize it!
15277 While it is possible to make a token with a mixture of letters
15278 and punctuation symbols, this is not recommended. It is better to
15279 break it into several tokens, as we did with @samp{foo()} above.
15281 The symbol @samp{#} in a syntax pattern matches any Calc expression.
15282 On the righthand side, the things that matched the @samp{#}s can
15283 be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
15284 matches the leftmost @samp{#} in the pattern). For example, these
15285 rules match a user-defined function, prefix operator, infix operator,
15286 and postfix operator, respectively:
15289 foo ( # ) := myfunc(#1)
15290 foo # := myprefix(#1)
15291 # foo # := myinfix(#1,#2)
15292 # foo := mypostfix(#1)
15295 Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
15296 will parse as @samp{mypostfix(2+3)}.
15298 It is important to write the first two rules in the order shown,
15299 because Calc tries rules in order from first to last. If the
15300 pattern @samp{foo #} came first, it would match anything that could
15301 match the @samp{foo ( # )} rule, since an expression in parentheses
15302 is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would
15303 never get to match anything. Likewise, the last two rules must be
15304 written in the order shown or else @samp{3 foo 4} will be parsed as
15305 @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these
15306 ambiguities is not to use the same symbol in more than one way at
15307 the same time! In case you're not convinced, try the following
15308 exercise: How will the above rules parse the input @samp{foo(3,4)},
15309 if at all? Work it out for yourself, then try it in Calc and see.)
15311 Calc is quite flexible about what sorts of patterns are allowed.
15312 The only rule is that every pattern must begin with a literal
15313 token (like @samp{foo} in the first two patterns above), or with
15314 a @samp{#} followed by a literal token (as in the last two
15315 patterns). After that, any mixture is allowed, although putting
15316 two @samp{#}s in a row will not be very useful since two
15317 expressions with nothing between them will be parsed as one
15318 expression that uses implicit multiplication.
15320 As a more practical example, Maple uses the notation
15321 @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
15322 recognize at present. To handle this syntax, we simply add the
15326 sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
15330 to the Maple mode syntax table. As another example, C mode can't
15331 read assignment operators like @samp{++} and @samp{*=}. We can
15332 define these operators quite easily:
15335 # *= # := muleq(#1,#2)
15336 # ++ := postinc(#1)
15341 To complete the job, we would use corresponding composition functions
15342 and @kbd{Z C} to cause these functions to display in their respective
15343 Maple and C notations. (Note that the C example ignores issues of
15344 operator precedence, which are discussed in the next section.)
15346 You can enclose any token in quotes to prevent its usual
15347 interpretation in syntax patterns:
15350 # ":=" # := becomes(#1,#2)
15353 Quotes also allow you to include spaces in a token, although once
15354 again it is generally better to use two tokens than one token with
15355 an embedded space. To include an actual quotation mark in a quoted
15356 token, precede it with a backslash. (This also works to include
15357 backslashes in tokens.)
15360 # "bad token" # "/\"\\" # := silly(#1,#2,#3)
15364 This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
15366 The token @kbd{#} has a predefined meaning in Calc's formula parser;
15367 it is not legal to use @samp{"#"} in a syntax rule. However, longer
15368 tokens that include the @samp{#} character are allowed. Also, while
15369 @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
15370 the syntax table will prevent those characters from working in their
15371 usual ways (referring to stack entries and quoting strings,
15374 Finally, the notation @samp{%%} anywhere in a syntax table causes
15375 the rest of the line to be ignored as a comment.
15377 @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
15378 @subsubsection Precedence
15381 Different operators are generally assigned different @dfn{precedences}.
15382 By default, an operator defined by a rule like
15385 # foo # := foo(#1,#2)
15389 will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
15390 will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the
15391 precedence of an operator, use the notation @samp{#/@var{p}} in
15392 place of @samp{#}, where @var{p} is an integer precedence level.
15393 For example, 185 lies between the precedences for @samp{+} and
15394 @samp{*}, so if we change this rule to
15397 #/185 foo #/186 := foo(#1,#2)
15401 then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
15402 Also, because we've given the righthand expression slightly higher
15403 precedence, our new operator will be left-associative:
15404 @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
15405 By raising the precedence of the lefthand expression instead, we
15406 can create a right-associative operator.
15408 @xref{Composition Basics}, for a table of precedences of the
15409 standard Calc operators. For the precedences of operators in other
15410 language modes, look in the Calc source file @file{calc-lang.el}.
15412 @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
15413 @subsubsection Advanced Syntax Patterns
15416 To match a function with a variable number of arguments, you could
15420 foo ( # ) := myfunc(#1)
15421 foo ( # , # ) := myfunc(#1,#2)
15422 foo ( # , # , # ) := myfunc(#1,#2,#3)
15426 but this isn't very elegant. To match variable numbers of items,
15427 Calc uses some notations inspired regular expressions and the
15428 ``extended BNF'' style used by some language designers.
15431 foo ( @{ # @}*, ) := apply(myfunc,#1)
15434 The token @samp{@{} introduces a repeated or optional portion.
15435 One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
15436 ends the portion. These will match zero or more, one or more,
15437 or zero or one copies of the enclosed pattern, respectively.
15438 In addition, @samp{@}*} and @samp{@}+} can be followed by a
15439 separator token (with no space in between, as shown above).
15440 Thus @samp{@{ # @}*,} matches nothing, or one expression, or
15441 several expressions separated by commas.
15443 A complete @samp{@{ ... @}} item matches as a vector of the
15444 items that matched inside it. For example, the above rule will
15445 match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
15446 The Calc @code{apply} function takes a function name and a vector
15447 of arguments and builds a call to the function with those
15448 arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
15450 If the body of a @samp{@{ ... @}} contains several @samp{#}s
15451 (or nested @samp{@{ ... @}} constructs), then the items will be
15452 strung together into the resulting vector. If the body
15453 does not contain anything but literal tokens, the result will
15454 always be an empty vector.
15457 foo ( @{ # , # @}+, ) := bar(#1)
15458 foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
15462 will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
15463 @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after
15464 some thought it's easy to see how this pair of rules will parse
15465 @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
15466 rule will only match an even number of arguments. The rule
15469 foo ( # @{ , # , # @}? ) := bar(#1,#2)
15473 will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
15474 @samp{foo(2)} as @samp{bar(2,[])}.
15476 The notation @samp{@{ ... @}?.} (note the trailing period) works
15477 just the same as regular @samp{@{ ... @}?}, except that it does not
15478 count as an argument; the following two rules are equivalent:
15481 foo ( # , @{ also @}? # ) := bar(#1,#3)
15482 foo ( # , @{ also @}?. # ) := bar(#1,#2)
15486 Note that in the first case the optional text counts as @samp{#2},
15487 which will always be an empty vector, but in the second case no
15488 empty vector is produced.
15490 Another variant is @samp{@{ ... @}?$}, which means the body is
15491 optional only at the end of the input formula. All built-in syntax
15492 rules in Calc use this for closing delimiters, so that during
15493 algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
15494 the closing parenthesis and bracket. Calc does this automatically
15495 for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
15496 rules, but you can use @samp{@{ ... @}?$} explicitly to get
15497 this effect with any token (such as @samp{"@}"} or @samp{end}).
15498 Like @samp{@{ ... @}?.}, this notation does not count as an
15499 argument. Conversely, you can use quotes, as in @samp{")"}, to
15500 prevent a closing-delimiter token from being automatically treated
15503 Calc's parser does not have full backtracking, which means some
15504 patterns will not work as you might expect:
15507 foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
15511 Here we are trying to make the first argument optional, so that
15512 @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc
15513 first tries to match @samp{2,} against the optional part of the
15514 pattern, finds a match, and so goes ahead to match the rest of the
15515 pattern. Later on it will fail to match the second comma, but it
15516 doesn't know how to go back and try the other alternative at that
15517 point. One way to get around this would be to use two rules:
15520 foo ( # , # , # ) := bar([#1],#2,#3)
15521 foo ( # , # ) := bar([],#1,#2)
15524 More precisely, when Calc wants to match an optional or repeated
15525 part of a pattern, it scans forward attempting to match that part.
15526 If it reaches the end of the optional part without failing, it
15527 ``finalizes'' its choice and proceeds. If it fails, though, it
15528 backs up and tries the other alternative. Thus Calc has ``partial''
15529 backtracking. A fully backtracking parser would go on to make sure
15530 the rest of the pattern matched before finalizing the choice.
15532 @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
15533 @subsubsection Conditional Syntax Rules
15536 It is possible to attach a @dfn{condition} to a syntax rule. For
15540 foo ( # ) := ifoo(#1) :: integer(#1)
15541 foo ( # ) := gfoo(#1)
15545 will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
15546 @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any
15547 number of conditions may be attached; all must be true for the
15548 rule to succeed. A condition is ``true'' if it evaluates to a
15549 nonzero number. @xref{Logical Operations}, for a list of Calc
15550 functions like @code{integer} that perform logical tests.
15552 The exact sequence of events is as follows: When Calc tries a
15553 rule, it first matches the pattern as usual. It then substitutes
15554 @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the
15555 conditions are simplified and evaluated in order from left to right,
15556 as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}).
15557 Each result is true if it is a nonzero number, or an expression
15558 that can be proven to be nonzero (@pxref{Declarations}). If the
15559 results of all conditions are true, the expression (such as
15560 @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
15561 result of the parse. If the result of any condition is false, Calc
15562 goes on to try the next rule in the syntax table.
15564 Syntax rules also support @code{let} conditions, which operate in
15565 exactly the same way as they do in algebraic rewrite rules.
15566 @xref{Other Features of Rewrite Rules}, for details. A @code{let}
15567 condition is always true, but as a side effect it defines a
15568 variable which can be used in later conditions, and also in the
15569 expression after the @samp{:=} sign:
15572 foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
15576 The @code{dnumint} function tests if a value is numerically an
15577 integer, i.e., either a true integer or an integer-valued float.
15578 This rule will parse @code{foo} with a half-integer argument,
15579 like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
15581 The lefthand side of a syntax rule @code{let} must be a simple
15582 variable, not the arbitrary pattern that is allowed in rewrite
15585 The @code{matches} function is also treated specially in syntax
15586 rule conditions (again, in the same way as in rewrite rules).
15587 @xref{Matching Commands}. If the matching pattern contains
15588 meta-variables, then those meta-variables may be used in later
15589 conditions and in the result expression. The arguments to
15590 @code{matches} are not evaluated in this situation.
15593 sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
15597 This is another way to implement the Maple mode @code{sum} notation.
15598 In this approach, we allow @samp{#2} to equal the whole expression
15599 @samp{i=1..10}. Then, we use @code{matches} to break it apart into
15600 its components. If the expression turns out not to match the pattern,
15601 the syntax rule will fail. Note that @kbd{Z S} always uses Calc's
15602 Normal language mode for editing expressions in syntax rules, so we
15603 must use regular Calc notation for the interval @samp{[b..c]} that
15604 will correspond to the Maple mode interval @samp{1..10}.
15606 @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
15607 @section The @code{Modes} Variable
15611 @pindex calc-get-modes
15612 The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
15613 a vector of numbers that describes the various mode settings that
15614 are in effect. With a numeric prefix argument, it pushes only the
15615 @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard
15616 macros can use the @kbd{m g} command to modify their behavior based
15617 on the current mode settings.
15619 @cindex @code{Modes} variable
15621 The modes vector is also available in the special variable
15622 @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
15623 It will not work to store into this variable; in fact, if you do,
15624 @code{Modes} will cease to track the current modes. (The @kbd{m g}
15625 command will continue to work, however.)
15627 In general, each number in this vector is suitable as a numeric
15628 prefix argument to the associated mode-setting command. (Recall
15629 that the @kbd{~} key takes a number from the stack and gives it as
15630 a numeric prefix to the next command.)
15632 The elements of the modes vector are as follows:
15636 Current precision. Default is 12; associated command is @kbd{p}.
15639 Binary word size. Default is 32; associated command is @kbd{b w}.
15642 Stack size (not counting the value about to be pushed by @kbd{m g}).
15643 This is zero if @kbd{m g} is executed with an empty stack.
15646 Number radix. Default is 10; command is @kbd{d r}.
15649 Floating-point format. This is the number of digits, plus the
15650 constant 0 for normal notation, 10000 for scientific notation,
15651 20000 for engineering notation, or 30000 for fixed-point notation.
15652 These codes are acceptable as prefix arguments to the @kbd{d n}
15653 command, but note that this may lose information: For example,
15654 @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
15655 identical) effects if the current precision is 12, but they both
15656 produce a code of 10012, which will be treated by @kbd{d n} as
15657 @kbd{C-u 12 d s}. If the precision then changes, the float format
15658 will still be frozen at 12 significant figures.
15661 Angular mode. Default is 1 (degrees). Other values are 2 (radians)
15662 and 3 (HMS). The @kbd{m d} command accepts these prefixes.
15665 Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}.
15668 Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}.
15671 Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0.
15672 Command is @kbd{m p}.
15675 Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar
15676 mode, @mathit{-2} for Matrix mode, or @var{N} for
15677 @texline @math{N\times N}
15678 @infoline @var{N}x@var{N}
15679 Matrix mode. Command is @kbd{m v}.
15682 Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}),
15683 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
15684 or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes.
15687 Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on,
15688 or 0 if the mode is on with positive zeros. Command is @kbd{m i}.
15691 For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
15692 precision by two, leaving a copy of the old precision on the stack.
15693 Later, @kbd{~ p} will restore the original precision using that
15694 stack value. (This sequence might be especially useful inside a
15697 As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
15698 oldest (bottommost) stack entry.
15700 Yet another example: The HP-48 ``round'' command rounds a number
15701 to the current displayed precision. You could roughly emulate this
15702 in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This
15703 would not work for fixed-point mode, but it wouldn't be hard to
15704 do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
15705 programming commands. @xref{Conditionals in Macros}.)
15707 @node Calc Mode Line, , Modes Variable, Mode Settings
15708 @section The Calc Mode Line
15711 @cindex Mode line indicators
15712 This section is a summary of all symbols that can appear on the
15713 Calc mode line, the highlighted bar that appears under the Calc
15714 stack window (or under an editing window in Embedded mode).
15716 The basic mode line format is:
15719 --%%-Calc: 12 Deg @var{other modes} (Calculator)
15722 The @samp{%%} is the Emacs symbol for ``read-only''; it shows that
15723 regular Emacs commands are not allowed to edit the stack buffer
15724 as if it were text.
15726 The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode
15727 is enabled. The words after this describe the various Calc modes
15728 that are in effect.
15730 The first mode is always the current precision, an integer.
15731 The second mode is always the angular mode, either @code{Deg},
15732 @code{Rad}, or @code{Hms}.
15734 Here is a complete list of the remaining symbols that can appear
15739 Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
15742 Incomplete algebraic mode (@kbd{C-u m a}).
15745 Total algebraic mode (@kbd{m t}).
15748 Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
15751 Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
15753 @item Matrix@var{n}
15754 Dimensioned Matrix mode (@kbd{C-u @var{n} m v}).
15757 Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
15760 Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
15763 Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
15766 Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
15769 Positive Infinite mode (@kbd{C-u 0 m i}).
15772 Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
15775 Default simplifications for numeric arguments only (@kbd{m N}).
15777 @item BinSimp@var{w}
15778 Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
15781 Algebraic simplification mode (@kbd{m A}).
15784 Extended algebraic simplification mode (@kbd{m E}).
15787 Units simplification mode (@kbd{m U}).
15790 Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
15793 Current radix is 8 (@kbd{d 8}).
15796 Current radix is 16 (@kbd{d 6}).
15799 Current radix is @var{n} (@kbd{d r}).
15802 Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
15805 Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
15808 One-line normal language mode (@kbd{d O}).
15811 Unformatted language mode (@kbd{d U}).
15814 C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
15817 Pascal language mode (@kbd{d P}).
15820 FORTRAN language mode (@kbd{d F}).
15823 @TeX{} language mode (@kbd{d T}; @pxref{TeX Language Mode}).
15826 @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
15829 Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
15832 Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
15835 Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
15838 Fixed point mode with @var{n} digits after the point (@kbd{d f}).
15841 Scientific notation mode (@kbd{d s}).
15844 Scientific notation with @var{n} digits (@kbd{d s}).
15847 Engineering notation mode (@kbd{d e}).
15850 Engineering notation with @var{n} digits (@kbd{d e}).
15853 Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
15856 Right-justified display (@kbd{d >}).
15859 Right-justified display with width @var{n} (@kbd{d >}).
15862 Centered display (@kbd{d =}).
15864 @item Center@var{n}
15865 Centered display with center column @var{n} (@kbd{d =}).
15868 Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
15871 No line breaking (@kbd{d b}).
15874 Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
15877 Record modes in @file{~/.calc.el} (@kbd{m R}; @pxref{General Mode Commands}).
15880 Record modes in Embedded buffer (@kbd{m R}).
15883 Record modes as editing-only in Embedded buffer (@kbd{m R}).
15886 Record modes as permanent-only in Embedded buffer (@kbd{m R}).
15889 Record modes as global in Embedded buffer (@kbd{m R}).
15892 Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
15896 GNUPLOT process is alive in background (@pxref{Graphics}).
15899 Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
15902 The stack display may not be up-to-date (@pxref{Display Modes}).
15905 ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
15908 ``Hyperbolic'' prefix was pressed (@kbd{H}).
15911 ``Keep-arguments'' prefix was pressed (@kbd{K}).
15914 Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
15917 In addition, the symbols @code{Active} and @code{~Active} can appear
15918 as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}.
15920 @node Arithmetic, Scientific Functions, Mode Settings, Top
15921 @chapter Arithmetic Functions
15924 This chapter describes the Calc commands for doing simple calculations
15925 on numbers, such as addition, absolute value, and square roots. These
15926 commands work by removing the top one or two values from the stack,
15927 performing the desired operation, and pushing the result back onto the
15928 stack. If the operation cannot be performed, the result pushed is a
15929 formula instead of a number, such as @samp{2/0} (because division by zero
15930 is illegal) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
15932 Most of the commands described here can be invoked by a single keystroke.
15933 Some of the more obscure ones are two-letter sequences beginning with
15934 the @kbd{f} (``functions'') prefix key.
15936 @xref{Prefix Arguments}, for a discussion of the effect of numeric
15937 prefix arguments on commands in this chapter which do not otherwise
15938 interpret a prefix argument.
15941 * Basic Arithmetic::
15942 * Integer Truncation::
15943 * Complex Number Functions::
15945 * Date Arithmetic::
15946 * Financial Functions::
15947 * Binary Functions::
15950 @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
15951 @section Basic Arithmetic
15960 The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may
15961 be any of the standard Calc data types. The resulting sum is pushed back
15964 If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
15965 the result is a vector or matrix sum. If one argument is a vector and the
15966 other a scalar (i.e., a non-vector), the scalar is added to each of the
15967 elements of the vector to form a new vector. If the scalar is not a
15968 number, the operation is left in symbolic form: Suppose you added @samp{x}
15969 to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or
15970 you may plan to substitute a 2-vector for @samp{x} in the future. Since
15971 the Calculator can't tell which interpretation you want, it makes the
15972 safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x}
15973 to every element of a vector.
15975 If either argument of @kbd{+} is a complex number, the result will in general
15976 be complex. If one argument is in rectangular form and the other polar,
15977 the current Polar mode determines the form of the result. If Symbolic
15978 mode is enabled, the sum may be left as a formula if the necessary
15979 conversions for polar addition are non-trivial.
15981 If both arguments of @kbd{+} are HMS forms, the forms are added according to
15982 the usual conventions of hours-minutes-seconds notation. If one argument
15983 is an HMS form and the other is a number, that number is converted from
15984 degrees or radians (depending on the current Angular mode) to HMS format
15985 and then the two HMS forms are added.
15987 If one argument of @kbd{+} is a date form, the other can be either a
15988 real number, which advances the date by a certain number of days, or
15989 an HMS form, which advances the date by a certain amount of time.
15990 Subtracting two date forms yields the number of days between them.
15991 Adding two date forms is meaningless, but Calc interprets it as the
15992 subtraction of one date form and the negative of the other. (The
15993 negative of a date form can be understood by remembering that dates
15994 are stored as the number of days before or after Jan 1, 1 AD.)
15996 If both arguments of @kbd{+} are error forms, the result is an error form
15997 with an appropriately computed standard deviation. If one argument is an
15998 error form and the other is a number, the number is taken to have zero error.
15999 Error forms may have symbolic formulas as their mean and/or error parts;
16000 adding these will produce a symbolic error form result. However, adding an
16001 error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
16002 work, for the same reasons just mentioned for vectors. Instead you must
16003 write @samp{(a +/- b) + (c +/- 0)}.
16005 If both arguments of @kbd{+} are modulo forms with equal values of @expr{M},
16006 or if one argument is a modulo form and the other a plain number, the
16007 result is a modulo form which represents the sum, modulo @expr{M}, of
16010 If both arguments of @kbd{+} are intervals, the result is an interval
16011 which describes all possible sums of the possible input values. If
16012 one argument is a plain number, it is treated as the interval
16013 @w{@samp{[x ..@: x]}}.
16015 If one argument of @kbd{+} is an infinity and the other is not, the
16016 result is that same infinity. If both arguments are infinite and in
16017 the same direction, the result is the same infinity, but if they are
16018 infinite in different directions the result is @code{nan}.
16026 The @kbd{-} (@code{calc-minus}) command subtracts two values. The top
16027 number on the stack is subtracted from the one behind it, so that the
16028 computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options
16029 available for @kbd{+} are available for @kbd{-} as well.
16037 The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one
16038 argument is a vector and the other a scalar, the scalar is multiplied by
16039 the elements of the vector to produce a new vector. If both arguments
16040 are vectors, the interpretation depends on the dimensions of the
16041 vectors: If both arguments are matrices, a matrix multiplication is
16042 done. If one argument is a matrix and the other a plain vector, the
16043 vector is interpreted as a row vector or column vector, whichever is
16044 dimensionally correct. If both arguments are plain vectors, the result
16045 is a single scalar number which is the dot product of the two vectors.
16047 If one argument of @kbd{*} is an HMS form and the other a number, the
16048 HMS form is multiplied by that amount. It is an error to multiply two
16049 HMS forms together, or to attempt any multiplication involving date
16050 forms. Error forms, modulo forms, and intervals can be multiplied;
16051 see the comments for addition of those forms. When two error forms
16052 or intervals are multiplied they are considered to be statistically
16053 independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
16054 whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
16057 @pindex calc-divide
16062 The @kbd{/} (@code{calc-divide}) command divides two numbers. When
16063 dividing a scalar @expr{B} by a square matrix @expr{A}, the computation
16064 performed is @expr{B} times the inverse of @expr{A}. This also occurs
16065 if @expr{B} is itself a vector or matrix, in which case the effect is
16066 to solve the set of linear equations represented by @expr{B}. If @expr{B}
16067 is a matrix with the same number of rows as @expr{A}, or a plain vector
16068 (which is interpreted here as a column vector), then the equation
16069 @expr{A X = B} is solved for the vector or matrix @expr{X}. Otherwise,
16070 if @expr{B} is a non-square matrix with the same number of @emph{columns}
16071 as @expr{A}, the equation @expr{X A = B} is solved. If you wish a vector
16072 @expr{B} to be interpreted as a row vector to be solved as @expr{X A = B},
16073 make it into a one-row matrix with @kbd{C-u 1 v p} first. To force a
16074 left-handed solution with a square matrix @expr{B}, transpose @expr{A} and
16075 @expr{B} before dividing, then transpose the result.
16077 HMS forms can be divided by real numbers or by other HMS forms. Error
16078 forms can be divided in any combination of ways. Modulo forms where both
16079 values and the modulo are integers can be divided to get an integer modulo
16080 form result. Intervals can be divided; dividing by an interval that
16081 encompasses zero or has zero as a limit will result in an infinite
16090 The @kbd{^} (@code{calc-power}) command raises a number to a power. If
16091 the power is an integer, an exact result is computed using repeated
16092 multiplications. For non-integer powers, Calc uses Newton's method or
16093 logarithms and exponentials. Square matrices can be raised to integer
16094 powers. If either argument is an error (or interval or modulo) form,
16095 the result is also an error (or interval or modulo) form.
16099 If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
16100 computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5.
16101 (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
16110 The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
16111 to produce an integer result. It is equivalent to dividing with
16112 @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
16113 more convenient and efficient. Also, since it is an all-integer
16114 operation when the arguments are integers, it avoids problems that
16115 @kbd{/ F} would have with floating-point roundoff.
16123 The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
16124 operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
16125 for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For
16126 positive @expr{b}, the result will always be between 0 (inclusive) and
16127 @expr{b} (exclusive). Modulo does not work for HMS forms and error forms.
16128 If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which
16129 must be positive real number.
16134 The @kbd{:} (@code{calc-fdiv}) command [@code{fdiv} function in a formula]
16135 divides the two integers on the top of the stack to produce a fractional
16136 result. This is a convenient shorthand for enabling Fraction mode (with
16137 @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry
16138 the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
16139 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in
16140 this case, it would be much easier simply to enter the fraction directly
16141 as @kbd{8:6 @key{RET}}!)
16144 @pindex calc-change-sign
16145 The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
16146 of the stack. It works on numbers, vectors and matrices, HMS forms, date
16147 forms, error forms, intervals, and modulo forms.
16152 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
16153 value of a number. The result of @code{abs} is always a nonnegative
16154 real number: With a complex argument, it computes the complex magnitude.
16155 With a vector or matrix argument, it computes the Frobenius norm, i.e.,
16156 the square root of the sum of the squares of the absolute values of the
16157 elements. The absolute value of an error form is defined by replacing
16158 the mean part with its absolute value and leaving the error part the same.
16159 The absolute value of a modulo form is undefined. The absolute value of
16160 an interval is defined in the obvious way.
16163 @pindex calc-abssqr
16165 The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
16166 absolute value squared of a number, vector or matrix, or error form.
16171 The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
16172 argument is positive, @mathit{-1} if its argument is negative, or 0 if its
16173 argument is zero. In algebraic form, you can also write @samp{sign(a,x)}
16174 which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
16175 zero depending on the sign of @samp{a}.
16181 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
16182 reciprocal of a number, i.e., @expr{1 / x}. Operating on a square
16183 matrix, it computes the inverse of that matrix.
16188 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
16189 root of a number. For a negative real argument, the result will be a
16190 complex number whose form is determined by the current Polar mode.
16195 The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
16196 root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)}
16197 is the length of the hypotenuse of a right triangle with sides @expr{a}
16198 and @expr{b}. If the arguments are complex numbers, their squared
16199 magnitudes are used.
16204 The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
16205 integer square root of an integer. This is the true square root of the
16206 number, rounded down to an integer. For example, @samp{isqrt(10)}
16207 produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact
16208 integer arithmetic throughout to avoid roundoff problems. If the input
16209 is a floating-point number or other non-integer value, this is exactly
16210 the same as @samp{floor(sqrt(x))}.
16218 The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
16219 [@code{max}] commands take the minimum or maximum of two real numbers,
16220 respectively. These commands also work on HMS forms, date forms,
16221 intervals, and infinities. (In algebraic expressions, these functions
16222 take any number of arguments and return the maximum or minimum among
16223 all the arguments.)
16227 @pindex calc-mant-part
16229 @pindex calc-xpon-part
16231 The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
16232 the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X}
16233 (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
16234 @expr{e}. The original number is equal to
16235 @texline @math{m \times 10^e},
16236 @infoline @expr{m * 10^e},
16237 where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
16238 @expr{m=e=0} if the original number is zero. For integers
16239 and fractions, @code{mant} returns the number unchanged and @code{xpon}
16240 returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be
16241 used to ``unpack'' a floating-point number; this produces an integer
16242 mantissa and exponent, with the constraint that the mantissa is not
16243 a multiple of ten (again except for the @expr{m=e=0} case).
16246 @pindex calc-scale-float
16248 The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
16249 by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any
16250 real @samp{x}. The second argument must be an integer, but the first
16251 may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05}
16252 or @samp{1:20} depending on the current Fraction mode.
16256 @pindex calc-decrement
16257 @pindex calc-increment
16260 The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
16261 (@code{calc-increment}) [@code{incr}] functions decrease or increase
16262 a number by one unit. For integers, the effect is obvious. For
16263 floating-point numbers, the change is by one unit in the last place.
16264 For example, incrementing @samp{12.3456} when the current precision
16265 is 6 digits yields @samp{12.3457}. If the current precision had been
16266 8 digits, the result would have been @samp{12.345601}. Incrementing
16267 @samp{0.0} produces
16268 @texline @math{10^{-p}},
16269 @infoline @expr{10^-p},
16270 where @expr{p} is the current
16271 precision. These operations are defined only on integers and floats.
16272 With numeric prefix arguments, they change the number by @expr{n} units.
16274 Note that incrementing followed by decrementing, or vice-versa, will
16275 almost but not quite always cancel out. Suppose the precision is
16276 6 digits and the number @samp{9.99999} is on the stack. Incrementing
16277 will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
16278 One digit has been dropped. This is an unavoidable consequence of the
16279 way floating-point numbers work.
16281 Incrementing a date/time form adjusts it by a certain number of seconds.
16282 Incrementing a pure date form adjusts it by a certain number of days.
16284 @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
16285 @section Integer Truncation
16288 There are four commands for truncating a real number to an integer,
16289 differing mainly in their treatment of negative numbers. All of these
16290 commands have the property that if the argument is an integer, the result
16291 is the same integer. An integer-valued floating-point argument is converted
16294 If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
16295 expressed as an integer-valued floating-point number.
16297 @cindex Integer part of a number
16306 The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
16307 truncates a real number to the next lower integer, i.e., toward minus
16308 infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
16312 @pindex calc-ceiling
16319 The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
16320 command truncates toward positive infinity. Thus @kbd{3.6 I F} produces
16321 4, and @kbd{_3.6 I F} produces @mathit{-3}.
16331 The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
16332 rounds to the nearest integer. When the fractional part is .5 exactly,
16333 this command rounds away from zero. (All other rounding in the
16334 Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4
16335 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}.
16345 The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
16346 command truncates toward zero. In other words, it ``chops off''
16347 everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and
16348 @kbd{_3.6 I R} produces @mathit{-3}.
16350 These functions may not be applied meaningfully to error forms, but they
16351 do work for intervals. As a convenience, applying @code{floor} to a
16352 modulo form floors the value part of the form. Applied to a vector,
16353 these functions operate on all elements of the vector one by one.
16354 Applied to a date form, they operate on the internal numerical
16355 representation of dates, converting a date/time form into a pure date.
16373 There are two more rounding functions which can only be entered in
16374 algebraic notation. The @code{roundu} function is like @code{round}
16375 except that it rounds up, toward plus infinity, when the fractional
16376 part is .5. This distinction matters only for negative arguments.
16377 Also, @code{rounde} rounds to an even number in the case of a tie,
16378 rounding up or down as necessary. For example, @samp{rounde(3.5)} and
16379 @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
16380 The advantage of round-to-even is that the net error due to rounding
16381 after a long calculation tends to cancel out to zero. An important
16382 subtle point here is that the number being fed to @code{rounde} will
16383 already have been rounded to the current precision before @code{rounde}
16384 begins. For example, @samp{rounde(2.500001)} with a current precision
16385 of 6 will incorrectly, or at least surprisingly, yield 2 because the
16386 argument will first have been rounded down to @expr{2.5} (which
16387 @code{rounde} sees as an exact tie between 2 and 3).
16389 Each of these functions, when written in algebraic formulas, allows
16390 a second argument which specifies the number of digits after the
16391 decimal point to keep. For example, @samp{round(123.4567, 2)} will
16392 produce the answer 123.46, and @samp{round(123.4567, -1)} will
16393 produce 120 (i.e., the cutoff is one digit to the @emph{left} of
16394 the decimal point). A second argument of zero is equivalent to
16395 no second argument at all.
16397 @cindex Fractional part of a number
16398 To compute the fractional part of a number (i.e., the amount which, when
16399 added to `@t{floor(}@var{n}@t{)}', will produce @var{n}) just take @var{n}
16400 modulo 1 using the @code{%} command.
16402 Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
16403 and @kbd{f Q} (integer square root) commands, which are analogous to
16404 @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
16405 arguments and return the result rounded down to an integer.
16407 @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
16408 @section Complex Number Functions
16414 The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
16415 complex conjugate of a number. For complex number @expr{a+bi}, the
16416 complex conjugate is @expr{a-bi}. If the argument is a real number,
16417 this command leaves it the same. If the argument is a vector or matrix,
16418 this command replaces each element by its complex conjugate.
16421 @pindex calc-argument
16423 The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
16424 ``argument'' or polar angle of a complex number. For a number in polar
16425 notation, this is simply the second component of the pair
16426 @texline `@t{(}@var{r}@t{;}@math{\theta}@t{)}'.
16427 @infoline `@t{(}@var{r}@t{;}@var{theta}@t{)}'.
16428 The result is expressed according to the current angular mode and will
16429 be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees
16430 (inclusive), or the equivalent range in radians.
16432 @pindex calc-imaginary
16433 The @code{calc-imaginary} command multiplies the number on the
16434 top of the stack by the imaginary number @expr{i = (0,1)}. This
16435 command is not normally bound to a key in Calc, but it is available
16436 on the @key{IMAG} button in Keypad mode.
16441 The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
16442 by its real part. This command has no effect on real numbers. (As an
16443 added convenience, @code{re} applied to a modulo form extracts
16449 The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
16450 by its imaginary part; real numbers are converted to zero. With a vector
16451 or matrix argument, these functions operate element-wise.
16456 @kindex v p (complex)
16458 The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
16459 the stack into a composite object such as a complex number. With
16460 a prefix argument of @mathit{-1}, it produces a rectangular complex number;
16461 with an argument of @mathit{-2}, it produces a polar complex number.
16462 (Also, @pxref{Building Vectors}.)
16467 @kindex v u (complex)
16468 @pindex calc-unpack
16469 The @kbd{v u} (@code{calc-unpack}) command takes the complex number
16470 (or other composite object) on the top of the stack and unpacks it
16471 into its separate components.
16473 @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
16474 @section Conversions
16477 The commands described in this section convert numbers from one form
16478 to another; they are two-key sequences beginning with the letter @kbd{c}.
16483 The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
16484 number on the top of the stack to floating-point form. For example,
16485 @expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to
16486 @expr{1.5}, and @expr{2.3} is left the same. If the value is a composite
16487 object such as a complex number or vector, each of the components is
16488 converted to floating-point. If the value is a formula, all numbers
16489 in the formula are converted to floating-point. Note that depending
16490 on the current floating-point precision, conversion to floating-point
16491 format may lose information.
16493 As a special exception, integers which appear as powers or subscripts
16494 are not floated by @kbd{c f}. If you really want to float a power,
16495 you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
16496 Because @kbd{c f} cannot examine the formula outside of the selection,
16497 it does not notice that the thing being floated is a power.
16498 @xref{Selecting Subformulas}.
16500 The normal @kbd{c f} command is ``pervasive'' in the sense that it
16501 applies to all numbers throughout the formula. The @code{pfloat}
16502 algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
16503 changes to @samp{a + 1.0} as soon as it is evaluated.
16507 With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
16508 only on the number or vector of numbers at the top level of its
16509 argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
16510 is left unevaluated because its argument is not a number.
16512 You should use @kbd{H c f} if you wish to guarantee that the final
16513 value, once all the variables have been assigned, is a float; you
16514 would use @kbd{c f} if you wish to do the conversion on the numbers
16515 that appear right now.
16518 @pindex calc-fraction
16520 The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
16521 floating-point number into a fractional approximation. By default, it
16522 produces a fraction whose decimal representation is the same as the
16523 input number, to within the current precision. You can also give a
16524 numeric prefix argument to specify a tolerance, either directly, or,
16525 if the prefix argument is zero, by using the number on top of the stack
16526 as the tolerance. If the tolerance is a positive integer, the fraction
16527 is correct to within that many significant figures. If the tolerance is
16528 a non-positive integer, it specifies how many digits fewer than the current
16529 precision to use. If the tolerance is a floating-point number, the
16530 fraction is correct to within that absolute amount.
16534 The @code{pfrac} function is pervasive, like @code{pfloat}.
16535 There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
16536 which is analogous to @kbd{H c f} discussed above.
16539 @pindex calc-to-degrees
16541 The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
16542 number into degrees form. The value on the top of the stack may be an
16543 HMS form (interpreted as degrees-minutes-seconds), or a real number which
16544 will be interpreted in radians regardless of the current angular mode.
16547 @pindex calc-to-radians
16549 The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
16550 HMS form or angle in degrees into an angle in radians.
16553 @pindex calc-to-hms
16555 The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
16556 number, interpreted according to the current angular mode, to an HMS
16557 form describing the same angle. In algebraic notation, the @code{hms}
16558 function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
16559 (The three-argument version is independent of the current angular mode.)
16561 @pindex calc-from-hms
16562 The @code{calc-from-hms} command converts the HMS form on the top of the
16563 stack into a real number according to the current angular mode.
16570 The @kbd{c p} (@code{calc-polar}) command converts the complex number on
16571 the top of the stack from polar to rectangular form, or from rectangular
16572 to polar form, whichever is appropriate. Real numbers are left the same.
16573 This command is equivalent to the @code{rect} or @code{polar}
16574 functions in algebraic formulas, depending on the direction of
16575 conversion. (It uses @code{polar}, except that if the argument is
16576 already a polar complex number, it uses @code{rect} instead. The
16577 @kbd{I c p} command always uses @code{rect}.)
16582 The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
16583 number on the top of the stack. Floating point numbers are re-rounded
16584 according to the current precision. Polar numbers whose angular
16585 components have strayed from the @mathit{-180} to @mathit{+180} degree range
16586 are normalized. (Note that results will be undesirable if the current
16587 angular mode is different from the one under which the number was
16588 produced!) Integers and fractions are generally unaffected by this
16589 operation. Vectors and formulas are cleaned by cleaning each component
16590 number (i.e., pervasively).
16592 If the simplification mode is set below the default level, it is raised
16593 to the default level for the purposes of this command. Thus, @kbd{c c}
16594 applies the default simplifications even if their automatic application
16595 is disabled. @xref{Simplification Modes}.
16597 @cindex Roundoff errors, correcting
16598 A numeric prefix argument to @kbd{c c} sets the floating-point precision
16599 to that value for the duration of the command. A positive prefix (of at
16600 least 3) sets the precision to the specified value; a negative or zero
16601 prefix decreases the precision by the specified amount.
16604 @pindex calc-clean-num
16605 The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
16606 to @kbd{c c} with the corresponding negative prefix argument. If roundoff
16607 errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
16608 decimal place often conveniently does the trick.
16610 The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
16611 through @kbd{c 9} commands, also ``clip'' very small floating-point
16612 numbers to zero. If the exponent is less than or equal to the negative
16613 of the specified precision, the number is changed to 0.0. For example,
16614 if the current precision is 12, then @kbd{c 2} changes the vector
16615 @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
16616 Numbers this small generally arise from roundoff noise.
16618 If the numbers you are using really are legitimately this small,
16619 you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
16620 (The plain @kbd{c c} command rounds to the current precision but
16621 does not clip small numbers.)
16623 One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
16624 a prefix argument, is that integer-valued floats are converted to
16625 plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
16626 produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge
16627 numbers (@samp{1e100} is technically an integer-valued float, but
16628 you wouldn't want it automatically converted to a 100-digit integer).
16633 With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
16634 operate non-pervasively [@code{clean}].
16636 @node Date Arithmetic, Financial Functions, Conversions, Arithmetic
16637 @section Date Arithmetic
16640 @cindex Date arithmetic, additional functions
16641 The commands described in this section perform various conversions
16642 and calculations involving date forms (@pxref{Date Forms}). They
16643 use the @kbd{t} (for time/date) prefix key followed by shifted
16646 The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
16647 commands. In particular, adding a number to a date form advances the
16648 date form by a certain number of days; adding an HMS form to a date
16649 form advances the date by a certain amount of time; and subtracting two
16650 date forms produces a difference measured in days. The commands
16651 described here provide additional, more specialized operations on dates.
16653 Many of these commands accept a numeric prefix argument; if you give
16654 plain @kbd{C-u} as the prefix, these commands will instead take the
16655 additional argument from the top of the stack.
16658 * Date Conversions::
16664 @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
16665 @subsection Date Conversions
16671 The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
16672 date form into a number, measured in days since Jan 1, 1 AD. The
16673 result will be an integer if @var{date} is a pure date form, or a
16674 fraction or float if @var{date} is a date/time form. Or, if its
16675 argument is a number, it converts this number into a date form.
16677 With a numeric prefix argument, @kbd{t D} takes that many objects
16678 (up to six) from the top of the stack and interprets them in one
16679 of the following ways:
16681 The @samp{date(@var{year}, @var{month}, @var{day})} function
16682 builds a pure date form out of the specified year, month, and
16683 day, which must all be integers. @var{Year} is a year number,
16684 such as 1991 (@emph{not} the same as 91!). @var{Month} must be
16685 an integer in the range 1 to 12; @var{day} must be in the range
16686 1 to 31. If the specified month has fewer than 31 days and
16687 @var{day} is too large, the equivalent day in the following
16688 month will be used.
16690 The @samp{date(@var{month}, @var{day})} function builds a
16691 pure date form using the current year, as determined by the
16694 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
16695 function builds a date/time form using an @var{hms} form.
16697 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
16698 @var{minute}, @var{second})} function builds a date/time form.
16699 @var{hour} should be an integer in the range 0 to 23;
16700 @var{minute} should be an integer in the range 0 to 59;
16701 @var{second} should be any real number in the range @samp{[0 .. 60)}.
16702 The last two arguments default to zero if omitted.
16705 @pindex calc-julian
16707 @cindex Julian day counts, conversions
16708 The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
16709 a date form into a Julian day count, which is the number of days
16710 since noon on Jan 1, 4713 BC. A pure date is converted to an integer
16711 Julian count representing noon of that day. A date/time form is
16712 converted to an exact floating-point Julian count, adjusted to
16713 interpret the date form in the current time zone but the Julian
16714 day count in Greenwich Mean Time. A numeric prefix argument allows
16715 you to specify the time zone; @pxref{Time Zones}. Use a prefix of
16716 zero to suppress the time zone adjustment. Note that pure date forms
16717 are never time-zone adjusted.
16719 This command can also do the opposite conversion, from a Julian day
16720 count (either an integer day, or a floating-point day and time in
16721 the GMT zone), into a pure date form or a date/time form in the
16722 current or specified time zone.
16725 @pindex calc-unix-time
16727 @cindex Unix time format, conversions
16728 The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
16729 converts a date form into a Unix time value, which is the number of
16730 seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result
16731 will be an integer if the current precision is 12 or less; for higher
16732 precisions, the result may be a float with (@var{precision}@minus{}12)
16733 digits after the decimal. Just as for @kbd{t J}, the numeric time
16734 is interpreted in the GMT time zone and the date form is interpreted
16735 in the current or specified zone. Some systems use Unix-like
16736 numbering but with the local time zone; give a prefix of zero to
16737 suppress the adjustment if so.
16740 @pindex calc-convert-time-zones
16742 @cindex Time Zones, converting between
16743 The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
16744 command converts a date form from one time zone to another. You
16745 are prompted for each time zone name in turn; you can answer with
16746 any suitable Calc time zone expression (@pxref{Time Zones}).
16747 If you answer either prompt with a blank line, the local time
16748 zone is used for that prompt. You can also answer the first
16749 prompt with @kbd{$} to take the two time zone names from the
16750 stack (and the date to be converted from the third stack level).
16752 @node Date Functions, Business Days, Date Conversions, Date Arithmetic
16753 @subsection Date Functions
16759 The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
16760 current date and time on the stack as a date form. The time is
16761 reported in terms of the specified time zone; with no numeric prefix
16762 argument, @kbd{t N} reports for the current time zone.
16765 @pindex calc-date-part
16766 The @kbd{t P} (@code{calc-date-part}) command extracts one part
16767 of a date form. The prefix argument specifies the part; with no
16768 argument, this command prompts for a part code from 1 to 9.
16769 The various part codes are described in the following paragraphs.
16772 The @kbd{M-1 t P} [@code{year}] function extracts the year number
16773 from a date form as an integer, e.g., 1991. This and the
16774 following functions will also accept a real number for an
16775 argument, which is interpreted as a standard Calc day number.
16776 Note that this function will never return zero, since the year
16777 1 BC immediately precedes the year 1 AD.
16780 The @kbd{M-2 t P} [@code{month}] function extracts the month number
16781 from a date form as an integer in the range 1 to 12.
16784 The @kbd{M-3 t P} [@code{day}] function extracts the day number
16785 from a date form as an integer in the range 1 to 31.
16788 The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
16789 a date form as an integer in the range 0 (midnight) to 23. Note
16790 that 24-hour time is always used. This returns zero for a pure
16791 date form. This function (and the following two) also accept
16792 HMS forms as input.
16795 The @kbd{M-5 t P} [@code{minute}] function extracts the minute
16796 from a date form as an integer in the range 0 to 59.
16799 The @kbd{M-6 t P} [@code{second}] function extracts the second
16800 from a date form. If the current precision is 12 or less,
16801 the result is an integer in the range 0 to 59. For higher
16802 precisions, the result may instead be a floating-point number.
16805 The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
16806 number from a date form as an integer in the range 0 (Sunday)
16810 The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
16811 number from a date form as an integer in the range 1 (January 1)
16812 to 366 (December 31 of a leap year).
16815 The @kbd{M-9 t P} [@code{time}] function extracts the time portion
16816 of a date form as an HMS form. This returns @samp{0@@ 0' 0"}
16817 for a pure date form.
16820 @pindex calc-new-month
16822 The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
16823 computes a new date form that represents the first day of the month
16824 specified by the input date. The result is always a pure date
16825 form; only the year and month numbers of the input are retained.
16826 With a numeric prefix argument @var{n} in the range from 1 to 31,
16827 @kbd{t M} computes the @var{n}th day of the month. (If @var{n}
16828 is greater than the actual number of days in the month, or if
16829 @var{n} is zero, the last day of the month is used.)
16832 @pindex calc-new-year
16834 The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
16835 computes a new pure date form that represents the first day of
16836 the year specified by the input. The month, day, and time
16837 of the input date form are lost. With a numeric prefix argument
16838 @var{n} in the range from 1 to 366, @kbd{t Y} computes the
16839 @var{n}th day of the year (366 is treated as 365 in non-leap
16840 years). A prefix argument of 0 computes the last day of the
16841 year (December 31). A negative prefix argument from @mathit{-1} to
16842 @mathit{-12} computes the first day of the @var{n}th month of the year.
16845 @pindex calc-new-week
16847 The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
16848 computes a new pure date form that represents the Sunday on or before
16849 the input date. With a numeric prefix argument, it can be made to
16850 use any day of the week as the starting day; the argument must be in
16851 the range from 0 (Sunday) to 6 (Saturday). This function always
16852 subtracts between 0 and 6 days from the input date.
16854 Here's an example use of @code{newweek}: Find the date of the next
16855 Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
16856 will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
16857 will give you the following Wednesday. A further look at the definition
16858 of @code{newweek} shows that if the input date is itself a Wednesday,
16859 this formula will return the Wednesday one week in the future. An
16860 exercise for the reader is to modify this formula to yield the same day
16861 if the input is already a Wednesday. Another interesting exercise is
16862 to preserve the time-of-day portion of the input (@code{newweek} resets
16863 the time to midnight; hint:@: how can @code{newweek} be defined in terms
16864 of the @code{weekday} function?).
16870 The @samp{pwday(@var{date})} function (not on any key) computes the
16871 day-of-month number of the Sunday on or before @var{date}. With
16872 two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
16873 number of the Sunday on or before day number @var{day} of the month
16874 specified by @var{date}. The @var{day} must be in the range from
16875 7 to 31; if the day number is greater than the actual number of days
16876 in the month, the true number of days is used instead. Thus
16877 @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
16878 @samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
16879 With a third @var{weekday} argument, @code{pwday} can be made to look
16880 for any day of the week instead of Sunday.
16883 @pindex calc-inc-month
16885 The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
16886 increases a date form by one month, or by an arbitrary number of
16887 months specified by a numeric prefix argument. The time portion,
16888 if any, of the date form stays the same. The day also stays the
16889 same, except that if the new month has fewer days the day
16890 number may be reduced to lie in the valid range. For example,
16891 @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
16892 Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
16893 the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
16900 The @samp{incyear(@var{date}, @var{step})} function increases
16901 a date form by the specified number of years, which may be
16902 any positive or negative integer. Note that @samp{incyear(d, n)}
16903 is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
16904 simple equivalents in terms of day arithmetic because
16905 months and years have varying lengths. If the @var{step}
16906 argument is omitted, 1 year is assumed. There is no keyboard
16907 command for this function; use @kbd{C-u 12 t I} instead.
16909 There is no @code{newday} function at all because @kbd{F} [@code{floor}]
16910 serves this purpose. Similarly, instead of @code{incday} and
16911 @code{incweek} simply use @expr{d + n} or @expr{d + 7 n}.
16913 @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
16914 which can adjust a date/time form by a certain number of seconds.
16916 @node Business Days, Time Zones, Date Functions, Date Arithmetic
16917 @subsection Business Days
16920 Often time is measured in ``business days'' or ``working days,''
16921 where weekends and holidays are skipped. Calc's normal date
16922 arithmetic functions use calendar days, so that subtracting two
16923 consecutive Mondays will yield a difference of 7 days. By contrast,
16924 subtracting two consecutive Mondays would yield 5 business days
16925 (assuming two-day weekends and the absence of holidays).
16931 @pindex calc-business-days-plus
16932 @pindex calc-business-days-minus
16933 The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
16934 and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
16935 commands perform arithmetic using business days. For @kbd{t +},
16936 one argument must be a date form and the other must be a real
16937 number (positive or negative). If the number is not an integer,
16938 then a certain amount of time is added as well as a number of
16939 days; for example, adding 0.5 business days to a time in Friday
16940 evening will produce a time in Monday morning. It is also
16941 possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
16942 half a business day. For @kbd{t -}, the arguments are either a
16943 date form and a number or HMS form, or two date forms, in which
16944 case the result is the number of business days between the two
16947 @cindex @code{Holidays} variable
16949 By default, Calc considers any day that is not a Saturday or
16950 Sunday to be a business day. You can define any number of
16951 additional holidays by editing the variable @code{Holidays}.
16952 (There is an @w{@kbd{s H}} convenience command for editing this
16953 variable.) Initially, @code{Holidays} contains the vector
16954 @samp{[sat, sun]}. Entries in the @code{Holidays} vector may
16955 be any of the following kinds of objects:
16959 Date forms (pure dates, not date/time forms). These specify
16960 particular days which are to be treated as holidays.
16963 Intervals of date forms. These specify a range of days, all of
16964 which are holidays (e.g., Christmas week). @xref{Interval Forms}.
16967 Nested vectors of date forms. Each date form in the vector is
16968 considered to be a holiday.
16971 Any Calc formula which evaluates to one of the above three things.
16972 If the formula involves the variable @expr{y}, it stands for a
16973 yearly repeating holiday; @expr{y} will take on various year
16974 numbers like 1992. For example, @samp{date(y, 12, 25)} specifies
16975 Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
16976 Thanksgiving (which is held on the fourth Thursday of November).
16977 If the formula involves the variable @expr{m}, that variable
16978 takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is
16979 a holiday that takes place on the 15th of every month.
16982 A weekday name, such as @code{sat} or @code{sun}. This is really
16983 a variable whose name is a three-letter, lower-case day name.
16986 An interval of year numbers (integers). This specifies the span of
16987 years over which this holiday list is to be considered valid. Any
16988 business-day arithmetic that goes outside this range will result
16989 in an error message. Use this if you are including an explicit
16990 list of holidays, rather than a formula to generate them, and you
16991 want to make sure you don't accidentally go beyond the last point
16992 where the holidays you entered are complete. If there is no
16993 limiting interval in the @code{Holidays} vector, the default
16994 @samp{[1 .. 2737]} is used. (This is the absolute range of years
16995 for which Calc's business-day algorithms will operate.)
16998 An interval of HMS forms. This specifies the span of hours that
16999 are to be considered one business day. For example, if this
17000 range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
17001 the business day is only eight hours long, so that @kbd{1.5 t +}
17002 on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
17003 four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
17004 Likewise, @kbd{t -} will now express differences in time as
17005 fractions of an eight-hour day. Times before 9am will be treated
17006 as 9am by business date arithmetic, and times at or after 5pm will
17007 be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays},
17008 the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
17009 (Regardless of the type of bounds you specify, the interval is
17010 treated as inclusive on the low end and exclusive on the high end,
17011 so that the work day goes from 9am up to, but not including, 5pm.)
17014 If the @code{Holidays} vector is empty, then @kbd{t +} and
17015 @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
17016 then be no difference between business days and calendar days.
17018 Calc expands the intervals and formulas you give into a complete
17019 list of holidays for internal use. This is done mainly to make
17020 sure it can detect multiple holidays. (For example,
17021 @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
17022 Calc's algorithms take care to count it only once when figuring
17023 the number of holidays between two dates.)
17025 Since the complete list of holidays for all the years from 1 to
17026 2737 would be huge, Calc actually computes only the part of the
17027 list between the smallest and largest years that have been involved
17028 in business-day calculations so far. Normally, you won't have to
17029 worry about this. Keep in mind, however, that if you do one
17030 calculation for 1992, and another for 1792, even if both involve
17031 only a small range of years, Calc will still work out all the
17032 holidays that fall in that 200-year span.
17034 If you add a (positive) number of days to a date form that falls on a
17035 weekend or holiday, the date form is treated as if it were the most
17036 recent business day. (Thus adding one business day to a Friday,
17037 Saturday, or Sunday will all yield the following Monday.) If you
17038 subtract a number of days from a weekend or holiday, the date is
17039 effectively on the following business day. (So subtracting one business
17040 day from Saturday, Sunday, or Monday yields the preceding Friday.) The
17041 difference between two dates one or both of which fall on holidays
17042 equals the number of actual business days between them. These
17043 conventions are consistent in the sense that, if you add @var{n}
17044 business days to any date, the difference between the result and the
17045 original date will come out to @var{n} business days. (It can't be
17046 completely consistent though; a subtraction followed by an addition
17047 might come out a bit differently, since @kbd{t +} is incapable of
17048 producing a date that falls on a weekend or holiday.)
17054 There is a @code{holiday} function, not on any keys, that takes
17055 any date form and returns 1 if that date falls on a weekend or
17056 holiday, as defined in @code{Holidays}, or 0 if the date is a
17059 @node Time Zones, , Business Days, Date Arithmetic
17060 @subsection Time Zones
17064 @cindex Daylight savings time
17065 Time zones and daylight savings time are a complicated business.
17066 The conversions to and from Julian and Unix-style dates automatically
17067 compute the correct time zone and daylight savings adjustment to use,
17068 provided they can figure out this information. This section describes
17069 Calc's time zone adjustment algorithm in detail, in case you want to
17070 do conversions in different time zones or in case Calc's algorithms
17071 can't determine the right correction to use.
17073 Adjustments for time zones and daylight savings time are done by
17074 @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
17075 commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
17076 to exactly 30 days even though there is a daylight-savings
17077 transition in between. This is also true for Julian pure dates:
17078 @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian
17079 and Unix date/times will adjust for daylight savings time:
17080 @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
17081 evaluates to @samp{29.95834} (that's 29 days and 23 hours)
17082 because one hour was lost when daylight savings commenced on
17085 In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
17086 computes the actual number of 24-hour periods between two dates, whereas
17087 @samp{@var{date1} - @var{date2}} computes the number of calendar
17088 days between two dates without taking daylight savings into account.
17090 @pindex calc-time-zone
17095 The @code{calc-time-zone} [@code{tzone}] command converts the time
17096 zone specified by its numeric prefix argument into a number of
17097 seconds difference from Greenwich mean time (GMT). If the argument
17098 is a number, the result is simply that value multiplied by 3600.
17099 Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If
17100 Daylight Savings time is in effect, one hour should be subtracted from
17101 the normal difference.
17103 If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
17104 date arithmetic commands that include a time zone argument) takes the
17105 zone argument from the top of the stack. (In the case of @kbd{t J}
17106 and @kbd{t U}, the normal argument is then taken from the second-to-top
17107 stack position.) This allows you to give a non-integer time zone
17108 adjustment. The time-zone argument can also be an HMS form, or
17109 it can be a variable which is a time zone name in upper- or lower-case.
17110 For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
17111 (for Pacific standard and daylight savings times, respectively).
17113 North American and European time zone names are defined as follows;
17114 note that for each time zone there is one name for standard time,
17115 another for daylight savings time, and a third for ``generalized'' time
17116 in which the daylight savings adjustment is computed from context.
17120 YST PST MST CST EST AST NST GMT WET MET MEZ
17121 9 8 7 6 5 4 3.5 0 -1 -2 -2
17123 YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ
17124 8 7 6 5 4 3 2.5 -1 -2 -3 -3
17126 YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ
17127 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3
17131 @vindex math-tzone-names
17132 To define time zone names that do not appear in the above table,
17133 you must modify the Lisp variable @code{math-tzone-names}. This
17134 is a list of lists describing the different time zone names; its
17135 structure is best explained by an example. The three entries for
17136 Pacific Time look like this:
17140 ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard
17141 ( "PDT" 8 -1 ) ; adjustment, then daylight savings adjustment.
17142 ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone.
17146 @cindex @code{TimeZone} variable
17148 With no arguments, @code{calc-time-zone} or @samp{tzone()} obtains an
17149 argument from the Calc variable @code{TimeZone} if a value has been
17150 stored for that variable. If not, Calc runs the Unix @samp{date}
17151 command and looks for one of the above time zone names in the output;
17152 if this does not succeed, @samp{tzone()} leaves itself unevaluated.
17153 The time zone name in the @samp{date} output may be followed by a signed
17154 adjustment, e.g., @samp{GMT+5} or @samp{GMT+0500} which specifies a
17155 number of hours and minutes to be added to the base time zone.
17156 Calc stores the time zone it finds into @code{TimeZone} to speed
17157 later calls to @samp{tzone()}.
17159 The special time zone name @code{local} is equivalent to no argument,
17160 i.e., it uses the local time zone as obtained from the @code{date}
17163 If the time zone name found is one of the standard or daylight
17164 savings zone names from the above table, and Calc's internal
17165 daylight savings algorithm says that time and zone are consistent
17166 (e.g., @code{PDT} accompanies a date that Calc's algorithm would also
17167 consider to be daylight savings, or @code{PST} accompanies a date
17168 that Calc would consider to be standard time), then Calc substitutes
17169 the corresponding generalized time zone (like @code{PGT}).
17171 If your system does not have a suitable @samp{date} command, you
17172 may wish to put a @samp{(setq var-TimeZone ...)} in your Emacs
17173 initialization file to set the time zone. (Since you are interacting
17174 with the variable @code{TimeZone} directly from Emacs Lisp, the
17175 @code{var-} prefix needs to be present.) The easiest way to do
17176 this is to edit the @code{TimeZone} variable using Calc's @kbd{s T}
17177 command, then use the @kbd{s p} (@code{calc-permanent-variable})
17178 command to save the value of @code{TimeZone} permanently.
17180 The @kbd{t J} and @code{t U} commands with no numeric prefix
17181 arguments do the same thing as @samp{tzone()}. If the current
17182 time zone is a generalized time zone, e.g., @code{EGT}, Calc
17183 examines the date being converted to tell whether to use standard
17184 or daylight savings time. But if the current time zone is explicit,
17185 e.g., @code{EST} or @code{EDT}, then that adjustment is used exactly
17186 and Calc's daylight savings algorithm is not consulted.
17188 Some places don't follow the usual rules for daylight savings time.
17189 The state of Arizona, for example, does not observe daylight savings
17190 time. If you run Calc during the winter season in Arizona, the
17191 Unix @code{date} command will report @code{MST} time zone, which
17192 Calc will change to @code{MGT}. If you then convert a time that
17193 lies in the summer months, Calc will apply an incorrect daylight
17194 savings time adjustment. To avoid this, set your @code{TimeZone}
17195 variable explicitly to @code{MST} to force the use of standard,
17196 non-daylight-savings time.
17198 @vindex math-daylight-savings-hook
17199 @findex math-std-daylight-savings
17200 By default Calc always considers daylight savings time to begin at
17201 2 a.m.@: on the first Sunday of April, and to end at 2 a.m.@: on the
17202 last Sunday of October. This is the rule that has been in effect
17203 in North America since 1987. If you are in a country that uses
17204 different rules for computing daylight savings time, you have two
17205 choices: Write your own daylight savings hook, or control time
17206 zones explicitly by setting the @code{TimeZone} variable and/or
17207 always giving a time-zone argument for the conversion functions.
17209 The Lisp variable @code{math-daylight-savings-hook} holds the
17210 name of a function that is used to compute the daylight savings
17211 adjustment for a given date. The default is
17212 @code{math-std-daylight-savings}, which computes an adjustment
17213 (either 0 or @mathit{-1}) using the North American rules given above.
17215 The daylight savings hook function is called with four arguments:
17216 The date, as a floating-point number in standard Calc format;
17217 a six-element list of the date decomposed into year, month, day,
17218 hour, minute, and second, respectively; a string which contains
17219 the generalized time zone name in upper-case, e.g., @code{"WEGT"};
17220 and a special adjustment to be applied to the hour value when
17221 converting into a generalized time zone (see below).
17223 @findex math-prev-weekday-in-month
17224 The Lisp function @code{math-prev-weekday-in-month} is useful for
17225 daylight savings computations. This is an internal version of
17226 the user-level @code{pwday} function described in the previous
17227 section. It takes four arguments: The floating-point date value,
17228 the corresponding six-element date list, the day-of-month number,
17229 and the weekday number (0-6).
17231 The default daylight savings hook ignores the time zone name, but a
17232 more sophisticated hook could use different algorithms for different
17233 time zones. It would also be possible to use different algorithms
17234 depending on the year number, but the default hook always uses the
17235 algorithm for 1987 and later. Here is a listing of the default
17236 daylight savings hook:
17239 (defun math-std-daylight-savings (date dt zone bump)
17240 (cond ((< (nth 1 dt) 4) 0)
17242 (let ((sunday (math-prev-weekday-in-month date dt 7 0)))
17243 (cond ((< (nth 2 dt) sunday) 0)
17244 ((= (nth 2 dt) sunday)
17245 (if (>= (nth 3 dt) (+ 3 bump)) -1 0))
17247 ((< (nth 1 dt) 10) -1)
17249 (let ((sunday (math-prev-weekday-in-month date dt 31 0)))
17250 (cond ((< (nth 2 dt) sunday) -1)
17251 ((= (nth 2 dt) sunday)
17252 (if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
17259 The @code{bump} parameter is equal to zero when Calc is converting
17260 from a date form in a generalized time zone into a GMT date value.
17261 It is @mathit{-1} when Calc is converting in the other direction. The
17262 adjustments shown above ensure that the conversion behaves correctly
17263 and reasonably around the 2 a.m.@: transition in each direction.
17265 There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
17266 beginning of daylight savings time; converting a date/time form that
17267 falls in this hour results in a time value for the following hour,
17268 from 3 a.m.@: to 4 a.m. At the end of daylight savings time, the
17269 hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
17270 form that falls in in this hour results in a time value for the first
17271 manifestation of that time (@emph{not} the one that occurs one hour later).
17273 If @code{math-daylight-savings-hook} is @code{nil}, then the
17274 daylight savings adjustment is always taken to be zero.
17276 In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
17277 computes the time zone adjustment for a given zone name at a
17278 given date. The @var{date} is ignored unless @var{zone} is a
17279 generalized time zone. If @var{date} is a date form, the
17280 daylight savings computation is applied to it as it appears.
17281 If @var{date} is a numeric date value, it is adjusted for the
17282 daylight-savings version of @var{zone} before being given to
17283 the daylight savings hook. This odd-sounding rule ensures
17284 that the daylight-savings computation is always done in
17285 local time, not in the GMT time that a numeric @var{date}
17286 is typically represented in.
17292 The @samp{dsadj(@var{date}, @var{zone})} function computes the
17293 daylight savings adjustment that is appropriate for @var{date} in
17294 time zone @var{zone}. If @var{zone} is explicitly in or not in
17295 daylight savings time (e.g., @code{PDT} or @code{PST}) the
17296 @var{date} is ignored. If @var{zone} is a generalized time zone,
17297 the algorithms described above are used. If @var{zone} is omitted,
17298 the computation is done for the current time zone.
17300 @xref{Reporting Bugs}, for the address of Calc's author, if you
17301 should wish to contribute your improved versions of
17302 @code{math-tzone-names} and @code{math-daylight-savings-hook}
17303 to the Calc distribution.
17305 @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
17306 @section Financial Functions
17309 Calc's financial or business functions use the @kbd{b} prefix
17310 key followed by a shifted letter. (The @kbd{b} prefix followed by
17311 a lower-case letter is used for operations on binary numbers.)
17313 Note that the rate and the number of intervals given to these
17314 functions must be on the same time scale, e.g., both months or
17315 both years. Mixing an annual interest rate with a time expressed
17316 in months will give you very wrong answers!
17318 It is wise to compute these functions to a higher precision than
17319 you really need, just to make sure your answer is correct to the
17320 last penny; also, you may wish to check the definitions at the end
17321 of this section to make sure the functions have the meaning you expect.
17327 * Related Financial Functions::
17328 * Depreciation Functions::
17329 * Definitions of Financial Functions::
17332 @node Percentages, Future Value, Financial Functions, Financial Functions
17333 @subsection Percentages
17336 @pindex calc-percent
17339 The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
17340 say 5.4, and converts it to an equivalent actual number. For example,
17341 @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or
17342 @key{ESC} key combined with @kbd{%}.)
17344 Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
17345 You can enter @samp{5.4%} yourself during algebraic entry. The
17346 @samp{%} operator simply means, ``the preceding value divided by
17347 100.'' The @samp{%} operator has very high precedence, so that
17348 @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
17349 (The @samp{%} operator is just a postfix notation for the
17350 @code{percent} function, just like @samp{20!} is the notation for
17351 @samp{fact(20)}, or twenty-factorial.)
17353 The formula @samp{5.4%} would normally evaluate immediately to
17354 0.054, but the @kbd{M-%} command suppresses evaluation as it puts
17355 the formula onto the stack. However, the next Calc command that
17356 uses the formula @samp{5.4%} will evaluate it as its first step.
17357 The net effect is that you get to look at @samp{5.4%} on the stack,
17358 but Calc commands see it as @samp{0.054}, which is what they expect.
17360 In particular, @samp{5.4%} and @samp{0.054} are suitable values
17361 for the @var{rate} arguments of the various financial functions,
17362 but the number @samp{5.4} is probably @emph{not} suitable---it
17363 represents a rate of 540 percent!
17365 The key sequence @kbd{M-% *} effectively means ``percent-of.''
17366 For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
17367 68 (and also 68% of 25, which comes out to the same thing).
17370 @pindex calc-convert-percent
17371 The @kbd{c %} (@code{calc-convert-percent}) command converts the
17372 value on the top of the stack from numeric to percentage form.
17373 For example, if 0.08 is on the stack, @kbd{c %} converts it to
17374 @samp{8%}. The quantity is the same, it's just represented
17375 differently. (Contrast this with @kbd{M-%}, which would convert
17376 this number to @samp{0.08%}.) The @kbd{=} key is a convenient way
17377 to convert a formula like @samp{8%} back to numeric form, 0.08.
17379 To compute what percentage one quantity is of another quantity,
17380 use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
17384 @pindex calc-percent-change
17386 The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
17387 calculates the percentage change from one number to another.
17388 For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
17389 since 50 is 25% larger than 40. A negative result represents a
17390 decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
17391 20% smaller than 50. (The answers are different in magnitude
17392 because, in the first case, we're increasing by 25% of 40, but
17393 in the second case, we're decreasing by 20% of 50.) The effect
17394 of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting
17395 the answer to percentage form as if by @kbd{c %}.
17397 @node Future Value, Present Value, Percentages, Financial Functions
17398 @subsection Future Value
17402 @pindex calc-fin-fv
17404 The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
17405 the future value of an investment. It takes three arguments
17406 from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}.
17407 If you give payments of @var{payment} every year for @var{n}
17408 years, and the money you have paid earns interest at @var{rate} per
17409 year, then this function tells you what your investment would be
17410 worth at the end of the period. (The actual interval doesn't
17411 have to be years, as long as @var{n} and @var{rate} are expressed
17412 in terms of the same intervals.) This function assumes payments
17413 occur at the @emph{end} of each interval.
17417 The @kbd{I b F} [@code{fvb}] command does the same computation,
17418 but assuming your payments are at the beginning of each interval.
17419 Suppose you plan to deposit $1000 per year in a savings account
17420 earning 5.4% interest, starting right now. How much will be
17421 in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}.
17422 Thus you will have earned $870 worth of interest over the years.
17423 Using the stack, this calculation would have been
17424 @kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed
17425 as a number between 0 and 1, @emph{not} as a percentage.
17429 The @kbd{H b F} [@code{fvl}] command computes the future value
17430 of an initial lump sum investment. Suppose you could deposit
17431 those five thousand dollars in the bank right now; how much would
17432 they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}.
17434 The algebraic functions @code{fv} and @code{fvb} accept an optional
17435 fourth argument, which is used as an initial lump sum in the sense
17436 of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n},
17437 @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
17438 + fvl(@var{rate}, @var{n}, @var{initial})}.
17440 To illustrate the relationships between these functions, we could
17441 do the @code{fvb} calculation ``by hand'' using @code{fvl}. The
17442 final balance will be the sum of the contributions of our five
17443 deposits at various times. The first deposit earns interest for
17444 five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second
17445 deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) =
17446 1234.13}. And so on down to the last deposit, which earns one
17447 year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of
17448 these five values is, sure enough, $5870.73, just as was computed
17449 by @code{fvb} directly.
17451 What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments
17452 are now at the ends of the periods. The end of one year is the same
17453 as the beginning of the next, so what this really means is that we've
17454 lost the payment at year zero (which contributed $1300.78), but we're
17455 now counting the payment at year five (which, since it didn't have
17456 a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 =
17457 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
17459 @node Present Value, Related Financial Functions, Future Value, Financial Functions
17460 @subsection Present Value
17464 @pindex calc-fin-pv
17466 The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
17467 the present value of an investment. Like @code{fv}, it takes
17468 three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}.
17469 It computes the present value of a series of regular payments.
17470 Suppose you have the chance to make an investment that will
17471 pay $2000 per year over the next four years; as you receive
17472 these payments you can put them in the bank at 9% interest.
17473 You want to know whether it is better to make the investment, or
17474 to keep the money in the bank where it earns 9% interest right
17475 from the start. The calculation @code{pv(9%, 4, 2000)} gives the
17476 result 6479.44. If your initial investment must be less than this,
17477 say, $6000, then the investment is worthwhile. But if you had to
17478 put up $7000, then it would be better just to leave it in the bank.
17480 Here is the interpretation of the result of @code{pv}: You are
17481 trying to compare the return from the investment you are
17482 considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
17483 the return from leaving the money in the bank, which is
17484 @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
17485 you would have to put up in advance. The @code{pv} function
17486 finds the break-even point, @expr{x = 6479.44}, at which
17487 @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is
17488 the largest amount you should be willing to invest.
17492 The @kbd{I b P} [@code{pvb}] command solves the same problem,
17493 but with payments occurring at the beginning of each interval.
17494 It has the same relationship to @code{fvb} as @code{pv} has
17495 to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59},
17496 a larger number than @code{pv} produced because we get to start
17497 earning interest on the return from our investment sooner.
17501 The @kbd{H b P} [@code{pvl}] command computes the present value of
17502 an investment that will pay off in one lump sum at the end of the
17503 period. For example, if we get our $8000 all at the end of the
17504 four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much
17505 less than @code{pv} reported, because we don't earn any interest
17506 on the return from this investment. Note that @code{pvl} and
17507 @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}.
17509 You can give an optional fourth lump-sum argument to @code{pv}
17510 and @code{pvb}; this is handled in exactly the same way as the
17511 fourth argument for @code{fv} and @code{fvb}.
17514 @pindex calc-fin-npv
17516 The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
17517 the net present value of a series of irregular investments.
17518 The first argument is the interest rate. The second argument is
17519 a vector which represents the expected return from the investment
17520 at the end of each interval. For example, if the rate represents
17521 a yearly interest rate, then the vector elements are the return
17522 from the first year, second year, and so on.
17524 Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
17525 Obviously this function is more interesting when the payments are
17528 The @code{npv} function can actually have two or more arguments.
17529 Multiple arguments are interpreted in the same way as for the
17530 vector statistical functions like @code{vsum}.
17531 @xref{Single-Variable Statistics}. Basically, if there are several
17532 payment arguments, each either a vector or a plain number, all these
17533 values are collected left-to-right into the complete list of payments.
17534 A numeric prefix argument on the @kbd{b N} command says how many
17535 payment values or vectors to take from the stack.
17539 The @kbd{I b N} [@code{npvb}] command computes the net present
17540 value where payments occur at the beginning of each interval
17541 rather than at the end.
17543 @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
17544 @subsection Related Financial Functions
17547 The functions in this section are basically inverses of the
17548 present value functions with respect to the various arguments.
17551 @pindex calc-fin-pmt
17553 The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
17554 the amount of periodic payment necessary to amortize a loan.
17555 Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
17556 value of @var{payment} such that @code{pv(@var{rate}, @var{n},
17557 @var{payment}) = @var{amount}}.
17561 The @kbd{I b M} [@code{pmtb}] command does the same computation
17562 but using @code{pvb} instead of @code{pv}. Like @code{pv} and
17563 @code{pvb}, these functions can also take a fourth argument which
17564 represents an initial lump-sum investment.
17567 The @kbd{H b M} key just invokes the @code{fvl} function, which is
17568 the inverse of @code{pvl}. There is no explicit @code{pmtl} function.
17571 @pindex calc-fin-nper
17573 The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
17574 the number of regular payments necessary to amortize a loan.
17575 Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
17576 the value of @var{n} such that @code{pv(@var{rate}, @var{n},
17577 @var{payment}) = @var{amount}}. If @var{payment} is too small
17578 ever to amortize a loan for @var{amount} at interest rate @var{rate},
17579 the @code{nper} function is left in symbolic form.
17583 The @kbd{I b #} [@code{nperb}] command does the same computation
17584 but using @code{pvb} instead of @code{pv}. You can give a fourth
17585 lump-sum argument to these functions, but the computation will be
17586 rather slow in the four-argument case.
17590 The @kbd{H b #} [@code{nperl}] command does the same computation
17591 using @code{pvl}. By exchanging @var{payment} and @var{amount} you
17592 can also get the solution for @code{fvl}. For example,
17593 @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
17594 bank account earning 8%, it will take nine years to grow to $2000.
17597 @pindex calc-fin-rate
17599 The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
17600 the rate of return on an investment. This is also an inverse of @code{pv}:
17601 @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
17602 @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
17603 @var{amount}}. The result is expressed as a formula like @samp{6.3%}.
17609 The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
17610 commands solve the analogous equations with @code{pvb} or @code{pvl}
17611 in place of @code{pv}. Also, @code{rate} and @code{rateb} can
17612 accept an optional fourth argument just like @code{pv} and @code{pvb}.
17613 To redo the above example from a different perspective,
17614 @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
17615 interest rate of 8% in order to double your account in nine years.
17618 @pindex calc-fin-irr
17620 The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
17621 analogous function to @code{rate} but for net present value.
17622 Its argument is a vector of payments. Thus @code{irr(@var{payments})}
17623 computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
17624 this rate is known as the @dfn{internal rate of return}.
17628 The @kbd{I b I} [@code{irrb}] command computes the internal rate of
17629 return assuming payments occur at the beginning of each period.
17631 @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
17632 @subsection Depreciation Functions
17635 The functions in this section calculate @dfn{depreciation}, which is
17636 the amount of value that a possession loses over time. These functions
17637 are characterized by three parameters: @var{cost}, the original cost
17638 of the asset; @var{salvage}, the value the asset will have at the end
17639 of its expected ``useful life''; and @var{life}, the number of years
17640 (or other periods) of the expected useful life.
17642 There are several methods for calculating depreciation that differ in
17643 the way they spread the depreciation over the lifetime of the asset.
17646 @pindex calc-fin-sln
17648 The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
17649 ``straight-line'' depreciation. In this method, the asset depreciates
17650 by the same amount every year (or period). For example,
17651 @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000
17652 initially and will be worth $2000 after five years; it loses $2000
17656 @pindex calc-fin-syd
17658 The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
17659 accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation
17660 is higher during the early years of the asset's life. Since the
17661 depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
17662 parameter which specifies which year is requested, from 1 to @var{life}.
17663 If @var{period} is outside this range, the @code{syd} function will
17667 @pindex calc-fin-ddb
17669 The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
17670 accelerated depreciation using the double-declining balance method.
17671 It also takes a fourth @var{period} parameter.
17673 For symmetry, the @code{sln} function will accept a @var{period}
17674 parameter as well, although it will ignore its value except that the
17675 return value will as usual be zero if @var{period} is out of range.
17677 For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
17678 and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
17679 ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
17680 the three depreciation methods:
17684 [ [ 2000, 3333, 4800 ]
17685 [ 2000, 2667, 2880 ]
17686 [ 2000, 2000, 1728 ]
17687 [ 2000, 1333, 592 ]
17693 (Values have been rounded to nearest integers in this figure.)
17694 We see that @code{sln} depreciates by the same amount each year,
17695 @kbd{syd} depreciates more at the beginning and less at the end,
17696 and @kbd{ddb} weights the depreciation even more toward the beginning.
17698 Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]};
17699 the total depreciation in any method is (by definition) the
17700 difference between the cost and the salvage value.
17702 @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
17703 @subsection Definitions
17706 For your reference, here are the actual formulas used to compute
17707 Calc's financial functions.
17709 Calc will not evaluate a financial function unless the @var{rate} or
17710 @var{n} argument is known. However, @var{payment} or @var{amount} can
17711 be a variable. Calc expands these functions according to the
17712 formulas below for symbolic arguments only when you use the @kbd{a "}
17713 (@code{calc-expand-formula}) command, or when taking derivatives or
17714 integrals or solving equations involving the functions.
17717 These formulas are shown using the conventions of Big display
17718 mode (@kbd{d B}); for example, the formula for @code{fv} written
17719 linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
17724 fv(rate, n, pmt) = pmt * ---------------
17728 ((1 + rate) - 1) (1 + rate)
17729 fvb(rate, n, pmt) = pmt * ----------------------------
17733 fvl(rate, n, pmt) = pmt * (1 + rate)
17737 pv(rate, n, pmt) = pmt * ----------------
17741 (1 - (1 + rate) ) (1 + rate)
17742 pvb(rate, n, pmt) = pmt * -----------------------------
17746 pvl(rate, n, pmt) = pmt * (1 + rate)
17749 npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate)
17752 npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate)
17755 (amt - x * (1 + rate) ) * rate
17756 pmt(rate, n, amt, x) = -------------------------------
17761 (amt - x * (1 + rate) ) * rate
17762 pmtb(rate, n, amt, x) = -------------------------------
17764 (1 - (1 + rate) ) (1 + rate)
17767 nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate)
17771 nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
17775 nperl(rate, pmt, amt) = - log(---, 1 + rate)
17780 ratel(n, pmt, amt) = ------ - 1
17785 sln(cost, salv, life) = -----------
17788 (cost - salv) * (life - per + 1)
17789 syd(cost, salv, life, per) = --------------------------------
17790 life * (life + 1) / 2
17793 ddb(cost, salv, life, per) = --------, book = cost - depreciation so far
17799 $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
17800 $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
17801 $$ \code{fvl}(r, n, p) = p (1 + r)^n $$
17802 $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
17803 $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
17804 $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
17805 $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
17806 $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
17807 $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
17808 $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
17809 (1 - (1 + r)^{-n}) (1 + r) } $$
17810 $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
17811 $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
17812 $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
17813 $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
17814 $$ \code{sln}(c, s, l) = { c - s \over l } $$
17815 $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
17816 $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
17820 In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted.
17822 These functions accept any numeric objects, including error forms,
17823 intervals, and even (though not very usefully) complex numbers. The
17824 above formulas specify exactly the behavior of these functions with
17825 all sorts of inputs.
17827 Note that if the first argument to the @code{log} in @code{nper} is
17828 negative, @code{nper} leaves itself in symbolic form rather than
17829 returning a (financially meaningless) complex number.
17831 @samp{rate(num, pmt, amt)} solves the equation
17832 @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
17833 (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
17834 for an initial guess. The @code{rateb} function is the same except
17835 that it uses @code{pvb}. Note that @code{ratel} can be solved
17836 directly; its formula is shown in the above list.
17838 Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
17841 If you give a fourth argument to @code{nper} or @code{nperb}, Calc
17842 will also use @kbd{H a R} to solve the equation using an initial
17843 guess interval of @samp{[0 .. 100]}.
17845 A fourth argument to @code{fv} simply sums the two components
17846 calculated from the above formulas for @code{fv} and @code{fvl}.
17847 The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
17849 The @kbd{ddb} function is computed iteratively; the ``book'' value
17850 starts out equal to @var{cost}, and decreases according to the above
17851 formula for the specified number of periods. If the book value
17852 would decrease below @var{salvage}, it only decreases to @var{salvage}
17853 and the depreciation is zero for all subsequent periods. The @code{ddb}
17854 function returns the amount the book value decreased in the specified
17857 The Calc financial function names were borrowed mostly from Microsoft
17858 Excel and Borland's Quattro. The @code{ratel} function corresponds to
17859 @samp{@@CGR} in Borland's Reflex. The @code{nper} and @code{nperl}
17860 functions correspond to @samp{@@TERM} and @samp{@@CTERM} in Quattro,
17861 respectively. Beware that the Calc functions may take their arguments
17862 in a different order than the corresponding functions in your favorite
17865 @node Binary Functions, , Financial Functions, Arithmetic
17866 @section Binary Number Functions
17869 The commands in this chapter all use two-letter sequences beginning with
17870 the @kbd{b} prefix.
17872 @cindex Binary numbers
17873 The ``binary'' operations actually work regardless of the currently
17874 displayed radix, although their results make the most sense in a radix
17875 like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
17876 commands, respectively). You may also wish to enable display of leading
17877 zeros with @kbd{d z}. @xref{Radix Modes}.
17879 @cindex Word size for binary operations
17880 The Calculator maintains a current @dfn{word size} @expr{w}, an
17881 arbitrary positive or negative integer. For a positive word size, all
17882 of the binary operations described here operate modulo @expr{2^w}. In
17883 particular, negative arguments are converted to positive integers modulo
17884 @expr{2^w} by all binary functions.
17886 If the word size is negative, binary operations produce 2's complement
17888 @texline @math{-2^{-w-1}}
17889 @infoline @expr{-(2^(-w-1))}
17891 @texline @math{2^{-w-1}-1}
17892 @infoline @expr{2^(-w-1)-1}
17893 inclusive. Either mode accepts inputs in any range; the sign of
17894 @expr{w} affects only the results produced.
17899 The @kbd{b c} (@code{calc-clip})
17900 [@code{clip}] command can be used to clip a number by reducing it modulo
17901 @expr{2^w}. The commands described in this chapter automatically clip
17902 their results to the current word size. Note that other operations like
17903 addition do not use the current word size, since integer addition
17904 generally is not ``binary.'' (However, @pxref{Simplification Modes},
17905 @code{calc-bin-simplify-mode}.) For example, with a word size of 8
17906 bits @kbd{b c} converts a number to the range 0 to 255; with a word
17907 size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127.
17910 @pindex calc-word-size
17911 The default word size is 32 bits. All operations except the shifts and
17912 rotates allow you to specify a different word size for that one
17913 operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the
17914 top of stack to the range 0 to 255 regardless of the current word size.
17915 To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
17916 This command displays a prompt with the current word size; press @key{RET}
17917 immediately to keep this word size, or type a new word size at the prompt.
17919 When the binary operations are written in symbolic form, they take an
17920 optional second (or third) word-size parameter. When a formula like
17921 @samp{and(a,b)} is finally evaluated, the word size current at that time
17922 will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
17923 @mathit{-8} will always be used. A symbolic binary function will be left
17924 in symbolic form unless the all of its argument(s) are integers or
17925 integer-valued floats.
17927 If either or both arguments are modulo forms for which @expr{M} is a
17928 power of two, that power of two is taken as the word size unless a
17929 numeric prefix argument overrides it. The current word size is never
17930 consulted when modulo-power-of-two forms are involved.
17935 The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
17936 AND of the two numbers on the top of the stack. In other words, for each
17937 of the @expr{w} binary digits of the two numbers (pairwise), the corresponding
17938 bit of the result is 1 if and only if both input bits are 1:
17939 @samp{and(2#1100, 2#1010) = 2#1000}.
17944 The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
17945 inclusive OR of two numbers. A bit is 1 if either of the input bits, or
17946 both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}.
17951 The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
17952 exclusive OR of two numbers. A bit is 1 if exactly one of the input bits
17953 is 1: @samp{xor(2#1100, 2#1010) = 2#0110}.
17958 The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
17959 difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
17960 so that @samp{diff(2#1100, 2#1010) = 2#0100}.
17965 The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
17966 NOT of a number. A bit is 1 if the input bit is 0 and vice-versa.
17969 @pindex calc-lshift-binary
17971 The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
17972 number left by one bit, or by the number of bits specified in the numeric
17973 prefix argument. A negative prefix argument performs a logical right shift,
17974 in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)}
17975 is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
17976 Bits shifted ``off the end,'' according to the current word size, are lost.
17992 The @kbd{H b l} command also does a left shift, but it takes two arguments
17993 from the stack (the value to shift, and, at top-of-stack, the number of
17994 bits to shift). This version interprets the prefix argument just like
17995 the regular binary operations, i.e., as a word size. The Hyperbolic flag
17996 has a similar effect on the rest of the binary shift and rotate commands.
17999 @pindex calc-rshift-binary
18001 The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
18002 number right by one bit, or by the number of bits specified in the numeric
18003 prefix argument: @samp{rsh(a,n) = lsh(a,-n)}.
18006 @pindex calc-lshift-arith
18008 The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
18009 number left. It is analogous to @code{lsh}, except that if the shift
18010 is rightward (the prefix argument is negative), an arithmetic shift
18011 is performed as described below.
18014 @pindex calc-rshift-arith
18016 The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
18017 an ``arithmetic'' shift to the right, in which the leftmost bit (according
18018 to the current word size) is duplicated rather than shifting in zeros.
18019 This corresponds to dividing by a power of two where the input is interpreted
18020 as a signed, twos-complement number. (The distinction between the @samp{rsh}
18021 and @samp{rash} operations is totally independent from whether the word
18022 size is positive or negative.) With a negative prefix argument, this
18023 performs a standard left shift.
18026 @pindex calc-rotate-binary
18028 The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
18029 number one bit to the left. The leftmost bit (according to the current
18030 word size) is dropped off the left and shifted in on the right. With a
18031 numeric prefix argument, the number is rotated that many bits to the left
18034 @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
18035 pack and unpack binary integers into sets. (For example, @kbd{b u}
18036 unpacks the number @samp{2#11001} to the set of bit-numbers
18037 @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1''
18038 bits in a binary integer.
18040 Another interesting use of the set representation of binary integers
18041 is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to
18042 unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
18043 with 31 minus that bit-number; type @kbd{b p} to pack the set back
18044 into a binary integer.
18046 @node Scientific Functions, Matrix Functions, Arithmetic, Top
18047 @chapter Scientific Functions
18050 The functions described here perform trigonometric and other transcendental
18051 calculations. They generally produce floating-point answers correct to the
18052 full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
18053 flag keys must be used to get some of these functions from the keyboard.
18057 @cindex @code{pi} variable
18060 @cindex @code{e} variable
18063 @cindex @code{gamma} variable
18065 @cindex Gamma constant, Euler's
18066 @cindex Euler's gamma constant
18068 @cindex @code{phi} variable
18069 @cindex Phi, golden ratio
18070 @cindex Golden ratio
18071 One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
18072 the value of @cpi{} (at the current precision) onto the stack. With the
18073 Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms.
18074 With the Inverse flag, it pushes Euler's constant
18075 @texline @math{\gamma}
18076 @infoline @expr{gamma}
18077 (about 0.5772). With both Inverse and Hyperbolic, it
18078 pushes the ``golden ratio''
18079 @texline @math{\phi}
18080 @infoline @expr{phi}
18081 (about 1.618). (At present, Euler's constant is not available
18082 to unlimited precision; Calc knows only the first 100 digits.)
18083 In Symbolic mode, these commands push the
18084 actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
18085 respectively, instead of their values; @pxref{Symbolic Mode}.
18095 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
18096 @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command
18097 computes the square of the argument.
18099 @xref{Prefix Arguments}, for a discussion of the effect of numeric
18100 prefix arguments on commands in this chapter which do not otherwise
18101 interpret a prefix argument.
18104 * Logarithmic Functions::
18105 * Trigonometric and Hyperbolic Functions::
18106 * Advanced Math Functions::
18109 * Combinatorial Functions::
18110 * Probability Distribution Functions::
18113 @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
18114 @section Logarithmic Functions
18124 The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
18125 logarithm of the real or complex number on the top of the stack. With
18126 the Inverse flag it computes the exponential function instead, although
18127 this is redundant with the @kbd{E} command.
18136 The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
18137 exponential, i.e., @expr{e} raised to the power of the number on the stack.
18138 The meanings of the Inverse and Hyperbolic flags follow from those for
18139 the @code{calc-ln} command.
18154 The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
18155 (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}],
18156 it raises ten to a given power.) Note that the common logarithm of a
18157 complex number is computed by taking the natural logarithm and dividing
18159 @texline @math{\ln10}.
18160 @infoline @expr{ln(10)}.
18167 The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
18168 to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since
18169 @texline @math{2^{10} = 1024}.
18170 @infoline @expr{2^10 = 1024}.
18171 In certain cases like @samp{log(3,9)}, the result
18172 will be either @expr{1:2} or @expr{0.5} depending on the current Fraction
18173 mode setting. With the Inverse flag [@code{alog}], this command is
18174 similar to @kbd{^} except that the order of the arguments is reversed.
18179 The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
18180 integer logarithm of a number to any base. The number and the base must
18181 themselves be positive integers. This is the true logarithm, rounded
18182 down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the
18183 range from 1000 to 9999. If both arguments are positive integers, exact
18184 integer arithmetic is used; otherwise, this is equivalent to
18185 @samp{floor(log(x,b))}.
18190 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
18191 @texline @math{e^x - 1},
18192 @infoline @expr{exp(x)-1},
18193 but using an algorithm that produces a more accurate
18194 answer when the result is close to zero, i.e., when
18195 @texline @math{e^x}
18196 @infoline @expr{exp(x)}
18202 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
18203 @texline @math{\ln(x+1)},
18204 @infoline @expr{ln(x+1)},
18205 producing a more accurate answer when @expr{x} is close to zero.
18207 @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
18208 @section Trigonometric/Hyperbolic Functions
18214 The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
18215 of an angle or complex number. If the input is an HMS form, it is interpreted
18216 as degrees-minutes-seconds; otherwise, the input is interpreted according
18217 to the current angular mode. It is best to use Radians mode when operating
18218 on complex numbers.
18220 Calc's ``units'' mechanism includes angular units like @code{deg},
18221 @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated
18222 all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
18223 simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
18224 of the current angular mode. @xref{Basic Operations on Units}.
18226 Also, the symbolic variable @code{pi} is not ordinarily recognized in
18227 arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
18228 the @kbd{a s} (@code{calc-simplify}) command recognizes many such
18229 formulas when the current angular mode is Radians @emph{and} Symbolic
18230 mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
18231 @xref{Symbolic Mode}. Beware, this simplification occurs even if you
18232 have stored a different value in the variable @samp{pi}; this is one
18233 reason why changing built-in variables is a bad idea. Arguments of
18234 the form @expr{x} plus a multiple of @cpiover{2} are also simplified.
18235 Calc includes similar formulas for @code{cos} and @code{tan}.
18237 The @kbd{a s} command knows all angles which are integer multiples of
18238 @cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode,
18239 analogous simplifications occur for integer multiples of 15 or 18
18240 degrees, and for arguments plus multiples of 90 degrees.
18243 @pindex calc-arcsin
18245 With the Inverse flag, @code{calc-sin} computes an arcsine. This is also
18246 available as the @code{calc-arcsin} command or @code{arcsin} algebraic
18247 function. The returned argument is converted to degrees, radians, or HMS
18248 notation depending on the current angular mode.
18254 @pindex calc-arcsinh
18256 With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
18257 sine, also available as @code{calc-sinh} [@code{sinh}]. With the
18258 Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
18259 (@code{calc-arcsinh}) [@code{arcsinh}].
18268 @pindex calc-arccos
18286 @pindex calc-arccosh
18304 @pindex calc-arctan
18322 @pindex calc-arctanh
18327 The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
18328 of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
18329 computes the tangent, along with all the various inverse and hyperbolic
18330 variants of these functions.
18333 @pindex calc-arctan2
18335 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
18336 numbers from the stack and computes the arc tangent of their ratio. The
18337 result is in the full range from @mathit{-180} (exclusive) to @mathit{+180}
18338 (inclusive) degrees, or the analogous range in radians. A similar
18339 result would be obtained with @kbd{/} followed by @kbd{I T}, but the
18340 value would only be in the range from @mathit{-90} to @mathit{+90} degrees
18341 since the division loses information about the signs of the two
18342 components, and an error might result from an explicit division by zero
18343 which @code{arctan2} would avoid. By (arbitrary) definition,
18344 @samp{arctan2(0,0)=0}.
18346 @pindex calc-sincos
18358 The @code{calc-sincos} [@code{sincos}] command computes the sine and
18359 cosine of a number, returning them as a vector of the form
18360 @samp{[@var{cos}, @var{sin}]}.
18361 With the Inverse flag [@code{arcsincos}], this command takes a two-element
18362 vector as an argument and computes @code{arctan2} of the elements.
18363 (This command does not accept the Hyperbolic flag.)
18365 @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
18366 @section Advanced Mathematical Functions
18369 Calc can compute a variety of less common functions that arise in
18370 various branches of mathematics. All of the functions described in
18371 this section allow arbitrary complex arguments and, except as noted,
18372 will work to arbitrarily large precisions. They can not at present
18373 handle error forms or intervals as arguments.
18375 NOTE: These functions are still experimental. In particular, their
18376 accuracy is not guaranteed in all domains. It is advisable to set the
18377 current precision comfortably higher than you actually need when
18378 using these functions. Also, these functions may be impractically
18379 slow for some values of the arguments.
18384 The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
18385 gamma function. For positive integer arguments, this is related to the
18386 factorial function: @samp{gamma(n+1) = fact(n)}. For general complex
18387 arguments the gamma function can be defined by the following definite
18389 @texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}.
18390 @infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
18391 (The actual implementation uses far more efficient computational methods.)
18407 @pindex calc-inc-gamma
18420 The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
18421 the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by
18423 @texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}.
18424 @infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
18425 This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the
18426 definition of the normal gamma function).
18428 Several other varieties of incomplete gamma function are defined.
18429 The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by
18430 some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
18431 You can think of this as taking the other half of the integral, from
18432 @expr{x} to infinity.
18435 The functions corresponding to the integrals that define @expr{P(a,x)}
18436 and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)}
18437 factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively
18438 (where @expr{g} and @expr{G} represent the lower- and upper-case Greek
18439 letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}]
18440 and @kbd{H I f G} [@code{gammaG}] commands.
18444 The functions corresponding to the integrals that define $P(a,x)$
18445 and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
18446 factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
18447 You can obtain these using the \kbd{H f G} [\code{gammag}] and
18448 \kbd{I H f G} [\code{gammaG}] commands.
18454 The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
18455 Euler beta function, which is defined in terms of the gamma function as
18456 @texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)},
18457 @infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)},
18459 @texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}.
18460 @infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
18464 @pindex calc-inc-beta
18467 The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
18468 the incomplete beta function @expr{I(x,a,b)}. It is defined by
18469 @texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}.
18470 @infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
18471 Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
18472 un-normalized version [@code{betaB}].
18479 The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
18481 @texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}.
18482 @infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
18483 The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
18484 is the corresponding integral from @samp{x} to infinity; the sum
18485 @texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}.
18486 @infoline @expr{erf(x) + erfc(x) = 1}.
18490 @pindex calc-bessel-J
18491 @pindex calc-bessel-Y
18494 The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
18495 (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
18496 functions of the first and second kinds, respectively.
18497 In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
18498 @expr{n} is often an integer, but is not required to be one.
18499 Calc's implementation of the Bessel functions currently limits the
18500 precision to 8 digits, and may not be exact even to that precision.
18503 @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
18504 @section Branch Cuts and Principal Values
18507 @cindex Branch cuts
18508 @cindex Principal values
18509 All of the logarithmic, trigonometric, and other scientific functions are
18510 defined for complex numbers as well as for reals.
18511 This section describes the values
18512 returned in cases where the general result is a family of possible values.
18513 Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
18514 second edition, in these matters. This section will describe each
18515 function briefly; for a more detailed discussion (including some nifty
18516 diagrams), consult Steele's book.
18518 Note that the branch cuts for @code{arctan} and @code{arctanh} were
18519 changed between the first and second editions of Steele. Versions of
18520 Calc starting with 2.00 follow the second edition.
18522 The new branch cuts exactly match those of the HP-28/48 calculators.
18523 They also match those of Mathematica 1.2, except that Mathematica's
18524 @code{arctan} cut is always in the right half of the complex plane,
18525 and its @code{arctanh} cut is always in the top half of the plane.
18526 Calc's cuts are continuous with quadrants I and III for @code{arctan},
18527 or II and IV for @code{arctanh}.
18529 Note: The current implementations of these functions with complex arguments
18530 are designed with proper behavior around the branch cuts in mind, @emph{not}
18531 efficiency or accuracy. You may need to increase the floating precision
18532 and wait a while to get suitable answers from them.
18534 For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive
18535 or zero, the result is close to the @expr{+i} axis. For @expr{b} small and
18536 negative, the result is close to the @expr{-i} axis. The result always lies
18537 in the right half of the complex plane.
18539 For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}.
18540 The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
18541 Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
18542 negative real axis.
18544 The following table describes these branch cuts in another way.
18545 If the real and imaginary parts of @expr{z} are as shown, then
18546 the real and imaginary parts of @expr{f(z)} will be as shown.
18547 Here @code{eps} stands for a small positive value; each
18548 occurrence of @code{eps} may stand for a different small value.
18552 ----------------------------------------
18555 -, +eps +eps, + +eps, +
18556 -, -eps +eps, - +eps, -
18559 For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}.
18560 One interesting consequence of this is that @samp{(-8)^1:3} does
18561 not evaluate to @mathit{-2} as you might expect, but to the complex
18562 number @expr{(1., 1.732)}. Both of these are valid cube roots
18563 of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps
18564 less-obvious root for the sake of mathematical consistency.
18566 For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
18567 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18569 For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
18570 or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on
18571 the real axis, less than @mathit{-1} and greater than 1.
18573 For @samp{arctan(z)}: This is defined by
18574 @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the
18575 imaginary axis, below @expr{-i} and above @expr{i}.
18577 For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}.
18578 The branch cuts are on the imaginary axis, below @expr{-i} and
18581 For @samp{arccosh(z)}: This is defined by
18582 @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the
18583 real axis less than 1.
18585 For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
18586 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18588 The following tables for @code{arcsin}, @code{arccos}, and
18589 @code{arctan} assume the current angular mode is Radians. The
18590 hyperbolic functions operate independently of the angular mode.
18593 z arcsin(z) arccos(z)
18594 -------------------------------------------------------
18595 (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0
18596 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps
18597 (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps
18598 <-1, 0 -pi/2, + pi, -
18599 <-1, +eps -pi/2 + eps, + pi - eps, -
18600 <-1, -eps -pi/2 + eps, - pi - eps, +
18602 >1, +eps pi/2 - eps, + +eps, -
18603 >1, -eps pi/2 - eps, - +eps, +
18607 z arccosh(z) arctanh(z)
18608 -----------------------------------------------------
18609 (-1..1), 0 0, (0..pi) any, 0
18610 (-1..1), +eps +eps, (0..pi) any, +eps
18611 (-1..1), -eps +eps, (-pi..0) any, -eps
18612 <-1, 0 +, pi -, pi/2
18613 <-1, +eps +, pi - eps -, pi/2 - eps
18614 <-1, -eps +, -pi + eps -, -pi/2 + eps
18615 >1, 0 +, 0 +, -pi/2
18616 >1, +eps +, +eps +, pi/2 - eps
18617 >1, -eps +, -eps +, -pi/2 + eps
18621 z arcsinh(z) arctan(z)
18622 -----------------------------------------------------
18623 0, (-1..1) 0, (-pi/2..pi/2) 0, any
18624 0, <-1 -, -pi/2 -pi/2, -
18625 +eps, <-1 +, -pi/2 + eps pi/2 - eps, -
18626 -eps, <-1 -, -pi/2 + eps -pi/2 + eps, -
18627 0, >1 +, pi/2 pi/2, +
18628 +eps, >1 +, pi/2 - eps pi/2 - eps, +
18629 -eps, >1 -, pi/2 - eps -pi/2 + eps, +
18632 Finally, the following identities help to illustrate the relationship
18633 between the complex trigonometric and hyperbolic functions. They
18634 are valid everywhere, including on the branch cuts.
18637 sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z)
18638 cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z)
18639 tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z)
18640 sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)
18643 The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
18644 for general complex arguments, but their branch cuts and principal values
18645 are not rigorously specified at present.
18647 @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
18648 @section Random Numbers
18652 @pindex calc-random
18654 The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
18655 random numbers of various sorts.
18657 Given a positive numeric prefix argument @expr{M}, it produces a random
18658 integer @expr{N} in the range
18659 @texline @math{0 \le N < M}.
18660 @infoline @expr{0 <= N < M}.
18661 Each of the @expr{M} values appears with equal probability.
18663 With no numeric prefix argument, the @kbd{k r} command takes its argument
18664 from the stack instead. Once again, if this is a positive integer @expr{M}
18665 the result is a random integer less than @expr{M}. However, note that
18666 while numeric prefix arguments are limited to six digits or so, an @expr{M}
18667 taken from the stack can be arbitrarily large. If @expr{M} is negative,
18668 the result is a random integer in the range
18669 @texline @math{M < N \le 0}.
18670 @infoline @expr{M < N <= 0}.
18672 If the value on the stack is a floating-point number @expr{M}, the result
18673 is a random floating-point number @expr{N} in the range
18674 @texline @math{0 \le N < M}
18675 @infoline @expr{0 <= N < M}
18677 @texline @math{M < N \le 0},
18678 @infoline @expr{M < N <= 0},
18679 according to the sign of @expr{M}.
18681 If @expr{M} is zero, the result is a Gaussian-distributed random real
18682 number; the distribution has a mean of zero and a standard deviation
18683 of one. The algorithm used generates random numbers in pairs; thus,
18684 every other call to this function will be especially fast.
18686 If @expr{M} is an error form
18687 @texline @math{m} @code{+/-} @math{\sigma}
18688 @infoline @samp{m +/- s}
18690 @texline @math{\sigma}
18692 are both real numbers, the result uses a Gaussian distribution with mean
18693 @var{m} and standard deviation
18694 @texline @math{\sigma}.
18697 If @expr{M} is an interval form, the lower and upper bounds specify the
18698 acceptable limits of the random numbers. If both bounds are integers,
18699 the result is a random integer in the specified range. If either bound
18700 is floating-point, the result is a random real number in the specified
18701 range. If the interval is open at either end, the result will be sure
18702 not to equal that end value. (This makes a big difference for integer
18703 intervals, but for floating-point intervals it's relatively minor:
18704 with a precision of 6, @samp{random([1.0..2.0))} will return any of one
18705 million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
18706 additionally return 2.00000, but the probability of this happening is
18709 If @expr{M} is a vector, the result is one element taken at random from
18710 the vector. All elements of the vector are given equal probabilities.
18713 The sequence of numbers produced by @kbd{k r} is completely random by
18714 default, i.e., the sequence is seeded each time you start Calc using
18715 the current time and other information. You can get a reproducible
18716 sequence by storing a particular ``seed value'' in the Calc variable
18717 @code{RandSeed}. Any integer will do for a seed; integers of from 1
18718 to 12 digits are good. If you later store a different integer into
18719 @code{RandSeed}, Calc will switch to a different pseudo-random
18720 sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
18721 from the current time. If you store the same integer that you used
18722 before back into @code{RandSeed}, you will get the exact same sequence
18723 of random numbers as before.
18725 @pindex calc-rrandom
18726 The @code{calc-rrandom} command (not on any key) produces a random real
18727 number between zero and one. It is equivalent to @samp{random(1.0)}.
18730 @pindex calc-random-again
18731 The @kbd{k a} (@code{calc-random-again}) command produces another random
18732 number, re-using the most recent value of @expr{M}. With a numeric
18733 prefix argument @var{n}, it produces @var{n} more random numbers using
18734 that value of @expr{M}.
18737 @pindex calc-shuffle
18739 The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
18740 random values with no duplicates. The value on the top of the stack
18741 specifies the set from which the random values are drawn, and may be any
18742 of the @expr{M} formats described above. The numeric prefix argument
18743 gives the length of the desired list. (If you do not provide a numeric
18744 prefix argument, the length of the list is taken from the top of the
18745 stack, and @expr{M} from second-to-top.)
18747 If @expr{M} is a floating-point number, zero, or an error form (so
18748 that the random values are being drawn from the set of real numbers)
18749 there is little practical difference between using @kbd{k h} and using
18750 @kbd{k r} several times. But if the set of possible values consists
18751 of just a few integers, or the elements of a vector, then there is
18752 a very real chance that multiple @kbd{k r}'s will produce the same
18753 number more than once. The @kbd{k h} command produces a vector whose
18754 elements are always distinct. (Actually, there is a slight exception:
18755 If @expr{M} is a vector, no given vector element will be drawn more
18756 than once, but if several elements of @expr{M} are equal, they may
18757 each make it into the result vector.)
18759 One use of @kbd{k h} is to rearrange a list at random. This happens
18760 if the prefix argument is equal to the number of values in the list:
18761 @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
18762 @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument
18763 @var{n} is negative it is replaced by the size of the set represented
18764 by @expr{M}. Naturally, this is allowed only when @expr{M} specifies
18765 a small discrete set of possibilities.
18767 To do the equivalent of @kbd{k h} but with duplications allowed,
18768 given @expr{M} on the stack and with @var{n} just entered as a numeric
18769 prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use
18770 @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
18771 elements of this vector. @xref{Matrix Functions}.
18774 * Random Number Generator:: (Complete description of Calc's algorithm)
18777 @node Random Number Generator, , Random Numbers, Random Numbers
18778 @subsection Random Number Generator
18780 Calc's random number generator uses several methods to ensure that
18781 the numbers it produces are highly random. Knuth's @emph{Art of
18782 Computer Programming}, Volume II, contains a thorough description
18783 of the theory of random number generators and their measurement and
18786 If @code{RandSeed} has no stored value, Calc calls Emacs' built-in
18787 @code{random} function to get a stream of random numbers, which it
18788 then treats in various ways to avoid problems inherent in the simple
18789 random number generators that many systems use to implement @code{random}.
18791 When Calc's random number generator is first invoked, it ``seeds''
18792 the low-level random sequence using the time of day, so that the
18793 random number sequence will be different every time you use Calc.
18795 Since Emacs Lisp doesn't specify the range of values that will be
18796 returned by its @code{random} function, Calc exercises the function
18797 several times to estimate the range. When Calc subsequently uses
18798 the @code{random} function, it takes only 10 bits of the result
18799 near the most-significant end. (It avoids at least the bottom
18800 four bits, preferably more, and also tries to avoid the top two
18801 bits.) This strategy works well with the linear congruential
18802 generators that are typically used to implement @code{random}.
18804 If @code{RandSeed} contains an integer, Calc uses this integer to
18805 seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
18807 @texline @math{X_{n-55} - X_{n-24}}.
18808 @infoline @expr{X_n-55 - X_n-24}).
18809 This method expands the seed
18810 value into a large table which is maintained internally; the variable
18811 @code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]}
18812 to indicate that the seed has been absorbed into this table. When
18813 @code{RandSeed} contains a vector, @kbd{k r} and related commands
18814 continue to use the same internal table as last time. There is no
18815 way to extract the complete state of the random number generator
18816 so that you can restart it from any point; you can only restart it
18817 from the same initial seed value. A simple way to restart from the
18818 same seed is to type @kbd{s r RandSeed} to get the seed vector,
18819 @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
18820 to reseed the generator with that number.
18822 Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
18823 of Knuth. It fills a table with 13 random 10-bit numbers. Then,
18824 to generate a new random number, it uses the previous number to
18825 index into the table, picks the value it finds there as the new
18826 random number, then replaces that table entry with a new value
18827 obtained from a call to the base random number generator (either
18828 the additive congruential generator or the @code{random} function
18829 supplied by the system). If there are any flaws in the base
18830 generator, shuffling will tend to even them out. But if the system
18831 provides an excellent @code{random} function, shuffling will not
18832 damage its randomness.
18834 To create a random integer of a certain number of digits, Calc
18835 builds the integer three decimal digits at a time. For each group
18836 of three digits, Calc calls its 10-bit shuffling random number generator
18837 (which returns a value from 0 to 1023); if the random value is 1000
18838 or more, Calc throws it out and tries again until it gets a suitable
18841 To create a random floating-point number with precision @var{p}, Calc
18842 simply creates a random @var{p}-digit integer and multiplies by
18843 @texline @math{10^{-p}}.
18844 @infoline @expr{10^-p}.
18845 The resulting random numbers should be very clean, but note
18846 that relatively small numbers will have few significant random digits.
18847 In other words, with a precision of 12, you will occasionally get
18848 numbers on the order of
18849 @texline @math{10^{-9}}
18850 @infoline @expr{10^-9}
18852 @texline @math{10^{-10}},
18853 @infoline @expr{10^-10},
18854 but those numbers will only have two or three random digits since they
18855 correspond to small integers times
18856 @texline @math{10^{-12}}.
18857 @infoline @expr{10^-12}.
18859 To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
18860 counts the digits in @var{m}, creates a random integer with three
18861 additional digits, then reduces modulo @var{m}. Unless @var{m} is a
18862 power of ten the resulting values will be very slightly biased toward
18863 the lower numbers, but this bias will be less than 0.1%. (For example,
18864 if @var{m} is 42, Calc will reduce a random integer less than 100000
18865 modulo 42 to get a result less than 42. It is easy to show that the
18866 numbers 40 and 41 will be only 2380/2381 as likely to result from this
18867 modulo operation as numbers 39 and below.) If @var{m} is a power of
18868 ten, however, the numbers should be completely unbiased.
18870 The Gaussian random numbers generated by @samp{random(0.0)} use the
18871 ``polar'' method described in Knuth section 3.4.1C. This method
18872 generates a pair of Gaussian random numbers at a time, so only every
18873 other call to @samp{random(0.0)} will require significant calculations.
18875 @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
18876 @section Combinatorial Functions
18879 Commands relating to combinatorics and number theory begin with the
18880 @kbd{k} key prefix.
18885 The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
18886 Greatest Common Divisor of two integers. It also accepts fractions;
18887 the GCD of two fractions is defined by taking the GCD of the
18888 numerators, and the LCM of the denominators. This definition is
18889 consistent with the idea that @samp{a / gcd(a,x)} should yield an
18890 integer for any @samp{a} and @samp{x}. For other types of arguments,
18891 the operation is left in symbolic form.
18896 The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
18897 Least Common Multiple of two integers or fractions. The product of
18898 the LCM and GCD of two numbers is equal to the product of the
18902 @pindex calc-extended-gcd
18904 The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
18905 the GCD of two integers @expr{x} and @expr{y} and returns a vector
18906 @expr{[g, a, b]} where
18907 @texline @math{g = \gcd(x,y) = a x + b y}.
18908 @infoline @expr{g = gcd(x,y) = a x + b y}.
18911 @pindex calc-factorial
18917 The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
18918 factorial of the number at the top of the stack. If the number is an
18919 integer, the result is an exact integer. If the number is an
18920 integer-valued float, the result is a floating-point approximation. If
18921 the number is a non-integral real number, the generalized factorial is used,
18922 as defined by the Euler Gamma function. Please note that computation of
18923 large factorials can be slow; using floating-point format will help
18924 since fewer digits must be maintained. The same is true of many of
18925 the commands in this section.
18928 @pindex calc-double-factorial
18934 The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
18935 computes the ``double factorial'' of an integer. For an even integer,
18936 this is the product of even integers from 2 to @expr{N}. For an odd
18937 integer, this is the product of odd integers from 3 to @expr{N}. If
18938 the argument is an integer-valued float, the result is a floating-point
18939 approximation. This function is undefined for negative even integers.
18940 The notation @expr{N!!} is also recognized for double factorials.
18943 @pindex calc-choose
18945 The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
18946 binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number
18947 on the top of the stack and @expr{N} is second-to-top. If both arguments
18948 are integers, the result is an exact integer. Otherwise, the result is a
18949 floating-point approximation. The binomial coefficient is defined for all
18951 @texline @math{N! \over M! (N-M)!\,}.
18952 @infoline @expr{N! / M! (N-M)!}.
18958 The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
18959 number-of-permutations function @expr{N! / (N-M)!}.
18962 The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
18963 number-of-perm\-utations function $N! \over (N-M)!\,$.
18968 @pindex calc-bernoulli-number
18970 The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
18971 computes a given Bernoulli number. The value at the top of the stack
18972 is a nonnegative integer @expr{n} that specifies which Bernoulli number
18973 is desired. The @kbd{H k b} command computes a Bernoulli polynomial,
18974 taking @expr{n} from the second-to-top position and @expr{x} from the
18975 top of the stack. If @expr{x} is a variable or formula the result is
18976 a polynomial in @expr{x}; if @expr{x} is a number the result is a number.
18980 @pindex calc-euler-number
18982 The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
18983 computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
18984 Bernoulli and Euler numbers occur in the Taylor expansions of several
18989 @pindex calc-stirling-number
18992 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
18993 computes a Stirling number of the first
18994 @texline kind@tie{}@math{n \brack m},
18996 given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s}
18997 [@code{stir2}] command computes a Stirling number of the second
18998 @texline kind@tie{}@math{n \brace m}.
19000 These are the number of @expr{m}-cycle permutations of @expr{n} objects,
19001 and the number of ways to partition @expr{n} objects into @expr{m}
19002 non-empty sets, respectively.
19005 @pindex calc-prime-test
19007 The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
19008 the top of the stack is prime. For integers less than eight million, the
19009 answer is always exact and reasonably fast. For larger integers, a
19010 probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
19011 The number is first checked against small prime factors (up to 13). Then,
19012 any number of iterations of the algorithm are performed. Each step either
19013 discovers that the number is non-prime, or substantially increases the
19014 certainty that the number is prime. After a few steps, the chance that
19015 a number was mistakenly described as prime will be less than one percent.
19016 (Indeed, this is a worst-case estimate of the probability; in practice
19017 even a single iteration is quite reliable.) After the @kbd{k p} command,
19018 the number will be reported as definitely prime or non-prime if possible,
19019 or otherwise ``probably'' prime with a certain probability of error.
19025 The normal @kbd{k p} command performs one iteration of the primality
19026 test. Pressing @kbd{k p} repeatedly for the same integer will perform
19027 additional iterations. Also, @kbd{k p} with a numeric prefix performs
19028 the specified number of iterations. There is also an algebraic function
19029 @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n}
19030 is (probably) prime and 0 if not.
19033 @pindex calc-prime-factors
19035 The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
19036 attempts to decompose an integer into its prime factors. For numbers up
19037 to 25 million, the answer is exact although it may take some time. The
19038 result is a vector of the prime factors in increasing order. For larger
19039 inputs, prime factors above 5000 may not be found, in which case the
19040 last number in the vector will be an unfactored integer greater than 25
19041 million (with a warning message). For negative integers, the first
19042 element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and
19043 @mathit{1}, the result is a list of the same number.
19046 @pindex calc-next-prime
19048 @mindex nextpr@idots
19051 The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
19052 the next prime above a given number. Essentially, it searches by calling
19053 @code{calc-prime-test} on successive integers until it finds one that
19054 passes the test. This is quite fast for integers less than eight million,
19055 but once the probabilistic test comes into play the search may be rather
19056 slow. Ordinarily this command stops for any prime that passes one iteration
19057 of the primality test. With a numeric prefix argument, a number must pass
19058 the specified number of iterations before the search stops. (This only
19059 matters when searching above eight million.) You can always use additional
19060 @kbd{k p} commands to increase your certainty that the number is indeed
19064 @pindex calc-prev-prime
19066 @mindex prevpr@idots
19069 The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
19070 analogously finds the next prime less than a given number.
19073 @pindex calc-totient
19075 The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
19077 @texline function@tie{}@math{\phi(n)},
19078 @infoline function,
19079 the number of integers less than @expr{n} which
19080 are relatively prime to @expr{n}.
19083 @pindex calc-moebius
19085 The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
19086 @texline M@"obius @math{\mu}
19087 @infoline Moebius ``mu''
19088 function. If the input number is a product of @expr{k}
19089 distinct factors, this is @expr{(-1)^k}. If the input number has any
19090 duplicate factors (i.e., can be divided by the same prime more than once),
19091 the result is zero.
19093 @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
19094 @section Probability Distribution Functions
19097 The functions in this section compute various probability distributions.
19098 For continuous distributions, this is the integral of the probability
19099 density function from @expr{x} to infinity. (These are the ``upper
19100 tail'' distribution functions; there are also corresponding ``lower
19101 tail'' functions which integrate from minus infinity to @expr{x}.)
19102 For discrete distributions, the upper tail function gives the sum
19103 from @expr{x} to infinity; the lower tail function gives the sum
19104 from minus infinity up to, but not including,@w{ }@expr{x}.
19106 To integrate from @expr{x} to @expr{y}, just use the distribution
19107 function twice and subtract. For example, the probability that a
19108 Gaussian random variable with mean 2 and standard deviation 1 will
19109 lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
19110 (``the probability that it is greater than 2.5, but not greater than 2.8''),
19111 or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
19118 The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
19119 binomial distribution. Push the parameters @var{n}, @var{p}, and
19120 then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
19121 probability that an event will occur @var{x} or more times out
19122 of @var{n} trials, if its probability of occurring in any given
19123 trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is
19124 the probability that the event will occur fewer than @var{x} times.
19126 The other probability distribution functions similarly take the
19127 form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
19128 and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
19129 @var{x}. The arguments to the algebraic functions are the value of
19130 the random variable first, then whatever other parameters define the
19131 distribution. Note these are among the few Calc functions where the
19132 order of the arguments in algebraic form differs from the order of
19133 arguments as found on the stack. (The random variable comes last on
19134 the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
19135 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
19136 recover the original arguments but substitute a new value for @expr{x}.)
19149 The @samp{utpc(x,v)} function uses the chi-square distribution with
19150 @texline @math{\nu}
19152 degrees of freedom. It is the probability that a model is
19153 correct if its chi-square statistic is @expr{x}.
19166 The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
19167 various statistical tests. The parameters
19168 @texline @math{\nu_1}
19169 @infoline @expr{v1}
19171 @texline @math{\nu_2}
19172 @infoline @expr{v2}
19173 are the degrees of freedom in the numerator and denominator,
19174 respectively, used in computing the statistic @expr{F}.
19187 The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
19188 with mean @expr{m} and standard deviation
19189 @texline @math{\sigma}.
19190 @infoline @expr{s}.
19191 It is the probability that such a normal-distributed random variable
19192 would exceed @expr{x}.
19205 The @samp{utpp(n,x)} function uses a Poisson distribution with
19206 mean @expr{x}. It is the probability that @expr{n} or more such
19207 Poisson random events will occur.
19220 The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
19222 @texline @math{\nu}
19224 degrees of freedom. It is the probability that a
19225 t-distributed random variable will be greater than @expr{t}.
19226 (Note: This computes the distribution function
19227 @texline @math{A(t|\nu)}
19228 @infoline @expr{A(t|v)}
19230 @texline @math{A(0|\nu) = 1}
19231 @infoline @expr{A(0|v) = 1}
19233 @texline @math{A(\infty|\nu) \to 0}.
19234 @infoline @expr{A(inf|v) -> 0}.
19235 The @code{UTPT} operation on the HP-48 uses a different definition which
19236 returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.)
19238 While Calc does not provide inverses of the probability distribution
19239 functions, the @kbd{a R} command can be used to solve for the inverse.
19240 Since the distribution functions are monotonic, @kbd{a R} is guaranteed
19241 to be able to find a solution given any initial guess.
19242 @xref{Numerical Solutions}.
19244 @node Matrix Functions, Algebra, Scientific Functions, Top
19245 @chapter Vector/Matrix Functions
19248 Many of the commands described here begin with the @kbd{v} prefix.
19249 (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
19250 The commands usually apply to both plain vectors and matrices; some
19251 apply only to matrices or only to square matrices. If the argument
19252 has the wrong dimensions the operation is left in symbolic form.
19254 Vectors are entered and displayed using @samp{[a,b,c]} notation.
19255 Matrices are vectors of which all elements are vectors of equal length.
19256 (Though none of the standard Calc commands use this concept, a
19257 three-dimensional matrix or rank-3 tensor could be defined as a
19258 vector of matrices, and so on.)
19261 * Packing and Unpacking::
19262 * Building Vectors::
19263 * Extracting Elements::
19264 * Manipulating Vectors::
19265 * Vector and Matrix Arithmetic::
19267 * Statistical Operations::
19268 * Reducing and Mapping::
19269 * Vector and Matrix Formats::
19272 @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
19273 @section Packing and Unpacking
19276 Calc's ``pack'' and ``unpack'' commands collect stack entries to build
19277 composite objects such as vectors and complex numbers. They are
19278 described in this chapter because they are most often used to build
19283 The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
19284 elements from the stack into a matrix, complex number, HMS form, error
19285 form, etc. It uses a numeric prefix argument to specify the kind of
19286 object to be built; this argument is referred to as the ``packing mode.''
19287 If the packing mode is a nonnegative integer, a vector of that
19288 length is created. For example, @kbd{C-u 5 v p} will pop the top
19289 five stack elements and push back a single vector of those five
19290 elements. (@kbd{C-u 0 v p} simply creates an empty vector.)
19292 The same effect can be had by pressing @kbd{[} to push an incomplete
19293 vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
19294 the incomplete object up past a certain number of elements, and
19295 then pressing @kbd{]} to complete the vector.
19297 Negative packing modes create other kinds of composite objects:
19301 Two values are collected to build a complex number. For example,
19302 @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
19303 @expr{(5, 7)}. The result is always a rectangular complex
19304 number. The two input values must both be real numbers,
19305 i.e., integers, fractions, or floats. If they are not, Calc
19306 will instead build a formula like @samp{a + (0, 1) b}. (The
19307 other packing modes also create a symbolic answer if the
19308 components are not suitable.)
19311 Two values are collected to build a polar complex number.
19312 The first is the magnitude; the second is the phase expressed
19313 in either degrees or radians according to the current angular
19317 Three values are collected into an HMS form. The first
19318 two values (hours and minutes) must be integers or
19319 integer-valued floats. The third value may be any real
19323 Two values are collected into an error form. The inputs
19324 may be real numbers or formulas.
19327 Two values are collected into a modulo form. The inputs
19328 must be real numbers.
19331 Two values are collected into the interval @samp{[a .. b]}.
19332 The inputs may be real numbers, HMS or date forms, or formulas.
19335 Two values are collected into the interval @samp{[a .. b)}.
19338 Two values are collected into the interval @samp{(a .. b]}.
19341 Two values are collected into the interval @samp{(a .. b)}.
19344 Two integer values are collected into a fraction.
19347 Two values are collected into a floating-point number.
19348 The first is the mantissa; the second, which must be an
19349 integer, is the exponent. The result is the mantissa
19350 times ten to the power of the exponent.
19353 This is treated the same as @mathit{-11} by the @kbd{v p} command.
19354 When unpacking, @mathit{-12} specifies that a floating-point mantissa
19358 A real number is converted into a date form.
19361 Three numbers (year, month, day) are packed into a pure date form.
19364 Six numbers are packed into a date/time form.
19367 With any of the two-input negative packing modes, either or both
19368 of the inputs may be vectors. If both are vectors of the same
19369 length, the result is another vector made by packing corresponding
19370 elements of the input vectors. If one input is a vector and the
19371 other is a plain number, the number is packed along with each vector
19372 element to produce a new vector. For example, @kbd{C-u -4 v p}
19373 could be used to convert a vector of numbers and a vector of errors
19374 into a single vector of error forms; @kbd{C-u -5 v p} could convert
19375 a vector of numbers and a single number @var{M} into a vector of
19376 numbers modulo @var{M}.
19378 If you don't give a prefix argument to @kbd{v p}, it takes
19379 the packing mode from the top of the stack. The elements to
19380 be packed then begin at stack level 2. Thus
19381 @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
19382 enter the error form @samp{1 +/- 2}.
19384 If the packing mode taken from the stack is a vector, the result is a
19385 matrix with the dimensions specified by the elements of the vector,
19386 which must each be integers. For example, if the packing mode is
19387 @samp{[2, 3]}, then six numbers will be taken from the stack and
19388 returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
19390 If any elements of the vector are negative, other kinds of
19391 packing are done at that level as described above. For
19392 example, @samp{[2, 3, -4]} takes 12 objects and creates a
19393 @texline @math{2\times3}
19395 matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
19396 Also, @samp{[-4, -10]} will convert four integers into an
19397 error form consisting of two fractions: @samp{a:b +/- c:d}.
19403 There is an equivalent algebraic function,
19404 @samp{pack(@var{mode}, @var{items})} where @var{mode} is a
19405 packing mode (an integer or a vector of integers) and @var{items}
19406 is a vector of objects to be packed (re-packed, really) according
19407 to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
19408 yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is
19409 left in symbolic form if the packing mode is illegal, or if the
19410 number of data items does not match the number of items required
19414 @pindex calc-unpack
19415 The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
19416 number, HMS form, or other composite object on the top of the stack and
19417 ``unpacks'' it, pushing each of its elements onto the stack as separate
19418 objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value
19419 at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
19420 each of the arguments of the top-level operator onto the stack.
19422 You can optionally give a numeric prefix argument to @kbd{v u}
19423 to specify an explicit (un)packing mode. If the packing mode is
19424 negative and the input is actually a vector or matrix, the result
19425 will be two or more similar vectors or matrices of the elements.
19426 For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
19427 the result of @kbd{C-u -4 v u} will be the two vectors
19428 @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
19430 Note that the prefix argument can have an effect even when the input is
19431 not a vector. For example, if the input is the number @mathit{-5}, then
19432 @kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5}
19433 when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
19434 and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5}
19435 and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational
19436 number). Plain @kbd{v u} with this input would complain that the input
19437 is not a composite object.
19439 Unpacking mode @mathit{-11} converts a float into an integer mantissa and
19440 an integer exponent, where the mantissa is not divisible by 10
19441 (except that 0.0 is represented by a mantissa and exponent of 0).
19442 Unpacking mode @mathit{-12} converts a float into a floating-point mantissa
19443 and integer exponent, where the mantissa (for non-zero numbers)
19444 is guaranteed to lie in the range [1 .. 10). In both cases,
19445 the mantissa is shifted left or right (and the exponent adjusted
19446 to compensate) in order to satisfy these constraints.
19448 Positive unpacking modes are treated differently than for @kbd{v p}.
19449 A mode of 1 is much like plain @kbd{v u} with no prefix argument,
19450 except that in addition to the components of the input object,
19451 a suitable packing mode to re-pack the object is also pushed.
19452 Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
19455 A mode of 2 unpacks two levels of the object; the resulting
19456 re-packing mode will be a vector of length 2. This might be used
19457 to unpack a matrix, say, or a vector of error forms. Higher
19458 unpacking modes unpack the input even more deeply.
19464 There are two algebraic functions analogous to @kbd{v u}.
19465 The @samp{unpack(@var{mode}, @var{item})} function unpacks the
19466 @var{item} using the given @var{mode}, returning the result as
19467 a vector of components. Here the @var{mode} must be an
19468 integer, not a vector. For example, @samp{unpack(-4, a +/- b)}
19469 returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
19475 The @code{unpackt} function is like @code{unpack} but instead
19476 of returning a simple vector of items, it returns a vector of
19477 two things: The mode, and the vector of items. For example,
19478 @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
19479 and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
19480 The identity for re-building the original object is
19481 @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The
19482 @code{apply} function builds a function call given the function
19483 name and a vector of arguments.)
19485 @cindex Numerator of a fraction, extracting
19486 Subscript notation is a useful way to extract a particular part
19487 of an object. For example, to get the numerator of a rational
19488 number, you can use @samp{unpack(-10, @var{x})_1}.
19490 @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
19491 @section Building Vectors
19494 Vectors and matrices can be added,
19495 subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.
19498 @pindex calc-concat
19503 The @kbd{|} (@code{calc-concat}) command ``concatenates'' two vectors
19504 into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
19505 will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments
19506 are matrices, the rows of the first matrix are concatenated with the
19507 rows of the second. (In other words, two matrices are just two vectors
19508 of row-vectors as far as @kbd{|} is concerned.)
19510 If either argument to @kbd{|} is a scalar (a non-vector), it is treated
19511 like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |}
19512 produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a
19513 matrix and the other is a plain vector, the vector is treated as a
19518 The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
19519 two vectors without any special cases. Both inputs must be vectors.
19520 Whether or not they are matrices is not taken into account. If either
19521 argument is a scalar, the @code{append} function is left in symbolic form.
19522 See also @code{cons} and @code{rcons} below.
19526 The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
19527 two stack arguments in the opposite order. Thus @kbd{I |} is equivalent
19528 to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
19533 The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
19534 square matrix. The optional numeric prefix gives the number of rows
19535 and columns in the matrix. If the value at the top of the stack is a
19536 vector, the elements of the vector are used as the diagonal elements; the
19537 prefix, if specified, must match the size of the vector. If the value on
19538 the stack is a scalar, it is used for each element on the diagonal, and
19539 the prefix argument is required.
19541 To build a constant square matrix, e.g., a
19542 @texline @math{3\times3}
19544 matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero
19545 matrix first and then add a constant value to that matrix. (Another
19546 alternative would be to use @kbd{v b} and @kbd{v a}; see below.)
19551 The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
19552 matrix of the specified size. It is a convenient form of @kbd{v d}
19553 where the diagonal element is always one. If no prefix argument is given,
19554 this command prompts for one.
19556 In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
19557 except that @expr{a} is required to be a scalar (non-vector) quantity.
19558 If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an
19559 identity matrix of unknown size. Calc can operate algebraically on
19560 such generic identity matrices, and if one is combined with a matrix
19561 whose size is known, it is converted automatically to an identity
19562 matrix of a suitable matching size. The @kbd{v i} command with an
19563 argument of zero creates a generic identity matrix, @samp{idn(1)}.
19564 Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic
19565 identity matrices are immediately expanded to the current default
19571 The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
19572 of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
19573 prefix argument. If you do not provide a prefix argument, you will be
19574 prompted to enter a suitable number. If @var{n} is negative, the result
19575 is a vector of negative integers from @var{n} to @mathit{-1}.
19577 With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
19578 three values from the stack: @var{n}, @var{start}, and @var{incr} (with
19579 @var{incr} at top-of-stack). Counting starts at @var{start} and increases
19580 by @var{incr} for successive vector elements. If @var{start} or @var{n}
19581 is in floating-point format, the resulting vector elements will also be
19582 floats. Note that @var{start} and @var{incr} may in fact be any kind
19583 of numbers or formulas.
19585 When @var{start} and @var{incr} are specified, a negative @var{n} has a
19586 different interpretation: It causes a geometric instead of arithmetic
19587 sequence to be generated. For example, @samp{index(-3, a, b)} produces
19588 @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form,
19589 @samp{index(@var{n}, @var{start})}, the default value for @var{incr}
19590 is one for positive @var{n} or two for negative @var{n}.
19593 @pindex calc-build-vector
19595 The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
19596 vector of @var{n} copies of the value on the top of the stack, where @var{n}
19597 is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)}
19598 can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
19599 (Interactively, just use @kbd{v b} twice: once to build a row, then again
19600 to build a matrix of copies of that row.)
19608 The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
19609 element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
19610 function returns the vector with its first element removed. In both
19611 cases, the argument must be a non-empty vector.
19616 The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
19617 and a vector @var{t} from the stack, and produces the vector whose head is
19618 @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except
19619 if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
19620 whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
19640 Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
19641 @code{rtail}, @code{rcons}] in which case @var{t} instead represents
19642 the @emph{last} single element of the vector, with @var{h}
19643 representing the remainder of the vector. Thus the vector
19644 @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
19645 Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
19646 @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
19648 @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
19649 @section Extracting Vector Elements
19655 The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
19656 the matrix on the top of the stack, or one element of the plain vector on
19657 the top of the stack. The row or element is specified by the numeric
19658 prefix argument; the default is to prompt for the row or element number.
19659 The matrix or vector is replaced by the specified row or element in the
19660 form of a vector or scalar, respectively.
19662 @cindex Permutations, applying
19663 With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
19664 the element or row from the top of the stack, and the vector or matrix
19665 from the second-to-top position. If the index is itself a vector of
19666 integers, the result is a vector of the corresponding elements of the
19667 input vector, or a matrix of the corresponding rows of the input matrix.
19668 This command can be used to obtain any permutation of a vector.
19670 With @kbd{C-u}, if the index is an interval form with integer components,
19671 it is interpreted as a range of indices and the corresponding subvector or
19672 submatrix is returned.
19674 @cindex Subscript notation
19676 @pindex calc-subscript
19679 Subscript notation in algebraic formulas (@samp{a_b}) stands for the
19680 Calc function @code{subscr}, which is synonymous with @code{mrow}.
19681 Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if
19682 @expr{k} is one, two, or three, respectively. A double subscript
19683 (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
19684 access the element at row @expr{i}, column @expr{j} of a matrix.
19685 The @kbd{a _} (@code{calc-subscript}) command creates a subscript
19686 formula @samp{a_b} out of two stack entries. (It is on the @kbd{a}
19687 ``algebra'' prefix because subscripted variables are often used
19688 purely as an algebraic notation.)
19691 Given a negative prefix argument, @kbd{v r} instead deletes one row or
19692 element from the matrix or vector on the top of the stack. Thus
19693 @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
19694 replaces the matrix with the same matrix with its second row removed.
19695 In algebraic form this function is called @code{mrrow}.
19698 Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
19699 of a square matrix in the form of a vector. In algebraic form this
19700 function is called @code{getdiag}.
19706 The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
19707 the analogous operation on columns of a matrix. Given a plain vector
19708 it extracts (or removes) one element, just like @kbd{v r}. If the
19709 index in @kbd{C-u v c} is an interval or vector and the argument is a
19710 matrix, the result is a submatrix with only the specified columns
19711 retained (and possibly permuted in the case of a vector index).
19713 To extract a matrix element at a given row and column, use @kbd{v r} to
19714 extract the row as a vector, then @kbd{v c} to extract the column element
19715 from that vector. In algebraic formulas, it is often more convenient to
19716 use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j}
19717 of matrix @expr{m}.
19720 @pindex calc-subvector
19722 The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
19723 a subvector of a vector. The arguments are the vector, the starting
19724 index, and the ending index, with the ending index in the top-of-stack
19725 position. The starting index indicates the first element of the vector
19726 to take. The ending index indicates the first element @emph{past} the
19727 range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
19728 the subvector @samp{[b, c]}. You could get the same result using
19729 @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
19731 If either the start or the end index is zero or negative, it is
19732 interpreted as relative to the end of the vector. Thus
19733 @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In
19734 the algebraic form, the end index can be omitted in which case it
19735 is taken as zero, i.e., elements from the starting element to the
19736 end of the vector are used. The infinity symbol, @code{inf}, also
19737 has this effect when used as the ending index.
19741 With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
19742 from a vector. The arguments are interpreted the same as for the
19743 normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
19744 produces @samp{[a, d, e]}. It is always true that @code{subvec} and
19745 @code{rsubvec} return complementary parts of the input vector.
19747 @xref{Selecting Subformulas}, for an alternative way to operate on
19748 vectors one element at a time.
19750 @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
19751 @section Manipulating Vectors
19755 @pindex calc-vlength
19757 The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
19758 length of a vector. The length of a non-vector is considered to be zero.
19759 Note that matrices are just vectors of vectors for the purposes of this
19764 With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
19765 of the dimensions of a vector, matrix, or higher-order object. For
19766 example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
19768 @texline @math{2\times3}
19773 @pindex calc-vector-find
19775 The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
19776 along a vector for the first element equal to a given target. The target
19777 is on the top of the stack; the vector is in the second-to-top position.
19778 If a match is found, the result is the index of the matching element.
19779 Otherwise, the result is zero. The numeric prefix argument, if given,
19780 allows you to select any starting index for the search.
19783 @pindex calc-arrange-vector
19785 @cindex Arranging a matrix
19786 @cindex Reshaping a matrix
19787 @cindex Flattening a matrix
19788 The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
19789 rearranges a vector to have a certain number of columns and rows. The
19790 numeric prefix argument specifies the number of columns; if you do not
19791 provide an argument, you will be prompted for the number of columns.
19792 The vector or matrix on the top of the stack is @dfn{flattened} into a
19793 plain vector. If the number of columns is nonzero, this vector is
19794 then formed into a matrix by taking successive groups of @var{n} elements.
19795 If the number of columns does not evenly divide the number of elements
19796 in the vector, the last row will be short and the result will not be
19797 suitable for use as a matrix. For example, with the matrix
19798 @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
19799 @samp{[[1, 2, 3, 4]]} (a
19800 @texline @math{1\times4}
19802 matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a
19803 @texline @math{4\times1}
19805 matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original
19806 @texline @math{2\times2}
19808 matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a
19809 matrix), and @kbd{v a 0} produces the flattened list
19810 @samp{[1, 2, @w{3, 4}]}.
19812 @cindex Sorting data
19818 The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
19819 a vector into increasing order. Real numbers, real infinities, and
19820 constant interval forms come first in this ordering; next come other
19821 kinds of numbers, then variables (in alphabetical order), then finally
19822 come formulas and other kinds of objects; these are sorted according
19823 to a kind of lexicographic ordering with the useful property that
19824 one vector is less or greater than another if the first corresponding
19825 unequal elements are less or greater, respectively. Since quoted strings
19826 are stored by Calc internally as vectors of ASCII character codes
19827 (@pxref{Strings}), this means vectors of strings are also sorted into
19828 alphabetical order by this command.
19830 The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
19832 @cindex Permutation, inverse of
19833 @cindex Inverse of permutation
19834 @cindex Index tables
19835 @cindex Rank tables
19841 The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
19842 produces an index table or permutation vector which, if applied to the
19843 input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
19844 A permutation vector is just a vector of integers from 1 to @var{n}, where
19845 each integer occurs exactly once. One application of this is to sort a
19846 matrix of data rows using one column as the sort key; extract that column,
19847 grade it with @kbd{V G}, then use the result to reorder the original matrix
19848 with @kbd{C-u v r}. Another interesting property of the @code{V G} command
19849 is that, if the input is itself a permutation vector, the result will
19850 be the inverse of the permutation. The inverse of an index table is
19851 a rank table, whose @var{k}th element says where the @var{k}th original
19852 vector element will rest when the vector is sorted. To get a rank
19853 table, just use @kbd{V G V G}.
19855 With the Inverse flag, @kbd{I V G} produces an index table that would
19856 sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G}
19857 use a ``stable'' sorting algorithm, i.e., any two elements which are equal
19858 will not be moved out of their original order. Generally there is no way
19859 to tell with @kbd{V S}, since two elements which are equal look the same,
19860 but with @kbd{V G} this can be an important issue. In the matrix-of-rows
19861 example, suppose you have names and telephone numbers as two columns and
19862 you wish to sort by phone number primarily, and by name when the numbers
19863 are equal. You can sort the data matrix by names first, and then again
19864 by phone numbers. Because the sort is stable, any two rows with equal
19865 phone numbers will remain sorted by name even after the second sort.
19869 @pindex calc-histogram
19871 @mindex histo@idots
19874 The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
19875 histogram of a vector of numbers. Vector elements are assumed to be
19876 integers or real numbers in the range [0..@var{n}) for some ``number of
19877 bins'' @var{n}, which is the numeric prefix argument given to the
19878 command. The result is a vector of @var{n} counts of how many times
19879 each value appeared in the original vector. Non-integers in the input
19880 are rounded down to integers. Any vector elements outside the specified
19881 range are ignored. (You can tell if elements have been ignored by noting
19882 that the counts in the result vector don't add up to the length of the
19886 With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
19887 The second-to-top vector is the list of numbers as before. The top
19888 vector is an equal-sized list of ``weights'' to attach to the elements
19889 of the data vector. For example, if the first data element is 4.2 and
19890 the first weight is 10, then 10 will be added to bin 4 of the result
19891 vector. Without the hyperbolic flag, every element has a weight of one.
19894 @pindex calc-transpose
19896 The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
19897 the transpose of the matrix at the top of the stack. If the argument
19898 is a plain vector, it is treated as a row vector and transposed into
19899 a one-column matrix.
19902 @pindex calc-reverse-vector
19904 The @kbd{v v} (@code{calc-reverse-vector}) [@code{vec}] command reverses
19905 a vector end-for-end. Given a matrix, it reverses the order of the rows.
19906 (To reverse the columns instead, just use @kbd{v t v v v t}. The same
19907 principle can be used to apply other vector commands to the columns of
19911 @pindex calc-mask-vector
19913 The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
19914 one vector as a mask to extract elements of another vector. The mask
19915 is in the second-to-top position; the target vector is on the top of
19916 the stack. These vectors must have the same length. The result is
19917 the same as the target vector, but with all elements which correspond
19918 to zeros in the mask vector deleted. Thus, for example,
19919 @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
19920 @xref{Logical Operations}.
19923 @pindex calc-expand-vector
19925 The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
19926 expands a vector according to another mask vector. The result is a
19927 vector the same length as the mask, but with nonzero elements replaced
19928 by successive elements from the target vector. The length of the target
19929 vector is normally the number of nonzero elements in the mask. If the
19930 target vector is longer, its last few elements are lost. If the target
19931 vector is shorter, the last few nonzero mask elements are left
19932 unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
19933 produces @samp{[a, 0, b, 0, 7]}.
19936 With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
19937 top of the stack; the mask and target vectors come from the third and
19938 second elements of the stack. This filler is used where the mask is
19939 zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
19940 @samp{[a, z, c, z, 7]}. If the filler value is itself a vector,
19941 then successive values are taken from it, so that the effect is to
19942 interleave two vectors according to the mask:
19943 @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
19944 @samp{[a, x, b, 7, y, 0]}.
19946 Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
19947 with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
19948 You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
19949 operation across the two vectors. @xref{Logical Operations}. Note that
19950 the @code{? :} operation also discussed there allows other types of
19951 masking using vectors.
19953 @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
19954 @section Vector and Matrix Arithmetic
19957 Basic arithmetic operations like addition and multiplication are defined
19958 for vectors and matrices as well as for numbers. Division of matrices, in
19959 the sense of multiplying by the inverse, is supported. (Division by a
19960 matrix actually uses LU-decomposition for greater accuracy and speed.)
19961 @xref{Basic Arithmetic}.
19963 The following functions are applied element-wise if their arguments are
19964 vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
19965 @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
19966 @code{float}, @code{frac}. @xref{Function Index}.
19969 @pindex calc-conj-transpose
19971 The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
19972 the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
19977 @kindex A (vectors)
19978 @pindex calc-abs (vectors)
19982 @tindex abs (vectors)
19983 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
19984 Frobenius norm of a vector or matrix argument. This is the square
19985 root of the sum of the squares of the absolute values of the
19986 elements of the vector or matrix. If the vector is interpreted as
19987 a point in two- or three-dimensional space, this is the distance
19988 from that point to the origin.
19993 The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes
19994 the row norm, or infinity-norm, of a vector or matrix. For a plain
19995 vector, this is the maximum of the absolute values of the elements.
19996 For a matrix, this is the maximum of the row-absolute-value-sums,
19997 i.e., of the sums of the absolute values of the elements along the
20003 The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
20004 the column norm, or one-norm, of a vector or matrix. For a plain
20005 vector, this is the sum of the absolute values of the elements.
20006 For a matrix, this is the maximum of the column-absolute-value-sums.
20007 General @expr{k}-norms for @expr{k} other than one or infinity are
20013 The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
20014 right-handed cross product of two vectors, each of which must have
20015 exactly three elements.
20020 @kindex & (matrices)
20021 @pindex calc-inv (matrices)
20025 @tindex inv (matrices)
20026 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
20027 inverse of a square matrix. If the matrix is singular, the inverse
20028 operation is left in symbolic form. Matrix inverses are recorded so
20029 that once an inverse (or determinant) of a particular matrix has been
20030 computed, the inverse and determinant of the matrix can be recomputed
20031 quickly in the future.
20033 If the argument to @kbd{&} is a plain number @expr{x}, this
20034 command simply computes @expr{1/x}. This is okay, because the
20035 @samp{/} operator also does a matrix inversion when dividing one
20041 The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
20042 determinant of a square matrix.
20047 The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
20048 LU decomposition of a matrix. The result is a list of three matrices
20049 which, when multiplied together left-to-right, form the original matrix.
20050 The first is a permutation matrix that arises from pivoting in the
20051 algorithm, the second is lower-triangular with ones on the diagonal,
20052 and the third is upper-triangular.
20055 @pindex calc-mtrace
20057 The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
20058 trace of a square matrix. This is defined as the sum of the diagonal
20059 elements of the matrix.
20061 @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
20062 @section Set Operations using Vectors
20065 @cindex Sets, as vectors
20066 Calc includes several commands which interpret vectors as @dfn{sets} of
20067 objects. A set is a collection of objects; any given object can appear
20068 only once in the set. Calc stores sets as vectors of objects in
20069 sorted order. Objects in a Calc set can be any of the usual things,
20070 such as numbers, variables, or formulas. Two set elements are considered
20071 equal if they are identical, except that numerically equal numbers like
20072 the integer 4 and the float 4.0 are considered equal even though they
20073 are not ``identical.'' Variables are treated like plain symbols without
20074 attached values by the set operations; subtracting the set @samp{[b]}
20075 from @samp{[a, b]} always yields the set @samp{[a]} even though if
20076 the variables @samp{a} and @samp{b} both equaled 17, you might
20077 expect the answer @samp{[]}.
20079 If a set contains interval forms, then it is assumed to be a set of
20080 real numbers. In this case, all set operations require the elements
20081 of the set to be only things that are allowed in intervals: Real
20082 numbers, plus and minus infinity, HMS forms, and date forms. If
20083 there are variables or other non-real objects present in a real set,
20084 all set operations on it will be left in unevaluated form.
20086 If the input to a set operation is a plain number or interval form
20087 @var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
20088 The result is always a vector, except that if the set consists of a
20089 single interval, the interval itself is returned instead.
20091 @xref{Logical Operations}, for the @code{in} function which tests if
20092 a certain value is a member of a given set. To test if the set @expr{A}
20093 is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}.
20096 @pindex calc-remove-duplicates
20098 The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
20099 converts an arbitrary vector into set notation. It works by sorting
20100 the vector as if by @kbd{V S}, then removing duplicates. (For example,
20101 @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
20102 reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as
20103 necessary. You rarely need to use @kbd{V +} explicitly, since all the
20104 other set-based commands apply @kbd{V +} to their inputs before using
20108 @pindex calc-set-union
20110 The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
20111 the union of two sets. An object is in the union of two sets if and
20112 only if it is in either (or both) of the input sets. (You could
20113 accomplish the same thing by concatenating the sets with @kbd{|},
20114 then using @kbd{V +}.)
20117 @pindex calc-set-intersect
20119 The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
20120 the intersection of two sets. An object is in the intersection if
20121 and only if it is in both of the input sets. Thus if the input
20122 sets are disjoint, i.e., if they share no common elements, the result
20123 will be the empty vector @samp{[]}. Note that the characters @kbd{V}
20124 and @kbd{^} were chosen to be close to the conventional mathematical
20126 @texline union@tie{}(@math{A \cup B})
20129 @texline intersection@tie{}(@math{A \cap B}).
20130 @infoline intersection.
20133 @pindex calc-set-difference
20135 The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
20136 the difference between two sets. An object is in the difference
20137 @expr{A - B} if and only if it is in @expr{A} but not in @expr{B}.
20138 Thus subtracting @samp{[y,z]} from a set will remove the elements
20139 @samp{y} and @samp{z} if they are present. You can also think of this
20140 as a general @dfn{set complement} operator; if @expr{A} is the set of
20141 all possible values, then @expr{A - B} is the ``complement'' of @expr{B}.
20142 Obviously this is only practical if the set of all possible values in
20143 your problem is small enough to list in a Calc vector (or simple
20144 enough to express in a few intervals).
20147 @pindex calc-set-xor
20149 The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
20150 the ``exclusive-or,'' or ``symmetric difference'' of two sets.
20151 An object is in the symmetric difference of two sets if and only
20152 if it is in one, but @emph{not} both, of the sets. Objects that
20153 occur in both sets ``cancel out.''
20156 @pindex calc-set-complement
20158 The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
20159 computes the complement of a set with respect to the real numbers.
20160 Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
20161 For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
20162 @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
20165 @pindex calc-set-floor
20167 The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
20168 reinterprets a set as a set of integers. Any non-integer values,
20169 and intervals that do not enclose any integers, are removed. Open
20170 intervals are converted to equivalent closed intervals. Successive
20171 integers are converted into intervals of integers. For example, the
20172 complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
20173 the complement with respect to the set of integers you could type
20174 @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
20177 @pindex calc-set-enumerate
20179 The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
20180 converts a set of integers into an explicit vector. Intervals in
20181 the set are expanded out to lists of all integers encompassed by
20182 the intervals. This only works for finite sets (i.e., sets which
20183 do not involve @samp{-inf} or @samp{inf}).
20186 @pindex calc-set-span
20188 The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
20189 set of reals into an interval form that encompasses all its elements.
20190 The lower limit will be the smallest element in the set; the upper
20191 limit will be the largest element. For an empty set, @samp{vspan([])}
20192 returns the empty interval @w{@samp{[0 .. 0)}}.
20195 @pindex calc-set-cardinality
20197 The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
20198 the number of integers in a set. The result is the length of the vector
20199 that would be produced by @kbd{V E}, although the computation is much
20200 more efficient than actually producing that vector.
20202 @cindex Sets, as binary numbers
20203 Another representation for sets that may be more appropriate in some
20204 cases is binary numbers. If you are dealing with sets of integers
20205 in the range 0 to 49, you can use a 50-bit binary number where a
20206 particular bit is 1 if the corresponding element is in the set.
20207 @xref{Binary Functions}, for a list of commands that operate on
20208 binary numbers. Note that many of the above set operations have
20209 direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}),
20210 @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
20211 @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
20212 respectively. You can use whatever representation for sets is most
20217 @pindex calc-pack-bits
20218 @pindex calc-unpack-bits
20221 The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
20222 converts an integer that represents a set in binary into a set
20223 in vector/interval notation. For example, @samp{vunpack(67)}
20224 returns @samp{[[0 .. 1], 6]}. If the input is negative, the set
20225 it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
20226 Use @kbd{V E} afterwards to expand intervals to individual
20227 values if you wish. Note that this command uses the @kbd{b}
20228 (binary) prefix key.
20230 The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
20231 converts the other way, from a vector or interval representing
20232 a set of nonnegative integers into a binary integer describing
20233 the same set. The set may include positive infinity, but must
20234 not include any negative numbers. The input is interpreted as a
20235 set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware
20236 that a simple input like @samp{[100]} can result in a huge integer
20238 @texline (@math{2^{100}}, a 31-digit integer, in this case).
20239 @infoline (@expr{2^100}, a 31-digit integer, in this case).
20241 @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
20242 @section Statistical Operations on Vectors
20245 @cindex Statistical functions
20246 The commands in this section take vectors as arguments and compute
20247 various statistical measures on the data stored in the vectors. The
20248 references used in the definitions of these functions are Bevington's
20249 @emph{Data Reduction and Error Analysis for the Physical Sciences},
20250 and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
20253 The statistical commands use the @kbd{u} prefix key followed by
20254 a shifted letter or other character.
20256 @xref{Manipulating Vectors}, for a description of @kbd{V H}
20257 (@code{calc-histogram}).
20259 @xref{Curve Fitting}, for the @kbd{a F} command for doing
20260 least-squares fits to statistical data.
20262 @xref{Probability Distribution Functions}, for several common
20263 probability distribution functions.
20266 * Single-Variable Statistics::
20267 * Paired-Sample Statistics::
20270 @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
20271 @subsection Single-Variable Statistics
20274 These functions do various statistical computations on single
20275 vectors. Given a numeric prefix argument, they actually pop
20276 @var{n} objects from the stack and combine them into a data
20277 vector. Each object may be either a number or a vector; if a
20278 vector, any sub-vectors inside it are ``flattened'' as if by
20279 @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object
20280 is popped, which (in order to be useful) is usually a vector.
20282 If an argument is a variable name, and the value stored in that
20283 variable is a vector, then the stored vector is used. This method
20284 has the advantage that if your data vector is large, you can avoid
20285 the slow process of manipulating it directly on the stack.
20287 These functions are left in symbolic form if any of their arguments
20288 are not numbers or vectors, e.g., if an argument is a formula, or
20289 a non-vector variable. However, formulas embedded within vector
20290 arguments are accepted; the result is a symbolic representation
20291 of the computation, based on the assumption that the formula does
20292 not itself represent a vector. All varieties of numbers such as
20293 error forms and interval forms are acceptable.
20295 Some of the functions in this section also accept a single error form
20296 or interval as an argument. They then describe a property of the
20297 normal or uniform (respectively) statistical distribution described
20298 by the argument. The arguments are interpreted in the same way as
20299 the @var{M} argument of the random number function @kbd{k r}. In
20300 particular, an interval with integer limits is considered an integer
20301 distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
20302 An interval with at least one floating-point limit is a continuous
20303 distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as
20304 @samp{[2.0 .. 5.0]}!
20307 @pindex calc-vector-count
20309 The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
20310 computes the number of data values represented by the inputs.
20311 For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
20312 If the argument is a single vector with no sub-vectors, this
20313 simply computes the length of the vector.
20317 @pindex calc-vector-sum
20318 @pindex calc-vector-prod
20321 @cindex Summations (statistical)
20322 The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
20323 computes the sum of the data values. The @kbd{u *}
20324 (@code{calc-vector-prod}) [@code{vprod}] command computes the
20325 product of the data values. If the input is a single flat vector,
20326 these are the same as @kbd{V R +} and @kbd{V R *}
20327 (@pxref{Reducing and Mapping}).
20331 @pindex calc-vector-max
20332 @pindex calc-vector-min
20335 The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
20336 computes the maximum of the data values, and the @kbd{u N}
20337 (@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
20338 If the argument is an interval, this finds the minimum or maximum
20339 value in the interval. (Note that @samp{vmax([2..6)) = 5} as
20340 described above.) If the argument is an error form, this returns
20341 plus or minus infinity.
20344 @pindex calc-vector-mean
20346 @cindex Mean of data values
20347 The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
20348 computes the average (arithmetic mean) of the data values.
20349 If the inputs are error forms
20350 @texline @math{x \pm \sigma},
20351 @infoline @samp{x +/- s},
20352 this is the weighted mean of the @expr{x} values with weights
20353 @texline @math{1 /\sigma^2}.
20354 @infoline @expr{1 / s^2}.
20357 $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
20358 \displaystyle \sum { 1 \over \sigma_i^2 } } $$
20360 If the inputs are not error forms, this is simply the sum of the
20361 values divided by the count of the values.
20363 Note that a plain number can be considered an error form with
20365 @texline @math{\sigma = 0}.
20366 @infoline @expr{s = 0}.
20367 If the input to @kbd{u M} is a mixture of
20368 plain numbers and error forms, the result is the mean of the
20369 plain numbers, ignoring all values with non-zero errors. (By the
20370 above definitions it's clear that a plain number effectively
20371 has an infinite weight, next to which an error form with a finite
20372 weight is completely negligible.)
20374 This function also works for distributions (error forms or
20375 intervals). The mean of an error form `@var{a} @t{+/-} @var{b}' is simply
20376 @expr{a}. The mean of an interval is the mean of the minimum
20377 and maximum values of the interval.
20380 @pindex calc-vector-mean-error
20382 The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
20383 command computes the mean of the data points expressed as an
20384 error form. This includes the estimated error associated with
20385 the mean. If the inputs are error forms, the error is the square
20386 root of the reciprocal of the sum of the reciprocals of the squares
20387 of the input errors. (I.e., the variance is the reciprocal of the
20388 sum of the reciprocals of the variances.)
20391 $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
20393 If the inputs are plain
20394 numbers, the error is equal to the standard deviation of the values
20395 divided by the square root of the number of values. (This works
20396 out to be equivalent to calculating the standard deviation and
20397 then assuming each value's error is equal to this standard
20401 $$ \sigma_\mu^2 = {\sigma^2 \over N} $$
20405 @pindex calc-vector-median
20407 @cindex Median of data values
20408 The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
20409 command computes the median of the data values. The values are
20410 first sorted into numerical order; the median is the middle
20411 value after sorting. (If the number of data values is even,
20412 the median is taken to be the average of the two middle values.)
20413 The median function is different from the other functions in
20414 this section in that the arguments must all be real numbers;
20415 variables are not accepted even when nested inside vectors.
20416 (Otherwise it is not possible to sort the data values.) If
20417 any of the input values are error forms, their error parts are
20420 The median function also accepts distributions. For both normal
20421 (error form) and uniform (interval) distributions, the median is
20422 the same as the mean.
20425 @pindex calc-vector-harmonic-mean
20427 @cindex Harmonic mean
20428 The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
20429 command computes the harmonic mean of the data values. This is
20430 defined as the reciprocal of the arithmetic mean of the reciprocals
20434 $$ { N \over \displaystyle \sum {1 \over x_i} } $$
20438 @pindex calc-vector-geometric-mean
20440 @cindex Geometric mean
20441 The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
20442 command computes the geometric mean of the data values. This
20443 is the @var{n}th root of the product of the values. This is also
20444 equal to the @code{exp} of the arithmetic mean of the logarithms
20445 of the data values.
20448 $$ \exp \left ( \sum { \ln x_i } \right ) =
20449 \left ( \prod { x_i } \right)^{1 / N} $$
20454 The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
20455 mean'' of two numbers taken from the stack. This is computed by
20456 replacing the two numbers with their arithmetic mean and geometric
20457 mean, then repeating until the two values converge.
20460 $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
20463 @cindex Root-mean-square
20464 Another commonly used mean, the RMS (root-mean-square), can be computed
20465 for a vector of numbers simply by using the @kbd{A} command.
20468 @pindex calc-vector-sdev
20470 @cindex Standard deviation
20471 @cindex Sample statistics
20472 The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
20473 computes the standard
20474 @texline deviation@tie{}@math{\sigma}
20475 @infoline deviation
20476 of the data values. If the values are error forms, the errors are used
20477 as weights just as for @kbd{u M}. This is the @emph{sample} standard
20478 deviation, whose value is the square root of the sum of the squares of
20479 the differences between the values and the mean of the @expr{N} values,
20480 divided by @expr{N-1}.
20483 $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
20486 This function also applies to distributions. The standard deviation
20487 of a single error form is simply the error part. The standard deviation
20488 of a continuous interval happens to equal the difference between the
20490 @texline @math{\sqrt{12}}.
20491 @infoline @expr{sqrt(12)}.
20492 The standard deviation of an integer interval is the same as the
20493 standard deviation of a vector of those integers.
20496 @pindex calc-vector-pop-sdev
20498 @cindex Population statistics
20499 The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
20500 command computes the @emph{population} standard deviation.
20501 It is defined by the same formula as above but dividing
20502 by @expr{N} instead of by @expr{N-1}. The population standard
20503 deviation is used when the input represents the entire set of
20504 data values in the distribution; the sample standard deviation
20505 is used when the input represents a sample of the set of all
20506 data values, so that the mean computed from the input is itself
20507 only an estimate of the true mean.
20510 $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
20513 For error forms and continuous intervals, @code{vpsdev} works
20514 exactly like @code{vsdev}. For integer intervals, it computes the
20515 population standard deviation of the equivalent vector of integers.
20519 @pindex calc-vector-variance
20520 @pindex calc-vector-pop-variance
20523 @cindex Variance of data values
20524 The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
20525 @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
20526 commands compute the variance of the data values. The variance
20528 @texline square@tie{}@math{\sigma^2}
20530 of the standard deviation, i.e., the sum of the
20531 squares of the deviations of the data values from the mean.
20532 (This definition also applies when the argument is a distribution.)
20538 The @code{vflat} algebraic function returns a vector of its
20539 arguments, interpreted in the same way as the other functions
20540 in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)}
20541 returns @samp{[1, 2, 3, 4, 5]}.
20543 @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
20544 @subsection Paired-Sample Statistics
20547 The functions in this section take two arguments, which must be
20548 vectors of equal size. The vectors are each flattened in the same
20549 way as by the single-variable statistical functions. Given a numeric
20550 prefix argument of 1, these functions instead take one object from
20551 the stack, which must be an
20552 @texline @math{N\times2}
20554 matrix of data values. Once again, variable names can be used in place
20555 of actual vectors and matrices.
20558 @pindex calc-vector-covariance
20561 The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
20562 computes the sample covariance of two vectors. The covariance
20563 of vectors @var{x} and @var{y} is the sum of the products of the
20564 differences between the elements of @var{x} and the mean of @var{x}
20565 times the differences between the corresponding elements of @var{y}
20566 and the mean of @var{y}, all divided by @expr{N-1}. Note that
20567 the variance of a vector is just the covariance of the vector
20568 with itself. Once again, if the inputs are error forms the
20569 errors are used as weight factors. If both @var{x} and @var{y}
20570 are composed of error forms, the error for a given data point
20571 is taken as the square root of the sum of the squares of the two
20575 $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
20576 $$ \sigma_{x\!y}^2 =
20577 {\displaystyle {1 \over N-1}
20578 \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
20579 \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
20584 @pindex calc-vector-pop-covariance
20586 The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
20587 command computes the population covariance, which is the same as the
20588 sample covariance computed by @kbd{u C} except dividing by @expr{N}
20589 instead of @expr{N-1}.
20592 @pindex calc-vector-correlation
20594 @cindex Correlation coefficient
20595 @cindex Linear correlation
20596 The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
20597 command computes the linear correlation coefficient of two vectors.
20598 This is defined by the covariance of the vectors divided by the
20599 product of their standard deviations. (There is no difference
20600 between sample or population statistics here.)
20603 $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
20606 @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
20607 @section Reducing and Mapping Vectors
20610 The commands in this section allow for more general operations on the
20611 elements of vectors.
20616 The simplest of these operations is @kbd{V A} (@code{calc-apply})
20617 [@code{apply}], which applies a given operator to the elements of a vector.
20618 For example, applying the hypothetical function @code{f} to the vector
20619 @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
20620 Applying the @code{+} function to the vector @samp{[a, b]} gives
20621 @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an
20622 error, since the @code{+} function expects exactly two arguments.
20624 While @kbd{V A} is useful in some cases, you will usually find that either
20625 @kbd{V R} or @kbd{V M}, described below, is closer to what you want.
20628 * Specifying Operators::
20631 * Nesting and Fixed Points::
20632 * Generalized Products::
20635 @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
20636 @subsection Specifying Operators
20639 Commands in this section (like @kbd{V A}) prompt you to press the key
20640 corresponding to the desired operator. Press @kbd{?} for a partial
20641 list of the available operators. Generally, an operator is any key or
20642 sequence of keys that would normally take one or more arguments from
20643 the stack and replace them with a result. For example, @kbd{V A H C}
20644 uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh}
20645 expects one argument, @kbd{V A H C} requires a vector with a single
20646 element as its argument.)
20648 You can press @kbd{x} at the operator prompt to select any algebraic
20649 function by name to use as the operator. This includes functions you
20650 have defined yourself using the @kbd{Z F} command. (@xref{Algebraic
20651 Definitions}.) If you give a name for which no function has been
20652 defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
20653 Calc will prompt for the number of arguments the function takes if it
20654 can't figure it out on its own (say, because you named a function that
20655 is currently undefined). It is also possible to type a digit key before
20656 the function name to specify the number of arguments, e.g.,
20657 @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
20658 looks like it ought to have only two. This technique may be necessary
20659 if the function allows a variable number of arguments. For example,
20660 the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
20661 if you want to map with the three-argument version, you will have to
20662 type @kbd{V M 3 v e}.
20664 It is also possible to apply any formula to a vector by treating that
20665 formula as a function. When prompted for the operator to use, press
20666 @kbd{'} (the apostrophe) and type your formula as an algebraic entry.
20667 You will then be prompted for the argument list, which defaults to a
20668 list of all variables that appear in the formula, sorted into alphabetic
20669 order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
20670 The default argument list would be @samp{(x y)}, which means that if
20671 this function is applied to the arguments @samp{[3, 10]} the result will
20672 be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this
20673 way often, you might consider defining it as a function with @kbd{Z F}.)
20675 Another way to specify the arguments to the formula you enter is with
20676 @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$}
20677 has the same effect as the previous example. The argument list is
20678 automatically taken to be @samp{($$ $)}. (The order of the arguments
20679 may seem backwards, but it is analogous to the way normal algebraic
20680 entry interacts with the stack.)
20682 If you press @kbd{$} at the operator prompt, the effect is similar to
20683 the apostrophe except that the relevant formula is taken from top-of-stack
20684 instead. The actual vector arguments of the @kbd{V A $} or related command
20685 then start at the second-to-top stack position. You will still be
20686 prompted for an argument list.
20688 @cindex Nameless functions
20689 @cindex Generic functions
20690 A function can be written without a name using the notation @samp{<#1 - #2>},
20691 which means ``a function of two arguments that computes the first
20692 argument minus the second argument.'' The symbols @samp{#1} and @samp{#2}
20693 are placeholders for the arguments. You can use any names for these
20694 placeholders if you wish, by including an argument list followed by a
20695 colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
20696 Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
20697 to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
20698 Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both
20699 cases, Calc also writes the nameless function to the Trail so that you
20700 can get it back later if you wish.
20702 If there is only one argument, you can write @samp{#} in place of @samp{#1}.
20703 (Note that @samp{< >} notation is also used for date forms. Calc tells
20704 that @samp{<@var{stuff}>} is a nameless function by the presence of
20705 @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
20706 begins with a list of variables followed by a colon.)
20708 You can type a nameless function directly to @kbd{V A '}, or put one on
20709 the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an
20710 argument list in this case, since the nameless function specifies the
20711 argument list as well as the function itself. In @kbd{V A '}, you can
20712 omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
20713 so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
20714 which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
20716 @cindex Lambda expressions
20721 The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
20722 (The word @code{lambda} derives from Lisp notation and the theory of
20723 functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
20724 ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called
20725 @code{lambda}; the whole point is that the @code{lambda} expression is
20726 used in its symbolic form, not evaluated for an answer until it is applied
20727 to specific arguments by a command like @kbd{V A} or @kbd{V M}.
20729 (Actually, @code{lambda} does have one special property: Its arguments
20730 are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
20731 will not simplify the @samp{2/3} until the nameless function is actually
20760 As usual, commands like @kbd{V A} have algebraic function name equivalents.
20761 For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
20762 @samp{apply(gcd, v)}. The first argument specifies the operator name,
20763 and is either a variable whose name is the same as the function name,
20764 or a nameless function like @samp{<#^3+1>}. Operators that are normally
20765 written as algebraic symbols have the names @code{add}, @code{sub},
20766 @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
20773 The @code{call} function builds a function call out of several arguments:
20774 @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
20775 in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call},
20776 like the other functions described here, may be either a variable naming a
20777 function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
20780 (Experts will notice that it's not quite proper to use a variable to name
20781 a function, since the name @code{gcd} corresponds to the Lisp variable
20782 @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc
20783 automatically makes this translation, so you don't have to worry
20786 @node Mapping, Reducing, Specifying Operators, Reducing and Mapping
20787 @subsection Mapping
20793 The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
20794 operator elementwise to one or more vectors. For example, mapping
20795 @code{A} [@code{abs}] produces a vector of the absolute values of the
20796 elements in the input vector. Mapping @code{+} pops two vectors from
20797 the stack, which must be of equal length, and produces a vector of the
20798 pairwise sums of the elements. If either argument is a non-vector, it
20799 is duplicated for each element of the other vector. For example,
20800 @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
20801 With the 2 listed first, it would have computed a vector of powers of
20802 two. Mapping a user-defined function pops as many arguments from the
20803 stack as the function requires. If you give an undefined name, you will
20804 be prompted for the number of arguments to use.
20806 If any argument to @kbd{V M} is a matrix, the operator is normally mapped
20807 across all elements of the matrix. For example, given the matrix
20808 @expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
20810 @texline @math{3\times2}
20812 matrix, @expr{[[1, 2, 3], [4, 5, 6]]}.
20815 The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
20816 operator prompt) maps by rows instead. For example, @kbd{V M _ A} views
20817 the above matrix as a vector of two 3-element row vectors. It produces
20818 a new vector which contains the absolute values of those row vectors,
20819 namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is
20820 defined as the square root of the sum of the squares of the elements.)
20821 Some operators accept vectors and return new vectors; for example,
20822 @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
20823 of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}.
20825 Sometimes a vector of vectors (representing, say, strings, sets, or lists)
20826 happens to look like a matrix. If so, remember to use @kbd{V M _} if you
20827 want to map a function across the whole strings or sets rather than across
20828 their individual elements.
20831 The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it
20832 transposes the input matrix, maps by rows, and then, if the result is a
20833 matrix, transposes again. For example, @kbd{V M : A} takes the absolute
20834 values of the three columns of the matrix, treating each as a 2-vector,
20835 and @kbd{V M : v v} reverses the columns to get the matrix
20836 @expr{[[-4, 5, -6], [1, -2, 3]]}.
20838 (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
20839 and column-like appearances, and were not already taken by useful
20840 operators. Also, they appear shifted on most keyboards so they are easy
20841 to type after @kbd{V M}.)
20843 The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
20844 not matrices (so if none of the arguments are matrices, they have no
20845 effect at all). If some of the arguments are matrices and others are
20846 plain numbers, the plain numbers are held constant for all rows of the
20847 matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
20848 a vector takes a dot product of the vector with itself).
20850 If some of the arguments are vectors with the same lengths as the
20851 rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
20852 arguments, those vectors are also held constant for every row or
20855 Sometimes it is useful to specify another mapping command as the operator
20856 to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +}
20857 to each row of the input matrix, which in turn adds the two values on that
20858 row. If you give another vector-operator command as the operator for
20859 @kbd{V M}, it automatically uses map-by-rows mode if you don't specify
20860 otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If
20861 you really want to map-by-elements another mapping command, you can use
20862 a triple-nested mapping command: @kbd{V M V M V A +} means to map
20863 @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
20864 mapped over the elements of each row.)
20868 Previous versions of Calc had ``map across'' and ``map down'' modes
20869 that are now considered obsolete; the old ``map across'' is now simply
20870 @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic
20871 functions @code{mapa} and @code{mapd} are still supported, though.
20872 Note also that, while the old mapping modes were persistent (once you
20873 set the mode, it would apply to later mapping commands until you reset
20874 it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
20875 mapping command. The default @kbd{V M} always means map-by-elements.
20877 @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
20878 @kbd{V M} but for equations and inequalities instead of vectors.
20879 @xref{Storing Variables}, for the @kbd{s m} command which modifies a
20880 variable's stored value using a @kbd{V M}-like operator.
20882 @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
20883 @subsection Reducing
20887 @pindex calc-reduce
20889 The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
20890 binary operator across all the elements of a vector. A binary operator is
20891 a function such as @code{+} or @code{max} which takes two arguments. For
20892 example, reducing @code{+} over a vector computes the sum of the elements
20893 of the vector. Reducing @code{-} computes the first element minus each of
20894 the remaining elements. Reducing @code{max} computes the maximum element
20895 and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
20896 produces @samp{f(f(f(a, b), c), d)}.
20900 The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
20901 that works from right to left through the vector. For example, plain
20902 @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
20903 but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
20904 or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently
20905 in power series expansions.
20909 The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
20910 accumulation operation. Here Calc does the corresponding reduction
20911 operation, but instead of producing only the final result, it produces
20912 a vector of all the intermediate results. Accumulating @code{+} over
20913 the vector @samp{[a, b, c, d]} produces the vector
20914 @samp{[a, a + b, a + b + c, a + b + c + d]}.
20918 The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
20919 For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
20920 vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
20926 As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For
20927 example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
20928 compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or
20929 @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}]
20930 command reduces ``across'' the matrix; it reduces each row of the matrix
20931 as a vector, then collects the results. Thus @kbd{V R _ +} of this
20932 matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :}
20933 [@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d,
20938 There is a third ``by rows'' mode for reduction that is occasionally
20939 useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
20940 the rows of the matrix themselves. Thus @kbd{V R = +} on the above
20941 matrix would get the same result as @kbd{V R : +}, since adding two
20942 row vectors is equivalent to adding their elements. But @kbd{V R = *}
20943 would multiply the two rows (to get a single number, their dot product),
20944 while @kbd{V R : *} would produce a vector of the products of the columns.
20946 These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
20947 but they are not currently supported with @kbd{V U} or @kbd{I V U}.
20951 The obsolete reduce-by-columns function, @code{reducec}, is still
20952 supported but there is no way to get it through the @kbd{V R} command.
20954 The commands @kbd{M-# :} and @kbd{M-# _} are equivalent to typing
20955 @kbd{M-# r} to grab a rectangle of data into Calc, and then typing
20956 @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
20957 rows of the matrix. @xref{Grabbing From Buffers}.
20959 @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
20960 @subsection Nesting and Fixed Points
20965 The @kbd{H V R} [@code{nest}] command applies a function to a given
20966 argument repeatedly. It takes two values, @samp{a} and @samp{n}, from
20967 the stack, where @samp{n} must be an integer. It then applies the
20968 function nested @samp{n} times; if the function is @samp{f} and @samp{n}
20969 is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be
20970 negative if Calc knows an inverse for the function @samp{f}; for
20971 example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
20975 The @kbd{H V U} [@code{anest}] command is an accumulating version of
20976 @code{nest}: It returns a vector of @samp{n+1} values, e.g.,
20977 @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and
20978 @samp{F} is the inverse of @samp{f}, then the result is of the
20979 form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
20983 @cindex Fixed points
20984 The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
20985 that it takes only an @samp{a} value from the stack; the function is
20986 applied until it reaches a ``fixed point,'' i.e., until the result
20991 The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
20992 The first element of the return vector will be the initial value @samp{a};
20993 the last element will be the final result that would have been returned
20996 For example, 0.739085 is a fixed point of the cosine function (in radians):
20997 @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say,
20998 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating
20999 version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553,
21000 0.65329, ...]}. With a precision of six, this command will take 36 steps
21001 to converge to 0.739085.)
21003 Newton's method for finding roots is a classic example of iteration
21004 to a fixed point. To find the square root of five starting with an
21005 initial guess, Newton's method would look for a fixed point of the
21006 function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack
21007 and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
21008 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root})
21009 command to find a root of the equation @samp{x^2 = 5}.
21011 These examples used numbers for @samp{a} values. Calc keeps applying
21012 the function until two successive results are equal to within the
21013 current precision. For complex numbers, both the real parts and the
21014 imaginary parts must be equal to within the current precision. If
21015 @samp{a} is a formula (say, a variable name), then the function is
21016 applied until two successive results are exactly the same formula.
21017 It is up to you to ensure that the function will eventually converge;
21018 if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
21020 The algebraic @code{fixp} function takes two optional arguments, @samp{n}
21021 and @samp{tol}. The first is the maximum number of steps to be allowed,
21022 and must be either an integer or the symbol @samp{inf} (infinity, the
21023 default). The second is a convergence tolerance. If a tolerance is
21024 specified, all results during the calculation must be numbers, not
21025 formulas, and the iteration stops when the magnitude of the difference
21026 between two successive results is less than or equal to the tolerance.
21027 (This implies that a tolerance of zero iterates until the results are
21030 Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
21031 computes the square root of @samp{A} given the initial guess @samp{B},
21032 stopping when the result is correct within the specified tolerance, or
21033 when 20 steps have been taken, whichever is sooner.
21035 @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
21036 @subsection Generalized Products
21039 @pindex calc-outer-product
21041 The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
21042 a given binary operator to all possible pairs of elements from two
21043 vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]}
21044 and @samp{[x, y, z]} on the stack produces a multiplication table:
21045 @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of
21046 the result matrix is obtained by applying the operator to element @var{r}
21047 of the lefthand vector and element @var{c} of the righthand vector.
21050 @pindex calc-inner-product
21052 The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
21053 the generalized inner product of two vectors or matrices, given a
21054 ``multiplicative'' operator and an ``additive'' operator. These can each
21055 actually be any binary operators; if they are @samp{*} and @samp{+},
21056 respectively, the result is a standard matrix multiplication. Element
21057 @var{r},@var{c} of the result matrix is obtained by mapping the
21058 multiplicative operator across row @var{r} of the lefthand matrix and
21059 column @var{c} of the righthand matrix, and then reducing with the additive
21060 operator. Just as for the standard @kbd{*} command, this can also do a
21061 vector-matrix or matrix-vector inner product, or a vector-vector
21062 generalized dot product.
21064 Since @kbd{V I} requires two operators, it prompts twice. In each case,
21065 you can use any of the usual methods for entering the operator. If you
21066 use @kbd{$} twice to take both operator formulas from the stack, the
21067 first (multiplicative) operator is taken from the top of the stack
21068 and the second (additive) operator is taken from second-to-top.
21070 @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
21071 @section Vector and Matrix Display Formats
21074 Commands for controlling vector and matrix display use the @kbd{v} prefix
21075 instead of the usual @kbd{d} prefix. But they are display modes; in
21076 particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
21077 in the same way (@pxref{Display Modes}). Matrix display is also
21078 influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
21079 @pxref{Normal Language Modes}.
21082 @pindex calc-matrix-left-justify
21084 @pindex calc-matrix-center-justify
21086 @pindex calc-matrix-right-justify
21087 The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
21088 (@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
21089 (@code{calc-matrix-center-justify}) control whether matrix elements
21090 are justified to the left, right, or center of their columns.
21093 @pindex calc-vector-brackets
21095 @pindex calc-vector-braces
21097 @pindex calc-vector-parens
21098 The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
21099 brackets that surround vectors and matrices displayed in the stack on
21100 and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
21101 (@code{calc-vector-parens}) commands use curly braces or parentheses,
21102 respectively, instead of square brackets. For example, @kbd{v @{} might
21103 be used in preparation for yanking a matrix into a buffer running
21104 Mathematica. (In fact, the Mathematica language mode uses this mode;
21105 @pxref{Mathematica Language Mode}.) Note that, regardless of the
21106 display mode, either brackets or braces may be used to enter vectors,
21107 and parentheses may never be used for this purpose.
21110 @pindex calc-matrix-brackets
21111 The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
21112 ``big'' style display of matrices. It prompts for a string of code
21113 letters; currently implemented letters are @code{R}, which enables
21114 brackets on each row of the matrix; @code{O}, which enables outer
21115 brackets in opposite corners of the matrix; and @code{C}, which
21116 enables commas or semicolons at the ends of all rows but the last.
21117 The default format is @samp{RO}. (Before Calc 2.00, the format
21118 was fixed at @samp{ROC}.) Here are some example matrices:
21122 [ [ 123, 0, 0 ] [ [ 123, 0, 0 ],
21123 [ 0, 123, 0 ] [ 0, 123, 0 ],
21124 [ 0, 0, 123 ] ] [ 0, 0, 123 ] ]
21133 [ 123, 0, 0 [ 123, 0, 0 ;
21134 0, 123, 0 0, 123, 0 ;
21135 0, 0, 123 ] 0, 0, 123 ]
21144 [ 123, 0, 0 ] 123, 0, 0
21145 [ 0, 123, 0 ] 0, 123, 0
21146 [ 0, 0, 123 ] 0, 0, 123
21153 Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
21154 @samp{OC} are all recognized as matrices during reading, while
21155 the others are useful for display only.
21158 @pindex calc-vector-commas
21159 The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
21160 off in vector and matrix display.
21162 In vectors of length one, and in all vectors when commas have been
21163 turned off, Calc adds extra parentheses around formulas that might
21164 otherwise be ambiguous. For example, @samp{[a b]} could be a vector
21165 of the one formula @samp{a b}, or it could be a vector of two
21166 variables with commas turned off. Calc will display the former
21167 case as @samp{[(a b)]}. You can disable these extra parentheses
21168 (to make the output less cluttered at the expense of allowing some
21169 ambiguity) by adding the letter @code{P} to the control string you
21170 give to @kbd{v ]} (as described above).
21173 @pindex calc-full-vectors
21174 The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
21175 display of long vectors on and off. In this mode, vectors of six
21176 or more elements, or matrices of six or more rows or columns, will
21177 be displayed in an abbreviated form that displays only the first
21178 three elements and the last element: @samp{[a, b, c, ..., z]}.
21179 When very large vectors are involved this will substantially
21180 improve Calc's display speed.
21183 @pindex calc-full-trail-vectors
21184 The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
21185 similar mode for recording vectors in the Trail. If you turn on
21186 this mode, vectors of six or more elements and matrices of six or
21187 more rows or columns will be abbreviated when they are put in the
21188 Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be
21189 unable to recover those vectors. If you are working with very
21190 large vectors, this mode will improve the speed of all operations
21191 that involve the trail.
21194 @pindex calc-break-vectors
21195 The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
21196 vector display on and off. Normally, matrices are displayed with one
21197 row per line but all other types of vectors are displayed in a single
21198 line. This mode causes all vectors, whether matrices or not, to be
21199 displayed with a single element per line. Sub-vectors within the
21200 vectors will still use the normal linear form.
21202 @node Algebra, Units, Matrix Functions, Top
21206 This section covers the Calc features that help you work with
21207 algebraic formulas. First, the general sub-formula selection
21208 mechanism is described; this works in conjunction with any Calc
21209 commands. Then, commands for specific algebraic operations are
21210 described. Finally, the flexible @dfn{rewrite rule} mechanism
21213 The algebraic commands use the @kbd{a} key prefix; selection
21214 commands use the @kbd{j} (for ``just a letter that wasn't used
21215 for anything else'') prefix.
21217 @xref{Editing Stack Entries}, to see how to manipulate formulas
21218 using regular Emacs editing commands.
21220 When doing algebraic work, you may find several of the Calculator's
21221 modes to be helpful, including Algebraic Simplification mode (@kbd{m A})
21222 or No-Simplification mode (@kbd{m O}),
21223 Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and
21224 Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions
21225 of these modes. You may also wish to select Big display mode (@kbd{d B}).
21226 @xref{Normal Language Modes}.
21229 * Selecting Subformulas::
21230 * Algebraic Manipulation::
21231 * Simplifying Formulas::
21234 * Solving Equations::
21235 * Numerical Solutions::
21238 * Logical Operations::
21242 @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
21243 @section Selecting Sub-Formulas
21247 @cindex Sub-formulas
21248 @cindex Parts of formulas
21249 When working with an algebraic formula it is often necessary to
21250 manipulate a portion of the formula rather than the formula as a
21251 whole. Calc allows you to ``select'' a portion of any formula on
21252 the stack. Commands which would normally operate on that stack
21253 entry will now operate only on the sub-formula, leaving the
21254 surrounding part of the stack entry alone.
21256 One common non-algebraic use for selection involves vectors. To work
21257 on one element of a vector in-place, simply select that element as a
21258 ``sub-formula'' of the vector.
21261 * Making Selections::
21262 * Changing Selections::
21263 * Displaying Selections::
21264 * Operating on Selections::
21265 * Rearranging with Selections::
21268 @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
21269 @subsection Making Selections
21273 @pindex calc-select-here
21274 To select a sub-formula, move the Emacs cursor to any character in that
21275 sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will
21276 highlight the smallest portion of the formula that contains that
21277 character. By default the sub-formula is highlighted by blanking out
21278 all of the rest of the formula with dots. Selection works in any
21279 display mode but is perhaps easiest in Big mode (@kbd{d B}).
21280 Suppose you enter the following formula:
21292 (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the
21293 cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
21306 Every character not part of the sub-formula @samp{b} has been changed
21307 to a dot. The @samp{*} next to the line number is to remind you that
21308 the formula has a portion of it selected. (In this case, it's very
21309 obvious, but it might not always be. If Embedded mode is enabled,
21310 the word @samp{Sel} also appears in the mode line because the stack
21311 may not be visible. @pxref{Embedded Mode}.)
21313 If you had instead placed the cursor on the parenthesis immediately to
21314 the right of the @samp{b}, the selection would have been:
21326 The portion selected is always large enough to be considered a complete
21327 formula all by itself, so selecting the parenthesis selects the whole
21328 formula that it encloses. Putting the cursor on the @samp{+} sign
21329 would have had the same effect.
21331 (Strictly speaking, the Emacs cursor is really the manifestation of
21332 the Emacs ``point,'' which is a position @emph{between} two characters
21333 in the buffer. So purists would say that Calc selects the smallest
21334 sub-formula which contains the character to the right of ``point.'')
21336 If you supply a numeric prefix argument @var{n}, the selection is
21337 expanded to the @var{n}th enclosing sub-formula. Thus, positioning
21338 the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
21339 @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
21342 If the cursor is not on any part of the formula, or if you give a
21343 numeric prefix that is too large, the entire formula is selected.
21345 If the cursor is on the @samp{.} line that marks the top of the stack
21346 (i.e., its normal ``rest position''), this command selects the entire
21347 formula at stack level 1. Most selection commands similarly operate
21348 on the formula at the top of the stack if you haven't positioned the
21349 cursor on any stack entry.
21352 @pindex calc-select-additional
21353 The @kbd{j a} (@code{calc-select-additional}) command enlarges the
21354 current selection to encompass the cursor. To select the smallest
21355 sub-formula defined by two different points, move to the first and
21356 press @kbd{j s}, then move to the other and press @kbd{j a}. This
21357 is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
21358 select the two ends of a region of text during normal Emacs editing.
21361 @pindex calc-select-once
21362 The @kbd{j o} (@code{calc-select-once}) command selects a formula in
21363 exactly the same way as @kbd{j s}, except that the selection will
21364 last only as long as the next command that uses it. For example,
21365 @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
21368 (A somewhat more precise definition: The @kbd{j o} command sets a flag
21369 such that the next command involving selected stack entries will clear
21370 the selections on those stack entries afterwards. All other selection
21371 commands except @kbd{j a} and @kbd{j O} clear this flag.)
21375 @pindex calc-select-here-maybe
21376 @pindex calc-select-once-maybe
21377 The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
21378 (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
21379 and @kbd{j o}, respectively, except that if the formula already
21380 has a selection they have no effect. This is analogous to the
21381 behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
21382 @pxref{Selections with Rewrite Rules}) and is mainly intended to be
21383 used in keyboard macros that implement your own selection-oriented
21386 Selection of sub-formulas normally treats associative terms like
21387 @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
21388 If you place the cursor anywhere inside @samp{a + b - c + d} except
21389 on one of the variable names and use @kbd{j s}, you will select the
21390 entire four-term sum.
21393 @pindex calc-break-selections
21394 The @kbd{j b} (@code{calc-break-selections}) command controls a mode
21395 in which the ``deep structure'' of these associative formulas shows
21396 through. Calc actually stores the above formulas as @samp{((a + b) - c) + d}
21397 and @samp{x * (y * z)}. (Note that for certain obscure reasons, Calc
21398 treats multiplication as right-associative.) Once you have enabled
21399 @kbd{j b} mode, selecting with the cursor on the @samp{-} sign would
21400 only select the @samp{a + b - c} portion, which makes sense when the
21401 deep structure of the sum is considered. There is no way to select
21402 the @samp{b - c + d} portion; although this might initially look
21403 like just as legitimate a sub-formula as @samp{a + b - c}, the deep
21404 structure shows that it isn't. The @kbd{d U} command can be used
21405 to view the deep structure of any formula (@pxref{Normal Language Modes}).
21407 When @kbd{j b} mode has not been enabled, the deep structure is
21408 generally hidden by the selection commands---what you see is what
21412 @pindex calc-unselect
21413 The @kbd{j u} (@code{calc-unselect}) command unselects the formula
21414 that the cursor is on. If there was no selection in the formula,
21415 this command has no effect. With a numeric prefix argument, it
21416 unselects the @var{n}th stack element rather than using the cursor
21420 @pindex calc-clear-selections
21421 The @kbd{j c} (@code{calc-clear-selections}) command unselects all
21424 @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
21425 @subsection Changing Selections
21429 @pindex calc-select-more
21430 Once you have selected a sub-formula, you can expand it using the
21431 @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is
21432 selected, pressing @w{@kbd{j m}} repeatedly works as follows:
21437 (a + b) . . . (a + b) + V c (a + b) + V c
21438 1* ............... 1* ............... 1* ---------------
21439 . . . . . . . . 2 x + 1
21444 In the last example, the entire formula is selected. This is roughly
21445 the same as having no selection at all, but because there are subtle
21446 differences the @samp{*} character is still there on the line number.
21448 With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
21449 times (or until the entire formula is selected). Note that @kbd{j s}
21450 with argument @var{n} is equivalent to plain @kbd{j s} followed by
21451 @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there
21452 is no current selection, it is equivalent to @w{@kbd{j s}}.
21454 Even though @kbd{j m} does not explicitly use the location of the
21455 cursor within the formula, it nevertheless uses the cursor to determine
21456 which stack element to operate on. As usual, @kbd{j m} when the cursor
21457 is not on any stack element operates on the top stack element.
21460 @pindex calc-select-less
21461 The @kbd{j l} (@code{calc-select-less}) command reduces the current
21462 selection around the cursor position. That is, it selects the
21463 immediate sub-formula of the current selection which contains the
21464 cursor, the opposite of @kbd{j m}. If the cursor is not inside the
21465 current selection, the command de-selects the formula.
21468 @pindex calc-select-part
21469 The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
21470 select the @var{n}th sub-formula of the current selection. They are
21471 like @kbd{j l} (@code{calc-select-less}) except they use counting
21472 rather than the cursor position to decide which sub-formula to select.
21473 For example, if the current selection is @kbd{a + b + c} or
21474 @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
21475 @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
21476 these cases, @kbd{j 4} through @kbd{j 9} would be errors.
21478 If there is no current selection, @kbd{j 1} through @kbd{j 9} select
21479 the @var{n}th top-level sub-formula. (In other words, they act as if
21480 the entire stack entry were selected first.) To select the @var{n}th
21481 sub-formula where @var{n} is greater than nine, you must instead invoke
21482 @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.
21486 @pindex calc-select-next
21487 @pindex calc-select-previous
21488 The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
21489 (@code{calc-select-previous}) commands change the current selection
21490 to the next or previous sub-formula at the same level. For example,
21491 if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
21492 selects @samp{c}. Further @kbd{j n} commands would be in error because,
21493 even though there is something to the right of @samp{c} (namely, @samp{x}),
21494 it is not at the same level; in this case, it is not a term of the
21495 same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select
21496 the whole product @samp{a*b*c} as a term of the sum) followed by
21497 @w{@kbd{j n}} would successfully select the @samp{x}.
21499 Similarly, @kbd{j p} moves the selection from the @samp{b} in this
21500 sample formula to the @samp{a}. Both commands accept numeric prefix
21501 arguments to move several steps at a time.
21503 It is interesting to compare Calc's selection commands with the
21504 Emacs Info system's commands for navigating through hierarchically
21505 organized documentation. Calc's @kbd{j n} command is completely
21506 analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to
21507 @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
21508 (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
21509 The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
21510 @kbd{j l}; in each case, you can jump directly to a sub-component
21511 of the hierarchy simply by pointing to it with the cursor.
21513 @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
21514 @subsection Displaying Selections
21518 @pindex calc-show-selections
21519 The @kbd{j d} (@code{calc-show-selections}) command controls how
21520 selected sub-formulas are displayed. One of the alternatives is
21521 illustrated in the above examples; if we press @kbd{j d} we switch
21522 to the other style in which the selected portion itself is obscured
21528 (a + b) . . . ## # ## + V c
21529 1* ............... 1* ---------------
21534 @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
21535 @subsection Operating on Selections
21538 Once a selection is made, all Calc commands that manipulate items
21539 on the stack will operate on the selected portions of the items
21540 instead. (Note that several stack elements may have selections
21541 at once, though there can be only one selection at a time in any
21542 given stack element.)
21545 @pindex calc-enable-selections
21546 The @kbd{j e} (@code{calc-enable-selections}) command disables the
21547 effect that selections have on Calc commands. The current selections
21548 still exist, but Calc commands operate on whole stack elements anyway.
21549 This mode can be identified by the fact that the @samp{*} markers on
21550 the line numbers are gone, even though selections are visible. To
21551 reactivate the selections, press @kbd{j e} again.
21553 To extract a sub-formula as a new formula, simply select the
21554 sub-formula and press @key{RET}. This normally duplicates the top
21555 stack element; here it duplicates only the selected portion of that
21558 To replace a sub-formula with something different, you can enter the
21559 new value onto the stack and press @key{TAB}. This normally exchanges
21560 the top two stack elements; here it swaps the value you entered into
21561 the selected portion of the formula, returning the old selected
21562 portion to the top of the stack.
21567 (a + b) . . . 17 x y . . . 17 x y + V c
21568 2* ............... 2* ............. 2: -------------
21569 . . . . . . . . 2 x + 1
21572 1: 17 x y 1: (a + b) 1: (a + b)
21576 In this example we select a sub-formula of our original example,
21577 enter a new formula, @key{TAB} it into place, then deselect to see
21578 the complete, edited formula.
21580 If you want to swap whole formulas around even though they contain
21581 selections, just use @kbd{j e} before and after.
21584 @pindex calc-enter-selection
21585 The @kbd{j '} (@code{calc-enter-selection}) command is another way
21586 to replace a selected sub-formula. This command does an algebraic
21587 entry just like the regular @kbd{'} key. When you press @key{RET},
21588 the formula you type replaces the original selection. You can use
21589 the @samp{$} symbol in the formula to refer to the original
21590 selection. If there is no selection in the formula under the cursor,
21591 the cursor is used to make a temporary selection for the purposes of
21592 the command. Thus, to change a term of a formula, all you have to
21593 do is move the Emacs cursor to that term and press @kbd{j '}.
21596 @pindex calc-edit-selection
21597 The @kbd{j `} (@code{calc-edit-selection}) command is a similar
21598 analogue of the @kbd{`} (@code{calc-edit}) command. It edits the
21599 selected sub-formula in a separate buffer. If there is no
21600 selection, it edits the sub-formula indicated by the cursor.
21602 To delete a sub-formula, press @key{DEL}. This generally replaces
21603 the sub-formula with the constant zero, but in a few suitable contexts
21604 it uses the constant one instead. The @key{DEL} key automatically
21605 deselects and re-simplifies the entire formula afterwards. Thus:
21610 17 x y + # # 17 x y 17 # y 17 y
21611 1* ------------- 1: ------- 1* ------- 1: -------
21612 2 x + 1 2 x + 1 2 x + 1 2 x + 1
21616 In this example, we first delete the @samp{sqrt(c)} term; Calc
21617 accomplishes this by replacing @samp{sqrt(c)} with zero and
21618 resimplifying. We then delete the @kbd{x} in the numerator;
21619 since this is part of a product, Calc replaces it with @samp{1}
21622 If you select an element of a vector and press @key{DEL}, that
21623 element is deleted from the vector. If you delete one side of
21624 an equation or inequality, only the opposite side remains.
21626 @kindex j @key{DEL}
21627 @pindex calc-del-selection
21628 The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
21629 @key{DEL} but with the auto-selecting behavior of @kbd{j '} and
21630 @kbd{j `}. It deletes the selected portion of the formula
21631 indicated by the cursor, or, in the absence of a selection, it
21632 deletes the sub-formula indicated by the cursor position.
21634 @kindex j @key{RET}
21635 @pindex calc-grab-selection
21636 (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
21639 Normal arithmetic operations also apply to sub-formulas. Here we
21640 select the denominator, press @kbd{5 -} to subtract five from the
21641 denominator, press @kbd{n} to negate the denominator, then
21642 press @kbd{Q} to take the square root.
21646 .. . .. . .. . .. .
21647 1* ....... 1* ....... 1* ....... 1* ..........
21648 2 x + 1 2 x - 4 4 - 2 x _________
21653 Certain types of operations on selections are not allowed. For
21654 example, for an arithmetic function like @kbd{-} no more than one of
21655 the arguments may be a selected sub-formula. (As the above example
21656 shows, the result of the subtraction is spliced back into the argument
21657 which had the selection; if there were more than one selection involved,
21658 this would not be well-defined.) If you try to subtract two selections,
21659 the command will abort with an error message.
21661 Operations on sub-formulas sometimes leave the formula as a whole
21662 in an ``un-natural'' state. Consider negating the @samp{2 x} term
21663 of our sample formula by selecting it and pressing @kbd{n}
21664 (@code{calc-change-sign}).
21669 1* .......... 1* ...........
21670 ......... ..........
21671 . . . 2 x . . . -2 x
21675 Unselecting the sub-formula reveals that the minus sign, which would
21676 normally have cancelled out with the subtraction automatically, has
21677 not been able to do so because the subtraction was not part of the
21678 selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
21679 any other mathematical operation on the whole formula will cause it
21685 1: ----------- 1: ----------
21686 __________ _________
21687 V 4 - -2 x V 4 + 2 x
21691 @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
21692 @subsection Rearranging Formulas using Selections
21696 @pindex calc-commute-right
21697 The @kbd{j R} (@code{calc-commute-right}) command moves the selected
21698 sub-formula to the right in its surrounding formula. Generally the
21699 selection is one term of a sum or product; the sum or product is
21700 rearranged according to the commutative laws of algebra.
21702 As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
21703 if there is no selection in the current formula. All commands described
21704 in this section share this property. In this example, we place the
21705 cursor on the @samp{a} and type @kbd{j R}, then repeat.
21708 1: a + b - c 1: b + a - c 1: b - c + a
21712 Note that in the final step above, the @samp{a} is switched with
21713 the @samp{c} but the signs are adjusted accordingly. When moving
21714 terms of sums and products, @kbd{j R} will never change the
21715 mathematical meaning of the formula.
21717 The selected term may also be an element of a vector or an argument
21718 of a function. The term is exchanged with the one to its right.
21719 In this case, the ``meaning'' of the vector or function may of
21720 course be drastically changed.
21723 1: [a, b, c] 1: [b, a, c] 1: [b, c, a]
21725 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a)
21729 @pindex calc-commute-left
21730 The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
21731 except that it swaps the selected term with the one to its left.
21733 With numeric prefix arguments, these commands move the selected
21734 term several steps at a time. It is an error to try to move a
21735 term left or right past the end of its enclosing formula.
21736 With numeric prefix arguments of zero, these commands move the
21737 selected term as far as possible in the given direction.
21740 @pindex calc-sel-distribute
21741 The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
21742 sum or product into the surrounding formula using the distributive
21743 law. For example, in @samp{a * (b - c)} with the @samp{b - c}
21744 selected, the result is @samp{a b - a c}. This also distributes
21745 products or quotients into surrounding powers, and can also do
21746 transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
21747 where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
21748 to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
21750 For multiple-term sums or products, @kbd{j D} takes off one term
21751 at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
21752 with the @samp{c - d} selected so that you can type @kbd{j D}
21753 repeatedly to expand completely. The @kbd{j D} command allows a
21754 numeric prefix argument which specifies the maximum number of
21755 times to expand at once; the default is one time only.
21757 @vindex DistribRules
21758 The @kbd{j D} command is implemented using rewrite rules.
21759 @xref{Selections with Rewrite Rules}. The rules are stored in
21760 the Calc variable @code{DistribRules}. A convenient way to view
21761 these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
21762 displays and edits the stored value of a variable. Press @kbd{C-c C-c}
21763 to return from editing mode; be careful not to make any actual changes
21764 or else you will affect the behavior of future @kbd{j D} commands!
21766 To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
21767 as described above. You can then use the @kbd{s p} command to save
21768 this variable's value permanently for future Calc sessions.
21769 @xref{Operations on Variables}.
21772 @pindex calc-sel-merge
21774 The @kbd{j M} (@code{calc-sel-merge}) command is the complement
21775 of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
21776 @samp{a c} selected, the result is @samp{a * (b - c)}. Once
21777 again, @kbd{j M} can also merge calls to functions like @code{exp}
21778 and @code{ln}; examine the variable @code{MergeRules} to see all
21779 the relevant rules.
21782 @pindex calc-sel-commute
21783 @vindex CommuteRules
21784 The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
21785 of the selected sum, product, or equation. It always behaves as
21786 if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
21787 treated as the nested sums @samp{(a + b) + c} by this command.
21788 If you put the cursor on the first @samp{+}, the result is
21789 @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
21790 result is @samp{c + (a + b)} (which the default simplifications
21791 will rearrange to @samp{(c + a) + b}). The relevant rules are stored
21792 in the variable @code{CommuteRules}.
21794 You may need to turn default simplifications off (with the @kbd{m O}
21795 command) in order to get the full benefit of @kbd{j C}. For example,
21796 commuting @samp{a - b} produces @samp{-b + a}, but the default
21797 simplifications will ``simplify'' this right back to @samp{a - b} if
21798 you don't turn them off. The same is true of some of the other
21799 manipulations described in this section.
21802 @pindex calc-sel-negate
21803 @vindex NegateRules
21804 The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
21805 term with the negative of that term, then adjusts the surrounding
21806 formula in order to preserve the meaning. For example, given
21807 @samp{exp(a - b)} where @samp{a - b} is selected, the result is
21808 @samp{1 / exp(b - a)}. By contrast, selecting a term and using the
21809 regular @kbd{n} (@code{calc-change-sign}) command negates the
21810 term without adjusting the surroundings, thus changing the meaning
21811 of the formula as a whole. The rules variable is @code{NegateRules}.
21814 @pindex calc-sel-invert
21815 @vindex InvertRules
21816 The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
21817 except it takes the reciprocal of the selected term. For example,
21818 given @samp{a - ln(b)} with @samp{b} selected, the result is
21819 @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}.
21822 @pindex calc-sel-jump-equals
21824 The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
21825 selected term from one side of an equation to the other. Given
21826 @samp{a + b = c + d} with @samp{c} selected, the result is
21827 @samp{a + b - c = d}. This command also works if the selected
21828 term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The
21829 relevant rules variable is @code{JumpRules}.
21833 @pindex calc-sel-isolate
21834 The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
21835 selected term on its side of an equation. It uses the @kbd{a S}
21836 (@code{calc-solve-for}) command to solve the equation, and the
21837 Hyperbolic flag affects it in the same way. @xref{Solving Equations}.
21838 When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
21839 It understands more rules of algebra, and works for inequalities
21840 as well as equations.
21844 @pindex calc-sel-mult-both-sides
21845 @pindex calc-sel-div-both-sides
21846 The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
21847 formula using algebraic entry, then multiplies both sides of the
21848 selected quotient or equation by that formula. It simplifies each
21849 side with @kbd{a s} (@code{calc-simplify}) before re-forming the
21850 quotient or equation. You can suppress this simplification by
21851 providing any numeric prefix argument. There is also a @kbd{j /}
21852 (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
21853 dividing instead of multiplying by the factor you enter.
21855 As a special feature, if the numerator of the quotient is 1, then
21856 the denominator is expanded at the top level using the distributive
21857 law (i.e., using the @kbd{C-u -1 a x} command). Suppose the
21858 formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish
21859 to eliminate the square root in the denominator by multiplying both
21860 sides by @samp{sqrt(a) - 1}. Calc's default simplifications would
21861 change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)}
21862 right back to the original form by cancellation; Calc expands the
21863 denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent
21864 this. (You would now want to use an @kbd{a x} command to expand
21865 the rest of the way, whereupon the denominator would cancel out to
21866 the desired form, @samp{a - 1}.) When the numerator is not 1, this
21867 initial expansion is not necessary because Calc's default
21868 simplifications will not notice the potential cancellation.
21870 If the selection is an inequality, @kbd{j *} and @kbd{j /} will
21871 accept any factor, but will warn unless they can prove the factor
21872 is either positive or negative. (In the latter case the direction
21873 of the inequality will be switched appropriately.) @xref{Declarations},
21874 for ways to inform Calc that a given variable is positive or
21875 negative. If Calc can't tell for sure what the sign of the factor
21876 will be, it will assume it is positive and display a warning
21879 For selections that are not quotients, equations, or inequalities,
21880 these commands pull out a multiplicative factor: They divide (or
21881 multiply) by the entered formula, simplify, then multiply (or divide)
21882 back by the formula.
21886 @pindex calc-sel-add-both-sides
21887 @pindex calc-sel-sub-both-sides
21888 The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
21889 (@code{calc-sel-sub-both-sides}) commands analogously add to or
21890 subtract from both sides of an equation or inequality. For other
21891 types of selections, they extract an additive factor. A numeric
21892 prefix argument suppresses simplification of the intermediate
21896 @pindex calc-sel-unpack
21897 The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
21898 selected function call with its argument. For example, given
21899 @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
21900 is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you
21901 wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
21902 now to take the cosine of the selected part.)
21905 @pindex calc-sel-evaluate
21906 The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
21907 normal default simplifications on the selected sub-formula.
21908 These are the simplifications that are normally done automatically
21909 on all results, but which may have been partially inhibited by
21910 previous selection-related operations, or turned off altogether
21911 by the @kbd{m O} command. This command is just an auto-selecting
21912 version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
21914 With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
21915 the @kbd{a s} (@code{calc-simplify}) command to the selected
21916 sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
21917 applies the @kbd{a e} (@code{calc-simplify-extended}) command.
21918 @xref{Simplifying Formulas}. With a negative prefix argument
21919 it simplifies at the top level only, just as with @kbd{a v}.
21920 Here the ``top'' level refers to the top level of the selected
21924 @pindex calc-sel-expand-formula
21925 The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
21926 (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
21928 You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
21929 to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}.
21931 @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
21932 @section Algebraic Manipulation
21935 The commands in this section perform general-purpose algebraic
21936 manipulations. They work on the whole formula at the top of the
21937 stack (unless, of course, you have made a selection in that
21940 Many algebra commands prompt for a variable name or formula. If you
21941 answer the prompt with a blank line, the variable or formula is taken
21942 from top-of-stack, and the normal argument for the command is taken
21943 from the second-to-top stack level.
21946 @pindex calc-alg-evaluate
21947 The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
21948 default simplifications on a formula; for example, @samp{a - -b} is
21949 changed to @samp{a + b}. These simplifications are normally done
21950 automatically on all Calc results, so this command is useful only if
21951 you have turned default simplifications off with an @kbd{m O}
21952 command. @xref{Simplification Modes}.
21954 It is often more convenient to type @kbd{=}, which is like @kbd{a v}
21955 but which also substitutes stored values for variables in the formula.
21956 Use @kbd{a v} if you want the variables to ignore their stored values.
21958 If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
21959 as if in Algebraic Simplification mode. This is equivalent to typing
21960 @kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix
21961 of 3 or more, it uses Extended Simplification mode (@kbd{a e}).
21963 If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3},
21964 it simplifies in the corresponding mode but only works on the top-level
21965 function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will
21966 simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
21967 @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector
21968 @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
21969 in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to
21970 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
21971 (@xref{Reducing and Mapping}.)
21975 The @kbd{=} command corresponds to the @code{evalv} function, and
21976 the related @kbd{N} command, which is like @kbd{=} but temporarily
21977 disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds
21978 to the @code{evalvn} function. (These commands interpret their prefix
21979 arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
21980 the number of stack elements to evaluate at once, and @kbd{N} treats
21981 it as a temporary different working precision.)
21983 The @code{evalvn} function can take an alternate working precision
21984 as an optional second argument. This argument can be either an
21985 integer, to set the precision absolutely, or a vector containing
21986 a single integer, to adjust the precision relative to the current
21987 precision. Note that @code{evalvn} with a larger than current
21988 precision will do the calculation at this higher precision, but the
21989 result will as usual be rounded back down to the current precision
21990 afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision
21991 of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
21992 will return @samp{9.26535897932e-5} (computing a 25-digit result which
21993 is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
21994 will return @samp{9.2654e-5}.
21997 @pindex calc-expand-formula
21998 The @kbd{a "} (@code{calc-expand-formula}) command expands functions
21999 into their defining formulas wherever possible. For example,
22000 @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions,
22001 like @code{sin} and @code{gcd}, are not defined by simple formulas
22002 and so are unaffected by this command. One important class of
22003 functions which @emph{can} be expanded is the user-defined functions
22004 created by the @kbd{Z F} command. @xref{Algebraic Definitions}.
22005 Other functions which @kbd{a "} can expand include the probability
22006 distribution functions, most of the financial functions, and the
22007 hyperbolic and inverse hyperbolic functions. A numeric prefix argument
22008 affects @kbd{a "} in the same way as it does @kbd{a v}: A positive
22009 argument expands all functions in the formula and then simplifies in
22010 various ways; a negative argument expands and simplifies only the
22011 top-level function call.
22014 @pindex calc-map-equation
22016 The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
22017 a given function or operator to one or more equations. It is analogous
22018 to @kbd{V M}, which operates on vectors instead of equations.
22019 @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes
22020 @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
22021 @samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}.
22022 With two equations on the stack, @kbd{a M +} would add the lefthand
22023 sides together and the righthand sides together to get the two
22024 respective sides of a new equation.
22026 Mapping also works on inequalities. Mapping two similar inequalities
22027 produces another inequality of the same type. Mapping an inequality
22028 with an equation produces an inequality of the same type. Mapping a
22029 @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
22030 If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
22031 are mapped, the direction of the second inequality is reversed to
22032 match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
22033 reverses the latter to get @samp{2 < a}, which then allows the
22034 combination @samp{a + 2 < b + a}, which the @kbd{a s} command can
22035 then simplify to get @samp{2 < b}.
22037 Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
22038 or invert an inequality will reverse the direction of the inequality.
22039 Other adjustments to inequalities are @emph{not} done automatically;
22040 @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
22041 though this is not true for all values of the variables.
22045 With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
22046 mapping operation without reversing the direction of any inequalities.
22047 Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
22048 (This change is mathematically incorrect, but perhaps you were
22049 fixing an inequality which was already incorrect.)
22053 With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
22054 the direction of the inequality. You might use @kbd{I a M C} to
22055 change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
22056 working with small positive angles.
22059 @pindex calc-substitute
22061 The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
22063 of some variable or sub-expression of an expression with a new
22064 sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)}
22065 in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
22066 @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
22067 Note that this is a purely structural substitution; the lone @samp{x} and
22068 the @samp{sin(2 x)} stayed the same because they did not look like
22069 @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for
22070 doing substitutions.
22072 The @kbd{a b} command normally prompts for two formulas, the old
22073 one and the new one. If you enter a blank line for the first
22074 prompt, all three arguments are taken from the stack (new, then old,
22075 then target expression). If you type an old formula but then enter a
22076 blank line for the new one, the new formula is taken from top-of-stack
22077 and the target from second-to-top. If you answer both prompts, the
22078 target is taken from top-of-stack as usual.
22080 Note that @kbd{a b} has no understanding of commutativity or
22081 associativity. The pattern @samp{x+y} will not match the formula
22082 @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
22083 because the @samp{+} operator is left-associative, so the ``deep
22084 structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U}
22085 (@code{calc-unformatted-language}) mode to see the true structure of
22086 a formula. The rewrite rule mechanism, discussed later, does not have
22089 As an algebraic function, @code{subst} takes three arguments:
22090 Target expression, old, new. Note that @code{subst} is always
22091 evaluated immediately, even if its arguments are variables, so if
22092 you wish to put a call to @code{subst} onto the stack you must
22093 turn the default simplifications off first (with @kbd{m O}).
22095 @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
22096 @section Simplifying Formulas
22100 @pindex calc-simplify
22102 The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies
22103 various algebraic rules to simplify a formula. This includes rules which
22104 are not part of the default simplifications because they may be too slow
22105 to apply all the time, or may not be desirable all of the time. For
22106 example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a}
22107 to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are
22108 simplified to @samp{x}.
22110 The sections below describe all the various kinds of algebraic
22111 simplifications Calc provides in full detail. None of Calc's
22112 simplification commands are designed to pull rabbits out of hats;
22113 they simply apply certain specific rules to put formulas into
22114 less redundant or more pleasing forms. Serious algebra in Calc
22115 must be done manually, usually with a combination of selections
22116 and rewrite rules. @xref{Rearranging with Selections}.
22117 @xref{Rewrite Rules}.
22119 @xref{Simplification Modes}, for commands to control what level of
22120 simplification occurs automatically. Normally only the ``default
22121 simplifications'' occur.
22124 * Default Simplifications::
22125 * Algebraic Simplifications::
22126 * Unsafe Simplifications::
22127 * Simplification of Units::
22130 @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
22131 @subsection Default Simplifications
22134 @cindex Default simplifications
22135 This section describes the ``default simplifications,'' those which are
22136 normally applied to all results. For example, if you enter the variable
22137 @expr{x} on the stack twice and push @kbd{+}, Calc's default
22138 simplifications automatically change @expr{x + x} to @expr{2 x}.
22140 The @kbd{m O} command turns off the default simplifications, so that
22141 @expr{x + x} will remain in this form unless you give an explicit
22142 ``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic
22143 Manipulation}. The @kbd{m D} command turns the default simplifications
22146 The most basic default simplification is the evaluation of functions.
22147 For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@t{sqrt}(9)}
22148 is evaluated to @expr{3}. Evaluation does not occur if the arguments
22149 to a function are somehow of the wrong type @expr{@t{tan}([2,3,4])}),
22150 range (@expr{@t{tan}(90)}), or number (@expr{@t{tan}(3,5)}),
22151 or if the function name is not recognized (@expr{@t{f}(5)}), or if
22152 Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation
22153 (@expr{@t{sqrt}(2)}).
22155 Calc simplifies (evaluates) the arguments to a function before it
22156 simplifies the function itself. Thus @expr{@t{sqrt}(5+4)} is
22157 simplified to @expr{@t{sqrt}(9)} before the @code{sqrt} function
22158 itself is applied. There are very few exceptions to this rule:
22159 @code{quote}, @code{lambda}, and @code{condition} (the @code{::}
22160 operator) do not evaluate their arguments, @code{if} (the @code{? :}
22161 operator) does not evaluate all of its arguments, and @code{evalto}
22162 does not evaluate its lefthand argument.
22164 Most commands apply the default simplifications to all arguments they
22165 take from the stack, perform a particular operation, then simplify
22166 the result before pushing it back on the stack. In the common special
22167 case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}],
22168 the arguments are simply popped from the stack and collected into a
22169 suitable function call, which is then simplified (the arguments being
22170 simplified first as part of the process, as described above).
22172 The default simplifications are too numerous to describe completely
22173 here, but this section will describe the ones that apply to the
22174 major arithmetic operators. This list will be rather technical in
22175 nature, and will probably be interesting to you only if you are
22176 a serious user of Calc's algebra facilities.
22182 As well as the simplifications described here, if you have stored
22183 any rewrite rules in the variable @code{EvalRules} then these rules
22184 will also be applied before any built-in default simplifications.
22185 @xref{Automatic Rewrites}, for details.
22191 And now, on with the default simplifications:
22193 Arithmetic operators like @kbd{+} and @kbd{*} always take two
22194 arguments in Calc's internal form. Sums and products of three or
22195 more terms are arranged by the associative law of algebra into
22196 a left-associative form for sums, @expr{((a + b) + c) + d}, and
22197 a right-associative form for products, @expr{a * (b * (c * d))}.
22198 Formulas like @expr{(a + b) + (c + d)} are rearranged to
22199 left-associative form, though this rarely matters since Calc's
22200 algebra commands are designed to hide the inner structure of
22201 sums and products as much as possible. Sums and products in
22202 their proper associative form will be written without parentheses
22203 in the examples below.
22205 Sums and products are @emph{not} rearranged according to the
22206 commutative law (@expr{a + b} to @expr{b + a}) except in a few
22207 special cases described below. Some algebra programs always
22208 rearrange terms into a canonical order, which enables them to
22209 see that @expr{a b + b a} can be simplified to @expr{2 a b}.
22210 Calc assumes you have put the terms into the order you want
22211 and generally leaves that order alone, with the consequence
22212 that formulas like the above will only be simplified if you
22213 explicitly give the @kbd{a s} command. @xref{Algebraic
22216 Differences @expr{a - b} are treated like sums @expr{a + (-b)}
22217 for purposes of simplification; one of the default simplifications
22218 is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b}
22219 represents a ``negative-looking'' term, into @expr{a - b} form.
22220 ``Negative-looking'' means negative numbers, negated formulas like
22221 @expr{-x}, and products or quotients in which either term is
22224 Other simplifications involving negation are @expr{-(-x)} to @expr{x};
22225 @expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is
22226 negative-looking, simplified by negating that term, or else where
22227 @expr{a} or @expr{b} is any number, by negating that number;
22228 @expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}.
22229 (This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only
22230 cases where the order of terms in a sum is changed by the default
22233 The distributive law is used to simplify sums in some cases:
22234 @expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents
22235 a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x})
22236 and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or
22237 @kbd{j M} commands to merge sums with non-numeric coefficients
22238 using the distributive law.
22240 The distributive law is only used for sums of two terms, or
22241 for adjacent terms in a larger sum. Thus @expr{a + b + b + c}
22242 is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b}
22243 is not simplified. The reason is that comparing all terms of a
22244 sum with one another would require time proportional to the
22245 square of the number of terms; Calc relegates potentially slow
22246 operations like this to commands that have to be invoked
22247 explicitly, like @kbd{a s}.
22249 Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}.
22250 A consequence of the above rules is that @expr{0 - a} is simplified
22257 The products @expr{1 a} and @expr{a 1} are simplified to @expr{a};
22258 @expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a};
22259 @expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that
22260 in Matrix mode where @expr{a} is not provably scalar the result
22261 is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is
22262 infinite the result is @samp{nan}.
22264 Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)},
22265 where this occurs for negated formulas but not for regular negative
22268 Products are commuted only to move numbers to the front:
22269 @expr{a b 2} is commuted to @expr{2 a b}.
22271 The product @expr{a (b + c)} is distributed over the sum only if
22272 @expr{a} and at least one of @expr{b} and @expr{c} are numbers:
22273 @expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula
22274 @expr{(-a) (b - c)}, where @expr{-a} is a negative number, is
22275 rewritten to @expr{a (c - b)}.
22277 The distributive law of products and powers is used for adjacent
22278 terms of the product: @expr{x^a x^b} goes to
22279 @texline @math{x^{a+b}}
22280 @infoline @expr{x^(a+b)}
22281 where @expr{a} is a number, or an implicit 1 (as in @expr{x}),
22282 or the implicit one-half of @expr{@t{sqrt}(x)}, and similarly for
22283 @expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt}
22284 if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively.
22285 If the sum of the powers is zero, the product is simplified to
22286 @expr{1} or to @samp{idn(1)} if Matrix mode is enabled.
22288 The product of a negative power times anything but another negative
22289 power is changed to use division:
22290 @texline @math{x^{-2} y}
22291 @infoline @expr{x^(-2) y}
22292 goes to @expr{y / x^2} unless Matrix mode is
22293 in effect and neither @expr{x} nor @expr{y} are scalar (in which
22294 case it is considered unsafe to rearrange the order of the terms).
22296 Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also
22297 @expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode.
22303 Simplifications for quotients are analogous to those for products.
22304 The quotient @expr{0 / x} is simplified to @expr{0}, with the same
22305 exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1}
22306 and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x},
22309 The quotient @expr{x / 0} is left unsimplified or changed to an
22310 infinite quantity, as directed by the current infinite mode.
22311 @xref{Infinite Mode}.
22314 @texline @math{a / b^{-c}}
22315 @infoline @expr{a / b^(-c)}
22316 is changed to @expr{a b^c}, where @expr{-c} is any negative-looking
22317 power. Also, @expr{1 / b^c} is changed to
22318 @texline @math{b^{-c}}
22319 @infoline @expr{b^(-c)}
22320 for any power @expr{c}.
22322 Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)};
22323 @expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)}
22324 goes to @expr{(a c) / b} unless Matrix mode prevents this
22325 rearrangement. Similarly, @expr{a / (b:c)} is simplified to
22326 @expr{(c:b) a} for any fraction @expr{b:c}.
22328 The distributive law is applied to @expr{(a + b) / c} only if
22329 @expr{c} and at least one of @expr{a} and @expr{b} are numbers.
22330 Quotients of powers and square roots are distributed just as
22331 described for multiplication.
22333 Quotients of products cancel only in the leading terms of the
22334 numerator and denominator. In other words, @expr{a x b / a y b}
22335 is cancelled to @expr{x b / y b} but not to @expr{x / y}. Once
22336 again this is because full cancellation can be slow; use @kbd{a s}
22337 to cancel all terms of the quotient.
22339 Quotients of negative-looking values are simplified according
22340 to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)}
22341 to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}.
22347 The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)}
22348 in Matrix mode. The formula @expr{0^x} is simplified to @expr{0}
22349 unless @expr{x} is a negative number or complex number, in which
22350 case the result is an infinity or an unsimplified formula according
22351 to the current infinite mode. Note that @expr{0^0} is an
22352 indeterminate form, as evidenced by the fact that the simplifications
22353 for @expr{x^0} and @expr{0^x} conflict when @expr{x=0}.
22355 Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c}
22356 are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c}
22357 is an integer, or if either @expr{a} or @expr{b} are nonnegative
22358 real numbers. Powers of powers @expr{(a^b)^c} are simplified to
22359 @texline @math{a^{b c}}
22360 @infoline @expr{a^(b c)}
22361 only when @expr{c} is an integer and @expr{b c} also
22362 evaluates to an integer. Without these restrictions these simplifications
22363 would not be safe because of problems with principal values.
22365 @texline @math{((-3)^{1/2})^2}
22366 @infoline @expr{((-3)^1:2)^2}
22367 is safe to simplify, but
22368 @texline @math{((-3)^2)^{1/2}}
22369 @infoline @expr{((-3)^2)^1:2}
22370 is not.) @xref{Declarations}, for ways to inform Calc that your
22371 variables satisfy these requirements.
22373 As a special case of this rule, @expr{@t{sqrt}(x)^n} is simplified to
22374 @texline @math{x^{n/2}}
22375 @infoline @expr{x^(n/2)}
22376 only for even integers @expr{n}.
22378 If @expr{a} is known to be real, @expr{b} is an even integer, and
22379 @expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is
22380 simplified to @expr{@t{abs}(a^(b c))}.
22382 Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an
22383 even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer,
22384 for any negative-looking expression @expr{-a}.
22386 Square roots @expr{@t{sqrt}(x)} generally act like one-half powers
22387 @texline @math{x^{1:2}}
22388 @infoline @expr{x^1:2}
22389 for the purposes of the above-listed simplifications.
22392 @texline @math{1 / x^{1:2}}
22393 @infoline @expr{1 / x^1:2}
22395 @texline @math{x^{-1:2}},
22396 @infoline @expr{x^(-1:2)},
22397 but @expr{1 / @t{sqrt}(x)} is left alone.
22403 Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
22404 following rules: @expr{@t{idn}(a) + b} to @expr{a + b} if @expr{b}
22405 is provably scalar, or expanded out if @expr{b} is a matrix;
22406 @expr{@t{idn}(a) + @t{idn}(b)} to @expr{@t{idn}(a + b)};
22407 @expr{-@t{idn}(a)} to @expr{@t{idn}(-a)}; @expr{a @t{idn}(b)} to
22408 @expr{@t{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b}
22409 if @expr{a} is provably non-scalar; @expr{@t{idn}(a) @t{idn}(b)} to
22410 @expr{@t{idn}(a b)}; analogous simplifications for quotients involving
22411 @code{idn}; and @expr{@t{idn}(a)^n} to @expr{@t{idn}(a^n)} where
22412 @expr{n} is an integer.
22418 The @code{floor} function and other integer truncation functions
22419 vanish if the argument is provably integer-valued, so that
22420 @expr{@t{floor}(@t{round}(x))} simplifies to @expr{@t{round}(x)}.
22421 Also, combinations of @code{float}, @code{floor} and its friends,
22422 and @code{ffloor} and its friends, are simplified in appropriate
22423 ways. @xref{Integer Truncation}.
22425 The expression @expr{@t{abs}(-x)} changes to @expr{@t{abs}(x)}.
22426 The expression @expr{@t{abs}(@t{abs}(x))} changes to
22427 @expr{@t{abs}(x)}; in fact, @expr{@t{abs}(x)} changes to @expr{x} or
22428 @expr{-x} if @expr{x} is provably nonnegative or nonpositive
22429 (@pxref{Declarations}).
22431 While most functions do not recognize the variable @code{i} as an
22432 imaginary number, the @code{arg} function does handle the two cases
22433 @expr{@t{arg}(@t{i})} and @expr{@t{arg}(-@t{i})} just for convenience.
22435 The expression @expr{@t{conj}(@t{conj}(x))} simplifies to @expr{x}.
22436 Various other expressions involving @code{conj}, @code{re}, and
22437 @code{im} are simplified, especially if some of the arguments are
22438 provably real or involve the constant @code{i}. For example,
22439 @expr{@t{conj}(a + b i)} is changed to
22440 @expr{@t{conj}(a) - @t{conj}(b) i}, or to @expr{a - b i} if @expr{a}
22441 and @expr{b} are known to be real.
22443 Functions like @code{sin} and @code{arctan} generally don't have
22444 any default simplifications beyond simply evaluating the functions
22445 for suitable numeric arguments and infinity. The @kbd{a s} command
22446 described in the next section does provide some simplifications for
22447 these functions, though.
22449 One important simplification that does occur is that
22450 @expr{@t{ln}(@t{e})} is simplified to 1, and @expr{@t{ln}(@t{e}^x)} is
22451 simplified to @expr{x} for any @expr{x}. This occurs even if you have
22452 stored a different value in the Calc variable @samp{e}; but this would
22453 be a bad idea in any case if you were also using natural logarithms!
22455 Among the logical functions, @t{(@var{a} <= @var{b})} changes to
22456 @t{@var{a} > @var{b}} and so on. Equations and inequalities where both sides
22457 are either negative-looking or zero are simplified by negating both sides
22458 and reversing the inequality. While it might seem reasonable to simplify
22459 @expr{!!x} to @expr{x}, this would not be valid in general because
22460 @expr{!!2} is 1, not 2.
22462 Most other Calc functions have few if any default simplifications
22463 defined, aside of course from evaluation when the arguments are
22466 @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas
22467 @subsection Algebraic Simplifications
22470 @cindex Algebraic simplifications
22471 The @kbd{a s} command makes simplifications that may be too slow to
22472 do all the time, or that may not be desirable all of the time.
22473 If you find these simplifications are worthwhile, you can type
22474 @kbd{m A} to have Calc apply them automatically.
22476 This section describes all simplifications that are performed by
22477 the @kbd{a s} command. Note that these occur in addition to the
22478 default simplifications; even if the default simplifications have
22479 been turned off by an @kbd{m O} command, @kbd{a s} will turn them
22480 back on temporarily while it simplifies the formula.
22482 There is a variable, @code{AlgSimpRules}, in which you can put rewrites
22483 to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules},
22484 but without the special restrictions. Basically, the simplifier does
22485 @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
22486 expression being simplified, then it traverses the expression applying
22487 the built-in rules described below. If the result is different from
22488 the original expression, the process repeats with the default
22489 simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
22490 then the built-in simplifications, and so on.
22496 Sums are simplified in two ways. Constant terms are commuted to the
22497 end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}.
22498 The only exception is that a constant will not be commuted away
22499 from the first position of a difference, i.e., @expr{2 - x} is not
22500 commuted to @expr{-x + 2}.
22502 Also, terms of sums are combined by the distributive law, as in
22503 @expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for
22504 adjacent terms, but @kbd{a s} compares all pairs of terms including
22511 Products are sorted into a canonical order using the commutative
22512 law. For example, @expr{b c a} is commuted to @expr{a b c}.
22513 This allows easier comparison of products; for example, the default
22514 simplifications will not change @expr{x y + y x} to @expr{2 x y},
22515 but @kbd{a s} will; it first rewrites the sum to @expr{x y + x y},
22516 and then the default simplifications are able to recognize a sum
22517 of identical terms.
22519 The canonical ordering used to sort terms of products has the
22520 property that real-valued numbers, interval forms and infinities
22521 come first, and are sorted into increasing order. The @kbd{V S}
22522 command uses the same ordering when sorting a vector.
22524 Sorting of terms of products is inhibited when Matrix mode is
22525 turned on; in this case, Calc will never exchange the order of
22526 two terms unless it knows at least one of the terms is a scalar.
22528 Products of powers are distributed by comparing all pairs of
22529 terms, using the same method that the default simplifications
22530 use for adjacent terms of products.
22532 Even though sums are not sorted, the commutative law is still
22533 taken into account when terms of a product are being compared.
22534 Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}.
22535 A subtle point is that @expr{(x - y) (y - x)} will @emph{not}
22536 be simplified to @expr{-(x - y)^2}; Calc does not notice that
22537 one term can be written as a constant times the other, even if
22538 that constant is @mathit{-1}.
22540 A fraction times any expression, @expr{(a:b) x}, is changed to
22541 a quotient involving integers: @expr{a x / b}. This is not
22542 done for floating-point numbers like @expr{0.5}, however. This
22543 is one reason why you may find it convenient to turn Fraction mode
22544 on while doing algebra; @pxref{Fraction Mode}.
22550 Quotients are simplified by comparing all terms in the numerator
22551 with all terms in the denominator for possible cancellation using
22552 the distributive law. For example, @expr{a x^2 b / c x^3 d} will
22553 cancel @expr{x^2} from both sides to get @expr{a b / c x d}.
22554 (The terms in the denominator will then be rearranged to @expr{c d x}
22555 as described above.) If there is any common integer or fractional
22556 factor in the numerator and denominator, it is cancelled out;
22557 for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}.
22559 Non-constant common factors are not found even by @kbd{a s}. To
22560 cancel the factor @expr{a} in @expr{(a x + a) / a^2} you could first
22561 use @kbd{j M} on the product @expr{a x} to Merge the numerator to
22562 @expr{a (1+x)}, which can then be simplified successfully.
22568 Integer powers of the variable @code{i} are simplified according
22569 to the identity @expr{i^2 = -1}. If you store a new value other
22570 than the complex number @expr{(0,1)} in @code{i}, this simplification
22571 will no longer occur. This is done by @kbd{a s} instead of by default
22572 in case someone (unwisely) uses the name @code{i} for a variable
22573 unrelated to complex numbers; it would be unfortunate if Calc
22574 quietly and automatically changed this formula for reasons the
22575 user might not have been thinking of.
22577 Square roots of integer or rational arguments are simplified in
22578 several ways. (Note that these will be left unevaluated only in
22579 Symbolic mode.) First, square integer or rational factors are
22580 pulled out so that @expr{@t{sqrt}(8)} is rewritten as
22581 @texline @math{2\,\t{sqrt}(2)}.
22582 @infoline @expr{2 sqrt(2)}.
22583 Conceptually speaking this implies factoring the argument into primes
22584 and moving pairs of primes out of the square root, but for reasons of
22585 efficiency Calc only looks for primes up to 29.
22587 Square roots in the denominator of a quotient are moved to the
22588 numerator: @expr{1 / @t{sqrt}(3)} changes to @expr{@t{sqrt}(3) / 3}.
22589 The same effect occurs for the square root of a fraction:
22590 @expr{@t{sqrt}(2:3)} changes to @expr{@t{sqrt}(6) / 3}.
22596 The @code{%} (modulo) operator is simplified in several ways
22597 when the modulus @expr{M} is a positive real number. First, if
22598 the argument is of the form @expr{x + n} for some real number
22599 @expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For
22600 example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
22602 If the argument is multiplied by a constant, and this constant
22603 has a common integer divisor with the modulus, then this factor is
22604 cancelled out. For example, @samp{12 x % 15} is changed to
22605 @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
22606 is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
22607 not seem ``simpler,'' they allow Calc to discover useful information
22608 about modulo forms in the presence of declarations.
22610 If the modulus is 1, then Calc can use @code{int} declarations to
22611 evaluate the expression. For example, the idiom @samp{x % 2} is
22612 often used to check whether a number is odd or even. As described
22613 above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
22614 @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
22615 can simplify these to 0 and 1 (respectively) if @code{n} has been
22616 declared to be an integer.
22622 Trigonometric functions are simplified in several ways. First,
22623 @expr{@t{sin}(@t{arcsin}(x))} is simplified to @expr{x}, and
22624 similarly for @code{cos} and @code{tan}. If the argument to
22625 @code{sin} is negative-looking, it is simplified to
22626 @expr{-@t{sin}(x),}, and similarly for @code{cos} and @code{tan}.
22627 Finally, certain special values of the argument are recognized;
22628 @pxref{Trigonometric and Hyperbolic Functions}.
22630 Trigonometric functions of inverses of different trigonometric
22631 functions can also be simplified, as in @expr{@t{sin}(@t{arccos}(x))}
22632 to @expr{@t{sqrt}(1 - x^2)}.
22634 Hyperbolic functions of their inverses and of negative-looking
22635 arguments are also handled, as are exponentials of inverse
22636 hyperbolic functions.
22638 No simplifications for inverse trigonometric and hyperbolic
22639 functions are known, except for negative arguments of @code{arcsin},
22640 @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that
22641 @expr{@t{arcsin}(@t{sin}(x))} can @emph{not} safely change to
22642 @expr{x}, since this only correct within an integer multiple of
22643 @texline @math{2 \pi}
22644 @infoline @expr{2 pi}
22645 radians or 360 degrees. However, @expr{@t{arcsinh}(@t{sinh}(x))} is
22646 simplified to @expr{x} if @expr{x} is known to be real.
22648 Several simplifications that apply to logarithms and exponentials
22649 are that @expr{@t{exp}(@t{ln}(x))},
22650 @texline @t{e}@math{^{\ln(x)}},
22651 @infoline @expr{e^@t{ln}(x)},
22653 @texline @math{10^{{\rm log10}(x)}}
22654 @infoline @expr{10^@t{log10}(x)}
22655 all reduce to @expr{x}. Also, @expr{@t{ln}(@t{exp}(x))}, etc., can
22656 reduce to @expr{x} if @expr{x} is provably real. The form
22657 @expr{@t{exp}(x)^y} is simplified to @expr{@t{exp}(x y)}. If @expr{x}
22658 is a suitable multiple of
22659 @texline @math{\pi i}
22660 @infoline @expr{pi i}
22661 (as described above for the trigonometric functions), then
22662 @expr{@t{exp}(x)} or @expr{e^x} will be expanded. Finally,
22663 @expr{@t{ln}(x)} is simplified to a form involving @code{pi} and
22664 @code{i} where @expr{x} is provably negative, positive imaginary, or
22665 negative imaginary.
22667 The error functions @code{erf} and @code{erfc} are simplified when
22668 their arguments are negative-looking or are calls to the @code{conj}
22675 Equations and inequalities are simplified by cancelling factors
22676 of products, quotients, or sums on both sides. Inequalities
22677 change sign if a negative multiplicative factor is cancelled.
22678 Non-constant multiplicative factors as in @expr{a b = a c} are
22679 cancelled from equations only if they are provably nonzero (generally
22680 because they were declared so; @pxref{Declarations}). Factors
22681 are cancelled from inequalities only if they are nonzero and their
22684 Simplification also replaces an equation or inequality with
22685 1 or 0 (``true'' or ``false'') if it can through the use of
22686 declarations. If @expr{x} is declared to be an integer greater
22687 than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are
22688 all simplified to 0, but @expr{x > 3} is simplified to 1.
22689 By a similar analysis, @expr{abs(x) >= 0} is simplified to 1,
22690 as is @expr{x^2 >= 0} if @expr{x} is known to be real.
22692 @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
22693 @subsection ``Unsafe'' Simplifications
22696 @cindex Unsafe simplifications
22697 @cindex Extended simplification
22699 @pindex calc-simplify-extended
22701 @mindex esimpl@idots
22704 The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command
22706 except that it applies some additional simplifications which are not
22707 ``safe'' in all cases. Use this only if you know the values in your
22708 formula lie in the restricted ranges for which these simplifications
22709 are valid. The symbolic integrator uses @kbd{a e};
22710 one effect of this is that the integrator's results must be used with
22711 caution. Where an integral table will often attach conditions like
22712 ``for positive @expr{a} only,'' Calc (like most other symbolic
22713 integration programs) will simply produce an unqualified result.
22715 Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
22716 to type @kbd{C-u -3 a v}, which does extended simplification only
22717 on the top level of the formula without affecting the sub-formulas.
22718 In fact, @kbd{C-u -3 j v} allows you to target extended simplification
22719 to any specific part of a formula.
22721 The variable @code{ExtSimpRules} contains rewrites to be applied by
22722 the @kbd{a e} command. These are applied in addition to
22723 @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules}
22724 step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
22726 Following is a complete list of ``unsafe'' simplifications performed
22733 Inverse trigonometric or hyperbolic functions, called with their
22734 corresponding non-inverse functions as arguments, are simplified
22735 by @kbd{a e}. For example, @expr{@t{arcsin}(@t{sin}(x))} changes
22736 to @expr{x}. Also, @expr{@t{arcsin}(@t{cos}(x))} and
22737 @expr{@t{arccos}(@t{sin}(x))} both change to @expr{@t{pi}/2 - x}.
22738 These simplifications are unsafe because they are valid only for
22739 values of @expr{x} in a certain range; outside that range, values
22740 are folded down to the 360-degree range that the inverse trigonometric
22741 functions always produce.
22743 Powers of powers @expr{(x^a)^b} are simplified to
22744 @texline @math{x^{a b}}
22745 @infoline @expr{x^(a b)}
22746 for all @expr{a} and @expr{b}. These results will be valid only
22747 in a restricted range of @expr{x}; for example, in
22748 @texline @math{(x^2)^{1:2}}
22749 @infoline @expr{(x^2)^1:2}
22750 the powers cancel to get @expr{x}, which is valid for positive values
22751 of @expr{x} but not for negative or complex values.
22753 Similarly, @expr{@t{sqrt}(x^a)} and @expr{@t{sqrt}(x)^a} are both
22754 simplified (possibly unsafely) to
22755 @texline @math{x^{a/2}}.
22756 @infoline @expr{x^(a/2)}.
22758 Forms like @expr{@t{sqrt}(1 - sin(x)^2)} are simplified to, e.g.,
22759 @expr{@t{cos}(x)}. Calc has identities of this sort for @code{sin},
22760 @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
22762 Arguments of square roots are partially factored to look for
22763 squared terms that can be extracted. For example,
22764 @expr{@t{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to
22765 @expr{a b @t{sqrt}(a+b)}.
22767 The simplifications of @expr{@t{ln}(@t{exp}(x))},
22768 @expr{@t{ln}(@t{e}^x)}, and @expr{@t{log10}(10^x)} to @expr{x} are also
22769 unsafe because of problems with principal values (although these
22770 simplifications are safe if @expr{x} is known to be real).
22772 Common factors are cancelled from products on both sides of an
22773 equation, even if those factors may be zero: @expr{a x / b x}
22774 to @expr{a / b}. Such factors are never cancelled from
22775 inequalities: Even @kbd{a e} is not bold enough to reduce
22776 @expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending
22777 on whether you believe @expr{x} is positive or negative).
22778 The @kbd{a M /} command can be used to divide a factor out of
22779 both sides of an inequality.
22781 @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
22782 @subsection Simplification of Units
22785 The simplifications described in this section are applied by the
22786 @kbd{u s} (@code{calc-simplify-units}) command. These are in addition
22787 to the regular @kbd{a s} (but not @kbd{a e}) simplifications described
22788 earlier. @xref{Basic Operations on Units}.
22790 The variable @code{UnitSimpRules} contains rewrites to be applied by
22791 the @kbd{u s} command. These are applied in addition to @code{EvalRules}
22792 and @code{AlgSimpRules}.
22794 Scalar mode is automatically put into effect when simplifying units.
22795 @xref{Matrix Mode}.
22797 Sums @expr{a + b} involving units are simplified by extracting the
22798 units of @expr{a} as if by the @kbd{u x} command (call the result
22799 @expr{u_a}), then simplifying the expression @expr{b / u_a}
22800 using @kbd{u b} and @kbd{u s}. If the result has units then the sum
22801 is inconsistent and is left alone. Otherwise, it is rewritten
22802 in terms of the units @expr{u_a}.
22804 If units auto-ranging mode is enabled, products or quotients in
22805 which the first argument is a number which is out of range for the
22806 leading unit are modified accordingly.
22808 When cancelling and combining units in products and quotients,
22809 Calc accounts for unit names that differ only in the prefix letter.
22810 For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
22811 However, compatible but different units like @code{ft} and @code{in}
22812 are not combined in this way.
22814 Quotients @expr{a / b} are simplified in three additional ways. First,
22815 if @expr{b} is a number or a product beginning with a number, Calc
22816 computes the reciprocal of this number and moves it to the numerator.
22818 Second, for each pair of unit names from the numerator and denominator
22819 of a quotient, if the units are compatible (e.g., they are both
22820 units of area) then they are replaced by the ratio between those
22821 units. For example, in @samp{3 s in N / kg cm} the units
22822 @samp{in / cm} will be replaced by @expr{2.54}.
22824 Third, if the units in the quotient exactly cancel out, so that
22825 a @kbd{u b} command on the quotient would produce a dimensionless
22826 number for an answer, then the quotient simplifies to that number.
22828 For powers and square roots, the ``unsafe'' simplifications
22829 @expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c},
22830 and @expr{(a^b)^c} to
22831 @texline @math{a^{b c}}
22832 @infoline @expr{a^(b c)}
22833 are done if the powers are real numbers. (These are safe in the context
22834 of units because all numbers involved can reasonably be assumed to be
22837 Also, if a unit name is raised to a fractional power, and the
22838 base units in that unit name all occur to powers which are a
22839 multiple of the denominator of the power, then the unit name
22840 is expanded out into its base units, which can then be simplified
22841 according to the previous paragraph. For example, @samp{acre^1.5}
22842 is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre}
22843 is defined in terms of @samp{m^2}, and that the 2 in the power of
22844 @code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is
22845 replaced by approximately
22846 @texline @math{(4046 m^2)^{1.5}}
22847 @infoline @expr{(4046 m^2)^1.5},
22848 which is then changed to
22849 @texline @math{4046^{1.5} \, (m^2)^{1.5}},
22850 @infoline @expr{4046^1.5 (m^2)^1.5},
22851 then to @expr{257440 m^3}.
22853 The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
22854 as well as @code{floor} and the other integer truncation functions,
22855 applied to unit names or products or quotients involving units, are
22856 simplified. For example, @samp{round(1.6 in)} is changed to
22857 @samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
22858 and the righthand term simplifies to @code{in}.
22860 The functions @code{sin}, @code{cos}, and @code{tan} with arguments
22861 that have angular units like @code{rad} or @code{arcmin} are
22862 simplified by converting to base units (radians), then evaluating
22863 with the angular mode temporarily set to radians.
22865 @node Polynomials, Calculus, Simplifying Formulas, Algebra
22866 @section Polynomials
22868 A @dfn{polynomial} is a sum of terms which are coefficients times
22869 various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4}
22870 is a polynomial in @expr{x}. Some formulas can be considered
22871 polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2}
22872 is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients
22873 are often numbers, but they may in general be any formulas not
22874 involving the base variable.
22877 @pindex calc-factor
22879 The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
22880 polynomial into a product of terms. For example, the polynomial
22881 @expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another
22882 example, @expr{a c + b d + b c + a d} is factored into the product
22883 @expr{(a + b) (c + d)}.
22885 Calc currently has three algorithms for factoring. Formulas which are
22886 linear in several variables, such as the second example above, are
22887 merged according to the distributive law. Formulas which are
22888 polynomials in a single variable, with constant integer or fractional
22889 coefficients, are factored into irreducible linear and/or quadratic
22890 terms. The first example above factors into three linear terms
22891 (@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas
22892 which do not fit the above criteria are handled by the algebraic
22895 Calc's polynomial factorization algorithm works by using the general
22896 root-finding command (@w{@kbd{a P}}) to solve for the roots of the
22897 polynomial. It then looks for roots which are rational numbers
22898 or complex-conjugate pairs, and converts these into linear and
22899 quadratic terms, respectively. Because it uses floating-point
22900 arithmetic, it may be unable to find terms that involve large
22901 integers (whose number of digits approaches the current precision).
22902 Also, irreducible factors of degree higher than quadratic are not
22903 found, and polynomials in more than one variable are not treated.
22904 (A more robust factorization algorithm may be included in a future
22907 @vindex FactorRules
22919 The rewrite-based factorization method uses rules stored in the variable
22920 @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the
22921 operation of rewrite rules. The default @code{FactorRules} are able
22922 to factor quadratic forms symbolically into two linear terms,
22923 @expr{(a x + b) (c x + d)}. You can edit these rules to include other
22924 cases if you wish. To use the rules, Calc builds the formula
22925 @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
22926 base variable and @code{a}, @code{b}, etc., are polynomial coefficients
22927 (which may be numbers or formulas). The constant term is written first,
22928 i.e., in the @code{a} position. When the rules complete, they should have
22929 changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
22930 where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
22931 Calc then multiplies these terms together to get the complete
22932 factored form of the polynomial. If the rules do not change the
22933 @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
22934 polynomial alone on the assumption that it is unfactorable. (Note that
22935 the function names @code{thecoefs} and @code{thefactors} are used only
22936 as placeholders; there are no actual Calc functions by those names.)
22940 The @kbd{H a f} [@code{factors}] command also factors a polynomial,
22941 but it returns a list of factors instead of an expression which is the
22942 product of the factors. Each factor is represented by a sub-vector
22943 of the factor, and the power with which it appears. For example,
22944 @expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2}
22945 in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
22946 If there is an overall numeric factor, it always comes first in the list.
22947 The functions @code{factor} and @code{factors} allow a second argument
22948 when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with
22949 respect to the specific variable @expr{v}. The default is to factor with
22950 respect to all the variables that appear in @expr{x}.
22953 @pindex calc-collect
22955 The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
22957 polynomial in a given variable, ordered in decreasing powers of that
22958 variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on
22959 the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)},
22960 and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}.
22961 The polynomial will be expanded out using the distributive law as
22962 necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces
22963 @expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will
22966 The ``variable'' you specify at the prompt can actually be any
22967 expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
22968 by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears
22969 in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
22970 treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
22973 @pindex calc-expand
22975 The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
22976 expression by applying the distributive law everywhere. It applies to
22977 products, quotients, and powers involving sums. By default, it fully
22978 distributes all parts of the expression. With a numeric prefix argument,
22979 the distributive law is applied only the specified number of times, then
22980 the partially expanded expression is left on the stack.
22982 The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use
22983 @kbd{a x} if you want to expand all products of sums in your formula.
22984 Use @kbd{j D} if you want to expand a particular specified term of
22985 the formula. There is an exactly analogous correspondence between
22986 @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands
22987 also know many other kinds of expansions, such as
22988 @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
22991 Calc's automatic simplifications will sometimes reverse a partial
22992 expansion. For example, the first step in expanding @expr{(x+1)^3} is
22993 to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries
22994 to put this formula onto the stack, though, Calc will automatically
22995 simplify it back to @expr{(x+1)^3} form. The solution is to turn
22996 simplification off first (@pxref{Simplification Modes}), or to run
22997 @kbd{a x} without a numeric prefix argument so that it expands all
22998 the way in one step.
23003 The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
23004 rational function by partial fractions. A rational function is the
23005 quotient of two polynomials; @code{apart} pulls this apart into a
23006 sum of rational functions with simple denominators. In algebraic
23007 notation, the @code{apart} function allows a second argument that
23008 specifies which variable to use as the ``base''; by default, Calc
23009 chooses the base variable automatically.
23012 @pindex calc-normalize-rat
23014 The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
23015 attempts to arrange a formula into a quotient of two polynomials.
23016 For example, given @expr{1 + (a + b/c) / d}, the result would be
23017 @expr{(b + a c + c d) / c d}. The quotient is reduced, so that
23018 @kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
23019 out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}.
23022 @pindex calc-poly-div
23024 The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
23025 two polynomials @expr{u} and @expr{v}, yielding a new polynomial
23026 @expr{q}. If several variables occur in the inputs, the inputs are
23027 considered multivariate polynomials. (Calc divides by the variable
23028 with the largest power in @expr{u} first, or, in the case of equal
23029 powers, chooses the variables in alphabetical order.) For example,
23030 dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}.
23031 The remainder from the division, if any, is reported at the bottom
23032 of the screen and is also placed in the Trail along with the quotient.
23034 Using @code{pdiv} in algebraic notation, you can specify the particular
23035 variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
23036 If @code{pdiv} is given only two arguments (as is always the case with
23037 the @kbd{a \} command), then it does a multivariate division as outlined
23041 @pindex calc-poly-rem
23043 The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
23044 two polynomials and keeps the remainder @expr{r}. The quotient
23045 @expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the
23046 results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}.
23047 (This is analogous to plain @kbd{\} and @kbd{%}, which compute the
23048 integer quotient and remainder from dividing two numbers.)
23052 @pindex calc-poly-div-rem
23055 The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
23056 divides two polynomials and reports both the quotient and the
23057 remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}]
23058 command divides two polynomials and constructs the formula
23059 @expr{q + r/b} on the stack. (Naturally if the remainder is zero,
23060 this will immediately simplify to @expr{q}.)
23063 @pindex calc-poly-gcd
23065 The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
23066 the greatest common divisor of two polynomials. (The GCD actually
23067 is unique only to within a constant multiplier; Calc attempts to
23068 choose a GCD which will be unsurprising.) For example, the @kbd{a n}
23069 command uses @kbd{a g} to take the GCD of the numerator and denominator
23070 of a quotient, then divides each by the result using @kbd{a \}. (The
23071 definition of GCD ensures that this division can take place without
23072 leaving a remainder.)
23074 While the polynomials used in operations like @kbd{a /} and @kbd{a g}
23075 often have integer coefficients, this is not required. Calc can also
23076 deal with polynomials over the rationals or floating-point reals.
23077 Polynomials with modulo-form coefficients are also useful in many
23078 applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
23079 automatically transforms this into a polynomial over the field of
23080 integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
23082 Congratulations and thanks go to Ove Ewerlid
23083 (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
23084 polynomial routines used in the above commands.
23086 @xref{Decomposing Polynomials}, for several useful functions for
23087 extracting the individual coefficients of a polynomial.
23089 @node Calculus, Solving Equations, Polynomials, Algebra
23093 The following calculus commands do not automatically simplify their
23094 inputs or outputs using @code{calc-simplify}. You may find it helps
23095 to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help
23096 to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
23100 * Differentiation::
23102 * Customizing the Integrator::
23103 * Numerical Integration::
23107 @node Differentiation, Integration, Calculus, Calculus
23108 @subsection Differentiation
23113 @pindex calc-derivative
23116 The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
23117 the derivative of the expression on the top of the stack with respect to
23118 some variable, which it will prompt you to enter. Normally, variables
23119 in the formula other than the specified differentiation variable are
23120 considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With
23121 the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
23122 instead, in which derivatives of variables are not reduced to zero
23123 unless those variables are known to be ``constant,'' i.e., independent
23124 of any other variables. (The built-in special variables like @code{pi}
23125 are considered constant, as are variables that have been declared
23126 @code{const}; @pxref{Declarations}.)
23128 With a numeric prefix argument @var{n}, this command computes the
23129 @var{n}th derivative.
23131 When working with trigonometric functions, it is best to switch to
23132 Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)}
23133 in degrees is @samp{(pi/180) cos(x)}, probably not the expected
23136 If you use the @code{deriv} function directly in an algebraic formula,
23137 you can write @samp{deriv(f,x,x0)} which represents the derivative
23138 of @expr{f} with respect to @expr{x}, evaluated at the point
23139 @texline @math{x=x_0}.
23140 @infoline @expr{x=x0}.
23142 If the formula being differentiated contains functions which Calc does
23143 not know, the derivatives of those functions are produced by adding
23144 primes (apostrophe characters). For example, @samp{deriv(f(2x), x)}
23145 produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
23146 derivative of @code{f}.
23148 For functions you have defined with the @kbd{Z F} command, Calc expands
23149 the functions according to their defining formulas unless you have
23150 also defined @code{f'} suitably. For example, suppose we define
23151 @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate
23152 the formula @samp{sinc(2 x)}, the formula will be expanded to
23153 @samp{sin(2 x) / (2 x)} and differentiated. However, if we also
23154 define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
23155 result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}.
23157 For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
23158 to the first argument is written @samp{f'(x,y,z)}; derivatives with
23159 respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
23160 Various higher-order derivatives can be formed in the obvious way, e.g.,
23161 @samp{f'@var{}'(x)} (the second derivative of @code{f}) or
23162 @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
23165 @node Integration, Customizing the Integrator, Differentiation, Calculus
23166 @subsection Integration
23170 @pindex calc-integral
23172 The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
23173 indefinite integral of the expression on the top of the stack with
23174 respect to a variable. The integrator is not guaranteed to work for
23175 all integrable functions, but it is able to integrate several large
23176 classes of formulas. In particular, any polynomial or rational function
23177 (a polynomial divided by a polynomial) is acceptable. (Rational functions
23178 don't have to be in explicit quotient form, however;
23179 @texline @math{x/(1+x^{-2})}
23180 @infoline @expr{x/(1+x^-2)}
23181 is not strictly a quotient of polynomials, but it is equivalent to
23182 @expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving
23183 @expr{x} and @expr{x^2} may appear in rational functions being
23184 integrated. Finally, rational functions involving trigonometric or
23185 hyperbolic functions can be integrated.
23188 If you use the @code{integ} function directly in an algebraic formula,
23189 you can also write @samp{integ(f,x,v)} which expresses the resulting
23190 indefinite integral in terms of variable @code{v} instead of @code{x}.
23191 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23192 integral from @code{a} to @code{b}.
23195 If you use the @code{integ} function directly in an algebraic formula,
23196 you can also write @samp{integ(f,x,v)} which expresses the resulting
23197 indefinite integral in terms of variable @code{v} instead of @code{x}.
23198 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23199 integral $\int_a^b f(x) \, dx$.
23202 Please note that the current implementation of Calc's integrator sometimes
23203 produces results that are significantly more complex than they need to
23204 be. For example, the integral Calc finds for
23205 @texline @math{1/(x+\sqrt{x^2+1})}
23206 @infoline @expr{1/(x+sqrt(x^2+1))}
23207 is several times more complicated than the answer Mathematica
23208 returns for the same input, although the two forms are numerically
23209 equivalent. Also, any indefinite integral should be considered to have
23210 an arbitrary constant of integration added to it, although Calc does not
23211 write an explicit constant of integration in its result. For example,
23212 Calc's solution for
23213 @texline @math{1/(1+\tan x)}
23214 @infoline @expr{1/(1+tan(x))}
23215 differs from the solution given in the @emph{CRC Math Tables} by a
23217 @texline @math{\pi i / 2}
23218 @infoline @expr{pi i / 2},
23219 due to a different choice of constant of integration.
23221 The Calculator remembers all the integrals it has done. If conditions
23222 change in a way that would invalidate the old integrals, say, a switch
23223 from Degrees to Radians mode, then they will be thrown out. If you
23224 suspect this is not happening when it should, use the
23225 @code{calc-flush-caches} command; @pxref{Caches}.
23228 Calc normally will pursue integration by substitution or integration by
23229 parts up to 3 nested times before abandoning an approach as fruitless.
23230 If the integrator is taking too long, you can lower this limit by storing
23231 a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I}
23232 command is a convenient way to edit @code{IntegLimit}.) If this variable
23233 has no stored value or does not contain a nonnegative integer, a limit
23234 of 3 is used. The lower this limit is, the greater the chance that Calc
23235 will be unable to integrate a function it could otherwise handle. Raising
23236 this limit allows the Calculator to solve more integrals, though the time
23237 it takes may grow exponentially. You can monitor the integrator's actions
23238 by creating an Emacs buffer called @code{*Trace*}. If such a buffer
23239 exists, the @kbd{a i} command will write a log of its actions there.
23241 If you want to manipulate integrals in a purely symbolic way, you can
23242 set the integration nesting limit to 0 to prevent all but fast
23243 table-lookup solutions of integrals. You might then wish to define
23244 rewrite rules for integration by parts, various kinds of substitutions,
23245 and so on. @xref{Rewrite Rules}.
23247 @node Customizing the Integrator, Numerical Integration, Integration, Calculus
23248 @subsection Customizing the Integrator
23252 Calc has two built-in rewrite rules called @code{IntegRules} and
23253 @code{IntegAfterRules} which you can edit to define new integration
23254 methods. @xref{Rewrite Rules}. At each step of the integration process,
23255 Calc wraps the current integrand in a call to the fictitious function
23256 @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
23257 integrand and @var{var} is the integration variable. If your rules
23258 rewrite this to be a plain formula (not a call to @code{integtry}), then
23259 Calc will use this formula as the integral of @var{expr}. For example,
23260 the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
23261 integrate a function @code{mysin} that acts like the sine function.
23262 Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
23263 will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has
23264 automatically made various transformations on the integral to allow it
23265 to use your rule; integral tables generally give rules for
23266 @samp{mysin(a x + b)}, but you don't need to use this much generality
23267 in your @code{IntegRules}.
23269 @cindex Exponential integral Ei(x)
23274 As a more serious example, the expression @samp{exp(x)/x} cannot be
23275 integrated in terms of the standard functions, so the ``exponential
23276 integral'' function
23277 @texline @math{{\rm Ei}(x)}
23278 @infoline @expr{Ei(x)}
23279 was invented to describe it.
23280 We can get Calc to do this integral in terms of a made-up @code{Ei}
23281 function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
23282 to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack
23283 and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will
23284 work with Calc's various built-in integration methods (such as
23285 integration by substitution) to solve a variety of other problems
23286 involving @code{Ei}: For example, now Calc will also be able to
23287 integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
23288 and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
23290 Your rule may do further integration by calling @code{integ}. For
23291 example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
23292 to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
23293 Note that @code{integ} was called with only one argument. This notation
23294 is allowed only within @code{IntegRules}; it means ``integrate this
23295 with respect to the same integration variable.'' If Calc is unable
23296 to integrate @code{u}, the integration that invoked @code{IntegRules}
23297 also fails. Thus integrating @samp{twice(f(x))} fails, returning the
23298 unevaluated integral @samp{integ(twice(f(x)), x)}. It is still legal
23299 to call @code{integ} with two or more arguments, however; in this case,
23300 if @code{u} is not integrable, @code{twice} itself will still be
23301 integrated: If the above rule is changed to @samp{... := twice(integ(u,x))},
23302 then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
23304 If a rule instead produces the formula @samp{integsubst(@var{sexpr},
23305 @var{svar})}, either replacing the top-level @code{integtry} call or
23306 nested anywhere inside the expression, then Calc will apply the
23307 substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
23308 integrate the original @var{expr}. For example, the rule
23309 @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
23310 a square root in the integrand, it should attempt the substitution
23311 @samp{u = sqrt(x)}. (This particular rule is unnecessary because
23312 Calc always tries ``obvious'' substitutions where @var{sexpr} actually
23313 appears in the integrand.) The variable @var{svar} may be the same
23314 as the @var{var} that appeared in the call to @code{integtry}, but
23317 When integrating according to an @code{integsubst}, Calc uses the
23318 equation solver to find the inverse of @var{sexpr} (if the integrand
23319 refers to @var{var} anywhere except in subexpressions that exactly
23320 match @var{sexpr}). It uses the differentiator to find the derivative
23321 of @var{sexpr} and/or its inverse (it has two methods that use one
23322 derivative or the other). You can also specify these items by adding
23323 extra arguments to the @code{integsubst} your rules construct; the
23324 general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
23325 @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
23326 written as a function of @var{svar}), and @var{sprime} is the
23327 derivative of @var{sexpr} with respect to @var{svar}. If you don't
23328 specify these things, and Calc is not able to work them out on its
23329 own with the information it knows, then your substitution rule will
23330 work only in very specific, simple cases.
23332 Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
23333 in other words, Calc stops rewriting as soon as any rule in your rule
23334 set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
23335 example above would keep on adding layers of @code{integsubst} calls
23338 @vindex IntegSimpRules
23339 Another set of rules, stored in @code{IntegSimpRules}, are applied
23340 every time the integrator uses @kbd{a s} to simplify an intermediate
23341 result. For example, putting the rule @samp{twice(x) := 2 x} into
23342 @code{IntegSimpRules} would tell Calc to convert the @code{twice}
23343 function into a form it knows whenever integration is attempted.
23345 One more way to influence the integrator is to define a function with
23346 the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's
23347 integrator automatically expands such functions according to their
23348 defining formulas, even if you originally asked for the function to
23349 be left unevaluated for symbolic arguments. (Certain other Calc
23350 systems, such as the differentiator and the equation solver, also
23353 @vindex IntegAfterRules
23354 Sometimes Calc is able to find a solution to your integral, but it
23355 expresses the result in a way that is unnecessarily complicated. If
23356 this happens, you can either use @code{integsubst} as described
23357 above to try to hint at a more direct path to the desired result, or
23358 you can use @code{IntegAfterRules}. This is an extra rule set that
23359 runs after the main integrator returns its result; basically, Calc does
23360 an @kbd{a r IntegAfterRules} on the result before showing it to you.
23361 (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that
23362 to further simplify the result.) For example, Calc's integrator
23363 sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
23364 the default @code{IntegAfterRules} rewrite this into the more readable
23365 form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules},
23366 @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
23367 of times until no further changes are possible. Rewriting by
23368 @code{IntegAfterRules} occurs only after the main integrator has
23369 finished, not at every step as for @code{IntegRules} and
23370 @code{IntegSimpRules}.
23372 @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
23373 @subsection Numerical Integration
23377 @pindex calc-num-integral
23379 If you want a purely numerical answer to an integration problem, you can
23380 use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This
23381 command prompts for an integration variable, a lower limit, and an
23382 upper limit. Except for the integration variable, all other variables
23383 that appear in the integrand formula must have stored values. (A stored
23384 value, if any, for the integration variable itself is ignored.)
23386 Numerical integration works by evaluating your formula at many points in
23387 the specified interval. Calc uses an ``open Romberg'' method; this means
23388 that it does not evaluate the formula actually at the endpoints (so that
23389 it is safe to integrate @samp{sin(x)/x} from zero, for example). Also,
23390 the Romberg method works especially well when the function being
23391 integrated is fairly smooth. If the function is not smooth, Calc will
23392 have to evaluate it at quite a few points before it can accurately
23393 determine the value of the integral.
23395 Integration is much faster when the current precision is small. It is
23396 best to set the precision to the smallest acceptable number of digits
23397 before you use @kbd{a I}. If Calc appears to be taking too long, press
23398 @kbd{C-g} to halt it and try a lower precision. If Calc still appears
23399 to need hundreds of evaluations, check to make sure your function is
23400 well-behaved in the specified interval.
23402 It is possible for the lower integration limit to be @samp{-inf} (minus
23403 infinity). Likewise, the upper limit may be plus infinity. Calc
23404 internally transforms the integral into an equivalent one with finite
23405 limits. However, integration to or across singularities is not supported:
23406 The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
23407 by Calc's symbolic integrator, for example), but @kbd{a I} will fail
23408 because the integrand goes to infinity at one of the endpoints.
23410 @node Taylor Series, , Numerical Integration, Calculus
23411 @subsection Taylor Series
23415 @pindex calc-taylor
23417 The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
23418 power series expansion or Taylor series of a function. You specify the
23419 variable and the desired number of terms. You may give an expression of
23420 the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
23421 of just a variable to produce a Taylor expansion about the point @var{a}.
23422 You may specify the number of terms with a numeric prefix argument;
23423 otherwise the command will prompt you for the number of terms. Note that
23424 many series expansions have coefficients of zero for some terms, so you
23425 may appear to get fewer terms than you asked for.
23427 If the @kbd{a i} command is unable to find a symbolic integral for a
23428 function, you can get an approximation by integrating the function's
23431 @node Solving Equations, Numerical Solutions, Calculus, Algebra
23432 @section Solving Equations
23436 @pindex calc-solve-for
23438 @cindex Equations, solving
23439 @cindex Solving equations
23440 The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
23441 an equation to solve for a specific variable. An equation is an
23442 expression of the form @expr{L = R}. For example, the command @kbd{a S x}
23443 will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the
23444 input is not an equation, it is treated like an equation of the
23447 This command also works for inequalities, as in @expr{y < 3x + 6}.
23448 Some inequalities cannot be solved where the analogous equation could
23449 be; for example, solving
23450 @texline @math{a < b \, c}
23451 @infoline @expr{a < b c}
23452 for @expr{b} is impossible
23453 without knowing the sign of @expr{c}. In this case, @kbd{a S} will
23455 @texline @math{b \mathbin{\hbox{\code{!=}}} a/c}
23456 @infoline @expr{b != a/c}
23457 (using the not-equal-to operator) to signify that the direction of the
23458 inequality is now unknown. The inequality
23459 @texline @math{a \le b \, c}
23460 @infoline @expr{a <= b c}
23461 is not even partially solved. @xref{Declarations}, for a way to tell
23462 Calc that the signs of the variables in a formula are in fact known.
23464 Two useful commands for working with the result of @kbd{a S} are
23465 @kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2}
23466 to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
23467 another formula with @expr{x} set equal to @expr{y/3 - 2}.
23470 * Multiple Solutions::
23471 * Solving Systems of Equations::
23472 * Decomposing Polynomials::
23475 @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
23476 @subsection Multiple Solutions
23481 Some equations have more than one solution. The Hyperbolic flag
23482 (@code{H a S}) [@code{fsolve}] tells the solver to report the fully
23483 general family of solutions. It will invent variables @code{n1},
23484 @code{n2}, @dots{}, which represent independent arbitrary integers, and
23485 @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
23486 signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic
23487 flag, Calc will use zero in place of all arbitrary integers, and plus
23488 one in place of all arbitrary signs. Note that variables like @code{n1}
23489 and @code{s1} are not given any special interpretation in Calc except by
23490 the equation solver itself. As usual, you can use the @w{@kbd{s l}}
23491 (@code{calc-let}) command to obtain solutions for various actual values
23492 of these variables.
23494 For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
23495 get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
23496 equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to
23497 think about it is that the square-root operation is really a
23498 two-valued function; since every Calc function must return a
23499 single result, @code{sqrt} chooses to return the positive result.
23500 Then @kbd{H a S} doctors this result using @code{s1} to indicate
23501 the full set of possible values of the mathematical square-root.
23503 There is a similar phenomenon going the other direction: Suppose
23504 we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides
23505 to get @samp{y = x^2}. This is correct, except that it introduces
23506 some dubious solutions. Consider solving @samp{sqrt(y) = -3}:
23507 Calc will report @expr{y = 9} as a valid solution, which is true
23508 in the mathematical sense of square-root, but false (there is no
23509 solution) for the actual Calc positive-valued @code{sqrt}. This
23510 happens for both @kbd{a S} and @kbd{H a S}.
23512 @cindex @code{GenCount} variable
23522 If you store a positive integer in the Calc variable @code{GenCount},
23523 then Calc will generate formulas of the form @samp{as(@var{n})} for
23524 arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
23525 where @var{n} represents successive values taken by incrementing
23526 @code{GenCount} by one. While the normal arbitrary sign and
23527 integer symbols start over at @code{s1} and @code{n1} with each
23528 new Calc command, the @code{GenCount} approach will give each
23529 arbitrary value a name that is unique throughout the entire Calc
23530 session. Also, the arbitrary values are function calls instead
23531 of variables, which is advantageous in some cases. For example,
23532 you can make a rewrite rule that recognizes all arbitrary signs
23533 using a pattern like @samp{as(n)}. The @kbd{s l} command only works
23534 on variables, but you can use the @kbd{a b} (@code{calc-substitute})
23535 command to substitute actual values for function calls like @samp{as(3)}.
23537 The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
23538 way to create or edit this variable. Press @kbd{C-c C-c} to finish.
23540 If you have not stored a value in @code{GenCount}, or if the value
23541 in that variable is not a positive integer, the regular
23542 @code{s1}/@code{n1} notation is used.
23548 With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
23549 on top of the stack as a function of the specified variable and solves
23550 to find the inverse function, written in terms of the same variable.
23551 For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}.
23552 You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
23553 fully general inverse, as described above.
23556 @pindex calc-poly-roots
23558 Some equations, specifically polynomials, have a known, finite number
23559 of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
23560 command uses @kbd{H a S} to solve an equation in general form, then, for
23561 all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
23562 variables like @code{n1} for which @code{n1} only usefully varies over
23563 a finite range, it expands these variables out to all their possible
23564 values. The results are collected into a vector, which is returned.
23565 For example, @samp{roots(x^4 = 1, x)} returns the four solutions
23566 @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree
23567 polynomial will always have @var{n} roots on the complex plane.
23568 (If you have given a @code{real} declaration for the solution
23569 variable, then only the real-valued solutions, if any, will be
23570 reported; @pxref{Declarations}.)
23572 Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
23573 symbolic solutions if the polynomial has symbolic coefficients. Also
23574 note that Calc's solver is not able to get exact symbolic solutions
23575 to all polynomials. Polynomials containing powers up to @expr{x^4}
23576 can always be solved exactly; polynomials of higher degree sometimes
23577 can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1},
23578 which can be solved for @expr{x^3} using the quadratic equation, and then
23579 for @expr{x} by taking cube roots. But in many cases, like
23580 @expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
23581 into a form it can solve. The @kbd{a P} command can still deliver a
23582 list of numerical roots, however, provided that Symbolic mode (@kbd{m s})
23583 is not turned on. (If you work with Symbolic mode on, recall that the
23584 @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
23585 formula on the stack with Symbolic mode temporarily off.) Naturally,
23586 @kbd{a P} can only provide numerical roots if the polynomial coefficients
23587 are all numbers (real or complex).
23589 @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
23590 @subsection Solving Systems of Equations
23593 @cindex Systems of equations, symbolic
23594 You can also use the commands described above to solve systems of
23595 simultaneous equations. Just create a vector of equations, then
23596 specify a vector of variables for which to solve. (You can omit
23597 the surrounding brackets when entering the vector of variables
23600 For example, putting @samp{[x + y = a, x - y = b]} on the stack
23601 and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
23602 @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will
23603 have the same length as the variables vector, and the variables
23604 will be listed in the same order there. Note that the solutions
23605 are not always simplified as far as possible; the solution for
23606 @expr{x} here could be improved by an application of the @kbd{a n}
23609 Calc's algorithm works by trying to eliminate one variable at a
23610 time by solving one of the equations for that variable and then
23611 substituting into the other equations. Calc will try all the
23612 possibilities, but you can speed things up by noting that Calc
23613 first tries to eliminate the first variable with the first
23614 equation, then the second variable with the second equation,
23615 and so on. It also helps to put the simpler (e.g., more linear)
23616 equations toward the front of the list. Calc's algorithm will
23617 solve any system of linear equations, and also many kinds of
23624 Normally there will be as many variables as equations. If you
23625 give fewer variables than equations (an ``over-determined'' system
23626 of equations), Calc will find a partial solution. For example,
23627 typing @kbd{a S y @key{RET}} with the above system of equations
23628 would produce @samp{[y = a - x]}. There are now several ways to
23629 express this solution in terms of the original variables; Calc uses
23630 the first one that it finds. You can control the choice by adding
23631 variable specifiers of the form @samp{elim(@var{v})} to the
23632 variables list. This says that @var{v} should be eliminated from
23633 the equations; the variable will not appear at all in the solution.
23634 For example, typing @kbd{a S y,elim(x)} would yield
23635 @samp{[y = a - (b+a)/2]}.
23637 If the variables list contains only @code{elim} specifiers,
23638 Calc simply eliminates those variables from the equations
23639 and then returns the resulting set of equations. For example,
23640 @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable
23641 eliminated will reduce the number of equations in the system
23644 Again, @kbd{a S} gives you one solution to the system of
23645 equations. If there are several solutions, you can use @kbd{H a S}
23646 to get a general family of solutions, or, if there is a finite
23647 number of solutions, you can use @kbd{a P} to get a list. (In
23648 the latter case, the result will take the form of a matrix where
23649 the rows are different solutions and the columns correspond to the
23650 variables you requested.)
23652 Another way to deal with certain kinds of overdetermined systems of
23653 equations is the @kbd{a F} command, which does least-squares fitting
23654 to satisfy the equations. @xref{Curve Fitting}.
23656 @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
23657 @subsection Decomposing Polynomials
23664 The @code{poly} function takes a polynomial and a variable as
23665 arguments, and returns a vector of polynomial coefficients (constant
23666 coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns
23667 @expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x},
23668 the call to @code{poly} is left in symbolic form. If the input does
23669 not involve the variable @expr{x}, the input is returned in a list
23670 of length one, representing a polynomial with only a constant
23671 coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}.
23672 The last element of the returned vector is guaranteed to be nonzero;
23673 note that @samp{poly(0, x)} returns the empty vector @expr{[]}.
23674 Note also that @expr{x} may actually be any formula; for example,
23675 @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}.
23677 @cindex Coefficients of polynomial
23678 @cindex Degree of polynomial
23679 To get the @expr{x^k} coefficient of polynomial @expr{p}, use
23680 @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p},
23681 use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)}
23682 returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
23683 gives the @expr{x^2} coefficient of this polynomial, 6.
23689 One important feature of the solver is its ability to recognize
23690 formulas which are ``essentially'' polynomials. This ability is
23691 made available to the user through the @code{gpoly} function, which
23692 is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}.
23693 If @var{expr} is a polynomial in some term which includes @var{var}, then
23694 this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
23695 where @var{x} is the term that depends on @var{var}, @var{c} is a
23696 vector of polynomial coefficients (like the one returned by @code{poly}),
23697 and @var{a} is a multiplier which is usually 1. Basically,
23698 @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
23699 @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is
23700 guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
23701 (i.e., the trivial decomposition @var{expr} = @var{x} is not
23702 considered a polynomial). One side effect is that @samp{gpoly(x, x)}
23703 and @samp{gpoly(6, x)}, both of which might be expected to recognize
23704 their arguments as polynomials, will not because the decomposition
23705 is considered trivial.
23707 For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
23708 since the expanded form of this polynomial is @expr{4 - 4 x + x^2}.
23710 The term @var{x} may itself be a polynomial in @var{var}. This is
23711 done to reduce the size of the @var{c} vector. For example,
23712 @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
23713 since a quadratic polynomial in @expr{x^2} is easier to solve than
23714 a quartic polynomial in @expr{x}.
23716 A few more examples of the kinds of polynomials @code{gpoly} can
23720 sin(x) - 1 [sin(x), [-1, 1], 1]
23721 x + 1/x - 1 [x, [1, -1, 1], 1/x]
23722 x + 1/x [x^2, [1, 1], 1/x]
23723 x^3 + 2 x [x^2, [2, 1], x]
23724 x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2]
23725 x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1]
23726 (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x]
23729 The @code{poly} and @code{gpoly} functions accept a third integer argument
23730 which specifies the largest degree of polynomial that is acceptable.
23731 If this is @expr{n}, then only @var{c} vectors of length @expr{n+1}
23732 or less will be returned. Otherwise, the @code{poly} or @code{gpoly}
23733 call will remain in symbolic form. For example, the equation solver
23734 can handle quartics and smaller polynomials, so it calls
23735 @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
23736 can be treated by its linear, quadratic, cubic, or quartic formulas.
23742 The @code{pdeg} function computes the degree of a polynomial;
23743 @samp{pdeg(p,x)} is the highest power of @code{x} that appears in
23744 @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is
23745 much more efficient. If @code{p} is constant with respect to @code{x},
23746 then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x}
23747 (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
23748 It is possible to omit the second argument @code{x}, in which case
23749 @samp{pdeg(p)} returns the highest total degree of any term of the
23750 polynomial, counting all variables that appear in @code{p}. Note
23751 that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
23752 the degree of the constant zero is considered to be @code{-inf}
23759 The @code{plead} function finds the leading term of a polynomial.
23760 Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
23761 though again more efficient. In particular, @samp{plead((2x+1)^10, x)}
23762 returns 1024 without expanding out the list of coefficients. The
23763 value of @code{plead(p,x)} will be zero only if @expr{p = 0}.
23769 The @code{pcont} function finds the @dfn{content} of a polynomial. This
23770 is the greatest common divisor of all the coefficients of the polynomial.
23771 With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
23772 to get a list of coefficients, then uses @code{pgcd} (the polynomial
23773 GCD function) to combine these into an answer. For example,
23774 @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is
23775 basically the ``biggest'' polynomial that can be divided into @code{p}
23776 exactly. The sign of the content is the same as the sign of the leading
23779 With only one argument, @samp{pcont(p)} computes the numerical
23780 content of the polynomial, i.e., the @code{gcd} of the numerical
23781 coefficients of all the terms in the formula. Note that @code{gcd}
23782 is defined on rational numbers as well as integers; it computes
23783 the @code{gcd} of the numerators and the @code{lcm} of the
23784 denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
23785 Dividing the polynomial by this number will clear all the
23786 denominators, as well as dividing by any common content in the
23787 numerators. The numerical content of a polynomial is negative only
23788 if all the coefficients in the polynomial are negative.
23794 The @code{pprim} function finds the @dfn{primitive part} of a
23795 polynomial, which is simply the polynomial divided (using @code{pdiv}
23796 if necessary) by its content. If the input polynomial has rational
23797 coefficients, the result will have integer coefficients in simplest
23800 @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
23801 @section Numerical Solutions
23804 Not all equations can be solved symbolically. The commands in this
23805 section use numerical algorithms that can find a solution to a specific
23806 instance of an equation to any desired accuracy. Note that the
23807 numerical commands are slower than their algebraic cousins; it is a
23808 good idea to try @kbd{a S} before resorting to these commands.
23810 (@xref{Curve Fitting}, for some other, more specialized, operations
23811 on numerical data.)
23816 * Numerical Systems of Equations::
23819 @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
23820 @subsection Root Finding
23824 @pindex calc-find-root
23826 @cindex Newton's method
23827 @cindex Roots of equations
23828 @cindex Numerical root-finding
23829 The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
23830 numerical solution (or @dfn{root}) of an equation. (This command treats
23831 inequalities the same as equations. If the input is any other kind
23832 of formula, it is interpreted as an equation of the form @expr{X = 0}.)
23834 The @kbd{a R} command requires an initial guess on the top of the
23835 stack, and a formula in the second-to-top position. It prompts for a
23836 solution variable, which must appear in the formula. All other variables
23837 that appear in the formula must have assigned values, i.e., when
23838 a value is assigned to the solution variable and the formula is
23839 evaluated with @kbd{=}, it should evaluate to a number. Any assigned
23840 value for the solution variable itself is ignored and unaffected by
23843 When the command completes, the initial guess is replaced on the stack
23844 by a vector of two numbers: The value of the solution variable that
23845 solves the equation, and the difference between the lefthand and
23846 righthand sides of the equation at that value. Ordinarily, the second
23847 number will be zero or very nearly zero. (Note that Calc uses a
23848 slightly higher precision while finding the root, and thus the second
23849 number may be slightly different from the value you would compute from
23850 the equation yourself.)
23852 The @kbd{v h} (@code{calc-head}) command is a handy way to extract
23853 the first element of the result vector, discarding the error term.
23855 The initial guess can be a real number, in which case Calc searches
23856 for a real solution near that number, or a complex number, in which
23857 case Calc searches the whole complex plane near that number for a
23858 solution, or it can be an interval form which restricts the search
23859 to real numbers inside that interval.
23861 Calc tries to use @kbd{a d} to take the derivative of the equation.
23862 If this succeeds, it uses Newton's method. If the equation is not
23863 differentiable Calc uses a bisection method. (If Newton's method
23864 appears to be going astray, Calc switches over to bisection if it
23865 can, or otherwise gives up. In this case it may help to try again
23866 with a slightly different initial guess.) If the initial guess is a
23867 complex number, the function must be differentiable.
23869 If the formula (or the difference between the sides of an equation)
23870 is negative at one end of the interval you specify and positive at
23871 the other end, the root finder is guaranteed to find a root.
23872 Otherwise, Calc subdivides the interval into small parts looking for
23873 positive and negative values to bracket the root. When your guess is
23874 an interval, Calc will not look outside that interval for a root.
23878 The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
23879 that if the initial guess is an interval for which the function has
23880 the same sign at both ends, then rather than subdividing the interval
23881 Calc attempts to widen it to enclose a root. Use this mode if
23882 you are not sure if the function has a root in your interval.
23884 If the function is not differentiable, and you give a simple number
23885 instead of an interval as your initial guess, Calc uses this widening
23886 process even if you did not type the Hyperbolic flag. (If the function
23887 @emph{is} differentiable, Calc uses Newton's method which does not
23888 require a bounding interval in order to work.)
23890 If Calc leaves the @code{root} or @code{wroot} function in symbolic
23891 form on the stack, it will normally display an explanation for why
23892 no root was found. If you miss this explanation, press @kbd{w}
23893 (@code{calc-why}) to get it back.
23895 @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
23896 @subsection Minimization
23903 @pindex calc-find-minimum
23904 @pindex calc-find-maximum
23907 @cindex Minimization, numerical
23908 The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
23909 finds a minimum value for a formula. It is very similar in operation
23910 to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial
23911 guess on the stack, and are prompted for the name of a variable. The guess
23912 may be either a number near the desired minimum, or an interval enclosing
23913 the desired minimum. The function returns a vector containing the
23914 value of the variable which minimizes the formula's value, along
23915 with the minimum value itself.
23917 Note that this command looks for a @emph{local} minimum. Many functions
23918 have more than one minimum; some, like
23919 @texline @math{x \sin x},
23920 @infoline @expr{x sin(x)},
23921 have infinitely many. In fact, there is no easy way to define the
23922 ``global'' minimum of
23923 @texline @math{x \sin x}
23924 @infoline @expr{x sin(x)}
23925 but Calc can still locate any particular local minimum
23926 for you. Calc basically goes downhill from the initial guess until it
23927 finds a point at which the function's value is greater both to the left
23928 and to the right. Calc does not use derivatives when minimizing a function.
23930 If your initial guess is an interval and it looks like the minimum
23931 occurs at one or the other endpoint of the interval, Calc will return
23932 that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x}
23933 over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over
23934 @expr{(2..3]} would report no minimum found. In general, you should
23935 use closed intervals to find literally the minimum value in that
23936 range of @expr{x}, or open intervals to find the local minimum, if
23937 any, that happens to lie in that range.
23939 Most functions are smooth and flat near their minimum values. Because
23940 of this flatness, if the current precision is, say, 12 digits, the
23941 variable can only be determined meaningfully to about six digits. Thus
23942 you should set the precision to twice as many digits as you need in your
23953 The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
23954 expands the guess interval to enclose a minimum rather than requiring
23955 that the minimum lie inside the interval you supply.
23957 The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
23958 @kbd{H a X} [@code{wmaximize}] commands effectively minimize the
23959 negative of the formula you supply.
23961 The formula must evaluate to a real number at all points inside the
23962 interval (or near the initial guess if the guess is a number). If
23963 the initial guess is a complex number the variable will be minimized
23964 over the complex numbers; if it is real or an interval it will
23965 be minimized over the reals.
23967 @node Numerical Systems of Equations, , Minimization, Numerical Solutions
23968 @subsection Systems of Equations
23971 @cindex Systems of equations, numerical
23972 The @kbd{a R} command can also solve systems of equations. In this
23973 case, the equation should instead be a vector of equations, the
23974 guess should instead be a vector of numbers (intervals are not
23975 supported), and the variable should be a vector of variables. You
23976 can omit the brackets while entering the list of variables. Each
23977 equation must be differentiable by each variable for this mode to
23978 work. The result will be a vector of two vectors: The variable
23979 values that solved the system of equations, and the differences
23980 between the sides of the equations with those variable values.
23981 There must be the same number of equations as variables. Since
23982 only plain numbers are allowed as guesses, the Hyperbolic flag has
23983 no effect when solving a system of equations.
23985 It is also possible to minimize over many variables with @kbd{a N}
23986 (or maximize with @kbd{a X}). Once again the variable name should
23987 be replaced by a vector of variables, and the initial guess should
23988 be an equal-sized vector of initial guesses. But, unlike the case of
23989 multidimensional @kbd{a R}, the formula being minimized should
23990 still be a single formula, @emph{not} a vector. Beware that
23991 multidimensional minimization is currently @emph{very} slow.
23993 @node Curve Fitting, Summations, Numerical Solutions, Algebra
23994 @section Curve Fitting
23997 The @kbd{a F} command fits a set of data to a @dfn{model formula},
23998 such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters
23999 to be determined. For a typical set of measured data there will be
24000 no single @expr{m} and @expr{b} that exactly fit the data; in this
24001 case, Calc chooses values of the parameters that provide the closest
24006 * Polynomial and Multilinear Fits::
24007 * Error Estimates for Fits::
24008 * Standard Nonlinear Models::
24009 * Curve Fitting Details::
24013 @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
24014 @subsection Linear Fits
24018 @pindex calc-curve-fit
24020 @cindex Linear regression
24021 @cindex Least-squares fits
24022 The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
24023 to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a
24024 straight line, polynomial, or other function of @expr{x}. For the
24025 moment we will consider only the case of fitting to a line, and we
24026 will ignore the issue of whether or not the model was in fact a good
24029 In a standard linear least-squares fit, we have a set of @expr{(x,y)}
24030 data points that we wish to fit to the model @expr{y = m x + b}
24031 by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y}
24032 values calculated from the formula be as close as possible to the actual
24033 @expr{y} values in the data set. (In a polynomial fit, the model is
24034 instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit,
24035 we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is
24036 @expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.)
24038 In the model formula, variables like @expr{x} and @expr{x_2} are called
24039 the @dfn{independent variables}, and @expr{y} is the @dfn{dependent
24040 variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called
24041 the @dfn{parameters} of the model.
24043 The @kbd{a F} command takes the data set to be fitted from the stack.
24044 By default, it expects the data in the form of a matrix. For example,
24045 for a linear or polynomial fit, this would be a
24046 @texline @math{2\times N}
24048 matrix where the first row is a list of @expr{x} values and the second
24049 row has the corresponding @expr{y} values. For the multilinear fit
24050 shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2},
24051 @expr{x_3}, and @expr{y}, respectively).
24053 If you happen to have an
24054 @texline @math{N\times2}
24056 matrix instead of a
24057 @texline @math{2\times N}
24059 matrix, just press @kbd{v t} first to transpose the matrix.
24061 After you type @kbd{a F}, Calc prompts you to select a model. For a
24062 linear fit, press the digit @kbd{1}.
24064 Calc then prompts for you to name the variables. By default it chooses
24065 high letters like @expr{x} and @expr{y} for independent variables and
24066 low letters like @expr{a} and @expr{b} for parameters. (The dependent
24067 variable doesn't need a name.) The two kinds of variables are separated
24068 by a semicolon. Since you generally care more about the names of the
24069 independent variables than of the parameters, Calc also allows you to
24070 name only those and let the parameters use default names.
24072 For example, suppose the data matrix
24077 [ [ 1, 2, 3, 4, 5 ]
24078 [ 5, 7, 9, 11, 13 ] ]
24086 $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr
24087 5 & 7 & 9 & 11 & 13 }
24093 is on the stack and we wish to do a simple linear fit. Type
24094 @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
24095 the default names. The result will be the formula @expr{3 + 2 x}
24096 on the stack. Calc has created the model expression @kbd{a + b x},
24097 then found the optimal values of @expr{a} and @expr{b} to fit the
24098 data. (In this case, it was able to find an exact fit.) Calc then
24099 substituted those values for @expr{a} and @expr{b} in the model
24102 The @kbd{a F} command puts two entries in the trail. One is, as
24103 always, a copy of the result that went to the stack; the other is
24104 a vector of the actual parameter values, written as equations:
24105 @expr{[a = 3, b = 2]}, in case you'd rather read them in a list
24106 than pick them out of the formula. (You can type @kbd{t y}
24107 to move this vector to the stack; see @ref{Trail Commands}.
24109 Specifying a different independent variable name will affect the
24110 resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
24111 Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
24112 the equations that go into the trail.
24118 To see what happens when the fit is not exact, we could change
24119 the number 13 in the data matrix to 14 and try the fit again.
24126 Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
24127 a reasonably close match to the y-values in the data.
24130 [4.8, 7., 9.2, 11.4, 13.6]
24133 Since there is no line which passes through all the @var{n} data points,
24134 Calc has chosen a line that best approximates the data points using
24135 the method of least squares. The idea is to define the @dfn{chi-square}
24140 chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
24146 $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
24151 which is clearly zero if @expr{a + b x} exactly fits all data points,
24152 and increases as various @expr{a + b x_i} values fail to match the
24153 corresponding @expr{y_i} values. There are several reasons why the
24154 summand is squared, one of them being to ensure that
24155 @texline @math{\chi^2 \ge 0}.
24156 @infoline @expr{chi^2 >= 0}.
24157 Least-squares fitting simply chooses the values of @expr{a} and @expr{b}
24158 for which the error
24159 @texline @math{\chi^2}
24160 @infoline @expr{chi^2}
24161 is as small as possible.
24163 Other kinds of models do the same thing but with a different model
24164 formula in place of @expr{a + b x_i}.
24170 A numeric prefix argument causes the @kbd{a F} command to take the
24171 data in some other form than one big matrix. A positive argument @var{n}
24172 will take @var{N} items from the stack, corresponding to the @var{n} rows
24173 of a data matrix. In the linear case, @var{n} must be 2 since there
24174 is always one independent variable and one dependent variable.
24176 A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
24177 items from the stack, an @var{n}-row matrix of @expr{x} values, and a
24178 vector of @expr{y} values. If there is only one independent variable,
24179 the @expr{x} values can be either a one-row matrix or a plain vector,
24180 in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
24182 @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
24183 @subsection Polynomial and Multilinear Fits
24186 To fit the data to higher-order polynomials, just type one of the
24187 digits @kbd{2} through @kbd{9} when prompted for a model. For example,
24188 we could fit the original data matrix from the previous section
24189 (with 13, not 14) to a parabola instead of a line by typing
24190 @kbd{a F 2 @key{RET}}.
24193 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
24196 Note that since the constant and linear terms are enough to fit the
24197 data exactly, it's no surprise that Calc chose a tiny contribution
24198 for @expr{x^2}. (The fact that it's not exactly zero is due only
24199 to roundoff error. Since our data are exact integers, we could get
24200 an exact answer by typing @kbd{m f} first to get Fraction mode.
24201 Then the @expr{x^2} term would vanish altogether. Usually, though,
24202 the data being fitted will be approximate floats so Fraction mode
24205 Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
24206 gives a much larger @expr{x^2} contribution, as Calc bends the
24207 line slightly to improve the fit.
24210 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
24213 An important result from the theory of polynomial fitting is that it
24214 is always possible to fit @var{n} data points exactly using a polynomial
24215 of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
24216 Using the modified (14) data matrix, a model number of 4 gives
24217 a polynomial that exactly matches all five data points:
24220 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
24223 The actual coefficients we get with a precision of 12, like
24224 @expr{0.0416666663588}, clearly suffer from loss of precision.
24225 It is a good idea to increase the working precision to several
24226 digits beyond what you need when you do a fitting operation.
24227 Or, if your data are exact, use Fraction mode to get exact
24230 You can type @kbd{i} instead of a digit at the model prompt to fit
24231 the data exactly to a polynomial. This just counts the number of
24232 columns of the data matrix to choose the degree of the polynomial
24235 Fitting data ``exactly'' to high-degree polynomials is not always
24236 a good idea, though. High-degree polynomials have a tendency to
24237 wiggle uncontrollably in between the fitting data points. Also,
24238 if the exact-fit polynomial is going to be used to interpolate or
24239 extrapolate the data, it is numerically better to use the @kbd{a p}
24240 command described below. @xref{Interpolation}.
24246 Another generalization of the linear model is to assume the
24247 @expr{y} values are a sum of linear contributions from several
24248 @expr{x} values. This is a @dfn{multilinear} fit, and it is also
24249 selected by the @kbd{1} digit key. (Calc decides whether the fit
24250 is linear or multilinear by counting the rows in the data matrix.)
24252 Given the data matrix,
24256 [ [ 1, 2, 3, 4, 5 ]
24258 [ 14.5, 15, 18.5, 22.5, 24 ] ]
24263 the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the
24264 second row @expr{y}, and will fit the values in the third row to the
24265 model @expr{a + b x + c y}.
24271 Calc can do multilinear fits with any number of independent variables
24272 (i.e., with any number of data rows).
24278 Yet another variation is @dfn{homogeneous} linear models, in which
24279 the constant term is known to be zero. In the linear case, this
24280 means the model formula is simply @expr{a x}; in the multilinear
24281 case, the model might be @expr{a x + b y + c z}; and in the polynomial
24282 case, the model could be @expr{a x + b x^2 + c x^3}. You can get
24283 a homogeneous linear or multilinear model by pressing the letter
24284 @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
24286 It is certainly possible to have other constrained linear models,
24287 like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single
24288 key to select models like these, a later section shows how to enter
24289 any desired model by hand. In the first case, for example, you
24290 would enter @kbd{a F ' 2.3 + a x}.
24292 Another class of models that will work but must be entered by hand
24293 are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}.
24295 @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
24296 @subsection Error Estimates for Fits
24301 With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
24302 fitting operation as @kbd{a F}, but reports the coefficients as error
24303 forms instead of plain numbers. Fitting our two data matrices (first
24304 with 13, then with 14) to a line with @kbd{H a F} gives the results,
24308 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
24311 In the first case the estimated errors are zero because the linear
24312 fit is perfect. In the second case, the errors are nonzero but
24313 moderately small, because the data are still very close to linear.
24315 It is also possible for the @emph{input} to a fitting operation to
24316 contain error forms. The data values must either all include errors
24317 or all be plain numbers. Error forms can go anywhere but generally
24318 go on the numbers in the last row of the data matrix. If the last
24319 row contains error forms
24320 @texline `@var{y_i}@w{ @t{+/-} }@math{\sigma_i}',
24321 @infoline `@var{y_i}@w{ @t{+/-} }@var{sigma_i}',
24323 @texline @math{\chi^2}
24324 @infoline @expr{chi^2}
24329 chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
24335 $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
24340 so that data points with larger error estimates contribute less to
24341 the fitting operation.
24343 If there are error forms on other rows of the data matrix, all the
24344 errors for a given data point are combined; the square root of the
24345 sum of the squares of the errors forms the
24346 @texline @math{\sigma_i}
24347 @infoline @expr{sigma_i}
24348 used for the data point.
24350 Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
24351 matrix, although if you are concerned about error analysis you will
24352 probably use @kbd{H a F} so that the output also contains error
24355 If the input contains error forms but all the
24356 @texline @math{\sigma_i}
24357 @infoline @expr{sigma_i}
24358 values are the same, it is easy to see that the resulting fitted model
24359 will be the same as if the input did not have error forms at all
24360 @texline (@math{\chi^2}
24361 @infoline (@expr{chi^2}
24362 is simply scaled uniformly by
24363 @texline @math{1 / \sigma^2},
24364 @infoline @expr{1 / sigma^2},
24365 which doesn't affect where it has a minimum). But there @emph{will} be
24366 a difference in the estimated errors of the coefficients reported by
24369 Consult any text on statistical modeling of data for a discussion
24370 of where these error estimates come from and how they should be
24379 With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
24380 information. The result is a vector of six items:
24384 The model formula with error forms for its coefficients or
24385 parameters. This is the result that @kbd{H a F} would have
24389 A vector of ``raw'' parameter values for the model. These are the
24390 polynomial coefficients or other parameters as plain numbers, in the
24391 same order as the parameters appeared in the final prompt of the
24392 @kbd{I a F} command. For polynomials of degree @expr{d}, this vector
24393 will have length @expr{M = d+1} with the constant term first.
24396 The covariance matrix @expr{C} computed from the fit. This is
24397 an @var{m}x@var{m} symmetric matrix; the diagonal elements
24398 @texline @math{C_{jj}}
24399 @infoline @expr{C_j_j}
24401 @texline @math{\sigma_j^2}
24402 @infoline @expr{sigma_j^2}
24403 of the parameters. The other elements are covariances
24404 @texline @math{\sigma_{ij}^2}
24405 @infoline @expr{sigma_i_j^2}
24406 that describe the correlation between pairs of parameters. (A related
24407 set of numbers, the @dfn{linear correlation coefficients}
24408 @texline @math{r_{ij}},
24409 @infoline @expr{r_i_j},
24411 @texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.)
24412 @infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.)
24415 A vector of @expr{M} ``parameter filter'' functions whose
24416 meanings are described below. If no filters are necessary this
24417 will instead be an empty vector; this is always the case for the
24418 polynomial and multilinear fits described so far.
24422 @texline @math{\chi^2}
24423 @infoline @expr{chi^2}
24424 for the fit, calculated by the formulas shown above. This gives a
24425 measure of the quality of the fit; statisticians consider
24426 @texline @math{\chi^2 \approx N - M}
24427 @infoline @expr{chi^2 = N - M}
24428 to indicate a moderately good fit (where again @expr{N} is the number of
24429 data points and @expr{M} is the number of parameters).
24432 A measure of goodness of fit expressed as a probability @expr{Q}.
24433 This is computed from the @code{utpc} probability distribution
24435 @texline @math{\chi^2}
24436 @infoline @expr{chi^2}
24437 with @expr{N - M} degrees of freedom. A
24438 value of 0.5 implies a good fit; some texts recommend that often
24439 @expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In
24441 @texline @math{\chi^2}
24442 @infoline @expr{chi^2}
24443 statistics assume the errors in your inputs
24444 follow a normal (Gaussian) distribution; if they don't, you may
24445 have to accept smaller values of @expr{Q}.
24447 The @expr{Q} value is computed only if the input included error
24448 estimates. Otherwise, Calc will report the symbol @code{nan}
24449 for @expr{Q}. The reason is that in this case the
24450 @texline @math{\chi^2}
24451 @infoline @expr{chi^2}
24452 value has effectively been used to estimate the original errors
24453 in the input, and thus there is no redundant information left
24454 over to use for a confidence test.
24457 @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
24458 @subsection Standard Nonlinear Models
24461 The @kbd{a F} command also accepts other kinds of models besides
24462 lines and polynomials. Some common models have quick single-key
24463 abbreviations; others must be entered by hand as algebraic formulas.
24465 Here is a complete list of the standard models recognized by @kbd{a F}:
24469 Linear or multilinear. @mathit{a + b x + c y + d z}.
24471 Polynomials. @mathit{a + b x + c x^2 + d x^3}.
24473 Exponential. @mathit{a} @t{exp}@mathit{(b x)} @t{exp}@mathit{(c y)}.
24475 Base-10 exponential. @mathit{a} @t{10^}@mathit{(b x)} @t{10^}@mathit{(c y)}.
24477 Exponential (alternate notation). @t{exp}@mathit{(a + b x + c y)}.
24479 Base-10 exponential (alternate). @t{10^}@mathit{(a + b x + c y)}.
24481 Logarithmic. @mathit{a + b} @t{ln}@mathit{(x) + c} @t{ln}@mathit{(y)}.
24483 Base-10 logarithmic. @mathit{a + b} @t{log10}@mathit{(x) + c} @t{log10}@mathit{(y)}.
24485 General exponential. @mathit{a b^x c^y}.
24487 Power law. @mathit{a x^b y^c}.
24489 Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}.
24492 @texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}.
24493 @infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
24496 All of these models are used in the usual way; just press the appropriate
24497 letter at the model prompt, and choose variable names if you wish. The
24498 result will be a formula as shown in the above table, with the best-fit
24499 values of the parameters substituted. (You may find it easier to read
24500 the parameter values from the vector that is placed in the trail.)
24502 All models except Gaussian and polynomials can generalize as shown to any
24503 number of independent variables. Also, all the built-in models have an
24504 additive or multiplicative parameter shown as @expr{a} in the above table
24505 which can be replaced by zero or one, as appropriate, by typing @kbd{h}
24506 before the model key.
24508 Note that many of these models are essentially equivalent, but express
24509 the parameters slightly differently. For example, @expr{a b^x} and
24510 the other two exponential models are all algebraic rearrangements of
24511 each other. Also, the ``quadratic'' model is just a degree-2 polynomial
24512 with the parameters expressed differently. Use whichever form best
24513 matches the problem.
24515 The HP-28/48 calculators support four different models for curve
24516 fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
24517 These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
24518 @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case,
24519 @expr{a} is what the HP-48 identifies as the ``intercept,'' and
24520 @expr{b} is what it calls the ``slope.''
24526 If the model you want doesn't appear on this list, press @kbd{'}
24527 (the apostrophe key) at the model prompt to enter any algebraic
24528 formula, such as @kbd{m x - b}, as the model. (Not all models
24529 will work, though---see the next section for details.)
24531 The model can also be an equation like @expr{y = m x + b}.
24532 In this case, Calc thinks of all the rows of the data matrix on
24533 equal terms; this model effectively has two parameters
24534 (@expr{m} and @expr{b}) and two independent variables (@expr{x}
24535 and @expr{y}), with no ``dependent'' variables. Model equations
24536 do not need to take this @expr{y =} form. For example, the
24537 implicit line equation @expr{a x + b y = 1} works fine as a
24540 When you enter a model, Calc makes an alphabetical list of all
24541 the variables that appear in the model. These are used for the
24542 default parameters, independent variables, and dependent variable
24543 (in that order). If you enter a plain formula (not an equation),
24544 Calc assumes the dependent variable does not appear in the formula
24545 and thus does not need a name.
24547 For example, if the model formula has the variables @expr{a,mu,sigma,t,x},
24548 and the data matrix has three rows (meaning two independent variables),
24549 Calc will use @expr{a,mu,sigma} as the default parameters, and the
24550 data rows will be named @expr{t} and @expr{x}, respectively. If you
24551 enter an equation instead of a plain formula, Calc will use @expr{a,mu}
24552 as the parameters, and @expr{sigma,t,x} as the three independent
24555 You can, of course, override these choices by entering something
24556 different at the prompt. If you leave some variables out of the list,
24557 those variables must have stored values and those stored values will
24558 be used as constants in the model. (Stored values for the parameters
24559 and independent variables are ignored by the @kbd{a F} command.)
24560 If you list only independent variables, all the remaining variables
24561 in the model formula will become parameters.
24563 If there are @kbd{$} signs in the model you type, they will stand
24564 for parameters and all other variables (in alphabetical order)
24565 will be independent. Use @kbd{$} for one parameter, @kbd{$$} for
24566 another, and so on. Thus @kbd{$ x + $$} is another way to describe
24569 If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
24570 Calc will take the model formula from the stack. (The data must then
24571 appear at the second stack level.) The same conventions are used to
24572 choose which variables in the formula are independent by default and
24573 which are parameters.
24575 Models taken from the stack can also be expressed as vectors of
24576 two or three elements, @expr{[@var{model}, @var{vars}]} or
24577 @expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars}
24578 and @var{params} may be either a variable or a vector of variables.
24579 (If @var{params} is omitted, all variables in @var{model} except
24580 those listed as @var{vars} are parameters.)
24582 When you enter a model manually with @kbd{'}, Calc puts a 3-vector
24583 describing the model in the trail so you can get it back if you wish.
24591 Finally, you can store a model in one of the Calc variables
24592 @code{Model1} or @code{Model2}, then use this model by typing
24593 @kbd{a F u} or @kbd{a F U} (respectively). The value stored in
24594 the variable can be any of the formats that @kbd{a F $} would
24595 accept for a model on the stack.
24601 Calc uses the principal values of inverse functions like @code{ln}
24602 and @code{arcsin} when doing fits. For example, when you enter
24603 the model @samp{y = sin(a t + b)} Calc actually uses the easier
24604 form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always
24605 returns results in the range from @mathit{-90} to 90 degrees (or the
24606 equivalent range in radians). Suppose you had data that you
24607 believed to represent roughly three oscillations of a sine wave,
24608 so that the argument of the sine might go from zero to
24609 @texline @math{3\times360}
24610 @infoline @mathit{3*360}
24612 The above model would appear to be a good way to determine the
24613 true frequency and phase of the sine wave, but in practice it
24614 would fail utterly. The righthand side of the actual model
24615 @samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but
24616 the lefthand side will bounce back and forth between @mathit{-90} and 90.
24617 No values of @expr{a} and @expr{b} can make the two sides match,
24618 even approximately.
24620 There is no good solution to this problem at present. You could
24621 restrict your data to small enough ranges so that the above problem
24622 doesn't occur (i.e., not straddling any peaks in the sine wave).
24623 Or, in this case, you could use a totally different method such as
24624 Fourier analysis, which is beyond the scope of the @kbd{a F} command.
24625 (Unfortunately, Calc does not currently have any facilities for
24626 taking Fourier and related transforms.)
24628 @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
24629 @subsection Curve Fitting Details
24632 Calc's internal least-squares fitter can only handle multilinear
24633 models. More precisely, it can handle any model of the form
24634 @expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c}
24635 are the parameters and @expr{x,y,z} are the independent variables
24636 (of course there can be any number of each, not just three).
24638 In a simple multilinear or polynomial fit, it is easy to see how
24639 to convert the model into this form. For example, if the model
24640 is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x},
24641 and @expr{h(x) = x^2} are suitable functions.
24643 For other models, Calc uses a variety of algebraic manipulations
24644 to try to put the problem into the form
24647 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)
24651 where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes
24652 @expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points,
24653 does a standard linear fit to find the values of @expr{A}, @expr{B},
24654 and @expr{C}, then uses the equation solver to solve for @expr{a,b,c}
24655 in terms of @expr{A,B,C}.
24657 A remarkable number of models can be cast into this general form.
24658 We'll look at two examples here to see how it works. The power-law
24659 model @expr{y = a x^b} with two independent variables and two parameters
24660 can be rewritten as follows:
24665 y = exp(ln(a) + b ln(x))
24666 ln(y) = ln(a) + b ln(x)
24670 which matches the desired form with
24671 @texline @math{Y = \ln(y)},
24672 @infoline @expr{Y = ln(y)},
24673 @texline @math{A = \ln(a)},
24674 @infoline @expr{A = ln(a)},
24675 @expr{F = 1}, @expr{B = b}, and
24676 @texline @math{G = \ln(x)}.
24677 @infoline @expr{G = ln(x)}.
24678 Calc thus computes the logarithms of your @expr{y} and @expr{x} values,
24679 does a linear fit for @expr{A} and @expr{B}, then solves to get
24680 @texline @math{a = \exp(A)}
24681 @infoline @expr{a = exp(A)}
24684 Another interesting example is the ``quadratic'' model, which can
24685 be handled by expanding according to the distributive law.
24688 y = a + b*(x - c)^2
24689 y = a + b c^2 - 2 b c x + b x^2
24693 which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1},
24694 @expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily
24695 have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and
24698 The Gaussian model looks quite complicated, but a closer examination
24699 shows that it's actually similar to the quadratic model but with an
24700 exponential that can be brought to the top and moved into @expr{Y}.
24702 An example of a model that cannot be put into general linear
24703 form is a Gaussian with a constant background added on, i.e.,
24704 @expr{d} + the regular Gaussian formula. If you have a model like
24705 this, your best bet is to replace enough of your parameters with
24706 constants to make the model linearizable, then adjust the constants
24707 manually by doing a series of fits. You can compare the fits by
24708 graphing them, by examining the goodness-of-fit measures returned by
24709 @kbd{I a F}, or by some other method suitable to your application.
24710 Note that some models can be linearized in several ways. The
24711 Gaussian-plus-@var{d} model can be linearized by setting @expr{d}
24712 (the background) to a constant, or by setting @expr{b} (the standard
24713 deviation) and @expr{c} (the mean) to constants.
24715 To fit a model with constants substituted for some parameters, just
24716 store suitable values in those parameter variables, then omit them
24717 from the list of parameters when you answer the variables prompt.
24723 A last desperate step would be to use the general-purpose
24724 @code{minimize} function rather than @code{fit}. After all, both
24725 functions solve the problem of minimizing an expression (the
24726 @texline @math{\chi^2}
24727 @infoline @expr{chi^2}
24728 sum) by adjusting certain parameters in the expression. The @kbd{a F}
24729 command is able to use a vastly more efficient algorithm due to its
24730 special knowledge about linear chi-square sums, but the @kbd{a N}
24731 command can do the same thing by brute force.
24733 A compromise would be to pick out a few parameters without which the
24734 fit is linearizable, and use @code{minimize} on a call to @code{fit}
24735 which efficiently takes care of the rest of the parameters. The thing
24736 to be minimized would be the value of
24737 @texline @math{\chi^2}
24738 @infoline @expr{chi^2}
24739 returned as the fifth result of the @code{xfit} function:
24742 minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
24746 where @code{gaus} represents the Gaussian model with background,
24747 @code{data} represents the data matrix, and @code{guess} represents
24748 the initial guess for @expr{d} that @code{minimize} requires.
24749 This operation will only be, shall we say, extraordinarily slow
24750 rather than astronomically slow (as would be the case if @code{minimize}
24751 were used by itself to solve the problem).
24757 The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
24758 nonlinear models are used. The second item in the result is the
24759 vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The
24760 covariance matrix is written in terms of those raw parameters.
24761 The fifth item is a vector of @dfn{filter} expressions. This
24762 is the empty vector @samp{[]} if the raw parameters were the same
24763 as the requested parameters, i.e., if @expr{A = a}, @expr{B = b},
24764 and so on (which is always true if the model is already linear
24765 in the parameters as written, e.g., for polynomial fits). If the
24766 parameters had to be rearranged, the fifth item is instead a vector
24767 of one formula per parameter in the original model. The raw
24768 parameters are expressed in these ``filter'' formulas as
24769 @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B},
24772 When Calc needs to modify the model to return the result, it replaces
24773 @samp{fitdummy(1)} in all the filters with the first item in the raw
24774 parameters list, and so on for the other raw parameters, then
24775 evaluates the resulting filter formulas to get the actual parameter
24776 values to be substituted into the original model. In the case of
24777 @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
24778 Calc uses the square roots of the diagonal entries of the covariance
24779 matrix as error values for the raw parameters, then lets Calc's
24780 standard error-form arithmetic take it from there.
24782 If you use @kbd{I a F} with a nonlinear model, be sure to remember
24783 that the covariance matrix is in terms of the raw parameters,
24784 @emph{not} the actual requested parameters. It's up to you to
24785 figure out how to interpret the covariances in the presence of
24786 nontrivial filter functions.
24788 Things are also complicated when the input contains error forms.
24789 Suppose there are three independent and dependent variables, @expr{x},
24790 @expr{y}, and @expr{z}, one or more of which are error forms in the
24791 data. Calc combines all the error values by taking the square root
24792 of the sum of the squares of the errors. It then changes @expr{x}
24793 and @expr{y} to be plain numbers, and makes @expr{z} into an error
24794 form with this combined error. The @expr{Y(x,y,z)} part of the
24795 linearized model is evaluated, and the result should be an error
24796 form. The error part of that result is used for
24797 @texline @math{\sigma_i}
24798 @infoline @expr{sigma_i}
24799 for the data point. If for some reason @expr{Y(x,y,z)} does not return
24800 an error form, the combined error from @expr{z} is used directly for
24801 @texline @math{\sigma_i}.
24802 @infoline @expr{sigma_i}.
24803 Finally, @expr{z} is also stripped of its error
24804 for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on;
24805 the righthand side of the linearized model is computed in regular
24806 arithmetic with no error forms.
24808 (While these rules may seem complicated, they are designed to do
24809 the most reasonable thing in the typical case that @expr{Y(x,y,z)}
24810 depends only on the dependent variable @expr{z}, and in fact is
24811 often simply equal to @expr{z}. For common cases like polynomials
24812 and multilinear models, the combined error is simply used as the
24813 @texline @math{\sigma}
24814 @infoline @expr{sigma}
24815 for the data point with no further ado.)
24822 It may be the case that the model you wish to use is linearizable,
24823 but Calc's built-in rules are unable to figure it out. Calc uses
24824 its algebraic rewrite mechanism to linearize a model. The rewrite
24825 rules are kept in the variable @code{FitRules}. You can edit this
24826 variable using the @kbd{s e FitRules} command; in fact, there is
24827 a special @kbd{s F} command just for editing @code{FitRules}.
24828 @xref{Operations on Variables}.
24830 @xref{Rewrite Rules}, for a discussion of rewrite rules.
24864 Calc uses @code{FitRules} as follows. First, it converts the model
24865 to an equation if necessary and encloses the model equation in a
24866 call to the function @code{fitmodel} (which is not actually a defined
24867 function in Calc; it is only used as a placeholder by the rewrite rules).
24868 Parameter variables are renamed to function calls @samp{fitparam(1)},
24869 @samp{fitparam(2)}, and so on, and independent variables are renamed
24870 to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable
24871 is the highest-numbered @code{fitvar}. For example, the power law
24872 model @expr{a x^b} is converted to @expr{y = a x^b}, then to
24876 fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
24880 Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
24881 (The zero prefix means that rewriting should continue until no further
24882 changes are possible.)
24884 When rewriting is complete, the @code{fitmodel} call should have
24885 been replaced by a @code{fitsystem} call that looks like this:
24888 fitsystem(@var{Y}, @var{FGH}, @var{abc})
24892 where @var{Y} is a formula that describes the function @expr{Y(x,y,z)},
24893 @var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]},
24894 and @var{abc} is the vector of parameter filters which refer to the
24895 raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)}
24896 for @expr{B}, etc. While the number of raw parameters (the length of
24897 the @var{FGH} vector) is usually the same as the number of original
24898 parameters (the length of the @var{abc} vector), this is not required.
24900 The power law model eventually boils down to
24904 fitsystem(ln(fitvar(2)),
24905 [1, ln(fitvar(1))],
24906 [exp(fitdummy(1)), fitdummy(2)])
24910 The actual implementation of @code{FitRules} is complicated; it
24911 proceeds in four phases. First, common rearrangements are done
24912 to try to bring linear terms together and to isolate functions like
24913 @code{exp} and @code{ln} either all the way ``out'' (so that they
24914 can be put into @var{Y}) or all the way ``in'' (so that they can
24915 be put into @var{abc} or @var{FGH}). In particular, all
24916 non-constant powers are converted to logs-and-exponentials form,
24917 and the distributive law is used to expand products of sums.
24918 Quotients are rewritten to use the @samp{fitinv} function, where
24919 @samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules}
24920 are operating. (The use of @code{fitinv} makes recognition of
24921 linear-looking forms easier.) If you modify @code{FitRules}, you
24922 will probably only need to modify the rules for this phase.
24924 Phase two, whose rules can actually also apply during phases one
24925 and three, first rewrites @code{fitmodel} to a two-argument
24926 form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
24927 initially zero and @var{model} has been changed from @expr{a=b}
24928 to @expr{a-b} form. It then tries to peel off invertible functions
24929 from the outside of @var{model} and put them into @var{Y} instead,
24930 calling the equation solver to invert the functions. Finally, when
24931 this is no longer possible, the @code{fitmodel} is changed to a
24932 four-argument @code{fitsystem}, where the fourth argument is
24933 @var{model} and the @var{FGH} and @var{abc} vectors are initially
24934 empty. (The last vector is really @var{ABC}, corresponding to
24935 raw parameters, for now.)
24937 Phase three converts a sum of items in the @var{model} to a sum
24938 of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
24939 terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
24940 is all factors that do not involve any variables, @var{b} is all
24941 factors that involve only parameters, and @var{c} is the factors
24942 that involve only independent variables. (If this decomposition
24943 is not possible, the rule set will not complete and Calc will
24944 complain that the model is too complex.) Then @code{fitpart}s
24945 with equal @var{b} or @var{c} components are merged back together
24946 using the distributive law in order to minimize the number of
24947 raw parameters needed.
24949 Phase four moves the @code{fitpart} terms into the @var{FGH} and
24950 @var{ABC} vectors. Also, some of the algebraic expansions that
24951 were done in phase 1 are undone now to make the formulas more
24952 computationally efficient. Finally, it calls the solver one more
24953 time to convert the @var{ABC} vector to an @var{abc} vector, and
24954 removes the fourth @var{model} argument (which by now will be zero)
24955 to obtain the three-argument @code{fitsystem} that the linear
24956 least-squares solver wants to see.
24962 @mindex hasfit@idots
24964 @tindex hasfitparams
24972 Two functions which are useful in connection with @code{FitRules}
24973 are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
24974 whether @expr{x} refers to any parameters or independent variables,
24975 respectively. Specifically, these functions return ``true'' if the
24976 argument contains any @code{fitparam} (or @code{fitvar}) function
24977 calls, and ``false'' otherwise. (Recall that ``true'' means a
24978 nonzero number, and ``false'' means zero. The actual nonzero number
24979 returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
24980 or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
24986 The @code{fit} function in algebraic notation normally takes four
24987 arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
24988 where @var{model} is the model formula as it would be typed after
24989 @kbd{a F '}, @var{vars} is the independent variable or a vector of
24990 independent variables, @var{params} likewise gives the parameter(s),
24991 and @var{data} is the data matrix. Note that the length of @var{vars}
24992 must be equal to the number of rows in @var{data} if @var{model} is
24993 an equation, or one less than the number of rows if @var{model} is
24994 a plain formula. (Actually, a name for the dependent variable is
24995 allowed but will be ignored in the plain-formula case.)
24997 If @var{params} is omitted, the parameters are all variables in
24998 @var{model} except those that appear in @var{vars}. If @var{vars}
24999 is also omitted, Calc sorts all the variables that appear in
25000 @var{model} alphabetically and uses the higher ones for @var{vars}
25001 and the lower ones for @var{params}.
25003 Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
25004 where @var{modelvec} is a 2- or 3-vector describing the model
25005 and variables, as discussed previously.
25007 If Calc is unable to do the fit, the @code{fit} function is left
25008 in symbolic form, ordinarily with an explanatory message. The
25009 message will be ``Model expression is too complex'' if the
25010 linearizer was unable to put the model into the required form.
25012 The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
25013 (for @kbd{I a F}) functions are completely analogous.
25015 @node Interpolation, , Curve Fitting Details, Curve Fitting
25016 @subsection Polynomial Interpolation
25019 @pindex calc-poly-interp
25021 The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
25022 a polynomial interpolation at a particular @expr{x} value. It takes
25023 two arguments from the stack: A data matrix of the sort used by
25024 @kbd{a F}, and a single number which represents the desired @expr{x}
25025 value. Calc effectively does an exact polynomial fit as if by @kbd{a F i},
25026 then substitutes the @expr{x} value into the result in order to get an
25027 approximate @expr{y} value based on the fit. (Calc does not actually
25028 use @kbd{a F i}, however; it uses a direct method which is both more
25029 efficient and more numerically stable.)
25031 The result of @kbd{a p} is actually a vector of two values: The @expr{y}
25032 value approximation, and an error measure @expr{dy} that reflects Calc's
25033 estimation of the probable error of the approximation at that value of
25034 @expr{x}. If the input @expr{x} is equal to any of the @expr{x} values
25035 in the data matrix, the output @expr{y} will be the corresponding @expr{y}
25036 value from the matrix, and the output @expr{dy} will be exactly zero.
25038 A prefix argument of 2 causes @kbd{a p} to take separate x- and
25039 y-vectors from the stack instead of one data matrix.
25041 If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of
25042 interpolated results for each of those @expr{x} values. (The matrix will
25043 have two columns, the @expr{y} values and the @expr{dy} values.)
25044 If @expr{x} is a formula instead of a number, the @code{polint} function
25045 remains in symbolic form; use the @kbd{a "} command to expand it out to
25046 a formula that describes the fit in symbolic terms.
25048 In all cases, the @kbd{a p} command leaves the data vectors or matrix
25049 on the stack. Only the @expr{x} value is replaced by the result.
25053 The @kbd{H a p} [@code{ratint}] command does a rational function
25054 interpolation. It is used exactly like @kbd{a p}, except that it
25055 uses as its model the quotient of two polynomials. If there are
25056 @expr{N} data points, the numerator and denominator polynomials will
25057 each have degree @expr{N/2} (if @expr{N} is odd, the denominator will
25058 have degree one higher than the numerator).
25060 Rational approximations have the advantage that they can accurately
25061 describe functions that have poles (points at which the function's value
25062 goes to infinity, so that the denominator polynomial of the approximation
25063 goes to zero). If @expr{x} corresponds to a pole of the fitted rational
25064 function, then the result will be a division by zero. If Infinite mode
25065 is enabled, the result will be @samp{[uinf, uinf]}.
25067 There is no way to get the actual coefficients of the rational function
25068 used by @kbd{H a p}. (The algorithm never generates these coefficients
25069 explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
25070 capabilities to fit.)
25072 @node Summations, Logical Operations, Curve Fitting, Algebra
25073 @section Summations
25076 @cindex Summation of a series
25078 @pindex calc-summation
25080 The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
25081 the sum of a formula over a certain range of index values. The formula
25082 is taken from the top of the stack; the command prompts for the
25083 name of the summation index variable, the lower limit of the
25084 sum (any formula), and the upper limit of the sum. If you
25085 enter a blank line at any of these prompts, that prompt and
25086 any later ones are answered by reading additional elements from
25087 the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
25088 produces the result 55.
25091 $$ \sum_{k=1}^5 k^2 = 55 $$
25094 The choice of index variable is arbitrary, but it's best not to
25095 use a variable with a stored value. In particular, while
25096 @code{i} is often a favorite index variable, it should be avoided
25097 in Calc because @code{i} has the imaginary constant @expr{(0, 1)}
25098 as a value. If you pressed @kbd{=} on a sum over @code{i}, it would
25099 be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}!
25100 If you really want to use @code{i} as an index variable, use
25101 @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
25102 (@xref{Storing Variables}.)
25104 A numeric prefix argument steps the index by that amount rather
25105 than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
25106 yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix
25107 argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
25108 step value, in which case you can enter any formula or enter
25109 a blank line to take the step value from the stack. With the
25110 @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
25111 the stack: The formula, the variable, the lower limit, the
25112 upper limit, and (at the top of the stack), the step value.
25114 Calc knows how to do certain sums in closed form. For example,
25115 @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular,
25116 this is possible if the formula being summed is polynomial or
25117 exponential in the index variable. Sums of logarithms are
25118 transformed into logarithms of products. Sums of trigonometric
25119 and hyperbolic functions are transformed to sums of exponentials
25120 and then done in closed form. Also, of course, sums in which the
25121 lower and upper limits are both numbers can always be evaluated
25122 just by grinding them out, although Calc will use closed forms
25123 whenever it can for the sake of efficiency.
25125 The notation for sums in algebraic formulas is
25126 @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
25127 If @var{step} is omitted, it defaults to one. If @var{high} is
25128 omitted, @var{low} is actually the upper limit and the lower limit
25129 is one. If @var{low} is also omitted, the limits are @samp{-inf}
25130 and @samp{inf}, respectively.
25132 Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)}
25133 returns @expr{1}. This is done by evaluating the sum in closed
25134 form (to @samp{1. - 0.5^n} in this case), then evaluating this
25135 formula with @code{n} set to @code{inf}. Calc's usual rules
25136 for ``infinite'' arithmetic can find the answer from there. If
25137 infinite arithmetic yields a @samp{nan}, or if the sum cannot be
25138 solved in closed form, Calc leaves the @code{sum} function in
25139 symbolic form. @xref{Infinities}.
25141 As a special feature, if the limits are infinite (or omitted, as
25142 described above) but the formula includes vectors subscripted by
25143 expressions that involve the iteration variable, Calc narrows
25144 the limits to include only the range of integers which result in
25145 legal subscripts for the vector. For example, the sum
25146 @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
25148 The limits of a sum do not need to be integers. For example,
25149 @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
25150 Calc computes the number of iterations using the formula
25151 @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
25152 after simplification as if by @kbd{a s}, evaluate to an integer.
25154 If the number of iterations according to the above formula does
25155 not come out to an integer, the sum is illegal and will be left
25156 in symbolic form. However, closed forms are still supplied, and
25157 you are on your honor not to misuse the resulting formulas by
25158 substituting mismatched bounds into them. For example,
25159 @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
25160 evaluate the closed form solution for the limits 1 and 10 to get
25161 the rather dubious answer, 29.25.
25163 If the lower limit is greater than the upper limit (assuming a
25164 positive step size), the result is generally zero. However,
25165 Calc only guarantees a zero result when the upper limit is
25166 exactly one step less than the lower limit, i.e., if the number
25167 of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero
25168 but the sum from @samp{n} to @samp{n-2} may report a nonzero value
25169 if Calc used a closed form solution.
25171 Calc's logical predicates like @expr{a < b} return 1 for ``true''
25172 and 0 for ``false.'' @xref{Logical Operations}. This can be
25173 used to advantage for building conditional sums. For example,
25174 @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
25175 prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
25176 its argument is prime and 0 otherwise. You can read this expression
25177 as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed,
25178 @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
25179 squared, since the limits default to plus and minus infinity, but
25180 there are no such sums that Calc's built-in rules can do in
25183 As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
25184 sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding
25185 one value @expr{k_0}. Slightly more tricky is the summand
25186 @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
25187 the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where
25188 this would be a division by zero. But at @expr{k = k_0}, this
25189 formula works out to the indeterminate form @expr{0 / 0}, which
25190 Calc will not assume is zero. Better would be to use
25191 @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
25192 an ``if-then-else'' test: This expression says, ``if
25193 @texline @math{k \ne k_0},
25194 @infoline @expr{k != k_0},
25195 then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)}
25196 will not even be evaluated by Calc when @expr{k = k_0}.
25198 @cindex Alternating sums
25200 @pindex calc-alt-summation
25202 The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
25203 computes an alternating sum. Successive terms of the sequence
25204 are given alternating signs, with the first term (corresponding
25205 to the lower index value) being positive. Alternating sums
25206 are converted to normal sums with an extra term of the form
25207 @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately
25208 if the step value is other than one. For example, the Taylor
25209 series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
25210 (Calc cannot evaluate this infinite series, but it can approximate
25211 it if you replace @code{inf} with any particular odd number.)
25212 Calc converts this series to a regular sum with a step of one,
25213 namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
25215 @cindex Product of a sequence
25217 @pindex calc-product
25219 The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
25220 the analogous way to take a product of many terms. Calc also knows
25221 some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
25222 Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
25223 or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
25226 @pindex calc-tabulate
25228 The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
25229 evaluates a formula at a series of iterated index values, just
25230 like @code{sum} and @code{prod}, but its result is simply a
25231 vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)}
25232 produces @samp{[a_1, a_3, a_5, a_7]}.
25234 @node Logical Operations, Rewrite Rules, Summations, Algebra
25235 @section Logical Operations
25238 The following commands and algebraic functions return true/false values,
25239 where 1 represents ``true'' and 0 represents ``false.'' In cases where
25240 a truth value is required (such as for the condition part of a rewrite
25241 rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
25242 nonzero value is accepted to mean ``true.'' (Specifically, anything
25243 for which @code{dnonzero} returns 1 is ``true,'' and anything for
25244 which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
25245 Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
25246 portion if its condition is provably true, but it will execute the
25247 ``else'' portion for any condition like @expr{a = b} that is not
25248 provably true, even if it might be true. Algebraic functions that
25249 have conditions as arguments, like @code{? :} and @code{&&}, remain
25250 unevaluated if the condition is neither provably true nor provably
25251 false. @xref{Declarations}.)
25254 @pindex calc-equal-to
25258 The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
25259 (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
25260 formula) is true if @expr{a} and @expr{b} are equal, either because they
25261 are identical expressions, or because they are numbers which are
25262 numerically equal. (Thus the integer 1 is considered equal to the float
25263 1.0.) If the equality of @expr{a} and @expr{b} cannot be determined,
25264 the comparison is left in symbolic form. Note that as a command, this
25265 operation pops two values from the stack and pushes back either a 1 or
25266 a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
25268 Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
25269 For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
25270 an equation to solve for a given variable. The @kbd{a M}
25271 (@code{calc-map-equation}) command can be used to apply any
25272 function to both sides of an equation; for example, @kbd{2 a M *}
25273 multiplies both sides of the equation by two. Note that just
25274 @kbd{2 *} would not do the same thing; it would produce the formula
25275 @samp{2 (a = b)} which represents 2 if the equality is true or
25278 The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
25279 or @samp{a = b = c}) tests if all of its arguments are equal. In
25280 algebraic notation, the @samp{=} operator is unusual in that it is
25281 neither left- nor right-associative: @samp{a = b = c} is not the
25282 same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
25283 one variable with the 1 or 0 that results from comparing two other
25287 @pindex calc-not-equal-to
25290 The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
25291 @samp{a != b} function, is true if @expr{a} and @expr{b} are not equal.
25292 This also works with more than two arguments; @samp{a != b != c != d}
25293 tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are
25310 @pindex calc-less-than
25311 @pindex calc-greater-than
25312 @pindex calc-less-equal
25313 @pindex calc-greater-equal
25342 The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
25343 operation is true if @expr{a} is less than @expr{b}. Similar functions
25344 are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
25345 @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
25346 @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
25348 While the inequality functions like @code{lt} do not accept more
25349 than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
25350 equivalent expression involving intervals: @samp{b in [a .. c)}.
25351 (See the description of @code{in} below.) All four combinations
25352 of @samp{<} and @samp{<=} are allowed, or any of the four combinations
25353 of @samp{>} and @samp{>=}. Four-argument constructions like
25354 @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
25355 involve both equalities and inequalities, are not allowed.
25358 @pindex calc-remove-equal
25360 The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
25361 the righthand side of the equation or inequality on the top of the
25362 stack. It also works elementwise on vectors. For example, if
25363 @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
25364 @samp{[2.34, z / 2]}. As a special case, if the righthand side is a
25365 variable and the lefthand side is a number (as in @samp{2.34 = x}), then
25366 Calc keeps the lefthand side instead. Finally, this command works with
25367 assignments @samp{x := 2.34} as well as equations, always taking the
25368 the righthand side, and for @samp{=>} (evaluates-to) operators, always
25369 taking the lefthand side.
25372 @pindex calc-logical-and
25375 The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
25376 function is true if both of its arguments are true, i.e., are
25377 non-zero numbers. In this case, the result will be either @expr{a} or
25378 @expr{b}, chosen arbitrarily. If either argument is zero, the result is
25379 zero. Otherwise, the formula is left in symbolic form.
25382 @pindex calc-logical-or
25385 The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
25386 function is true if either or both of its arguments are true (nonzero).
25387 The result is whichever argument was nonzero, choosing arbitrarily if both
25388 are nonzero. If both @expr{a} and @expr{b} are zero, the result is
25392 @pindex calc-logical-not
25395 The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
25396 function is true if @expr{a} is false (zero), or false if @expr{a} is
25397 true (nonzero). It is left in symbolic form if @expr{a} is not a
25401 @pindex calc-logical-if
25411 @cindex Arguments, not evaluated
25412 The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
25413 function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero
25414 number or zero, respectively. If @expr{a} is not a number, the test is
25415 left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in
25416 any way. In algebraic formulas, this is one of the few Calc functions
25417 whose arguments are not automatically evaluated when the function itself
25418 is evaluated. The others are @code{lambda}, @code{quote}, and
25421 One minor surprise to watch out for is that the formula @samp{a?3:4}
25422 will not work because the @samp{3:4} is parsed as a fraction instead of
25423 as three separate symbols. Type something like @samp{a ? 3 : 4} or
25424 @samp{a?(3):4} instead.
25426 As a special case, if @expr{a} evaluates to a vector, then both @expr{b}
25427 and @expr{c} are evaluated; the result is a vector of the same length
25428 as @expr{a} whose elements are chosen from corresponding elements of
25429 @expr{b} and @expr{c} according to whether each element of @expr{a}
25430 is zero or nonzero. Each of @expr{b} and @expr{c} must be either a
25431 vector of the same length as @expr{a}, or a non-vector which is matched
25432 with all elements of @expr{a}.
25435 @pindex calc-in-set
25437 The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
25438 the number @expr{a} is in the set of numbers represented by @expr{b}.
25439 If @expr{b} is an interval form, @expr{a} must be one of the values
25440 encompassed by the interval. If @expr{b} is a vector, @expr{a} must be
25441 equal to one of the elements of the vector. (If any vector elements are
25442 intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a
25443 plain number, @expr{a} must be numerically equal to @expr{b}.
25444 @xref{Set Operations}, for a group of commands that manipulate sets
25451 The @samp{typeof(a)} function produces an integer or variable which
25452 characterizes @expr{a}. If @expr{a} is a number, vector, or variable,
25453 the result will be one of the following numbers:
25458 3 Floating-point number
25460 5 Rectangular complex number
25461 6 Polar complex number
25467 12 Infinity (inf, uinf, or nan)
25469 101 Vector (but not a matrix)
25473 Otherwise, @expr{a} is a formula, and the result is a variable which
25474 represents the name of the top-level function call.
25488 The @samp{integer(a)} function returns true if @expr{a} is an integer.
25489 The @samp{real(a)} function
25490 is true if @expr{a} is a real number, either integer, fraction, or
25491 float. The @samp{constant(a)} function returns true if @expr{a} is
25492 any of the objects for which @code{typeof} would produce an integer
25493 code result except for variables, and provided that the components of
25494 an object like a vector or error form are themselves constant.
25495 Note that infinities do not satisfy any of these tests, nor do
25496 special constants like @code{pi} and @code{e}.
25498 @xref{Declarations}, for a set of similar functions that recognize
25499 formulas as well as actual numbers. For example, @samp{dint(floor(x))}
25500 is true because @samp{floor(x)} is provably integer-valued, but
25501 @samp{integer(floor(x))} does not because @samp{floor(x)} is not
25502 literally an integer constant.
25508 The @samp{refers(a,b)} function is true if the variable (or sub-expression)
25509 @expr{b} appears in @expr{a}, or false otherwise. Unlike the other
25510 tests described here, this function returns a definite ``no'' answer
25511 even if its arguments are still in symbolic form. The only case where
25512 @code{refers} will be left unevaluated is if @expr{a} is a plain
25513 variable (different from @expr{b}).
25519 The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative,
25520 because it is a negative number, because it is of the form @expr{-x},
25521 or because it is a product or quotient with a term that looks negative.
25522 This is most useful in rewrite rules. Beware that @samp{negative(a)}
25523 evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only
25524 be stored in a formula if the default simplifications are turned off
25525 first with @kbd{m O} (or if it appears in an unevaluated context such
25526 as a rewrite rule condition).
25532 The @samp{variable(a)} function is true if @expr{a} is a variable,
25533 or false if not. If @expr{a} is a function call, this test is left
25534 in symbolic form. Built-in variables like @code{pi} and @code{inf}
25535 are considered variables like any others by this test.
25541 The @samp{nonvar(a)} function is true if @expr{a} is a non-variable.
25542 If its argument is a variable it is left unsimplified; it never
25543 actually returns zero. However, since Calc's condition-testing
25544 commands consider ``false'' anything not provably true, this is
25563 @cindex Linearity testing
25564 The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
25565 check if an expression is ``linear,'' i.e., can be written in the form
25566 @expr{a + b x} for some constants @expr{a} and @expr{b}, and some
25567 variable or subformula @expr{x}. The function @samp{islin(f,x)} checks
25568 if formula @expr{f} is linear in @expr{x}, returning 1 if so. For
25569 example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
25570 @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function
25571 is similar, except that instead of returning 1 it returns the vector
25572 @expr{[a, b, x]}. For the above examples, this vector would be
25573 @expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and
25574 @expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin}
25575 generally remain unevaluated for expressions which are not linear,
25576 e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second
25577 argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
25580 The @code{linnt} and @code{islinnt} functions perform a similar check,
25581 but require a ``non-trivial'' linear form, which means that the
25582 @expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)}
25583 returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]},
25584 but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
25585 (in other words, these formulas are considered to be only ``trivially''
25586 linear in @expr{x}).
25588 All four linearity-testing functions allow you to omit the second
25589 argument, in which case the input may be linear in any non-constant
25590 formula. Here, the @expr{a=0}, @expr{b=1} case is also considered
25591 trivial, and only constant values for @expr{a} and @expr{b} are
25592 recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]},
25593 @samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)}
25594 returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the
25595 first two cases but not the third. Also, neither @code{lin} nor
25596 @code{linnt} accept plain constants as linear in the one-argument
25597 case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
25603 The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero
25604 number or provably nonzero formula, or 0 if @expr{a} is anything else.
25605 Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
25606 used to make sure they are not evaluated prematurely. (Note that
25607 declarations are used when deciding whether a formula is true;
25608 @code{istrue} returns 1 when @code{dnonzero} would return 1, and
25609 it returns 0 when @code{dnonzero} would return 0 or leave itself
25612 @node Rewrite Rules, , Logical Operations, Algebra
25613 @section Rewrite Rules
25616 @cindex Rewrite rules
25617 @cindex Transformations
25618 @cindex Pattern matching
25620 @pindex calc-rewrite
25622 The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
25623 substitutions in a formula according to a specified pattern or patterns
25624 known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute})
25625 matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
25626 matches only the @code{sin} function applied to the variable @code{x},
25627 rewrite rules match general kinds of formulas; rewriting using the rule
25628 @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
25629 it with @code{cos} of that same argument. The only significance of the
25630 name @code{x} is that the same name is used on both sides of the rule.
25632 Rewrite rules rearrange formulas already in Calc's memory.
25633 @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
25634 similar to algebraic rewrite rules but operate when new algebraic
25635 entries are being parsed, converting strings of characters into
25639 * Entering Rewrite Rules::
25640 * Basic Rewrite Rules::
25641 * Conditional Rewrite Rules::
25642 * Algebraic Properties of Rewrite Rules::
25643 * Other Features of Rewrite Rules::
25644 * Composing Patterns in Rewrite Rules::
25645 * Nested Formulas with Rewrite Rules::
25646 * Multi-Phase Rewrite Rules::
25647 * Selections with Rewrite Rules::
25648 * Matching Commands::
25649 * Automatic Rewrites::
25650 * Debugging Rewrites::
25651 * Examples of Rewrite Rules::
25654 @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
25655 @subsection Entering Rewrite Rules
25658 Rewrite rules normally use the ``assignment'' operator
25659 @samp{@var{old} := @var{new}}.
25660 This operator is equivalent to the function call @samp{assign(old, new)}.
25661 The @code{assign} function is undefined by itself in Calc, so an
25662 assignment formula such as a rewrite rule will be left alone by ordinary
25663 Calc commands. But certain commands, like the rewrite system, interpret
25664 assignments in special ways.
25666 For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
25667 every occurrence of the sine of something, squared, with one minus the
25668 square of the cosine of that same thing. All by itself as a formula
25669 on the stack it does nothing, but when given to the @kbd{a r} command
25670 it turns that command into a sine-squared-to-cosine-squared converter.
25672 To specify a set of rules to be applied all at once, make a vector of
25675 When @kbd{a r} prompts you to enter the rewrite rules, you can answer
25680 With a rule: @kbd{f(x) := g(x) @key{RET}}.
25682 With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
25683 (You can omit the enclosing square brackets if you wish.)
25685 With the name of a variable that contains the rule or rules vector:
25686 @kbd{myrules @key{RET}}.
25688 With any formula except a rule, a vector, or a variable name; this
25689 will be interpreted as the @var{old} half of a rewrite rule,
25690 and you will be prompted a second time for the @var{new} half:
25691 @kbd{f(x) @key{RET} g(x) @key{RET}}.
25693 With a blank line, in which case the rule, rules vector, or variable
25694 will be taken from the top of the stack (and the formula to be
25695 rewritten will come from the second-to-top position).
25698 If you enter the rules directly (as opposed to using rules stored
25699 in a variable), those rules will be put into the Trail so that you
25700 can retrieve them later. @xref{Trail Commands}.
25702 It is most convenient to store rules you use often in a variable and
25703 invoke them by giving the variable name. The @kbd{s e}
25704 (@code{calc-edit-variable}) command is an easy way to create or edit a
25705 rule set stored in a variable. You may also wish to use @kbd{s p}
25706 (@code{calc-permanent-variable}) to save your rules permanently;
25707 @pxref{Operations on Variables}.
25709 Rewrite rules are compiled into a special internal form for faster
25710 matching. If you enter a rule set directly it must be recompiled
25711 every time. If you store the rules in a variable and refer to them
25712 through that variable, they will be compiled once and saved away
25713 along with the variable for later reference. This is another good
25714 reason to store your rules in a variable.
25716 Calc also accepts an obsolete notation for rules, as vectors
25717 @samp{[@var{old}, @var{new}]}. But because it is easily confused with a
25718 vector of two rules, the use of this notation is no longer recommended.
25720 @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
25721 @subsection Basic Rewrite Rules
25724 To match a particular formula @expr{x} with a particular rewrite rule
25725 @samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with
25726 the structure of @var{old}. Variables that appear in @var{old} are
25727 treated as @dfn{meta-variables}; the corresponding positions in @expr{x}
25728 may contain any sub-formulas. For example, the pattern @samp{f(x,y)}
25729 would match the expression @samp{f(12, a+1)} with the meta-variable
25730 @samp{x} corresponding to 12 and with @samp{y} corresponding to
25731 @samp{a+1}. However, this pattern would not match @samp{f(12)} or
25732 @samp{g(12, a+1)}, since there is no assignment of the meta-variables
25733 that will make the pattern match these expressions. Notice that if
25734 the pattern is a single meta-variable, it will match any expression.
25736 If a given meta-variable appears more than once in @var{old}, the
25737 corresponding sub-formulas of @expr{x} must be identical. Thus
25738 the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
25739 @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
25740 (@xref{Conditional Rewrite Rules}, for a way to match the latter.)
25742 Things other than variables must match exactly between the pattern
25743 and the target formula. To match a particular variable exactly, use
25744 the pseudo-function @samp{quote(v)} in the pattern. For example, the
25745 pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
25748 The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
25749 @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
25750 literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like
25751 @samp{sin(d + quote(e) + f)}.
25753 If the @var{old} pattern is found to match a given formula, that
25754 formula is replaced by @var{new}, where any occurrences in @var{new}
25755 of meta-variables from the pattern are replaced with the sub-formulas
25756 that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
25757 to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
25759 The normal @kbd{a r} command applies rewrite rules over and over
25760 throughout the target formula until no further changes are possible
25761 (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one
25764 @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
25765 @subsection Conditional Rewrite Rules
25768 A rewrite rule can also be @dfn{conditional}, written in the form
25769 @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete
25770 form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part
25772 rule, this is an additional condition that must be satisfied before
25773 the rule is accepted. Once @var{old} has been successfully matched
25774 to the target expression, @var{cond} is evaluated (with all the
25775 meta-variables substituted for the values they matched) and simplified
25776 with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero
25777 number or any other object known to be nonzero (@pxref{Declarations}),
25778 the rule is accepted. If the result is zero or if it is a symbolic
25779 formula that is not known to be nonzero, the rule is rejected.
25780 @xref{Logical Operations}, for a number of functions that return
25781 1 or 0 according to the results of various tests.
25783 For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n}
25784 is replaced by a positive or nonpositive number, respectively (or if
25785 @expr{n} has been declared to be positive or nonpositive). Thus,
25786 the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
25787 @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
25788 (assuming no outstanding declarations for @expr{a}). In the case of
25789 @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
25790 the case of @samp{f(12, a+1)}, the condition merely cannot be shown
25791 to be satisfied, but that is enough to reject the rule.
25793 While Calc will use declarations to reason about variables in the
25794 formula being rewritten, declarations do not apply to meta-variables.
25795 For example, the rule @samp{f(a) := g(a+1)} will match for any values
25796 of @samp{a}, such as complex numbers, vectors, or formulas, even if
25797 @samp{a} has been declared to be real or scalar. If you want the
25798 meta-variable @samp{a} to match only literal real numbers, use
25799 @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only
25800 reals and formulas which are provably real, use @samp{dreal(a)} as
25803 The @samp{::} operator is a shorthand for the @code{condition}
25804 function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
25805 the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
25807 If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
25808 or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent.
25810 It is also possible to embed conditions inside the pattern:
25811 @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational
25812 convenience, though; where a condition appears in a rule has no
25813 effect on when it is tested. The rewrite-rule compiler automatically
25814 decides when it is best to test each condition while a rule is being
25817 Certain conditions are handled as special cases by the rewrite rule
25818 system and are tested very efficiently: Where @expr{x} is any
25819 meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
25820 @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y}
25821 is either a constant or another meta-variable and @samp{>=} may be
25822 replaced by any of the six relational operators, and @samp{x % a = b}
25823 where @expr{a} and @expr{b} are constants. Other conditions, like
25824 @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
25825 since Calc must bring the whole evaluator and simplifier into play.
25827 An interesting property of @samp{::} is that neither of its arguments
25828 will be touched by Calc's default simplifications. This is important
25829 because conditions often are expressions that cannot safely be
25830 evaluated early. For example, the @code{typeof} function never
25831 remains in symbolic form; entering @samp{typeof(a)} will put the
25832 number 100 (the type code for variables like @samp{a}) on the stack.
25833 But putting the condition @samp{... :: typeof(a) = 6} on the stack
25834 is safe since @samp{::} prevents the @code{typeof} from being
25835 evaluated until the condition is actually used by the rewrite system.
25837 Since @samp{::} protects its lefthand side, too, you can use a dummy
25838 condition to protect a rule that must itself not evaluate early.
25839 For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
25840 the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
25841 where the meta-variable-ness of @code{f} on the righthand side has been
25842 lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
25843 the condition @samp{1} is always true (nonzero) so it has no effect on
25844 the functioning of the rule. (The rewrite compiler will ensure that
25845 it doesn't even impact the speed of matching the rule.)
25847 @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
25848 @subsection Algebraic Properties of Rewrite Rules
25851 The rewrite mechanism understands the algebraic properties of functions
25852 like @samp{+} and @samp{*}. In particular, pattern matching takes
25853 the associativity and commutativity of the following functions into
25857 + - * = != && || and or xor vint vunion vxor gcd lcm max min beta
25860 For example, the rewrite rule:
25863 a x + b x := (a + b) x
25867 will match formulas of the form,
25870 a x + b x, x a + x b, a x + x b, x a + b x
25873 Rewrites also understand the relationship between the @samp{+} and @samp{-}
25874 operators. The above rewrite rule will also match the formulas,
25877 a x - b x, x a - x b, a x - x b, x a - b x
25881 by matching @samp{b} in the pattern to @samp{-b} from the formula.
25883 Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
25884 pattern will check all pairs of terms for possible matches. The rewrite
25885 will take whichever suitable pair it discovers first.
25887 In general, a pattern using an associative operator like @samp{a + b}
25888 will try @var{2 n} different ways to match a sum of @var{n} terms
25889 like @samp{x + y + z - w}. First, @samp{a} is matched against each
25890 of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
25891 being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
25892 If none of these succeed, then @samp{b} is matched against each of the
25893 four terms with @samp{a} matching the remainder. Half-and-half matches,
25894 like @samp{(x + y) + (z - w)}, are not tried.
25896 Note that @samp{*} is not commutative when applied to matrices, but
25897 rewrite rules pretend that it is. If you type @kbd{m v} to enable
25898 Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
25899 literally, ignoring its usual commutativity property. (In the
25900 current implementation, the associativity also vanishes---it is as
25901 if the pattern had been enclosed in a @code{plain} marker; see below.)
25902 If you are applying rewrites to formulas with matrices, it's best to
25903 enable Matrix mode first to prevent algebraically incorrect rewrites
25906 The pattern @samp{-x} will actually match any expression. For example,
25914 will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use
25915 a @code{plain} marker as described below, or add a @samp{negative(x)}
25916 condition. The @code{negative} function is true if its argument
25917 ``looks'' negative, for example, because it is a negative number or
25918 because it is a formula like @samp{-x}. The new rule using this
25922 f(x) := -f(-x) :: negative(x) @r{or, equivalently,}
25923 f(-x) := -f(x) :: negative(-x)
25926 In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
25927 by matching @samp{y} to @samp{-b}.
25929 The pattern @samp{a b} will also match the formula @samp{x/y} if
25930 @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x}
25931 will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
25932 @samp{(a + 1:2) x}, depending on the current fraction mode).
25934 Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
25935 @samp{^}. For example, the pattern @samp{f(a b)} will not match
25936 @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
25937 though conceivably these patterns could match with @samp{a = b = x}.
25938 Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
25939 constant, even though it could be considered to match with @samp{a = x}
25940 and @samp{b = 1/y}. The reasons are partly for efficiency, and partly
25941 because while few mathematical operations are substantively different
25942 for addition and subtraction, often it is preferable to treat the cases
25943 of multiplication, division, and integer powers separately.
25945 Even more subtle is the rule set
25948 [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ]
25952 attempting to match @samp{f(x) - f(y)}. You might think that Calc
25953 will view this subtraction as @samp{f(x) + (-f(y))} and then apply
25954 the above two rules in turn, but actually this will not work because
25955 Calc only does this when considering rules for @samp{+} (like the
25956 first rule in this set). So it will see first that @samp{f(x) + (-f(y))}
25957 does not match @samp{f(a) + f(b)} for any assignments of the
25958 meta-variables, and then it will see that @samp{f(x) - f(y)} does
25959 not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc
25960 tries only one rule at a time, it will not be able to rewrite
25961 @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)}
25962 rule will have to be added.
25964 Another thing patterns will @emph{not} do is break up complex numbers.
25965 The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
25966 involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
25967 it will not match actual complex numbers like @samp{(3, -4)}. A version
25968 of the above rule for complex numbers would be
25971 myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0
25975 (Because the @code{re} and @code{im} functions understand the properties
25976 of the special constant @samp{i}, this rule will also work for
25977 @samp{3 - 4 i}. In fact, this particular rule would probably be better
25978 without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
25979 righthand side of the rule will still give the correct answer for the
25980 conjugate of a real number.)
25982 It is also possible to specify optional arguments in patterns. The rule
25985 opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d)
25989 will match the formula
25996 in a fairly straightforward manner, but it will also match reduced
26000 x + x^2, 2(x + 1) - x, x + x
26004 producing, respectively,
26007 f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0)
26010 (The latter two formulas can be entered only if default simplifications
26011 have been turned off with @kbd{m O}.)
26013 The default value for a term of a sum is zero. The default value
26014 for a part of a product, for a power, or for the denominator of a
26015 quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b}
26016 with @samp{a = -1}.
26018 In particular, the distributive-law rule can be refined to
26021 opt(a) x + opt(b) x := (a + b) x
26025 so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
26027 The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
26028 are linear in @samp{x}. You can also use the @code{lin} and @code{islin}
26029 functions with rewrite conditions to test for this; @pxref{Logical
26030 Operations}. These functions are not as convenient to use in rewrite
26031 rules, but they recognize more kinds of formulas as linear:
26032 @samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin},
26033 but it will not match the above pattern because that pattern calls
26034 for a multiplication, not a division.
26036 As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
26040 sin(x)^2 + cos(x)^2 := 1
26044 misses many cases because the sine and cosine may both be multiplied by
26045 an equal factor. Here's a more successful rule:
26048 opt(a) sin(x)^2 + opt(a) cos(x)^2 := a
26051 Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
26052 because one @expr{a} would have ``matched'' 1 while the other matched 6.
26054 Calc automatically converts a rule like
26064 f(temp, x) := g(x) :: temp = x-1
26068 (where @code{temp} stands for a new, invented meta-variable that
26069 doesn't actually have a name). This modified rule will successfully
26070 match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
26071 respectively, then verifying that they differ by one even though
26072 @samp{6} does not superficially look like @samp{x-1}.
26074 However, Calc does not solve equations to interpret a rule. The
26078 f(x-1, x+1) := g(x)
26082 will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
26083 but not @samp{f(6, 8)}. Calc always interprets at least one occurrence
26084 of a variable by literal matching. If the variable appears ``isolated''
26085 then Calc is smart enough to use it for literal matching. But in this
26086 last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
26087 := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
26088 actual ``something-minus-one'' in the target formula.
26090 A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
26091 You could make this resemble the original form more closely by using
26092 @code{let} notation, which is described in the next section:
26095 f(xm1, x+1) := g(x) :: let(x := xm1+1)
26098 Calc does this rewriting or ``conditionalizing'' for any sub-pattern
26099 which involves only the functions in the following list, operating
26100 only on constants and meta-variables which have already been matched
26101 elsewhere in the pattern. When matching a function call, Calc is
26102 careful to match arguments which are plain variables before arguments
26103 which are calls to any of the functions below, so that a pattern like
26104 @samp{f(x-1, x)} can be conditionalized even though the isolated
26105 @samp{x} comes after the @samp{x-1}.
26108 + - * / \ % ^ abs sign round rounde roundu trunc floor ceil
26109 max min re im conj arg
26112 You can suppress all of the special treatments described in this
26113 section by surrounding a function call with a @code{plain} marker.
26114 This marker causes the function call which is its argument to be
26115 matched literally, without regard to commutativity, associativity,
26116 negation, or conditionalization. When you use @code{plain}, the
26117 ``deep structure'' of the formula being matched can show through.
26121 plain(a - a b) := f(a, b)
26125 will match only literal subtractions. However, the @code{plain}
26126 marker does not affect its arguments' arguments. In this case,
26127 commutativity and associativity is still considered while matching
26128 the @w{@samp{a b}} sub-pattern, so the whole pattern will match
26129 @samp{x - y x} as well as @samp{x - x y}. We could go still
26133 plain(a - plain(a b)) := f(a, b)
26137 which would do a completely strict match for the pattern.
26139 By contrast, the @code{quote} marker means that not only the
26140 function name but also the arguments must be literally the same.
26141 The above pattern will match @samp{x - x y} but
26144 quote(a - a b) := f(a, b)
26148 will match only the single formula @samp{a - a b}. Also,
26151 quote(a - quote(a b)) := f(a, b)
26155 will match only @samp{a - quote(a b)}---probably not the desired
26158 A certain amount of algebra is also done when substituting the
26159 meta-variables on the righthand side of a rule. For example,
26163 a + f(b) := f(a + b)
26167 matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
26168 taken literally, but the rewrite mechanism will simplify the
26169 righthand side to @samp{f(x - y)} automatically. (Of course,
26170 the default simplifications would do this anyway, so this
26171 special simplification is only noticeable if you have turned the
26172 default simplifications off.) This rewriting is done only when
26173 a meta-variable expands to a ``negative-looking'' expression.
26174 If this simplification is not desirable, you can use a @code{plain}
26175 marker on the righthand side:
26178 a + f(b) := f(plain(a + b))
26182 In this example, we are still allowing the pattern-matcher to
26183 use all the algebra it can muster, but the righthand side will
26184 always simplify to a literal addition like @samp{f((-y) + x)}.
26186 @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
26187 @subsection Other Features of Rewrite Rules
26190 Certain ``function names'' serve as markers in rewrite rules.
26191 Here is a complete list of these markers. First are listed the
26192 markers that work inside a pattern; then come the markers that
26193 work in the righthand side of a rule.
26199 One kind of marker, @samp{import(x)}, takes the place of a whole
26200 rule. Here @expr{x} is the name of a variable containing another
26201 rule set; those rules are ``spliced into'' the rule set that
26202 imports them. For example, if @samp{[f(a+b) := f(a) + f(b),
26203 f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
26204 then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
26205 all three rules. It is possible to modify the imported rules
26206 slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports
26207 the rule set @expr{x} with all occurrences of
26208 @texline @math{v_1},
26209 @infoline @expr{v1},
26210 as either a variable name or a function name, replaced with
26211 @texline @math{x_1}
26212 @infoline @expr{x1}
26214 @texline @math{v_1}
26215 @infoline @expr{v1}
26216 is used as a function name, then
26217 @texline @math{x_1}
26218 @infoline @expr{x1}
26219 must be either a function name itself or a @w{@samp{< >}} nameless
26220 function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0,
26221 import(linearF, f, g)]} applies the linearity rules to the function
26222 @samp{g} instead of @samp{f}. Imports can be nested, but the
26223 import-with-renaming feature may fail to rename sub-imports properly.
26225 The special functions allowed in patterns are:
26233 This pattern matches exactly @expr{x}; variable names in @expr{x} are
26234 not interpreted as meta-variables. The only flexibility is that
26235 numbers are compared for numeric equality, so that the pattern
26236 @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
26237 (Numbers are always treated this way by the rewrite mechanism:
26238 The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
26239 The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
26240 as a result in this case.)
26247 Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This
26248 pattern matches a call to function @expr{f} with the specified
26249 argument patterns. No special knowledge of the properties of the
26250 function @expr{f} is used in this case; @samp{+} is not commutative or
26251 associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
26252 are treated as patterns. If you wish them to be treated ``plainly''
26253 as well, you must enclose them with more @code{plain} markers:
26254 @samp{plain(plain(@w{-a}) + plain(b c))}.
26261 Here @expr{x} must be a variable name. This must appear as an
26262 argument to a function or an element of a vector; it specifies that
26263 the argument or element is optional.
26264 As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
26265 or as the second argument to @samp{/} or @samp{^}, the value @var{def}
26266 may be omitted. The pattern @samp{x + opt(y)} matches a sum by
26267 binding one summand to @expr{x} and the other to @expr{y}, and it
26268 matches anything else by binding the whole expression to @expr{x} and
26269 zero to @expr{y}. The other operators above work similarly.
26271 For general miscellaneous functions, the default value @code{def}
26272 must be specified. Optional arguments are dropped starting with
26273 the rightmost one during matching. For example, the pattern
26274 @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
26275 or @samp{f(a,b,c)}. Default values of zero and @expr{b} are
26276 supplied in this example for the omitted arguments. Note that
26277 the literal variable @expr{b} will be the default in the latter
26278 case, @emph{not} the value that matched the meta-variable @expr{b}.
26279 In other words, the default @var{def} is effectively quoted.
26281 @item condition(x,c)
26287 This matches the pattern @expr{x}, with the attached condition
26288 @expr{c}. It is the same as @samp{x :: c}.
26296 This matches anything that matches both pattern @expr{x} and
26297 pattern @expr{y}. It is the same as @samp{x &&& y}.
26298 @pxref{Composing Patterns in Rewrite Rules}.
26306 This matches anything that matches either pattern @expr{x} or
26307 pattern @expr{y}. It is the same as @w{@samp{x ||| y}}.
26315 This matches anything that does not match pattern @expr{x}.
26316 It is the same as @samp{!!! x}.
26322 @tindex cons (rewrites)
26323 This matches any vector of one or more elements. The first
26324 element is matched to @expr{h}; a vector of the remaining
26325 elements is matched to @expr{t}. Note that vectors of fixed
26326 length can also be matched as actual vectors: The rule
26327 @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
26328 to the rule @samp{[a,b] := [a+b]}.
26334 @tindex rcons (rewrites)
26335 This is like @code{cons}, except that the @emph{last} element
26336 is matched to @expr{h}, with the remaining elements matched
26339 @item apply(f,args)
26343 @tindex apply (rewrites)
26344 This matches any function call. The name of the function, in
26345 the form of a variable, is matched to @expr{f}. The arguments
26346 of the function, as a vector of zero or more objects, are
26347 matched to @samp{args}. Constants, variables, and vectors
26348 do @emph{not} match an @code{apply} pattern. For example,
26349 @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
26350 matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
26351 matches any function call with exactly two arguments, and
26352 @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
26353 to the function @samp{f} with two or more arguments. Another
26354 way to implement the latter, if the rest of the rule does not
26355 need to refer to the first two arguments of @samp{f} by name,
26356 would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
26357 Here's a more interesting sample use of @code{apply}:
26360 apply(f,[x+n]) := n + apply(f,[x])
26361 :: in(f, [floor,ceil,round,trunc]) :: integer(n)
26364 Note, however, that this will be slower to match than a rule
26365 set with four separate rules. The reason is that Calc sorts
26366 the rules of a rule set according to top-level function name;
26367 if the top-level function is @code{apply}, Calc must try the
26368 rule for every single formula and sub-formula. If the top-level
26369 function in the pattern is, say, @code{floor}, then Calc invokes
26370 the rule only for sub-formulas which are calls to @code{floor}.
26372 Formulas normally written with operators like @code{+} are still
26373 considered function calls: @code{apply(f,x)} matches @samp{a+b}
26374 with @samp{f = add}, @samp{x = [a,b]}.
26376 You must use @code{apply} for meta-variables with function names
26377 on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)}
26378 is @emph{not} correct, because it rewrites @samp{spam(6)} into
26379 @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}.
26380 Also note that you will have to use No-Simplify mode (@kbd{m O})
26381 when entering this rule so that the @code{apply} isn't
26382 evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
26383 Or, use @kbd{s e} to enter the rule without going through the stack,
26384 or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
26385 @xref{Conditional Rewrite Rules}.
26392 This is used for applying rules to formulas with selections;
26393 @pxref{Selections with Rewrite Rules}.
26396 Special functions for the righthand sides of rules are:
26400 The notation @samp{quote(x)} is changed to @samp{x} when the
26401 righthand side is used. As far as the rewrite rule is concerned,
26402 @code{quote} is invisible. However, @code{quote} has the special
26403 property in Calc that its argument is not evaluated. Thus,
26404 while it will not work to put the rule @samp{t(a) := typeof(a)}
26405 on the stack because @samp{typeof(a)} is evaluated immediately
26406 to produce @samp{t(a) := 100}, you can use @code{quote} to
26407 protect the righthand side: @samp{t(a) := quote(typeof(a))}.
26408 (@xref{Conditional Rewrite Rules}, for another trick for
26409 protecting rules from evaluation.)
26412 Special properties of and simplifications for the function call
26413 @expr{x} are not used. One interesting case where @code{plain}
26414 is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
26415 shorthand notation for the @code{quote} function. This rule will
26416 not work as shown; instead of replacing @samp{q(foo)} with
26417 @samp{quote(foo)}, it will replace it with @samp{foo}! The correct
26418 rule would be @samp{q(x) := plain(quote(x))}.
26421 Where @expr{t} is a vector, this is converted into an expanded
26422 vector during rewrite processing. Note that @code{cons} is a regular
26423 Calc function which normally does this anyway; the only way @code{cons}
26424 is treated specially by rewrites is that @code{cons} on the righthand
26425 side of a rule will be evaluated even if default simplifications
26426 have been turned off.
26429 Analogous to @code{cons} except putting @expr{h} at the @emph{end} of
26430 the vector @expr{t}.
26432 @item apply(f,args)
26433 Where @expr{f} is a variable and @var{args} is a vector, this
26434 is converted to a function call. Once again, note that @code{apply}
26435 is also a regular Calc function.
26442 The formula @expr{x} is handled in the usual way, then the
26443 default simplifications are applied to it even if they have
26444 been turned off normally. This allows you to treat any function
26445 similarly to the way @code{cons} and @code{apply} are always
26446 treated. However, there is a slight difference: @samp{cons(2+3, [])}
26447 with default simplifications off will be converted to @samp{[2+3]},
26448 whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
26455 The formula @expr{x} has meta-variables substituted in the usual
26456 way, then algebraically simplified as if by the @kbd{a s} command.
26458 @item evalextsimp(x)
26462 @tindex evalextsimp
26463 The formula @expr{x} has meta-variables substituted in the normal
26464 way, then ``extendedly'' simplified as if by the @kbd{a e} command.
26467 @xref{Selections with Rewrite Rules}.
26470 There are also some special functions you can use in conditions.
26478 The expression @expr{x} is evaluated with meta-variables substituted.
26479 The @kbd{a s} command's simplifications are @emph{not} applied by
26480 default, but @expr{x} can include calls to @code{evalsimp} or
26481 @code{evalextsimp} as described above to invoke higher levels
26482 of simplification. The
26483 result of @expr{x} is then bound to the meta-variable @expr{v}. As
26484 usual, if this meta-variable has already been matched to something
26485 else the two values must be equal; if the meta-variable is new then
26486 it is bound to the result of the expression. This variable can then
26487 appear in later conditions, and on the righthand side of the rule.
26488 In fact, @expr{v} may be any pattern in which case the result of
26489 evaluating @expr{x} is matched to that pattern, binding any
26490 meta-variables that appear in that pattern. Note that @code{let}
26491 can only appear by itself as a condition, or as one term of an
26492 @samp{&&} which is a whole condition: It cannot be inside
26493 an @samp{||} term or otherwise buried.
26495 The alternate, equivalent form @samp{let(v, x)} is also recognized.
26496 Note that the use of @samp{:=} by @code{let}, while still being
26497 assignment-like in character, is unrelated to the use of @samp{:=}
26498 in the main part of a rewrite rule.
26500 As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
26501 replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
26502 that inverse exists and is constant. For example, if @samp{a} is a
26503 singular matrix the operation @samp{1/a} is left unsimplified and
26504 @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
26505 then the rule succeeds. Without @code{let} there would be no way
26506 to express this rule that didn't have to invert the matrix twice.
26507 Note that, because the meta-variable @samp{ia} is otherwise unbound
26508 in this rule, the @code{let} condition itself always ``succeeds''
26509 because no matter what @samp{1/a} evaluates to, it can successfully
26510 be bound to @code{ia}.
26512 Here's another example, for integrating cosines of linear
26513 terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
26514 The @code{lin} function returns a 3-vector if its argument is linear,
26515 or leaves itself unevaluated if not. But an unevaluated @code{lin}
26516 call will not match the 3-vector on the lefthand side of the @code{let},
26517 so this @code{let} both verifies that @code{y} is linear, and binds
26518 the coefficients @code{a} and @code{b} for use elsewhere in the rule.
26519 (It would have been possible to use @samp{sin(a x + b)/b} for the
26520 righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
26521 rearrangement of the argument of the sine.)
26527 Similarly, here is a rule that implements an inverse-@code{erf}
26528 function. It uses @code{root} to search for a solution. If
26529 @code{root} succeeds, it will return a vector of two numbers
26530 where the first number is the desired solution. If no solution
26531 is found, @code{root} remains in symbolic form. So we use
26532 @code{let} to check that the result was indeed a vector.
26535 ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5))
26539 The meta-variable @var{v}, which must already have been matched
26540 to something elsewhere in the rule, is compared against pattern
26541 @var{p}. Since @code{matches} is a standard Calc function, it
26542 can appear anywhere in a condition. But if it appears alone or
26543 as a term of a top-level @samp{&&}, then you get the special
26544 extra feature that meta-variables which are bound to things
26545 inside @var{p} can be used elsewhere in the surrounding rewrite
26548 The only real difference between @samp{let(p := v)} and
26549 @samp{matches(v, p)} is that the former evaluates @samp{v} using
26550 the default simplifications, while the latter does not.
26554 This is actually a variable, not a function. If @code{remember}
26555 appears as a condition in a rule, then when that rule succeeds
26556 the original expression and rewritten expression are added to the
26557 front of the rule set that contained the rule. If the rule set
26558 was not stored in a variable, @code{remember} is ignored. The
26559 lefthand side is enclosed in @code{quote} in the added rule if it
26560 contains any variables.
26562 For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
26563 to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
26564 of the rule set. The rule set @code{EvalRules} works slightly
26565 differently: There, the evaluation of @samp{f(6)} will complete before
26566 the result is added to the rule set, in this case as @samp{f(7) := 5040}.
26567 Thus @code{remember} is most useful inside @code{EvalRules}.
26569 It is up to you to ensure that the optimization performed by
26570 @code{remember} is safe. For example, the rule @samp{foo(n) := n
26571 :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
26572 the function equivalent of the @kbd{=} command); if the variable
26573 @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
26574 be added to the rule set and will continue to operate even if
26575 @code{eatfoo} is later changed to 0.
26582 Remember the match as described above, but only if condition @expr{c}
26583 is true. For example, @samp{remember(n % 4 = 0)} in the above factorial
26584 rule remembers only every fourth result. Note that @samp{remember(1)}
26585 is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
26588 @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
26589 @subsection Composing Patterns in Rewrite Rules
26592 There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
26593 that combine rewrite patterns to make larger patterns. The
26594 combinations are ``and,'' ``or,'' and ``not,'' respectively, and
26595 these operators are the pattern equivalents of @samp{&&}, @samp{||}
26596 and @samp{!} (which operate on zero-or-nonzero logical values).
26598 Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
26599 form by all regular Calc features; they have special meaning only in
26600 the context of rewrite rule patterns.
26602 The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
26603 matches both @var{p1} and @var{p2}. One especially useful case is
26604 when one of @var{p1} or @var{p2} is a meta-variable. For example,
26605 here is a rule that operates on error forms:
26608 f(x &&& a +/- b, x) := g(x)
26611 This does the same thing, but is arguably simpler than, the rule
26614 f(a +/- b, a +/- b) := g(a +/- b)
26621 Here's another interesting example:
26624 ends(cons(a, x) &&& rcons(y, b)) := [a, b]
26628 which effectively clips out the middle of a vector leaving just
26629 the first and last elements. This rule will change a one-element
26630 vector @samp{[a]} to @samp{[a, a]}. The similar rule
26633 ends(cons(a, rcons(y, b))) := [a, b]
26637 would do the same thing except that it would fail to match a
26638 one-element vector.
26644 The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
26645 matches either @var{p1} or @var{p2}. Calc first tries matching
26646 against @var{p1}; if that fails, it goes on to try @var{p2}.
26652 A simple example of @samp{|||} is
26655 curve(inf ||| -inf) := 0
26659 which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
26661 Here is a larger example:
26664 log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b)
26667 This matches both generalized and natural logarithms in a single rule.
26668 Note that the @samp{::} term must be enclosed in parentheses because
26669 that operator has lower precedence than @samp{|||} or @samp{:=}.
26671 (In practice this rule would probably include a third alternative,
26672 omitted here for brevity, to take care of @code{log10}.)
26674 While Calc generally treats interior conditions exactly the same as
26675 conditions on the outside of a rule, it does guarantee that if all the
26676 variables in the condition are special names like @code{e}, or already
26677 bound in the pattern to which the condition is attached (say, if
26678 @samp{a} had appeared in this condition), then Calc will process this
26679 condition right after matching the pattern to the left of the @samp{::}.
26680 Thus, we know that @samp{b} will be bound to @samp{e} only if the
26681 @code{ln} branch of the @samp{|||} was taken.
26683 Note that this rule was careful to bind the same set of meta-variables
26684 on both sides of the @samp{|||}. Calc does not check this, but if
26685 you bind a certain meta-variable only in one branch and then use that
26686 meta-variable elsewhere in the rule, results are unpredictable:
26689 f(a,b) ||| g(b) := h(a,b)
26692 Here if the pattern matches @samp{g(17)}, Calc makes no promises about
26693 the value that will be substituted for @samp{a} on the righthand side.
26699 The pattern @samp{!!! @var{pat}} matches anything that does not
26700 match @var{pat}. Any meta-variables that are bound while matching
26701 @var{pat} remain unbound outside of @var{pat}.
26706 f(x &&& !!! a +/- b, !!![]) := g(x)
26710 converts @code{f} whose first argument is anything @emph{except} an
26711 error form, and whose second argument is not the empty vector, into
26712 a similar call to @code{g} (but without the second argument).
26714 If we know that the second argument will be a vector (empty or not),
26715 then an equivalent rule would be:
26718 f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0
26722 where of course 7 is the @code{typeof} code for error forms.
26723 Another final condition, that works for any kind of @samp{y},
26724 would be @samp{!istrue(y == [])}. (The @code{istrue} function
26725 returns an explicit 0 if its argument was left in symbolic form;
26726 plain @samp{!(y == [])} or @samp{y != []} would not work to replace
26727 @samp{!!![]} since these would be left unsimplified, and thus cause
26728 the rule to fail, if @samp{y} was something like a variable name.)
26730 It is possible for a @samp{!!!} to refer to meta-variables bound
26731 elsewhere in the pattern. For example,
26738 matches any call to @code{f} with different arguments, changing
26739 this to @code{g} with only the first argument.
26741 If a function call is to be matched and one of the argument patterns
26742 contains a @samp{!!!} somewhere inside it, that argument will be
26750 will be careful to bind @samp{a} to the second argument of @code{f}
26751 before testing the first argument. If Calc had tried to match the
26752 first argument of @code{f} first, the results would have been
26753 disastrous: since @code{a} was unbound so far, the pattern @samp{a}
26754 would have matched anything at all, and the pattern @samp{!!!a}
26755 therefore would @emph{not} have matched anything at all!
26757 @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
26758 @subsection Nested Formulas with Rewrite Rules
26761 When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
26762 the top of the stack and attempts to match any of the specified rules
26763 to any part of the expression, starting with the whole expression
26764 and then, if that fails, trying deeper and deeper sub-expressions.
26765 For each part of the expression, the rules are tried in the order
26766 they appear in the rules vector. The first rule to match the first
26767 sub-expression wins; it replaces the matched sub-expression according
26768 to the @var{new} part of the rule.
26770 Often, the rule set will match and change the formula several times.
26771 The top-level formula is first matched and substituted repeatedly until
26772 it no longer matches the pattern; then, sub-formulas are tried, and
26773 so on. Once every part of the formula has gotten its chance, the
26774 rewrite mechanism starts over again with the top-level formula
26775 (in case a substitution of one of its arguments has caused it again
26776 to match). This continues until no further matches can be made
26777 anywhere in the formula.
26779 It is possible for a rule set to get into an infinite loop. The
26780 most obvious case, replacing a formula with itself, is not a problem
26781 because a rule is not considered to ``succeed'' unless the righthand
26782 side actually comes out to something different than the original
26783 formula or sub-formula that was matched. But if you accidentally
26784 had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
26785 @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
26786 run forever switching a formula back and forth between the two
26789 To avoid disaster, Calc normally stops after 100 changes have been
26790 made to the formula. This will be enough for most multiple rewrites,
26791 but it will keep an endless loop of rewrites from locking up the
26792 computer forever. (On most systems, you can also type @kbd{C-g} to
26793 halt any Emacs command prematurely.)
26795 To change this limit, give a positive numeric prefix argument.
26796 In particular, @kbd{M-1 a r} applies only one rewrite at a time,
26797 useful when you are first testing your rule (or just if repeated
26798 rewriting is not what is called for by your application).
26807 You can also put a ``function call'' @samp{iterations(@var{n})}
26808 in place of a rule anywhere in your rules vector (but usually at
26809 the top). Then, @var{n} will be used instead of 100 as the default
26810 number of iterations for this rule set. You can use
26811 @samp{iterations(inf)} if you want no iteration limit by default.
26812 A prefix argument will override the @code{iterations} limit in the
26820 More precisely, the limit controls the number of ``iterations,''
26821 where each iteration is a successful matching of a rule pattern whose
26822 righthand side, after substituting meta-variables and applying the
26823 default simplifications, is different from the original sub-formula
26826 A prefix argument of zero sets the limit to infinity. Use with caution!
26828 Given a negative numeric prefix argument, @kbd{a r} will match and
26829 substitute the top-level expression up to that many times, but
26830 will not attempt to match the rules to any sub-expressions.
26832 In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
26833 does a rewriting operation. Here @var{expr} is the expression
26834 being rewritten, @var{rules} is the rule, vector of rules, or
26835 variable containing the rules, and @var{n} is the optional
26836 iteration limit, which may be a positive integer, a negative
26837 integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted
26838 the @code{iterations} value from the rule set is used; if both
26839 are omitted, 100 is used.
26841 @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
26842 @subsection Multi-Phase Rewrite Rules
26845 It is possible to separate a rewrite rule set into several @dfn{phases}.
26846 During each phase, certain rules will be enabled while certain others
26847 will be disabled. A @dfn{phase schedule} controls the order in which
26848 phases occur during the rewriting process.
26855 If a call to the marker function @code{phase} appears in the rules
26856 vector in place of a rule, all rules following that point will be
26857 members of the phase(s) identified in the arguments to @code{phase}.
26858 Phases are given integer numbers. The markers @samp{phase()} and
26859 @samp{phase(all)} both mean the following rules belong to all phases;
26860 this is the default at the start of the rule set.
26862 If you do not explicitly schedule the phases, Calc sorts all phase
26863 numbers that appear in the rule set and executes the phases in
26864 ascending order. For example, the rule set
26881 has three phases, 1 through 3. Phase 1 consists of the @code{f0},
26882 @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of
26883 @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0}
26886 When Calc rewrites a formula using this rule set, it first rewrites
26887 the formula using only the phase 1 rules until no further changes are
26888 possible. Then it switches to the phase 2 rule set and continues
26889 until no further changes occur, then finally rewrites with phase 3.
26890 When no more phase 3 rules apply, rewriting finishes. (This is
26891 assuming @kbd{a r} with a large enough prefix argument to allow the
26892 rewriting to run to completion; the sequence just described stops
26893 early if the number of iterations specified in the prefix argument,
26894 100 by default, is reached.)
26896 During each phase, Calc descends through the nested levels of the
26897 formula as described previously. (@xref{Nested Formulas with Rewrite
26898 Rules}.) Rewriting starts at the top of the formula, then works its
26899 way down to the parts, then goes back to the top and works down again.
26900 The phase 2 rules do not begin until no phase 1 rules apply anywhere
26907 A @code{schedule} marker appearing in the rule set (anywhere, but
26908 conventionally at the top) changes the default schedule of phases.
26909 In the simplest case, @code{schedule} has a sequence of phase numbers
26910 for arguments; each phase number is invoked in turn until the
26911 arguments to @code{schedule} are exhausted. Thus adding
26912 @samp{schedule(3,2,1)} at the top of the above rule set would
26913 reverse the order of the phases; @samp{schedule(1,2,3)} would have
26914 no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
26915 would give phase 1 a second chance after phase 2 has completed, before
26916 moving on to phase 3.
26918 Any argument to @code{schedule} can instead be a vector of phase
26919 numbers (or even of sub-vectors). Then the sub-sequence of phases
26920 described by the vector are tried repeatedly until no change occurs
26921 in any phase in the sequence. For example, @samp{schedule([1, 2], 3)}
26922 tries phase 1, then phase 2, then, if either phase made any changes
26923 to the formula, repeats these two phases until they can make no
26924 further progress. Finally, it goes on to phase 3 for finishing
26927 Also, items in @code{schedule} can be variable names as well as
26928 numbers. A variable name is interpreted as the name of a function
26929 to call on the whole formula. For example, @samp{schedule(1, simplify)}
26930 says to apply the phase-1 rules (presumably, all of them), then to
26931 call @code{simplify} which is the function name equivalent of @kbd{a s}.
26932 Likewise, @samp{schedule([1, simplify])} says to alternate between
26933 phase 1 and @kbd{a s} until no further changes occur.
26935 Phases can be used purely to improve efficiency; if it is known that
26936 a certain group of rules will apply only at the beginning of rewriting,
26937 and a certain other group will apply only at the end, then rewriting
26938 will be faster if these groups are identified as separate phases.
26939 Once the phase 1 rules are done, Calc can put them aside and no longer
26940 spend any time on them while it works on phase 2.
26942 There are also some problems that can only be solved with several
26943 rewrite phases. For a real-world example of a multi-phase rule set,
26944 examine the set @code{FitRules}, which is used by the curve-fitting
26945 command to convert a model expression to linear form.
26946 @xref{Curve Fitting Details}. This set is divided into four phases.
26947 The first phase rewrites certain kinds of expressions to be more
26948 easily linearizable, but less computationally efficient. After the
26949 linear components have been picked out, the final phase includes the
26950 opposite rewrites to put each component back into an efficient form.
26951 If both sets of rules were included in one big phase, Calc could get
26952 into an infinite loop going back and forth between the two forms.
26954 Elsewhere in @code{FitRules}, the components are first isolated,
26955 then recombined where possible to reduce the complexity of the linear
26956 fit, then finally packaged one component at a time into vectors.
26957 If the packaging rules were allowed to begin before the recombining
26958 rules were finished, some components might be put away into vectors
26959 before they had a chance to recombine. By putting these rules in
26960 two separate phases, this problem is neatly avoided.
26962 @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
26963 @subsection Selections with Rewrite Rules
26966 If a sub-formula of the current formula is selected (as by @kbd{j s};
26967 @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
26968 command applies only to that sub-formula. Together with a negative
26969 prefix argument, you can use this fact to apply a rewrite to one
26970 specific part of a formula without affecting any other parts.
26973 @pindex calc-rewrite-selection
26974 The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
26975 sophisticated operations on selections. This command prompts for
26976 the rules in the same way as @kbd{a r}, but it then applies those
26977 rules to the whole formula in question even though a sub-formula
26978 of it has been selected. However, the selected sub-formula will
26979 first have been surrounded by a @samp{select( )} function call.
26980 (Calc's evaluator does not understand the function name @code{select};
26981 this is only a tag used by the @kbd{j r} command.)
26983 For example, suppose the formula on the stack is @samp{2 (a + b)^2}
26984 and the sub-formula @samp{a + b} is selected. This formula will
26985 be rewritten to @samp{2 select(a + b)^2} and then the rewrite
26986 rules will be applied in the usual way. The rewrite rules can
26987 include references to @code{select} to tell where in the pattern
26988 the selected sub-formula should appear.
26990 If there is still exactly one @samp{select( )} function call in
26991 the formula after rewriting is done, it indicates which part of
26992 the formula should be selected afterwards. Otherwise, the
26993 formula will be unselected.
26995 You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
26996 of the rewrite rule with @samp{select()}. However, @kbd{j r}
26997 allows you to use the current selection in more flexible ways.
26998 Suppose you wished to make a rule which removed the exponent from
26999 the selected term; the rule @samp{select(a)^x := select(a)} would
27000 work. In the above example, it would rewrite @samp{2 select(a + b)^2}
27001 to @samp{2 select(a + b)}. This would then be returned to the
27002 stack as @samp{2 (a + b)} with the @samp{a + b} selected.
27004 The @kbd{j r} command uses one iteration by default, unlike
27005 @kbd{a r} which defaults to 100 iterations. A numeric prefix
27006 argument affects @kbd{j r} in the same way as @kbd{a r}.
27007 @xref{Nested Formulas with Rewrite Rules}.
27009 As with other selection commands, @kbd{j r} operates on the stack
27010 entry that contains the cursor. (If the cursor is on the top-of-stack
27011 @samp{.} marker, it works as if the cursor were on the formula
27014 If you don't specify a set of rules, the rules are taken from the
27015 top of the stack, just as with @kbd{a r}. In this case, the
27016 cursor must indicate stack entry 2 or above as the formula to be
27017 rewritten (otherwise the same formula would be used as both the
27018 target and the rewrite rules).
27020 If the indicated formula has no selection, the cursor position within
27021 the formula temporarily selects a sub-formula for the purposes of this
27022 command. If the cursor is not on any sub-formula (e.g., it is in
27023 the line-number area to the left of the formula), the @samp{select( )}
27024 markers are ignored by the rewrite mechanism and the rules are allowed
27025 to apply anywhere in the formula.
27027 As a special feature, the normal @kbd{a r} command also ignores
27028 @samp{select( )} calls in rewrite rules. For example, if you used the
27029 above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
27030 the rule as if it were @samp{a^x := a}. Thus, you can write general
27031 purpose rules with @samp{select( )} hints inside them so that they
27032 will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
27033 both with and without selections.
27035 @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
27036 @subsection Matching Commands
27042 The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
27043 vector of formulas and a rewrite-rule-style pattern, and produces
27044 a vector of all formulas which match the pattern. The command
27045 prompts you to enter the pattern; as for @kbd{a r}, you can enter
27046 a single pattern (i.e., a formula with meta-variables), or a
27047 vector of patterns, or a variable which contains patterns, or
27048 you can give a blank response in which case the patterns are taken
27049 from the top of the stack. The pattern set will be compiled once
27050 and saved if it is stored in a variable. If there are several
27051 patterns in the set, vector elements are kept if they match any
27054 For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
27055 will return @samp{[x+y, x-y, x+y+z]}.
27057 The @code{import} mechanism is not available for pattern sets.
27059 The @kbd{a m} command can also be used to extract all vector elements
27060 which satisfy any condition: The pattern @samp{x :: x>0} will select
27061 all the positive vector elements.
27065 With the Inverse flag [@code{matchnot}], this command extracts all
27066 vector elements which do @emph{not} match the given pattern.
27072 There is also a function @samp{matches(@var{x}, @var{p})} which
27073 evaluates to 1 if expression @var{x} matches pattern @var{p}, or
27074 to 0 otherwise. This is sometimes useful for including into the
27075 conditional clauses of other rewrite rules.
27081 The function @code{vmatches} is just like @code{matches}, except
27082 that if the match succeeds it returns a vector of assignments to
27083 the meta-variables instead of the number 1. For example,
27084 @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
27085 If the match fails, the function returns the number 0.
27087 @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
27088 @subsection Automatic Rewrites
27091 @cindex @code{EvalRules} variable
27093 It is possible to get Calc to apply a set of rewrite rules on all
27094 results, effectively adding to the built-in set of default
27095 simplifications. To do this, simply store your rule set in the
27096 variable @code{EvalRules}. There is a convenient @kbd{s E} command
27097 for editing @code{EvalRules}; @pxref{Operations on Variables}.
27099 For example, suppose you want @samp{sin(a + b)} to be expanded out
27100 to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
27101 similarly for @samp{cos(a + b)}. The corresponding rewrite rule
27106 [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b),
27107 cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ]
27111 To apply these manually, you could put them in a variable called
27112 @code{trigexp} and then use @kbd{a r trigexp} every time you wanted
27113 to expand trig functions. But if instead you store them in the
27114 variable @code{EvalRules}, they will automatically be applied to all
27115 sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on
27116 the stack, typing @kbd{+ S} will (assuming Degrees mode) result in
27117 @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
27119 As each level of a formula is evaluated, the rules from
27120 @code{EvalRules} are applied before the default simplifications.
27121 Rewriting continues until no further @code{EvalRules} apply.
27122 Note that this is different from the usual order of application of
27123 rewrite rules: @code{EvalRules} works from the bottom up, simplifying
27124 the arguments to a function before the function itself, while @kbd{a r}
27125 applies rules from the top down.
27127 Because the @code{EvalRules} are tried first, you can use them to
27128 override the normal behavior of any built-in Calc function.
27130 It is important not to write a rule that will get into an infinite
27131 loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
27132 appears to be a good definition of a factorial function, but it is
27133 unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc
27134 will continue to subtract 1 from this argument forever without reaching
27135 zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
27136 Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting
27137 @samp{g(2, 4)}, this would bounce back and forth between that and
27138 @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules}
27139 occurs, Emacs will eventually stop with a ``Computation got stuck
27140 or ran too long'' message.
27142 Another subtle difference between @code{EvalRules} and regular rewrites
27143 concerns rules that rewrite a formula into an identical formula. For
27144 example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is
27145 already an integer. But in @code{EvalRules} this case is detected only
27146 if the righthand side literally becomes the original formula before any
27147 further simplification. This means that @samp{f(n) := f(floor(n))} will
27148 get into an infinite loop if it occurs in @code{EvalRules}. Calc will
27149 replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
27150 @samp{f(6)}, so it will consider the rule to have matched and will
27151 continue simplifying that formula; first the argument is simplified
27152 to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
27153 again, ad infinitum. A much safer rule would check its argument first,
27154 say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
27156 (What really happens is that the rewrite mechanism substitutes the
27157 meta-variables in the righthand side of a rule, compares to see if the
27158 result is the same as the original formula and fails if so, then uses
27159 the default simplifications to simplify the result and compares again
27160 (and again fails if the formula has simplified back to its original
27161 form). The only special wrinkle for the @code{EvalRules} is that the
27162 same rules will come back into play when the default simplifications
27163 are used. What Calc wants to do is build @samp{f(floor(6))}, see that
27164 this is different from the original formula, simplify to @samp{f(6)},
27165 see that this is the same as the original formula, and thus halt the
27166 rewriting. But while simplifying, @samp{f(6)} will again trigger
27167 the same @code{EvalRules} rule and Calc will get into a loop inside
27168 the rewrite mechanism itself.)
27170 The @code{phase}, @code{schedule}, and @code{iterations} markers do
27171 not work in @code{EvalRules}. If the rule set is divided into phases,
27172 only the phase 1 rules are applied, and the schedule is ignored.
27173 The rules are always repeated as many times as possible.
27175 The @code{EvalRules} are applied to all function calls in a formula,
27176 but not to numbers (and other number-like objects like error forms),
27177 nor to vectors or individual variable names. (Though they will apply
27178 to @emph{components} of vectors and error forms when appropriate.) You
27179 might try to make a variable @code{phihat} which automatically expands
27180 to its definition without the need to press @kbd{=} by writing the
27181 rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
27182 will not work as part of @code{EvalRules}.
27184 Finally, another limitation is that Calc sometimes calls its built-in
27185 functions directly rather than going through the default simplifications.
27186 When it does this, @code{EvalRules} will not be able to override those
27187 functions. For example, when you take the absolute value of the complex
27188 number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
27189 the multiplication, addition, and square root functions directly rather
27190 than applying the default simplifications to this formula. So an
27191 @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
27192 would not apply. (However, if you put Calc into Symbolic mode so that
27193 @samp{sqrt(13)} will be left in symbolic form by the built-in square
27194 root function, your rule will be able to apply. But if the complex
27195 number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated,
27196 then Symbolic mode will not help because @samp{sqrt(25)} can be
27197 evaluated exactly to 5.)
27199 One subtle restriction that normally only manifests itself with
27200 @code{EvalRules} is that while a given rewrite rule is in the process
27201 of being checked, that same rule cannot be recursively applied. Calc
27202 effectively removes the rule from its rule set while checking the rule,
27203 then puts it back once the match succeeds or fails. (The technical
27204 reason for this is that compiled pattern programs are not reentrant.)
27205 For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
27206 attempting to match @samp{foo(8)}. This rule will be inactive while
27207 the condition @samp{foo(4) > 0} is checked, even though it might be
27208 an integral part of evaluating that condition. Note that this is not
27209 a problem for the more usual recursive type of rule, such as
27210 @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
27211 been reactivated by the time the righthand side is evaluated.
27213 If @code{EvalRules} has no stored value (its default state), or if
27214 anything but a vector is stored in it, then it is ignored.
27216 Even though Calc's rewrite mechanism is designed to compare rewrite
27217 rules to formulas as quickly as possible, storing rules in
27218 @code{EvalRules} may make Calc run substantially slower. This is
27219 particularly true of rules where the top-level call is a commonly used
27220 function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will
27221 only activate the rewrite mechanism for calls to the function @code{f},
27222 but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
27225 apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
27229 may seem more ``efficient'' than two separate rules for @code{ln} and
27230 @code{log10}, but actually it is vastly less efficient because rules
27231 with @code{apply} as the top-level pattern must be tested against
27232 @emph{every} function call that is simplified.
27234 @cindex @code{AlgSimpRules} variable
27235 @vindex AlgSimpRules
27236 Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
27237 but only when @kbd{a s} is used to simplify the formula. The variable
27238 @code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command
27239 will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as
27240 well as all of its built-in simplifications.
27242 Most of the special limitations for @code{EvalRules} don't apply to
27243 @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules}
27244 command with an infinite repeat count as the first step of @kbd{a s}.
27245 It then applies its own built-in simplifications throughout the
27246 formula, and then repeats these two steps (along with applying the
27247 default simplifications) until no further changes are possible.
27249 @cindex @code{ExtSimpRules} variable
27250 @cindex @code{UnitSimpRules} variable
27251 @vindex ExtSimpRules
27252 @vindex UnitSimpRules
27253 There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
27254 that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
27255 also apply @code{EvalRules} and @code{AlgSimpRules}. The variable
27256 @code{IntegSimpRules} contains simplification rules that are used
27257 only during integration by @kbd{a i}.
27259 @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
27260 @subsection Debugging Rewrites
27263 If a buffer named @samp{*Trace*} exists, the rewrite mechanism will
27264 record some useful information there as it operates. The original
27265 formula is written there, as is the result of each successful rewrite,
27266 and the final result of the rewriting. All phase changes are also
27269 Calc always appends to @samp{*Trace*}. You must empty this buffer
27270 yourself periodically if it is in danger of growing unwieldy.
27272 Note that the rewriting mechanism is substantially slower when the
27273 @samp{*Trace*} buffer exists, even if the buffer is not visible on
27274 the screen. Once you are done, you will probably want to kill this
27275 buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in
27276 existence and forget about it, all your future rewrite commands will
27277 be needlessly slow.
27279 @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
27280 @subsection Examples of Rewrite Rules
27283 Returning to the example of substituting the pattern
27284 @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
27285 @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
27286 finding suitable cases. Another solution would be to use the rule
27287 @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
27288 if necessary. This rule will be the most effective way to do the job,
27289 but at the expense of making some changes that you might not desire.
27291 Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
27292 To make this work with the @w{@kbd{j r}} command so that it can be
27293 easily targeted to a particular exponential in a large formula,
27294 you might wish to write the rule as @samp{select(exp(x+y)) :=
27295 select(exp(x) exp(y))}. The @samp{select} markers will be
27296 ignored by the regular @kbd{a r} command
27297 (@pxref{Selections with Rewrite Rules}).
27299 A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
27300 This will simplify the formula whenever @expr{b} and/or @expr{c} can
27301 be made simpler by squaring. For example, applying this rule to
27302 @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
27303 Symbolic mode has been enabled to keep the square root from being
27304 evaluated to a floating-point approximation). This rule is also
27305 useful when working with symbolic complex numbers, e.g.,
27306 @samp{(a + b i) / (c + d i)}.
27308 As another example, we could define our own ``triangular numbers'' function
27309 with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter
27310 this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given
27311 a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
27312 to apply these rules repeatedly. After six applications, @kbd{a r} will
27313 stop with 15 on the stack. Once these rules are debugged, it would probably
27314 be most useful to add them to @code{EvalRules} so that Calc will evaluate
27315 the new @code{tri} function automatically. We could then use @kbd{Z K} on
27316 the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
27317 @code{tri} to the value on the top of the stack. @xref{Programming}.
27319 @cindex Quaternions
27320 The following rule set, contributed by
27321 @texline Fran\c cois
27323 Pinard, implements @dfn{quaternions}, a generalization of the concept of
27324 complex numbers. Quaternions have four components, and are here
27325 represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y},
27326 @var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts
27327 collected into a vector. Various arithmetical operations on quaternions
27328 are supported. To use these rules, either add them to @code{EvalRules},
27329 or create a command based on @kbd{a r} for simplifying quaternion
27330 formulas. A convenient way to enter quaternions would be a command
27331 defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $])
27335 [ quat(w, x, y, z) := quat(w, [x, y, z]),
27336 quat(w, [0, 0, 0]) := w,
27337 abs(quat(w, v)) := hypot(w, v),
27338 -quat(w, v) := quat(-w, -v),
27339 r + quat(w, v) := quat(r + w, v) :: real(r),
27340 r - quat(w, v) := quat(r - w, -v) :: real(r),
27341 quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
27342 r * quat(w, v) := quat(r * w, r * v) :: real(r),
27343 plain(quat(w1, v1) * quat(w2, v2))
27344 := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
27345 quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
27346 z / quat(w, v) := z * quatinv(quat(w, v)),
27347 quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
27348 quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
27349 quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
27350 :: integer(k) :: k > 0 :: k % 2 = 0,
27351 quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
27352 :: integer(k) :: k > 2,
27353 quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
27356 Quaternions, like matrices, have non-commutative multiplication.
27357 In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if
27358 @expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat}
27359 rule above uses @code{plain} to prevent Calc from rearranging the
27360 product. It may also be wise to add the line @samp{[quat(), matrix]}
27361 to the @code{Decls} matrix, to ensure that Calc's other algebraic
27362 operations will not rearrange a quaternion product. @xref{Declarations}.
27364 These rules also accept a four-argument @code{quat} form, converting
27365 it to the preferred form in the first rule. If you would rather see
27366 results in the four-argument form, just append the two items
27367 @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
27368 of the rule set. (But remember that multi-phase rule sets don't work
27369 in @code{EvalRules}.)
27371 @node Units, Store and Recall, Algebra, Top
27372 @chapter Operating on Units
27375 One special interpretation of algebraic formulas is as numbers with units.
27376 For example, the formula @samp{5 m / s^2} can be read ``five meters
27377 per second squared.'' The commands in this chapter help you
27378 manipulate units expressions in this form. Units-related commands
27379 begin with the @kbd{u} prefix key.
27382 * Basic Operations on Units::
27383 * The Units Table::
27384 * Predefined Units::
27385 * User-Defined Units::
27388 @node Basic Operations on Units, The Units Table, Units, Units
27389 @section Basic Operations on Units
27392 A @dfn{units expression} is a formula which is basically a number
27393 multiplied and/or divided by one or more @dfn{unit names}, which may
27394 optionally be raised to integer powers. Actually, the value part need not
27395 be a number; any product or quotient involving unit names is a units
27396 expression. Many of the units commands will also accept any formula,
27397 where the command applies to all units expressions which appear in the
27400 A unit name is a variable whose name appears in the @dfn{unit table},
27401 or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
27402 or @samp{u} (for ``micro'') followed by a name in the unit table.
27403 A substantial table of built-in units is provided with Calc;
27404 @pxref{Predefined Units}. You can also define your own unit names;
27405 @pxref{User-Defined Units}.
27407 Note that if the value part of a units expression is exactly @samp{1},
27408 it will be removed by the Calculator's automatic algebra routines: The
27409 formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a
27410 display anomaly, however; @samp{mm} will work just fine as a
27411 representation of one millimeter.
27413 You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working
27414 with units expressions easier. Otherwise, you will have to remember
27415 to hit the apostrophe key every time you wish to enter units.
27418 @pindex calc-simplify-units
27420 @mindex usimpl@idots
27423 The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
27425 expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the
27426 expression first as a regular algebraic formula; it then looks for
27427 features that can be further simplified by converting one object's units
27428 to be compatible with another's. For example, @samp{5 m + 23 mm} will
27429 simplify to @samp{5.023 m}. When different but compatible units are
27430 added, the righthand term's units are converted to match those of the
27431 lefthand term. @xref{Simplification Modes}, for a way to have this done
27432 automatically at all times.
27434 Units simplification also handles quotients of two units with the same
27435 dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
27436 powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
27437 @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
27438 @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
27439 @code{float}, @code{frac}, @code{abs}, and @code{clean}
27440 applied to units expressions, in which case
27441 the operation in question is applied only to the numeric part of the
27442 expression. Finally, trigonometric functions of quantities with units
27443 of angle are evaluated, regardless of the current angular mode.
27446 @pindex calc-convert-units
27447 The @kbd{u c} (@code{calc-convert-units}) command converts a units
27448 expression to new, compatible units. For example, given the units
27449 expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
27450 @samp{24.5872 m/s}. If the units you request are inconsistent with
27451 the original units, the number will be converted into your units
27452 times whatever ``remainder'' units are left over. For example,
27453 converting @samp{55 mph} into acres produces @samp{6.08e-3 acre / m s}.
27454 (Recall that multiplication binds more strongly than division in Calc
27455 formulas, so the units here are acres per meter-second.) Remainder
27456 units are expressed in terms of ``fundamental'' units like @samp{m} and
27457 @samp{s}, regardless of the input units.
27459 One special exception is that if you specify a single unit name, and
27460 a compatible unit appears somewhere in the units expression, then
27461 that compatible unit will be converted to the new unit and the
27462 remaining units in the expression will be left alone. For example,
27463 given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
27464 change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
27465 The ``remainder unit'' @samp{cm} is left alone rather than being
27466 changed to the base unit @samp{m}.
27468 You can use explicit unit conversion instead of the @kbd{u s} command
27469 to gain more control over the units of the result of an expression.
27470 For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
27471 @kbd{u c mm} to express the result in either meters or millimeters.
27472 (For that matter, you could type @kbd{u c fath} to express the result
27473 in fathoms, if you preferred!)
27475 In place of a specific set of units, you can also enter one of the
27476 units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
27477 For example, @kbd{u c si @key{RET}} converts the expression into
27478 International System of Units (SI) base units. Also, @kbd{u c base}
27479 converts to Calc's base units, which are the same as @code{si} units
27480 except that @code{base} uses @samp{g} as the fundamental unit of mass
27481 whereas @code{si} uses @samp{kg}.
27483 @cindex Composite units
27484 The @kbd{u c} command also accepts @dfn{composite units}, which
27485 are expressed as the sum of several compatible unit names. For
27486 example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
27487 feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first
27488 sorts the unit names into order of decreasing relative size.
27489 It then accounts for as much of the input quantity as it can
27490 using an integer number times the largest unit, then moves on
27491 to the next smaller unit, and so on. Only the smallest unit
27492 may have a non-integer amount attached in the result. A few
27493 standard unit names exist for common combinations, such as
27494 @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
27495 Composite units are expanded as if by @kbd{a x}, so that
27496 @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
27498 If the value on the stack does not contain any units, @kbd{u c} will
27499 prompt first for the old units which this value should be considered
27500 to have, then for the new units. Assuming the old and new units you
27501 give are consistent with each other, the result also will not contain
27502 any units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts the number
27503 2 on the stack to 5.08.
27506 @pindex calc-base-units
27507 The @kbd{u b} (@code{calc-base-units}) command is shorthand for
27508 @kbd{u c base}; it converts the units expression on the top of the
27509 stack into @code{base} units. If @kbd{u s} does not simplify a
27510 units expression as far as you would like, try @kbd{u b}.
27512 The @kbd{u c} and @kbd{u b} commands treat temperature units (like
27513 @samp{degC} and @samp{K}) as relative temperatures. For example,
27514 @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10
27515 degrees Celsius corresponds to a change of 18 degrees Fahrenheit.
27518 @pindex calc-convert-temperature
27519 @cindex Temperature conversion
27520 The @kbd{u t} (@code{calc-convert-temperature}) command converts
27521 absolute temperatures. The value on the stack must be a simple units
27522 expression with units of temperature only. This command would convert
27523 @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the
27527 @pindex calc-remove-units
27529 @pindex calc-extract-units
27530 The @kbd{u r} (@code{calc-remove-units}) command removes units from the
27531 formula at the top of the stack. The @kbd{u x}
27532 (@code{calc-extract-units}) command extracts only the units portion of a
27533 formula. These commands essentially replace every term of the formula
27534 that does or doesn't (respectively) look like a unit name by the
27535 constant 1, then resimplify the formula.
27538 @pindex calc-autorange-units
27539 The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
27540 mode in which unit prefixes like @code{k} (``kilo'') are automatically
27541 applied to keep the numeric part of a units expression in a reasonable
27542 range. This mode affects @kbd{u s} and all units conversion commands
27543 except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz}
27544 will be simplified to @samp{12.345 kHz}. Autoranging is useful for
27545 some kinds of units (like @code{Hz} and @code{m}), but is probably
27546 undesirable for non-metric units like @code{ft} and @code{tbsp}.
27547 (Composite units are more appropriate for those; see above.)
27549 Autoranging always applies the prefix to the leftmost unit name.
27550 Calc chooses the largest prefix that causes the number to be greater
27551 than or equal to 1.0. Thus an increasing sequence of adjusted times
27552 would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
27553 Generally the rule of thumb is that the number will be adjusted
27554 to be in the interval @samp{[1 .. 1000)}, although there are several
27555 exceptions to this rule. First, if the unit has a power then this
27556 is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
27557 Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
27558 but will not apply to other units. The ``deci-,'' ``deka-,'' and
27559 ``hecto-'' prefixes are never used. Thus the allowable interval is
27560 @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
27561 Finally, a prefix will not be added to a unit if the resulting name
27562 is also the actual name of another unit; @samp{1e-15 t} would normally
27563 be considered a ``femto-ton,'' but it is written as @samp{1000 at}
27564 (1000 atto-tons) instead because @code{ft} would be confused with feet.
27566 @node The Units Table, Predefined Units, Basic Operations on Units, Units
27567 @section The Units Table
27571 @pindex calc-enter-units-table
27572 The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
27573 in another buffer called @code{*Units Table*}. Each entry in this table
27574 gives the unit name as it would appear in an expression, the definition
27575 of the unit in terms of simpler units, and a full name or description of
27576 the unit. Fundamental units are defined as themselves; these are the
27577 units produced by the @kbd{u b} command. The fundamental units are
27578 meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
27581 The Units Table buffer also displays the Unit Prefix Table. Note that
27582 two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
27583 prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M}
27584 prefix. Whenever a unit name can be interpreted as either a built-in name
27585 or a prefix followed by another built-in name, the former interpretation
27586 wins. For example, @samp{2 pt} means two pints, not two pico-tons.
27588 The Units Table buffer, once created, is not rebuilt unless you define
27589 new units. To force the buffer to be rebuilt, give any numeric prefix
27590 argument to @kbd{u v}.
27593 @pindex calc-view-units-table
27594 The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
27595 that the cursor is not moved into the Units Table buffer. You can
27596 type @kbd{u V} again to remove the Units Table from the display. To
27597 return from the Units Table buffer after a @kbd{u v}, type @kbd{M-# c}
27598 again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
27599 command. You can also kill the buffer with @kbd{C-x k} if you wish;
27600 the actual units table is safely stored inside the Calculator.
27603 @pindex calc-get-unit-definition
27604 The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
27605 defining expression and pushes it onto the Calculator stack. For example,
27606 @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the
27607 same definition for the unit that would appear in the Units Table buffer.
27608 Note that this command works only for actual unit names; @kbd{u g km}
27609 will report that no such unit exists, for example, because @code{km} is
27610 really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a
27611 definition of a unit in terms of base units, it is easier to push the
27612 unit name on the stack and then reduce it to base units with @kbd{u b}.
27615 @pindex calc-explain-units
27616 The @kbd{u e} (@code{calc-explain-units}) command displays an English
27617 description of the units of the expression on the stack. For example,
27618 for the expression @samp{62 km^2 g / s^2 mol K}, the description is
27619 ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This
27620 command uses the English descriptions that appear in the righthand
27621 column of the Units Table.
27623 @node Predefined Units, User-Defined Units, The Units Table, Units
27624 @section Predefined Units
27627 Since the exact definitions of many kinds of units have evolved over the
27628 years, and since certain countries sometimes have local differences in
27629 their definitions, it is a good idea to examine Calc's definition of a
27630 unit before depending on its exact value. For example, there are three
27631 different units for gallons, corresponding to the US (@code{gal}),
27632 Canadian (@code{galC}), and British (@code{galUK}) definitions. Also,
27633 note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
27634 ounce, and @code{ozfl} is a fluid ounce.
27636 The temperature units corresponding to degrees Kelvin and Centigrade
27637 (Celsius) are the same in this table, since most units commands treat
27638 temperatures as being relative. The @code{calc-convert-temperature}
27639 command has special rules for handling the different absolute magnitudes
27640 of the various temperature scales.
27642 The unit of volume ``liters'' can be referred to by either the lower-case
27643 @code{l} or the upper-case @code{L}.
27645 The unit @code{A} stands for Amperes; the name @code{Ang} is used
27653 The unit @code{pt} stands for pints; the name @code{point} stands for
27654 a typographical point, defined by @samp{72 point = 1 in}. There is
27655 also @code{tpt}, which stands for a printer's point as defined by the
27656 @TeX{} typesetting system: @samp{72.27 tpt = 1 in}.
27658 The unit @code{e} stands for the elementary (electron) unit of charge;
27659 because algebra command could mistake this for the special constant
27660 @expr{e}, Calc provides the alternate unit name @code{ech} which is
27661 preferable to @code{e}.
27663 The name @code{g} stands for one gram of mass; there is also @code{gf},
27664 one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
27665 Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}.
27667 The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
27668 a metric ton of @samp{1000 kg}.
27670 The names @code{s} (or @code{sec}) and @code{min} refer to units of
27671 time; @code{arcsec} and @code{arcmin} are units of angle.
27673 Some ``units'' are really physical constants; for example, @code{c}
27674 represents the speed of light, and @code{h} represents Planck's
27675 constant. You can use these just like other units: converting
27676 @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
27677 meters per second. You can also use this merely as a handy reference;
27678 the @kbd{u g} command gets the definition of one of these constants
27679 in its normal terms, and @kbd{u b} expresses the definition in base
27682 Two units, @code{pi} and @code{fsc} (the fine structure constant,
27683 approximately @mathit{1/137}) are dimensionless. The units simplification
27684 commands simply treat these names as equivalent to their corresponding
27685 values. However you can, for example, use @kbd{u c} to convert a pure
27686 number into multiples of the fine structure constant, or @kbd{u b} to
27687 convert this back into a pure number. (When @kbd{u c} prompts for the
27688 ``old units,'' just enter a blank line to signify that the value
27689 really is unitless.)
27691 @c Describe angular units, luminosity vs. steradians problem.
27693 @node User-Defined Units, , Predefined Units, Units
27694 @section User-Defined Units
27697 Calc provides ways to get quick access to your selected ``favorite''
27698 units, as well as ways to define your own new units.
27701 @pindex calc-quick-units
27703 @cindex @code{Units} variable
27704 @cindex Quick units
27705 To select your favorite units, store a vector of unit names or
27706 expressions in the Calc variable @code{Units}. The @kbd{u 1}
27707 through @kbd{u 9} commands (@code{calc-quick-units}) provide access
27708 to these units. If the value on the top of the stack is a plain
27709 number (with no units attached), then @kbd{u 1} gives it the
27710 specified units. (Basically, it multiplies the number by the
27711 first item in the @code{Units} vector.) If the number on the
27712 stack @emph{does} have units, then @kbd{u 1} converts that number
27713 to the new units. For example, suppose the vector @samp{[in, ft]}
27714 is stored in @code{Units}. Then @kbd{30 u 1} will create the
27715 expression @samp{30 in}, and @kbd{u 2} will convert that expression
27718 The @kbd{u 0} command accesses the tenth element of @code{Units}.
27719 Only ten quick units may be defined at a time. If the @code{Units}
27720 variable has no stored value (the default), or if its value is not
27721 a vector, then the quick-units commands will not function. The
27722 @kbd{s U} command is a convenient way to edit the @code{Units}
27723 variable; @pxref{Operations on Variables}.
27726 @pindex calc-define-unit
27727 @cindex User-defined units
27728 The @kbd{u d} (@code{calc-define-unit}) command records the units
27729 expression on the top of the stack as the definition for a new,
27730 user-defined unit. For example, putting @samp{16.5 ft} on the stack and
27731 typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
27732 16.5 feet. The unit conversion and simplification commands will now
27733 treat @code{rod} just like any other unit of length. You will also be
27734 prompted for an optional English description of the unit, which will
27735 appear in the Units Table.
27738 @pindex calc-undefine-unit
27739 The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
27740 unit. It is not possible to remove one of the predefined units,
27743 If you define a unit with an existing unit name, your new definition
27744 will replace the original definition of that unit. If the unit was a
27745 predefined unit, the old definition will not be replaced, only
27746 ``shadowed.'' The built-in definition will reappear if you later use
27747 @kbd{u u} to remove the shadowing definition.
27749 To create a new fundamental unit, use either 1 or the unit name itself
27750 as the defining expression. Otherwise the expression can involve any
27751 other units that you like (except for composite units like @samp{mfi}).
27752 You can create a new composite unit with a sum of other units as the
27753 defining expression. The next unit operation like @kbd{u c} or @kbd{u v}
27754 will rebuild the internal unit table incorporating your modifications.
27755 Note that erroneous definitions (such as two units defined in terms of
27756 each other) will not be detected until the unit table is next rebuilt;
27757 @kbd{u v} is a convenient way to force this to happen.
27759 Temperature units are treated specially inside the Calculator; it is not
27760 possible to create user-defined temperature units.
27763 @pindex calc-permanent-units
27764 @cindex Calc init file, user-defined units
27765 The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
27766 units in your Calc init file (the file given by the variable
27767 @code{calc-settings-file}, typically @file{~/.calc.el}), so that the
27768 units will still be available in subsequent Emacs sessions. If there
27769 was already a set of user-defined units in your Calc init file, it
27770 is replaced by the new set. (@xref{General Mode Commands}, for a way to
27771 tell Calc to use a different file for the Calc init file.)
27773 @node Store and Recall, Graphics, Units, Top
27774 @chapter Storing and Recalling
27777 Calculator variables are really just Lisp variables that contain numbers
27778 or formulas in a form that Calc can understand. The commands in this
27779 section allow you to manipulate variables conveniently. Commands related
27780 to variables use the @kbd{s} prefix key.
27783 * Storing Variables::
27784 * Recalling Variables::
27785 * Operations on Variables::
27787 * Evaluates-To Operator::
27790 @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
27791 @section Storing Variables
27796 @cindex Storing variables
27797 @cindex Quick variables
27800 The @kbd{s s} (@code{calc-store}) command stores the value at the top of
27801 the stack into a specified variable. It prompts you to enter the
27802 name of the variable. If you press a single digit, the value is stored
27803 immediately in one of the ``quick'' variables @code{q0} through
27804 @code{q9}. Or you can enter any variable name.
27807 @pindex calc-store-into
27808 The @kbd{s s} command leaves the stored value on the stack. There is
27809 also an @kbd{s t} (@code{calc-store-into}) command, which removes a
27810 value from the stack and stores it in a variable.
27812 If the top of stack value is an equation @samp{a = 7} or assignment
27813 @samp{a := 7} with a variable on the lefthand side, then Calc will
27814 assign that variable with that value by default, i.e., if you type
27815 @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the
27816 value 7 would be stored in the variable @samp{a}. (If you do type
27817 a variable name at the prompt, the top-of-stack value is stored in
27818 its entirety, even if it is an equation: @samp{s s b @key{RET}}
27819 with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
27821 In fact, the top of stack value can be a vector of equations or
27822 assignments with different variables on their lefthand sides; the
27823 default will be to store all the variables with their corresponding
27824 righthand sides simultaneously.
27826 It is also possible to type an equation or assignment directly at
27827 the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}.
27828 In this case the expression to the right of the @kbd{=} or @kbd{:=}
27829 symbol is evaluated as if by the @kbd{=} command, and that value is
27830 stored in the variable. No value is taken from the stack; @kbd{s s}
27831 and @kbd{s t} are equivalent when used in this way.
27835 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
27836 digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
27837 equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used
27838 for trail and time/date commands.)
27874 @pindex calc-store-plus
27875 @pindex calc-store-minus
27876 @pindex calc-store-times
27877 @pindex calc-store-div
27878 @pindex calc-store-power
27879 @pindex calc-store-concat
27880 @pindex calc-store-neg
27881 @pindex calc-store-inv
27882 @pindex calc-store-decr
27883 @pindex calc-store-incr
27884 There are also several ``arithmetic store'' commands. For example,
27885 @kbd{s +} removes a value from the stack and adds it to the specified
27886 variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
27887 @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
27888 @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
27889 and @kbd{s ]} which decrease or increase a variable by one.
27891 All the arithmetic stores accept the Inverse prefix to reverse the
27892 order of the operands. If @expr{v} represents the contents of the
27893 variable, and @expr{a} is the value drawn from the stack, then regular
27894 @w{@kbd{s -}} assigns
27895 @texline @math{v \coloneq v - a},
27896 @infoline @expr{v := v - a},
27897 but @kbd{I s -} assigns
27898 @texline @math{v \coloneq a - v}.
27899 @infoline @expr{v := a - v}.
27900 While @kbd{I s *} might seem pointless, it is
27901 useful if matrix multiplication is involved. Actually, all the
27902 arithmetic stores use formulas designed to behave usefully both
27903 forwards and backwards:
27907 s + v := v + a v := a + v
27908 s - v := v - a v := a - v
27909 s * v := v * a v := a * v
27910 s / v := v / a v := a / v
27911 s ^ v := v ^ a v := a ^ v
27912 s | v := v | a v := a | v
27913 s n v := v / (-1) v := (-1) / v
27914 s & v := v ^ (-1) v := (-1) ^ v
27915 s [ v := v - 1 v := 1 - v
27916 s ] v := v - (-1) v := (-1) - v
27920 In the last four cases, a numeric prefix argument will be used in
27921 place of the number one. (For example, @kbd{M-2 s ]} increases
27922 a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
27923 minus-two minus the variable.
27925 The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
27926 etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
27927 arithmetic stores that don't remove the value @expr{a} from the stack.
27929 All arithmetic stores report the new value of the variable in the
27930 Trail for your information. They signal an error if the variable
27931 previously had no stored value. If default simplifications have been
27932 turned off, the arithmetic stores temporarily turn them on for numeric
27933 arguments only (i.e., they temporarily do an @kbd{m N} command).
27934 @xref{Simplification Modes}. Large vectors put in the trail by
27935 these commands always use abbreviated (@kbd{t .}) mode.
27938 @pindex calc-store-map
27939 The @kbd{s m} command is a general way to adjust a variable's value
27940 using any Calc function. It is a ``mapping'' command analogous to
27941 @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see
27942 how to specify a function for a mapping command. Basically,
27943 all you do is type the Calc command key that would invoke that
27944 function normally. For example, @kbd{s m n} applies the @kbd{n}
27945 key to negate the contents of the variable, so @kbd{s m n} is
27946 equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root
27947 of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
27948 reverse the vector stored in the variable, and @kbd{s m H I S}
27949 takes the hyperbolic arcsine of the variable contents.
27951 If the mapping function takes two or more arguments, the additional
27952 arguments are taken from the stack; the old value of the variable
27953 is provided as the first argument. Thus @kbd{s m -} with @expr{a}
27954 on the stack computes @expr{v - a}, just like @kbd{s -}. With the
27955 Inverse prefix, the variable's original value becomes the @emph{last}
27956 argument instead of the first. Thus @kbd{I s m -} is also
27957 equivalent to @kbd{I s -}.
27960 @pindex calc-store-exchange
27961 The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
27962 of a variable with the value on the top of the stack. Naturally, the
27963 variable must already have a stored value for this to work.
27965 You can type an equation or assignment at the @kbd{s x} prompt. The
27966 command @kbd{s x a=6} takes no values from the stack; instead, it
27967 pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
27970 @pindex calc-unstore
27971 @cindex Void variables
27972 @cindex Un-storing variables
27973 Until you store something in them, variables are ``void,'' that is, they
27974 contain no value at all. If they appear in an algebraic formula they
27975 will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
27976 The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
27979 The only variables with predefined values are the ``special constants''
27980 @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free
27981 to unstore these variables or to store new values into them if you like,
27982 although some of the algebraic-manipulation functions may assume these
27983 variables represent their standard values. Calc displays a warning if
27984 you change the value of one of these variables, or of one of the other
27985 special variables @code{inf}, @code{uinf}, and @code{nan} (which are
27988 Note that @code{pi} doesn't actually have 3.14159265359 stored
27989 in it, but rather a special magic value that evaluates to @cpi{}
27990 at the current precision. Likewise @code{e}, @code{i}, and
27991 @code{phi} evaluate according to the current precision or polar mode.
27992 If you recall a value from @code{pi} and store it back, this magic
27993 property will be lost.
27996 @pindex calc-copy-variable
27997 The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
27998 value of one variable to another. It differs from a simple @kbd{s r}
27999 followed by an @kbd{s t} in two important ways. First, the value never
28000 goes on the stack and thus is never rounded, evaluated, or simplified
28001 in any way; it is not even rounded down to the current precision.
28002 Second, the ``magic'' contents of a variable like @code{e} can
28003 be copied into another variable with this command, perhaps because
28004 you need to unstore @code{e} right now but you wish to put it
28005 back when you're done. The @kbd{s c} command is the only way to
28006 manipulate these magic values intact.
28008 @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
28009 @section Recalling Variables
28013 @pindex calc-recall
28014 @cindex Recalling variables
28015 The most straightforward way to extract the stored value from a variable
28016 is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts
28017 for a variable name (similarly to @code{calc-store}), looks up the value
28018 of the specified variable, and pushes that value onto the stack. It is
28019 an error to try to recall a void variable.
28021 It is also possible to recall the value from a variable by evaluating a
28022 formula containing that variable. For example, @kbd{' a @key{RET} =} is
28023 the same as @kbd{s r a @key{RET}} except that if the variable is void, the
28024 former will simply leave the formula @samp{a} on the stack whereas the
28025 latter will produce an error message.
28028 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
28029 equivalent to @kbd{s r 9}. (The @kbd{r} prefix is otherwise unused
28030 in the current version of Calc.)
28032 @node Operations on Variables, Let Command, Recalling Variables, Store and Recall
28033 @section Other Operations on Variables
28037 @pindex calc-edit-variable
28038 The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
28039 value of a variable without ever putting that value on the stack
28040 or simplifying or evaluating the value. It prompts for the name of
28041 the variable to edit. If the variable has no stored value, the
28042 editing buffer will start out empty. If the editing buffer is
28043 empty when you press @kbd{C-c C-c} to finish, the variable will
28044 be made void. @xref{Editing Stack Entries}, for a general
28045 description of editing.
28047 The @kbd{s e} command is especially useful for creating and editing
28048 rewrite rules which are stored in variables. Sometimes these rules
28049 contain formulas which must not be evaluated until the rules are
28050 actually used. (For example, they may refer to @samp{deriv(x,y)},
28051 where @code{x} will someday become some expression involving @code{y};
28052 if you let Calc evaluate the rule while you are defining it, Calc will
28053 replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
28054 not itself refer to @code{y}.) By contrast, recalling the variable,
28055 editing with @kbd{`}, and storing will evaluate the variable's value
28056 as a side effect of putting the value on the stack.
28104 @pindex calc-store-AlgSimpRules
28105 @pindex calc-store-Decls
28106 @pindex calc-store-EvalRules
28107 @pindex calc-store-FitRules
28108 @pindex calc-store-GenCount
28109 @pindex calc-store-Holidays
28110 @pindex calc-store-IntegLimit
28111 @pindex calc-store-LineStyles
28112 @pindex calc-store-PointStyles
28113 @pindex calc-store-PlotRejects
28114 @pindex calc-store-TimeZone
28115 @pindex calc-store-Units
28116 @pindex calc-store-ExtSimpRules
28117 There are several special-purpose variable-editing commands that
28118 use the @kbd{s} prefix followed by a shifted letter:
28122 Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}.
28124 Edit @code{Decls}. @xref{Declarations}.
28126 Edit @code{EvalRules}. @xref{Default Simplifications}.
28128 Edit @code{FitRules}. @xref{Curve Fitting}.
28130 Edit @code{GenCount}. @xref{Solving Equations}.
28132 Edit @code{Holidays}. @xref{Business Days}.
28134 Edit @code{IntegLimit}. @xref{Calculus}.
28136 Edit @code{LineStyles}. @xref{Graphics}.
28138 Edit @code{PointStyles}. @xref{Graphics}.
28140 Edit @code{PlotRejects}. @xref{Graphics}.
28142 Edit @code{TimeZone}. @xref{Time Zones}.
28144 Edit @code{Units}. @xref{User-Defined Units}.
28146 Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}.
28149 These commands are just versions of @kbd{s e} that use fixed variable
28150 names rather than prompting for the variable name.
28153 @pindex calc-permanent-variable
28154 @cindex Storing variables
28155 @cindex Permanent variables
28156 @cindex Calc init file, variables
28157 The @kbd{s p} (@code{calc-permanent-variable}) command saves a
28158 variable's value permanently in your Calc init file (the file given by
28159 the variable @code{calc-settings-file}, typically @file{~/.calc.el}), so
28160 that its value will still be available in future Emacs sessions. You
28161 can re-execute @w{@kbd{s p}} later on to update the saved value, but the
28162 only way to remove a saved variable is to edit your calc init file
28163 by hand. (@xref{General Mode Commands}, for a way to tell Calc to
28164 use a different file for the Calc init file.)
28166 If you do not specify the name of a variable to save (i.e.,
28167 @kbd{s p @key{RET}}), all Calc variables with defined values
28168 are saved except for the special constants @code{pi}, @code{e},
28169 @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
28170 and @code{PlotRejects};
28171 @code{FitRules}, @code{DistribRules}, and other built-in rewrite
28172 rules; and @code{PlotData@var{n}} variables generated
28173 by the graphics commands. (You can still save these variables by
28174 explicitly naming them in an @kbd{s p} command.)
28177 @pindex calc-insert-variables
28178 The @kbd{s i} (@code{calc-insert-variables}) command writes
28179 the values of all Calc variables into a specified buffer.
28180 The variables are written with the prefix @code{var-} in the form of
28181 Lisp @code{setq} commands
28182 which store the values in string form. You can place these commands
28183 in your Calc init file (or @file{.emacs}) if you wish, though in this case it
28184 would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i}
28185 omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
28186 is that @kbd{s i} will store the variables in any buffer, and it also
28187 stores in a more human-readable format.)
28189 @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
28190 @section The Let Command
28195 @cindex Variables, temporary assignment
28196 @cindex Temporary assignment to variables
28197 If you have an expression like @samp{a+b^2} on the stack and you wish to
28198 compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and
28199 then press @kbd{=} to reevaluate the formula. This has the side-effect
28200 of leaving the stored value of 3 in @expr{b} for future operations.
28202 The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
28203 @emph{temporary} assignment of a variable. It stores the value on the
28204 top of the stack into the specified variable, then evaluates the
28205 second-to-top stack entry, then restores the original value (or lack of one)
28206 in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
28207 the stack will contain the formula @samp{a + 9}. The subsequent command
28208 @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
28209 The variables @samp{a} and @samp{b} are not permanently affected in any way
28212 The value on the top of the stack may be an equation or assignment, or
28213 a vector of equations or assignments, in which case the default will be
28214 analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}.
28216 Also, you can answer the variable-name prompt with an equation or
28217 assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
28218 and typing @kbd{s l b @key{RET}}.
28220 The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
28221 a variable with a value in a formula. It does an actual substitution
28222 rather than temporarily assigning the variable and evaluating. For
28223 example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will
28224 produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
28225 since the evaluation step will also evaluate @code{pi}.
28227 @node Evaluates-To Operator, , Let Command, Store and Recall
28228 @section The Evaluates-To Operator
28233 @cindex Evaluates-to operator
28234 @cindex @samp{=>} operator
28235 The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
28236 operator}. (It will show up as an @code{evalto} function call in
28237 other language modes like Pascal and @TeX{}.) This is a binary
28238 operator, that is, it has a lefthand and a righthand argument,
28239 although it can be entered with the righthand argument omitted.
28241 A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
28242 follows: First, @var{a} is not simplified or modified in any
28243 way. The previous value of argument @var{b} is thrown away; the
28244 formula @var{a} is then copied and evaluated as if by the @kbd{=}
28245 command according to all current modes and stored variable values,
28246 and the result is installed as the new value of @var{b}.
28248 For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
28249 The number 17 is ignored, and the lefthand argument is left in its
28250 unevaluated form; the result is the formula @samp{2 + 3 => 5}.
28253 @pindex calc-evalto
28254 You can enter an @samp{=>} formula either directly using algebraic
28255 entry (in which case the righthand side may be omitted since it is
28256 going to be replaced right away anyhow), or by using the @kbd{s =}
28257 (@code{calc-evalto}) command, which takes @var{a} from the stack
28258 and replaces it with @samp{@var{a} => @var{b}}.
28260 Calc keeps track of all @samp{=>} operators on the stack, and
28261 recomputes them whenever anything changes that might affect their
28262 values, i.e., a mode setting or variable value. This occurs only
28263 if the @samp{=>} operator is at the top level of the formula, or
28264 if it is part of a top-level vector. In other words, pushing
28265 @samp{2 + (a => 17)} will change the 17 to the actual value of
28266 @samp{a} when you enter the formula, but the result will not be
28267 dynamically updated when @samp{a} is changed later because the
28268 @samp{=>} operator is buried inside a sum. However, a vector
28269 of @samp{=>} operators will be recomputed, since it is convenient
28270 to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
28271 make a concise display of all the variables in your problem.
28272 (Another way to do this would be to use @samp{[a, b, c] =>},
28273 which provides a slightly different format of display. You
28274 can use whichever you find easiest to read.)
28277 @pindex calc-auto-recompute
28278 The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
28279 turn this automatic recomputation on or off. If you turn
28280 recomputation off, you must explicitly recompute an @samp{=>}
28281 operator on the stack in one of the usual ways, such as by
28282 pressing @kbd{=}. Turning recomputation off temporarily can save
28283 a lot of time if you will be changing several modes or variables
28284 before you look at the @samp{=>} entries again.
28286 Most commands are not especially useful with @samp{=>} operators
28287 as arguments. For example, given @samp{x + 2 => 17}, it won't
28288 work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want
28289 to operate on the lefthand side of the @samp{=>} operator on
28290 the top of the stack, type @kbd{j 1} (that's the digit ``one'')
28291 to select the lefthand side, execute your commands, then type
28292 @kbd{j u} to unselect.
28294 All current modes apply when an @samp{=>} operator is computed,
28295 including the current simplification mode. Recall that the
28296 formula @samp{x + y + x} is not handled by Calc's default
28297 simplifications, but the @kbd{a s} command will reduce it to
28298 the simpler form @samp{y + 2 x}. You can also type @kbd{m A}
28299 to enable an Algebraic Simplification mode in which the
28300 equivalent of @kbd{a s} is used on all of Calc's results.
28301 If you enter @samp{x + y + x =>} normally, the result will
28302 be @samp{x + y + x => x + y + x}. If you change to
28303 Algebraic Simplification mode, the result will be
28304 @samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s}
28305 once will have no effect on @samp{x + y + x => x + y + x},
28306 because the righthand side depends only on the lefthand side
28307 and the current mode settings, and the lefthand side is not
28308 affected by commands like @kbd{a s}.
28310 The ``let'' command (@kbd{s l}) has an interesting interaction
28311 with the @samp{=>} operator. The @kbd{s l} command evaluates the
28312 second-to-top stack entry with the top stack entry supplying
28313 a temporary value for a given variable. As you might expect,
28314 if that stack entry is an @samp{=>} operator its righthand
28315 side will temporarily show this value for the variable. In
28316 fact, all @samp{=>}s on the stack will be updated if they refer
28317 to that variable. But this change is temporary in the sense
28318 that the next command that causes Calc to look at those stack
28319 entries will make them revert to the old variable value.
28323 2: a => a 2: a => 17 2: a => a
28324 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1
28327 17 s l a @key{RET} p 8 @key{RET}
28331 Here the @kbd{p 8} command changes the current precision,
28332 thus causing the @samp{=>} forms to be recomputed after the
28333 influence of the ``let'' is gone. The @kbd{d @key{SPC}} command
28334 (@code{calc-refresh}) is a handy way to force the @samp{=>}
28335 operators on the stack to be recomputed without any other
28339 @pindex calc-assign
28342 Embedded mode also uses @samp{=>} operators. In Embedded mode,
28343 the lefthand side of an @samp{=>} operator can refer to variables
28344 assigned elsewhere in the file by @samp{:=} operators. The
28345 assignment operator @samp{a := 17} does not actually do anything
28346 by itself. But Embedded mode recognizes it and marks it as a sort
28347 of file-local definition of the variable. You can enter @samp{:=}
28348 operators in Algebraic mode, or by using the @kbd{s :}
28349 (@code{calc-assign}) [@code{assign}] command which takes a variable
28350 and value from the stack and replaces them with an assignment.
28352 @xref{TeX Language Mode}, for the way @samp{=>} appears in
28353 @TeX{} language output. The @dfn{eqn} mode gives similar
28354 treatment to @samp{=>}.
28356 @node Graphics, Kill and Yank, Store and Recall, Top
28360 The commands for graphing data begin with the @kbd{g} prefix key. Calc
28361 uses GNUPLOT 2.0 or 3.0 to do graphics. These commands will only work
28362 if GNUPLOT is available on your system. (While GNUPLOT sounds like
28363 a relative of GNU Emacs, it is actually completely unrelated.
28364 However, it is free software and can be obtained from the Free
28365 Software Foundation's machine @samp{prep.ai.mit.edu}.)
28367 @vindex calc-gnuplot-name
28368 If you have GNUPLOT installed on your system but Calc is unable to
28369 find it, you may need to set the @code{calc-gnuplot-name} variable
28370 in your Calc init file or @file{.emacs}. You may also need to set some Lisp
28371 variables to show Calc how to run GNUPLOT on your system; these
28372 are described under @kbd{g D} and @kbd{g O} below. If you are
28373 using the X window system, Calc will configure GNUPLOT for you
28374 automatically. If you have GNUPLOT 3.0 and you are not using X,
28375 Calc will configure GNUPLOT to display graphs using simple character
28376 graphics that will work on any terminal.
28380 * Three Dimensional Graphics::
28381 * Managing Curves::
28382 * Graphics Options::
28386 @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
28387 @section Basic Graphics
28391 @pindex calc-graph-fast
28392 The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
28393 This command takes two vectors of equal length from the stack.
28394 The vector at the top of the stack represents the ``y'' values of
28395 the various data points. The vector in the second-to-top position
28396 represents the corresponding ``x'' values. This command runs
28397 GNUPLOT (if it has not already been started by previous graphing
28398 commands) and displays the set of data points. The points will
28399 be connected by lines, and there will also be some kind of symbol
28400 to indicate the points themselves.
28402 The ``x'' entry may instead be an interval form, in which case suitable
28403 ``x'' values are interpolated between the minimum and maximum values of
28404 the interval (whether the interval is open or closed is ignored).
28406 The ``x'' entry may also be a number, in which case Calc uses the
28407 sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc.
28408 (Generally the number 0 or 1 would be used for @expr{x} in this case.)
28410 The ``y'' entry may be any formula instead of a vector. Calc effectively
28411 uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
28412 the result of this must be a formula in a single (unassigned) variable.
28413 The formula is plotted with this variable taking on the various ``x''
28414 values. Graphs of formulas by default use lines without symbols at the
28415 computed data points. Note that if neither ``x'' nor ``y'' is a vector,
28416 Calc guesses at a reasonable number of data points to use. See the
28417 @kbd{g N} command below. (The ``x'' values must be either a vector
28418 or an interval if ``y'' is a formula.)
28424 If ``y'' is (or evaluates to) a formula of the form
28425 @samp{xy(@var{x}, @var{y})} then the result is a
28426 parametric plot. The two arguments of the fictitious @code{xy} function
28427 are used as the ``x'' and ``y'' coordinates of the curve, respectively.
28428 In this case the ``x'' vector or interval you specified is not directly
28429 visible in the graph. For example, if ``x'' is the interval @samp{[0..360]}
28430 and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
28433 Also, ``x'' and ``y'' may each be variable names, in which case Calc
28434 looks for suitable vectors, intervals, or formulas stored in those
28437 The ``x'' and ``y'' values for the data points (as pulled from the vectors,
28438 calculated from the formulas, or interpolated from the intervals) should
28439 be real numbers (integers, fractions, or floats). If either the ``x''
28440 value or the ``y'' value of a given data point is not a real number, that
28441 data point will be omitted from the graph. The points on either side
28442 of the invalid point will @emph{not} be connected by a line.
28444 See the documentation for @kbd{g a} below for a description of the way
28445 numeric prefix arguments affect @kbd{g f}.
28447 @cindex @code{PlotRejects} variable
28448 @vindex PlotRejects
28449 If you store an empty vector in the variable @code{PlotRejects}
28450 (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
28451 this vector for every data point which was rejected because its
28452 ``x'' or ``y'' values were not real numbers. The result will be
28453 a matrix where each row holds the curve number, data point number,
28454 ``x'' value, and ``y'' value for a rejected data point.
28455 @xref{Evaluates-To Operator}, for a handy way to keep tabs on the
28456 current value of @code{PlotRejects}. @xref{Operations on Variables},
28457 for the @kbd{s R} command which is another easy way to examine
28458 @code{PlotRejects}.
28461 @pindex calc-graph-clear
28462 To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
28463 If the GNUPLOT output device is an X window, the window will go away.
28464 Effects on other kinds of output devices will vary. You don't need
28465 to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
28466 or @kbd{g p} command later on, it will reuse the existing graphics
28467 window if there is one.
28469 @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
28470 @section Three-Dimensional Graphics
28473 @pindex calc-graph-fast-3d
28474 The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
28475 graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
28476 you will see a GNUPLOT error message if you try this command.
28478 The @kbd{g F} command takes three values from the stack, called ``x'',
28479 ``y'', and ``z'', respectively. As was the case for 2D graphs, there
28480 are several options for these values.
28482 In the first case, ``x'' and ``y'' are each vectors (not necessarily of
28483 the same length); either or both may instead be interval forms. The
28484 ``z'' value must be a matrix with the same number of rows as elements
28485 in ``x'', and the same number of columns as elements in ``y''. The
28486 result is a surface plot where
28487 @texline @math{z_{ij}}
28488 @infoline @expr{z_ij}
28489 is the height of the point
28490 at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will
28491 be displayed from a certain default viewpoint; you can change this
28492 viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*}
28493 buffer as described later. See the GNUPLOT 3.0 documentation for a
28494 description of the @samp{set view} command.
28496 Each point in the matrix will be displayed as a dot in the graph,
28497 and these points will be connected by a grid of lines (@dfn{isolines}).
28499 In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
28500 length. The resulting graph displays a 3D line instead of a surface,
28501 where the coordinates of points along the line are successive triplets
28502 of values from the input vectors.
28504 In the third case, ``x'' and ``y'' are vectors or interval forms, and
28505 ``z'' is any formula involving two variables (not counting variables
28506 with assigned values). These variables are sorted into alphabetical
28507 order; the first takes on values from ``x'' and the second takes on
28508 values from ``y'' to form a matrix of results that are graphed as a
28515 If the ``z'' formula evaluates to a call to the fictitious function
28516 @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
28517 ``parametric surface.'' In this case, the axes of the graph are
28518 taken from the @var{x} and @var{y} values in these calls, and the
28519 ``x'' and ``y'' values from the input vectors or intervals are used only
28520 to specify the range of inputs to the formula. For example, plotting
28521 @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
28522 will draw a sphere. (Since the default resolution for 3D plots is
28523 5 steps in each of ``x'' and ``y'', this will draw a very crude
28524 sphere. You could use the @kbd{g N} command, described below, to
28525 increase this resolution, or specify the ``x'' and ``y'' values as
28526 vectors with more than 5 elements.
28528 It is also possible to have a function in a regular @kbd{g f} plot
28529 evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not
28530 a surface, the result will be a 3D parametric line. For example,
28531 @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
28532 helix (a three-dimensional spiral).
28534 As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
28535 variables containing the relevant data.
28537 @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
28538 @section Managing Curves
28541 The @kbd{g f} command is really shorthand for the following commands:
28542 @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for
28543 @kbd{C-u g d g A g p}. You can gain more control over your graph
28544 by using these commands directly.
28547 @pindex calc-graph-add
28548 The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
28549 represented by the two values on the top of the stack to the current
28550 graph. You can have any number of curves in the same graph. When
28551 you give the @kbd{g p} command, all the curves will be drawn superimposed
28554 The @kbd{g a} command (and many others that affect the current graph)
28555 will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed
28556 in another window. This buffer is a template of the commands that will
28557 be sent to GNUPLOT when it is time to draw the graph. The first
28558 @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding
28559 @kbd{g a} commands add extra curves onto that @code{plot} command.
28560 Other graph-related commands put other GNUPLOT commands into this
28561 buffer. In normal usage you never need to work with this buffer
28562 directly, but you can if you wish. The only constraint is that there
28563 must be only one @code{plot} command, and it must be the last command
28564 in the buffer. If you want to save and later restore a complete graph
28565 configuration, you can use regular Emacs commands to save and restore
28566 the contents of the @samp{*Gnuplot Commands*} buffer.
28570 If the values on the stack are not variable names, @kbd{g a} will invent
28571 variable names for them (of the form @samp{PlotData@var{n}}) and store
28572 the values in those variables. The ``x'' and ``y'' variables are what
28573 go into the @code{plot} command in the template. If you add a curve
28574 that uses a certain variable and then later change that variable, you
28575 can replot the graph without having to delete and re-add the curve.
28576 That's because the variable name, not the vector, interval or formula
28577 itself, is what was added by @kbd{g a}.
28579 A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
28580 stack entries are interpreted as curves. With a positive prefix
28581 argument @expr{n}, the top @expr{n} stack entries are ``y'' values
28582 for @expr{n} different curves which share a common ``x'' value in
28583 the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix
28584 argument is equivalent to @kbd{C-u 1 g a}.)
28586 A prefix of zero or plain @kbd{C-u} means to take two stack entries,
28587 ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
28588 ``y'' values for several curves that share a common ``x''.
28590 A negative prefix argument tells Calc to read @expr{n} vectors from
28591 the stack; each vector @expr{[x, y]} describes an independent curve.
28592 This is the only form of @kbd{g a} that creates several curves at once
28593 that don't have common ``x'' values. (Of course, the range of ``x''
28594 values covered by all the curves ought to be roughly the same if
28595 they are to look nice on the same graph.)
28597 For example, to plot
28598 @texline @math{\sin n x}
28599 @infoline @expr{sin(n x)}
28600 for integers @expr{n}
28601 from 1 to 5, you could use @kbd{v x} to create a vector of integers
28602 (@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
28603 across this vector. The resulting vector of formulas is suitable
28604 for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
28608 @pindex calc-graph-add-3d
28609 The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
28610 to the graph. It is not legal to intermix 2D and 3D curves in a
28611 single graph. This command takes three arguments, ``x'', ``y'',
28612 and ``z'', from the stack. With a positive prefix @expr{n}, it
28613 takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n}
28614 separate ``z''s). With a zero prefix, it takes three stack entries
28615 but the ``z'' entry is a vector of curve values. With a negative
28616 prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}.
28617 The @kbd{g A} command works by adding a @code{splot} (surface-plot)
28618 command to the @samp{*Gnuplot Commands*} buffer.
28620 (Although @kbd{g a} adds a 2D @code{plot} command to the
28621 @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
28622 before sending it to GNUPLOT if it notices that the data points are
28623 evaluating to @code{xyz} calls. It will not work to mix 2D and 3D
28624 @kbd{g a} curves in a single graph, although Calc does not currently
28628 @pindex calc-graph-delete
28629 The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
28630 recently added curve from the graph. It has no effect if there are
28631 no curves in the graph. With a numeric prefix argument of any kind,
28632 it deletes all of the curves from the graph.
28635 @pindex calc-graph-hide
28636 The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
28637 the most recently added curve. A hidden curve will not appear in
28638 the actual plot, but information about it such as its name and line and
28639 point styles will be retained.
28642 @pindex calc-graph-juggle
28643 The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
28644 at the end of the list (the ``most recently added curve'') to the
28645 front of the list. The next-most-recent curve is thus exposed for
28646 @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work
28647 with any curve in the graph even though curve-related commands only
28648 affect the last curve in the list.
28651 @pindex calc-graph-plot
28652 The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
28653 the graph described in the @samp{*Gnuplot Commands*} buffer. Any
28654 GNUPLOT parameters which are not defined by commands in this buffer
28655 are reset to their default values. The variables named in the @code{plot}
28656 command are written to a temporary data file and the variable names
28657 are then replaced by the file name in the template. The resulting
28658 plotting commands are fed to the GNUPLOT program. See the documentation
28659 for the GNUPLOT program for more specific information. All temporary
28660 files are removed when Emacs or GNUPLOT exits.
28662 If you give a formula for ``y'', Calc will remember all the values that
28663 it calculates for the formula so that later plots can reuse these values.
28664 Calc throws out these saved values when you change any circumstances
28665 that may affect the data, such as switching from Degrees to Radians
28666 mode, or changing the value of a parameter in the formula. You can
28667 force Calc to recompute the data from scratch by giving a negative
28668 numeric prefix argument to @kbd{g p}.
28670 Calc uses a fairly rough step size when graphing formulas over intervals.
28671 This is to ensure quick response. You can ``refine'' a plot by giving
28672 a positive numeric prefix argument to @kbd{g p}. Calc goes through
28673 the data points it has computed and saved from previous plots of the
28674 function, and computes and inserts a new data point midway between
28675 each of the existing points. You can refine a plot any number of times,
28676 but beware that the amount of calculation involved doubles each time.
28678 Calc does not remember computed values for 3D graphs. This means the
28679 numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
28680 the current graph is three-dimensional.
28683 @pindex calc-graph-print
28684 The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
28685 except that it sends the output to a printer instead of to the
28686 screen. More precisely, @kbd{g p} looks for @samp{set terminal}
28687 or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer;
28688 lacking these it uses the default settings. However, @kbd{g P}
28689 ignores @samp{set terminal} and @samp{set output} commands and
28690 uses a different set of default values. All of these values are
28691 controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
28692 Provided everything is set up properly, @kbd{g p} will plot to
28693 the screen unless you have specified otherwise and @kbd{g P} will
28694 always plot to the printer.
28696 @node Graphics Options, Devices, Managing Curves, Graphics
28697 @section Graphics Options
28701 @pindex calc-graph-grid
28702 The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
28703 on and off. It is off by default; tick marks appear only at the
28704 edges of the graph. With the grid turned on, dotted lines appear
28705 across the graph at each tick mark. Note that this command only
28706 changes the setting in @samp{*Gnuplot Commands*}; to see the effects
28707 of the change you must give another @kbd{g p} command.
28710 @pindex calc-graph-border
28711 The @kbd{g b} (@code{calc-graph-border}) command turns the border
28712 (the box that surrounds the graph) on and off. It is on by default.
28713 This command will only work with GNUPLOT 3.0 and later versions.
28716 @pindex calc-graph-key
28717 The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
28718 on and off. The key is a chart in the corner of the graph that
28719 shows the correspondence between curves and line styles. It is
28720 off by default, and is only really useful if you have several
28721 curves on the same graph.
28724 @pindex calc-graph-num-points
28725 The @kbd{g N} (@code{calc-graph-num-points}) command allows you
28726 to select the number of data points in the graph. This only affects
28727 curves where neither ``x'' nor ``y'' is specified as a vector.
28728 Enter a blank line to revert to the default value (initially 15).
28729 With no prefix argument, this command affects only the current graph.
28730 With a positive prefix argument this command changes or, if you enter
28731 a blank line, displays the default number of points used for all
28732 graphs created by @kbd{g a} that don't specify the resolution explicitly.
28733 With a negative prefix argument, this command changes or displays
28734 the default value (initially 5) used for 3D graphs created by @kbd{g A}.
28735 Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points
28736 will be computed for the surface.
28738 Data values in the graph of a function are normally computed to a
28739 precision of five digits, regardless of the current precision at the
28740 time. This is usually more than adequate, but there are cases where
28741 it will not be. For example, plotting @expr{1 + x} with @expr{x} in the
28742 interval @samp{[0 ..@: 1e-6]} will round all the data points down
28743 to 1.0! Putting the command @samp{set precision @var{n}} in the
28744 @samp{*Gnuplot Commands*} buffer will cause the data to be computed
28745 at precision @var{n} instead of 5. Since this is such a rare case,
28746 there is no keystroke-based command to set the precision.
28749 @pindex calc-graph-header
28750 The @kbd{g h} (@code{calc-graph-header}) command sets the title
28751 for the graph. This will show up centered above the graph.
28752 The default title is blank (no title).
28755 @pindex calc-graph-name
28756 The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
28757 individual curve. Like the other curve-manipulating commands, it
28758 affects the most recently added curve, i.e., the last curve on the
28759 list in the @samp{*Gnuplot Commands*} buffer. To set the title of
28760 the other curves you must first juggle them to the end of the list
28761 with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand.
28762 Curve titles appear in the key; if the key is turned off they are
28767 @pindex calc-graph-title-x
28768 @pindex calc-graph-title-y
28769 The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
28770 (@code{calc-graph-title-y}) commands set the titles on the ``x''
28771 and ``y'' axes, respectively. These titles appear next to the
28772 tick marks on the left and bottom edges of the graph, respectively.
28773 Calc does not have commands to control the tick marks themselves,
28774 but you can edit them into the @samp{*Gnuplot Commands*} buffer if
28775 you wish. See the GNUPLOT documentation for details.
28779 @pindex calc-graph-range-x
28780 @pindex calc-graph-range-y
28781 The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
28782 (@code{calc-graph-range-y}) commands set the range of values on the
28783 ``x'' and ``y'' axes, respectively. You are prompted to enter a
28784 suitable range. This should be either a pair of numbers of the
28785 form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
28786 default behavior of setting the range based on the range of values
28787 in the data, or @samp{$} to take the range from the top of the stack.
28788 Ranges on the stack can be represented as either interval forms or
28789 vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
28793 @pindex calc-graph-log-x
28794 @pindex calc-graph-log-y
28795 The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
28796 commands allow you to set either or both of the axes of the graph to
28797 be logarithmic instead of linear.
28802 @pindex calc-graph-log-z
28803 @pindex calc-graph-range-z
28804 @pindex calc-graph-title-z
28805 For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
28806 letters with the Control key held down) are the corresponding commands
28807 for the ``z'' axis.
28811 @pindex calc-graph-zero-x
28812 @pindex calc-graph-zero-y
28813 The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
28814 (@code{calc-graph-zero-y}) commands control whether a dotted line is
28815 drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same
28816 dotted lines that would be drawn there anyway if you used @kbd{g g} to
28817 turn the ``grid'' feature on.) Zero-axis lines are on by default, and
28818 may be turned off only in GNUPLOT 3.0 and later versions. They are
28819 not available for 3D plots.
28822 @pindex calc-graph-line-style
28823 The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
28824 lines on or off for the most recently added curve, and optionally selects
28825 the style of lines to be used for that curve. Plain @kbd{g s} simply
28826 toggles the lines on and off. With a numeric prefix argument, @kbd{g s}
28827 turns lines on and sets a particular line style. Line style numbers
28828 start at one and their meanings vary depending on the output device.
28829 GNUPLOT guarantees that there will be at least six different line styles
28830 available for any device.
28833 @pindex calc-graph-point-style
28834 The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
28835 the symbols at the data points on or off, or sets the point style.
28836 If you turn both lines and points off, the data points will show as
28839 @cindex @code{LineStyles} variable
28840 @cindex @code{PointStyles} variable
28842 @vindex PointStyles
28843 Another way to specify curve styles is with the @code{LineStyles} and
28844 @code{PointStyles} variables. These variables initially have no stored
28845 values, but if you store a vector of integers in one of these variables,
28846 the @kbd{g a} and @kbd{g f} commands will use those style numbers
28847 instead of the defaults for new curves that are added to the graph.
28848 An entry should be a positive integer for a specific style, or 0 to let
28849 the style be chosen automatically, or @mathit{-1} to turn off lines or points
28850 altogether. If there are more curves than elements in the vector, the
28851 last few curves will continue to have the default styles. Of course,
28852 you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
28854 For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
28855 to have lines in style number 2, the second curve to have no connecting
28856 lines, and the third curve to have lines in style 3. Point styles will
28857 still be assigned automatically, but you could store another vector in
28858 @code{PointStyles} to define them, too.
28860 @node Devices, , Graphics Options, Graphics
28861 @section Graphical Devices
28865 @pindex calc-graph-device
28866 The @kbd{g D} (@code{calc-graph-device}) command sets the device name
28867 (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
28868 on this graph. It does not affect the permanent default device name.
28869 If you enter a blank name, the device name reverts to the default.
28870 Enter @samp{?} to see a list of supported devices.
28872 With a positive numeric prefix argument, @kbd{g D} instead sets
28873 the default device name, used by all plots in the future which do
28874 not override it with a plain @kbd{g D} command. If you enter a
28875 blank line this command shows you the current default. The special
28876 name @code{default} signifies that Calc should choose @code{x11} if
28877 the X window system is in use (as indicated by the presence of a
28878 @code{DISPLAY} environment variable), or otherwise @code{dumb} under
28879 GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0.
28880 This is the initial default value.
28882 The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
28883 terminals with no special graphics facilities. It writes a crude
28884 picture of the graph composed of characters like @code{-} and @code{|}
28885 to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays.
28886 The graph is made the same size as the Emacs screen, which on most
28887 dumb terminals will be
28888 @texline @math{80\times24}
28890 characters. The graph is displayed in
28891 an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit
28892 the recursive edit and return to Calc. Note that the @code{dumb}
28893 device is present only in GNUPLOT 3.0 and later versions.
28895 The word @code{dumb} may be followed by two numbers separated by
28896 spaces. These are the desired width and height of the graph in
28897 characters. Also, the device name @code{big} is like @code{dumb}
28898 but creates a graph four times the width and height of the Emacs
28899 screen. You will then have to scroll around to view the entire
28900 graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
28901 @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
28902 of the four directions.
28904 With a negative numeric prefix argument, @kbd{g D} sets or displays
28905 the device name used by @kbd{g P} (@code{calc-graph-print}). This
28906 is initially @code{postscript}. If you don't have a PostScript
28907 printer, you may decide once again to use @code{dumb} to create a
28908 plot on any text-only printer.
28911 @pindex calc-graph-output
28912 The @kbd{g O} (@code{calc-graph-output}) command sets the name of
28913 the output file used by GNUPLOT. For some devices, notably @code{x11},
28914 there is no output file and this information is not used. Many other
28915 ``devices'' are really file formats like @code{postscript}; in these
28916 cases the output in the desired format goes into the file you name
28917 with @kbd{g O}. Type @kbd{g O stdout @key{RET}} to set GNUPLOT to write
28918 to its standard output stream, i.e., to @samp{*Gnuplot Trail*}.
28919 This is the default setting.
28921 Another special output name is @code{tty}, which means that GNUPLOT
28922 is going to write graphics commands directly to its standard output,
28923 which you wish Emacs to pass through to your terminal. Tektronix
28924 graphics terminals, among other devices, operate this way. Calc does
28925 this by telling GNUPLOT to write to a temporary file, then running a
28926 sub-shell executing the command @samp{cat tempfile >/dev/tty}. On
28927 typical Unix systems, this will copy the temporary file directly to
28928 the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l}
28929 to Emacs afterwards to refresh the screen.
28931 Once again, @kbd{g O} with a positive or negative prefix argument
28932 sets the default or printer output file names, respectively. In each
28933 case you can specify @code{auto}, which causes Calc to invent a temporary
28934 file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file
28935 will be deleted once it has been displayed or printed. If the output file
28936 name is not @code{auto}, the file is not automatically deleted.
28938 The default and printer devices and output files can be saved
28939 permanently by the @kbd{m m} (@code{calc-save-modes}) command. The
28940 default number of data points (see @kbd{g N}) and the X geometry
28941 (see @kbd{g X}) are also saved. Other graph information is @emph{not}
28942 saved; you can save a graph's configuration simply by saving the contents
28943 of the @samp{*Gnuplot Commands*} buffer.
28945 @vindex calc-gnuplot-plot-command
28946 @vindex calc-gnuplot-default-device
28947 @vindex calc-gnuplot-default-output
28948 @vindex calc-gnuplot-print-command
28949 @vindex calc-gnuplot-print-device
28950 @vindex calc-gnuplot-print-output
28951 If you are installing Calc you may wish to configure the default and
28952 printer devices and output files for the whole system. The relevant
28953 Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
28954 and @code{calc-gnuplot-print-device} and @code{-output}. The output
28955 file names must be either strings as described above, or Lisp
28956 expressions which are evaluated on the fly to get the output file names.
28958 Other important Lisp variables are @code{calc-gnuplot-plot-command} and
28959 @code{calc-gnuplot-print-command}, which give the system commands to
28960 display or print the output of GNUPLOT, respectively. These may be
28961 @code{nil} if no command is necessary, or strings which can include
28962 @samp{%s} to signify the name of the file to be displayed or printed.
28963 Or, these variables may contain Lisp expressions which are evaluated
28964 to display or print the output.
28967 @pindex calc-graph-display
28968 The @kbd{g x} (@code{calc-graph-display}) command lets you specify
28969 on which X window system display your graphs should be drawn. Enter
28970 a blank line to see the current display name. This command has no
28971 effect unless the current device is @code{x11}.
28974 @pindex calc-graph-geometry
28975 The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
28976 command for specifying the position and size of the X window.
28977 The normal value is @code{default}, which generally means your
28978 window manager will let you place the window interactively.
28979 Entering @samp{800x500+0+0} would create an 800-by-500 pixel
28980 window in the upper-left corner of the screen.
28982 The buffer called @samp{*Gnuplot Trail*} holds a transcript of the
28983 session with GNUPLOT. This shows the commands Calc has ``typed'' to
28984 GNUPLOT and the responses it has received. Calc tries to notice when an
28985 error message has appeared here and display the buffer for you when
28986 this happens. You can check this buffer yourself if you suspect
28987 something has gone wrong.
28990 @pindex calc-graph-command
28991 The @kbd{g C} (@code{calc-graph-command}) command prompts you to
28992 enter any line of text, then simply sends that line to the current
28993 GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively
28994 like a Shell buffer but you can't type commands in it yourself.
28995 Instead, you must use @kbd{g C} for this purpose.
28999 @pindex calc-graph-view-commands
29000 @pindex calc-graph-view-trail
29001 The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
29002 (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*}
29003 and @samp{*Gnuplot Trail*} buffers, respectively, in another window.
29004 This happens automatically when Calc thinks there is something you
29005 will want to see in either of these buffers. If you type @kbd{g v}
29006 or @kbd{g V} when the relevant buffer is already displayed, the
29007 buffer is hidden again.
29009 One reason to use @kbd{g v} is to add your own commands to the
29010 @samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use
29011 @kbd{C-x o} to switch into that window. For example, GNUPLOT has
29012 @samp{set label} and @samp{set arrow} commands that allow you to
29013 annotate your plots. Since Calc doesn't understand these commands,
29014 you have to add them to the @samp{*Gnuplot Commands*} buffer
29015 yourself, then use @w{@kbd{g p}} to replot using these new commands. Note
29016 that your commands must appear @emph{before} the @code{plot} command.
29017 To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
29018 You may have to type @kbd{g C @key{RET}} a few times to clear the
29019 ``press return for more'' or ``subtopic of @dots{}'' requests.
29020 Note that Calc always sends commands (like @samp{set nolabel}) to
29021 reset all plotting parameters to the defaults before each plot, so
29022 to delete a label all you need to do is delete the @samp{set label}
29023 line you added (or comment it out with @samp{#}) and then replot
29027 @pindex calc-graph-quit
29028 You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
29029 process that is running. The next graphing command you give will
29030 start a fresh GNUPLOT process. The word @samp{Graph} appears in
29031 the Calc window's mode line whenever a GNUPLOT process is currently
29032 running. The GNUPLOT process is automatically killed when you
29033 exit Emacs if you haven't killed it manually by then.
29036 @pindex calc-graph-kill
29037 The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
29038 except that it also views the @samp{*Gnuplot Trail*} buffer so that
29039 you can see the process being killed. This is better if you are
29040 killing GNUPLOT because you think it has gotten stuck.
29042 @node Kill and Yank, Keypad Mode, Graphics, Top
29043 @chapter Kill and Yank Functions
29046 The commands in this chapter move information between the Calculator and
29047 other Emacs editing buffers.
29049 In many cases Embedded mode is an easier and more natural way to
29050 work with Calc from a regular editing buffer. @xref{Embedded Mode}.
29053 * Killing From Stack::
29054 * Yanking Into Stack::
29055 * Grabbing From Buffers::
29056 * Yanking Into Buffers::
29057 * X Cut and Paste::
29060 @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
29061 @section Killing from the Stack
29067 @pindex calc-copy-as-kill
29069 @pindex calc-kill-region
29071 @pindex calc-copy-region-as-kill
29073 @dfn{Kill} commands are Emacs commands that insert text into the
29074 ``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y}
29075 command. Three common kill commands in normal Emacs are @kbd{C-k}, which
29076 kills one line, @kbd{C-w}, which kills the region between mark and point,
29077 and @kbd{M-w}, which puts the region into the kill ring without actually
29078 deleting it. All of these commands work in the Calculator, too. Also,
29079 @kbd{M-k} has been provided to complete the set; it puts the current line
29080 into the kill ring without deleting anything.
29082 The kill commands are unusual in that they pay attention to the location
29083 of the cursor in the Calculator buffer. If the cursor is on or below the
29084 bottom line, the kill commands operate on the top of the stack. Otherwise,
29085 they operate on whatever stack element the cursor is on. Calc's kill
29086 commands always operate on whole stack entries. (They act the same as their
29087 standard Emacs cousins except they ``round up'' the specified region to
29088 encompass full lines.) The text is copied into the kill ring exactly as
29089 it appears on the screen, including line numbers if they are enabled.
29091 A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
29092 of lines killed. A positive argument kills the current line and @expr{n-1}
29093 lines below it. A negative argument kills the @expr{-n} lines above the
29094 current line. Again this mirrors the behavior of the standard Emacs
29095 @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k}
29096 with no argument copies only the number itself into the kill ring, whereas
29097 @kbd{C-k} with a prefix argument of 1 copies the number with its trailing
29100 @node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank
29101 @section Yanking into the Stack
29106 The @kbd{C-y} command yanks the most recently killed text back into the
29107 Calculator. It pushes this value onto the top of the stack regardless of
29108 the cursor position. In general it re-parses the killed text as a number
29109 or formula (or a list of these separated by commas or newlines). However if
29110 the thing being yanked is something that was just killed from the Calculator
29111 itself, its full internal structure is yanked. For example, if you have
29112 set the floating-point display mode to show only four significant digits,
29113 then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
29114 full 3.14159, even though yanking it into any other buffer would yank the
29115 number in its displayed form, 3.142. (Since the default display modes
29116 show all objects to their full precision, this feature normally makes no
29119 @node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank
29120 @section Grabbing from Other Buffers
29124 @pindex calc-grab-region
29125 The @kbd{M-# g} (@code{calc-grab-region}) command takes the text between
29126 point and mark in the current buffer and attempts to parse it as a
29127 vector of values. Basically, it wraps the text in vector brackets
29128 @samp{[ ]} unless the text already is enclosed in vector brackets,
29129 then reads the text as if it were an algebraic entry. The contents
29130 of the vector may be numbers, formulas, or any other Calc objects.
29131 If the @kbd{M-# g} command works successfully, it does an automatic
29132 @kbd{M-# c} to enter the Calculator buffer.
29134 A numeric prefix argument grabs the specified number of lines around
29135 point, ignoring the mark. A positive prefix grabs from point to the
29136 @expr{n}th following newline (so that @kbd{M-1 M-# g} grabs from point
29137 to the end of the current line); a negative prefix grabs from point
29138 back to the @expr{n+1}st preceding newline. In these cases the text
29139 that is grabbed is exactly the same as the text that @kbd{C-k} would
29140 delete given that prefix argument.
29142 A prefix of zero grabs the current line; point may be anywhere on the
29145 A plain @kbd{C-u} prefix interprets the region between point and mark
29146 as a single number or formula rather than a vector. For example,
29147 @kbd{M-# g} on the text @samp{2 a b} produces the vector of three
29148 values @samp{[2, a, b]}, but @kbd{C-u M-# g} on the same region
29149 reads a formula which is a product of three things: @samp{2 a b}.
29150 (The text @samp{a + b}, on the other hand, will be grabbed as a
29151 vector of one element by plain @kbd{M-# g} because the interpretation
29152 @samp{[a, +, b]} would be a syntax error.)
29154 If a different language has been specified (@pxref{Language Modes}),
29155 the grabbed text will be interpreted according to that language.
29158 @pindex calc-grab-rectangle
29159 The @kbd{M-# r} (@code{calc-grab-rectangle}) command takes the text between
29160 point and mark and attempts to parse it as a matrix. If point and mark
29161 are both in the leftmost column, the lines in between are parsed in their
29162 entirety. Otherwise, point and mark define the corners of a rectangle
29163 whose contents are parsed.
29165 Each line of the grabbed area becomes a row of the matrix. The result
29166 will actually be a vector of vectors, which Calc will treat as a matrix
29167 only if every row contains the same number of values.
29169 If a line contains a portion surrounded by square brackets (or curly
29170 braces), that portion is interpreted as a vector which becomes a row
29171 of the matrix. Any text surrounding the bracketed portion on the line
29174 Otherwise, the entire line is interpreted as a row vector as if it
29175 were surrounded by square brackets. Leading line numbers (in the
29176 format used in the Calc stack buffer) are ignored. If you wish to
29177 force this interpretation (even if the line contains bracketed
29178 portions), give a negative numeric prefix argument to the
29179 @kbd{M-# r} command.
29181 If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
29182 line is instead interpreted as a single formula which is converted into
29183 a one-element vector. Thus the result of @kbd{C-u M-# r} will be a
29184 one-column matrix. For example, suppose one line of the data is the
29185 expression @samp{2 a}. A plain @w{@kbd{M-# r}} will interpret this as
29186 @samp{[2 a]}, which in turn is read as a two-element vector that forms
29187 one row of the matrix. But a @kbd{C-u M-# r} will interpret this row
29190 If you give a positive numeric prefix argument @var{n}, then each line
29191 will be split up into columns of width @var{n}; each column is parsed
29192 separately as a matrix element. If a line contained
29193 @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
29194 would correctly split the line into two error forms.
29196 @xref{Matrix Functions}, to see how to pull the matrix apart into its
29197 constituent rows and columns. (If it is a
29198 @texline @math{1\times1}
29200 matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.)
29204 @pindex calc-grab-sum-across
29205 @pindex calc-grab-sum-down
29206 @cindex Summing rows and columns of data
29207 The @kbd{M-# :} (@code{calc-grab-sum-down}) command is a handy way to
29208 grab a rectangle of data and sum its columns. It is equivalent to
29209 typing @kbd{M-# r}, followed by @kbd{V R : +} (the vector reduction
29210 command that sums the columns of a matrix; @pxref{Reducing}). The
29211 result of the command will be a vector of numbers, one for each column
29212 in the input data. The @kbd{M-# _} (@code{calc-grab-sum-across}) command
29213 similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
29215 As well as being more convenient, @kbd{M-# :} and @kbd{M-# _} are also
29216 much faster because they don't actually place the grabbed vector on
29217 the stack. In a @kbd{M-# r V R : +} sequence, formatting the vector
29218 for display on the stack takes a large fraction of the total time
29219 (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
29221 For example, suppose we have a column of numbers in a file which we
29222 wish to sum. Go to one corner of the column and press @kbd{C-@@} to
29223 set the mark; go to the other corner and type @kbd{M-# :}. Since there
29224 is only one column, the result will be a vector of one number, the sum.
29225 (You can type @kbd{v u} to unpack this vector into a plain number if
29226 you want to do further arithmetic with it.)
29228 To compute the product of the column of numbers, we would have to do
29229 it ``by hand'' since there's no special grab-and-multiply command.
29230 Use @kbd{M-# r} to grab the column of numbers into the calculator in
29231 the form of a column matrix. The statistics command @kbd{u *} is a
29232 handy way to find the product of a vector or matrix of numbers.
29233 @xref{Statistical Operations}. Another approach would be to use
29234 an explicit column reduction command, @kbd{V R : *}.
29236 @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
29237 @section Yanking into Other Buffers
29241 @pindex calc-copy-to-buffer
29242 The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
29243 at the top of the stack into the most recently used normal editing buffer.
29244 (More specifically, this is the most recently used buffer which is displayed
29245 in a window and whose name does not begin with @samp{*}. If there is no
29246 such buffer, this is the most recently used buffer except for Calculator
29247 and Calc Trail buffers.) The number is inserted exactly as it appears and
29248 without a newline. (If line-numbering is enabled, the line number is
29249 normally not included.) The number is @emph{not} removed from the stack.
29251 With a prefix argument, @kbd{y} inserts several numbers, one per line.
29252 A positive argument inserts the specified number of values from the top
29253 of the stack. A negative argument inserts the @expr{n}th value from the
29254 top of the stack. An argument of zero inserts the entire stack. Note
29255 that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
29256 with no argument; the former always copies full lines, whereas the
29257 latter strips off the trailing newline.
29259 With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
29260 region in the other buffer with the yanked text, then quits the
29261 Calculator, leaving you in that buffer. A typical use would be to use
29262 @kbd{M-# g} to read a region of data into the Calculator, operate on the
29263 data to produce a new matrix, then type @kbd{C-u y} to replace the
29264 original data with the new data. One might wish to alter the matrix
29265 display style (@pxref{Vector and Matrix Formats}) or change the current
29266 display language (@pxref{Language Modes}) before doing this. Also, note
29267 that this command replaces a linear region of text (as grabbed by
29268 @kbd{M-# g}), not a rectangle (as grabbed by @kbd{M-# r}).
29270 If the editing buffer is in overwrite (as opposed to insert) mode,
29271 and the @kbd{C-u} prefix was not used, then the yanked number will
29272 overwrite the characters following point rather than being inserted
29273 before those characters. The usual conventions of overwrite mode
29274 are observed; for example, characters will be inserted at the end of
29275 a line rather than overflowing onto the next line. Yanking a multi-line
29276 object such as a matrix in overwrite mode overwrites the next @var{n}
29277 lines in the buffer, lengthening or shortening each line as necessary.
29278 Finally, if the thing being yanked is a simple integer or floating-point
29279 number (like @samp{-1.2345e-3}) and the characters following point also
29280 make up such a number, then Calc will replace that number with the new
29281 number, lengthening or shortening as necessary. The concept of
29282 ``overwrite mode'' has thus been generalized from overwriting characters
29283 to overwriting one complete number with another.
29286 The @kbd{M-# y} key sequence is equivalent to @kbd{y} except that
29287 it can be typed anywhere, not just in Calc. This provides an easy
29288 way to guarantee that Calc knows which editing buffer you want to use!
29290 @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
29291 @section X Cut and Paste
29294 If you are using Emacs with the X window system, there is an easier
29295 way to move small amounts of data into and out of the calculator:
29296 Use the mouse-oriented cut and paste facilities of X.
29298 The default bindings for a three-button mouse cause the left button
29299 to move the Emacs cursor to the given place, the right button to
29300 select the text between the cursor and the clicked location, and
29301 the middle button to yank the selection into the buffer at the
29302 clicked location. So, if you have a Calc window and an editing
29303 window on your Emacs screen, you can use left-click/right-click
29304 to select a number, vector, or formula from one window, then
29305 middle-click to paste that value into the other window. When you
29306 paste text into the Calc window, Calc interprets it as an algebraic
29307 entry. It doesn't matter where you click in the Calc window; the
29308 new value is always pushed onto the top of the stack.
29310 The @code{xterm} program that is typically used for general-purpose
29311 shell windows in X interprets the mouse buttons in the same way.
29312 So you can use the mouse to move data between Calc and any other
29313 Unix program. One nice feature of @code{xterm} is that a double
29314 left-click selects one word, and a triple left-click selects a
29315 whole line. So you can usually transfer a single number into Calc
29316 just by double-clicking on it in the shell, then middle-clicking
29317 in the Calc window.
29319 @node Keypad Mode, Embedded Mode, Kill and Yank, Introduction
29320 @chapter Keypad Mode
29324 @pindex calc-keypad
29325 The @kbd{M-# k} (@code{calc-keypad}) command starts the Calculator
29326 and displays a picture of a calculator-style keypad. If you are using
29327 the X window system, you can click on any of the ``keys'' in the
29328 keypad using the left mouse button to operate the calculator.
29329 The original window remains the selected window; in Keypad mode
29330 you can type in your file while simultaneously performing
29331 calculations with the mouse.
29333 @pindex full-calc-keypad
29334 If you have used @kbd{M-# b} first, @kbd{M-# k} instead invokes
29335 the @code{full-calc-keypad} command, which takes over the whole
29336 Emacs screen and displays the keypad, the Calc stack, and the Calc
29337 trail all at once. This mode would normally be used when running
29338 Calc standalone (@pxref{Standalone Operation}).
29340 If you aren't using the X window system, you must switch into
29341 the @samp{*Calc Keypad*} window, place the cursor on the desired
29342 ``key,'' and type @key{SPC} or @key{RET}. If you think this
29343 is easier than using Calc normally, go right ahead.
29345 Calc commands are more or less the same in Keypad mode. Certain
29346 keypad keys differ slightly from the corresponding normal Calc
29347 keystrokes; all such deviations are described below.
29349 Keypad mode includes many more commands than will fit on the keypad
29350 at once. Click the right mouse button [@code{calc-keypad-menu}]
29351 to switch to the next menu. The bottom five rows of the keypad
29352 stay the same; the top three rows change to a new set of commands.
29353 To return to earlier menus, click the middle mouse button
29354 [@code{calc-keypad-menu-back}] or simply advance through the menus
29355 until you wrap around. Typing @key{TAB} inside the keypad window
29356 is equivalent to clicking the right mouse button there.
29358 You can always click the @key{EXEC} button and type any normal
29359 Calc key sequence. This is equivalent to switching into the
29360 Calc buffer, typing the keys, then switching back to your
29364 * Keypad Main Menu::
29365 * Keypad Functions Menu::
29366 * Keypad Binary Menu::
29367 * Keypad Vectors Menu::
29368 * Keypad Modes Menu::
29371 @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
29376 |----+-----Calc 2.00-----+----1
29377 |FLR |CEIL|RND |TRNC|CLN2|FLT |
29378 |----+----+----+----+----+----|
29379 | LN |EXP | |ABS |IDIV|MOD |
29380 |----+----+----+----+----+----|
29381 |SIN |COS |TAN |SQRT|y^x |1/x |
29382 |----+----+----+----+----+----|
29383 | ENTER |+/- |EEX |UNDO| <- |
29384 |-----+---+-+--+--+-+---++----|
29385 | INV | 7 | 8 | 9 | / |
29386 |-----+-----+-----+-----+-----|
29387 | HYP | 4 | 5 | 6 | * |
29388 |-----+-----+-----+-----+-----|
29389 |EXEC | 1 | 2 | 3 | - |
29390 |-----+-----+-----+-----+-----|
29391 | OFF | 0 | . | PI | + |
29392 |-----+-----+-----+-----+-----+
29397 This is the menu that appears the first time you start Keypad mode.
29398 It will show up in a vertical window on the right side of your screen.
29399 Above this menu is the traditional Calc stack display. On a 24-line
29400 screen you will be able to see the top three stack entries.
29402 The ten digit keys, decimal point, and @key{EEX} key are used for
29403 entering numbers in the obvious way. @key{EEX} begins entry of an
29404 exponent in scientific notation. Just as with regular Calc, the
29405 number is pushed onto the stack as soon as you press @key{ENTER}
29406 or any other function key.
29408 The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During
29409 numeric entry it changes the sign of the number or of the exponent.
29410 At other times it changes the sign of the number on the top of the
29413 The @key{INV} and @key{HYP} keys modify other keys. As well as
29414 having the effects described elsewhere in this manual, Keypad mode
29415 defines several other ``inverse'' operations. These are described
29416 below and in the following sections.
29418 The @key{ENTER} key finishes the current numeric entry, or otherwise
29419 duplicates the top entry on the stack.
29421 The @key{UNDO} key undoes the most recent Calc operation.
29422 @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
29423 ``last arguments'' (@kbd{M-@key{RET}}).
29425 The @key{<-} key acts as a ``backspace'' during numeric entry.
29426 At other times it removes the top stack entry. @kbd{INV <-}
29427 clears the entire stack. @kbd{HYP <-} takes an integer from
29428 the stack, then removes that many additional stack elements.
29430 The @key{EXEC} key prompts you to enter any keystroke sequence
29431 that would normally work in Calc mode. This can include a
29432 numeric prefix if you wish. It is also possible simply to
29433 switch into the Calc window and type commands in it; there is
29434 nothing ``magic'' about this window when Keypad mode is active.
29436 The other keys in this display perform their obvious calculator
29437 functions. @key{CLN2} rounds the top-of-stack by temporarily
29438 reducing the precision by 2 digits. @key{FLT} converts an
29439 integer or fraction on the top of the stack to floating-point.
29441 The @key{INV} and @key{HYP} keys combined with several of these keys
29442 give you access to some common functions even if the appropriate menu
29443 is not displayed. Obviously you don't need to learn these keys
29444 unless you find yourself wasting time switching among the menus.
29448 is the same as @key{1/x}.
29450 is the same as @key{SQRT}.
29452 is the same as @key{CONJ}.
29454 is the same as @key{y^x}.
29456 is the same as @key{INV y^x} (the @expr{x}th root of @expr{y}).
29458 are the same as @key{SIN} / @kbd{INV SIN}.
29460 are the same as @key{COS} / @kbd{INV COS}.
29462 are the same as @key{TAN} / @kbd{INV TAN}.
29464 are the same as @key{LN} / @kbd{HYP LN}.
29466 are the same as @key{EXP} / @kbd{HYP EXP}.
29468 is the same as @key{ABS}.
29470 is the same as @key{RND} (@code{calc-round}).
29472 is the same as @key{CLN2}.
29474 is the same as @key{FLT} (@code{calc-float}).
29476 is the same as @key{IMAG}.
29478 is the same as @key{PREC}.
29480 is the same as @key{SWAP}.
29482 is the same as @key{RLL3}.
29483 @item INV HYP ENTER
29484 is the same as @key{OVER}.
29486 packs the top two stack entries as an error form.
29488 packs the top two stack entries as a modulo form.
29490 creates an interval form; this removes an integer which is one
29491 of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
29492 by the two limits of the interval.
29495 The @kbd{OFF} key turns Calc off; typing @kbd{M-# k} or @kbd{M-# M-#}
29496 again has the same effect. This is analogous to typing @kbd{q} or
29497 hitting @kbd{M-# c} again in the normal calculator. If Calc is
29498 running standalone (the @code{full-calc-keypad} command appeared in the
29499 command line that started Emacs), then @kbd{OFF} is replaced with
29500 @kbd{EXIT}; clicking on this actually exits Emacs itself.
29502 @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
29503 @section Functions Menu
29507 |----+----+----+----+----+----2
29508 |IGAM|BETA|IBET|ERF |BESJ|BESY|
29509 |----+----+----+----+----+----|
29510 |IMAG|CONJ| RE |ATN2|RAND|RAGN|
29511 |----+----+----+----+----+----|
29512 |GCD |FACT|DFCT|BNOM|PERM|NXTP|
29513 |----+----+----+----+----+----|
29518 This menu provides various operations from the @kbd{f} and @kbd{k}
29521 @key{IMAG} multiplies the number on the stack by the imaginary
29522 number @expr{i = (0, 1)}.
29524 @key{RE} extracts the real part a complex number. @kbd{INV RE}
29525 extracts the imaginary part.
29527 @key{RAND} takes a number from the top of the stack and computes
29528 a random number greater than or equal to zero but less than that
29529 number. (@xref{Random Numbers}.) @key{RAGN} is the ``random
29530 again'' command; it computes another random number using the
29531 same limit as last time.
29533 @key{INV GCD} computes the LCM (least common multiple) function.
29535 @key{INV FACT} is the gamma function.
29536 @texline @math{\Gamma(x) = (x-1)!}.
29537 @infoline @expr{gamma(x) = (x-1)!}.
29539 @key{PERM} is the number-of-permutations function, which is on the
29540 @kbd{H k c} key in normal Calc.
29542 @key{NXTP} finds the next prime after a number. @kbd{INV NXTP}
29543 finds the previous prime.
29545 @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
29546 @section Binary Menu
29550 |----+----+----+----+----+----3
29551 |AND | OR |XOR |NOT |LSH |RSH |
29552 |----+----+----+----+----+----|
29553 |DEC |HEX |OCT |BIN |WSIZ|ARSH|
29554 |----+----+----+----+----+----|
29555 | A | B | C | D | E | F |
29556 |----+----+----+----+----+----|
29561 The keys in this menu perform operations on binary integers.
29562 Note that both logical and arithmetic right-shifts are provided.
29563 @key{INV LSH} rotates one bit to the left.
29565 The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
29566 The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
29568 The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
29569 current radix for display and entry of numbers: Decimal, hexadecimal,
29570 octal, or binary. The six letter keys @key{A} through @key{F} are used
29571 for entering hexadecimal numbers.
29573 The @key{WSIZ} key displays the current word size for binary operations
29574 and allows you to enter a new word size. You can respond to the prompt
29575 using either the keyboard or the digits and @key{ENTER} from the keypad.
29576 The initial word size is 32 bits.
29578 @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
29579 @section Vectors Menu
29583 |----+----+----+----+----+----4
29584 |SUM |PROD|MAX |MAP*|MAP^|MAP$|
29585 |----+----+----+----+----+----|
29586 |MINV|MDET|MTRN|IDNT|CRSS|"x" |
29587 |----+----+----+----+----+----|
29588 |PACK|UNPK|INDX|BLD |LEN |... |
29589 |----+----+----+----+----+----|
29594 The keys in this menu operate on vectors and matrices.
29596 @key{PACK} removes an integer @var{n} from the top of the stack;
29597 the next @var{n} stack elements are removed and packed into a vector,
29598 which is replaced onto the stack. Thus the sequence
29599 @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
29600 @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row
29601 on the stack as a vector, then use a final @key{PACK} to collect the
29602 rows into a matrix.
29604 @key{UNPK} unpacks the vector on the stack, pushing each of its
29605 components separately.
29607 @key{INDX} removes an integer @var{n}, then builds a vector of
29608 integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers
29609 from the stack: The vector size @var{n}, the starting number,
29610 and the increment. @kbd{BLD} takes an integer @var{n} and any
29611 value @var{x} and builds a vector of @var{n} copies of @var{x}.
29613 @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
29616 @key{LEN} replaces a vector by its length, an integer.
29618 @key{...} turns on or off ``abbreviated'' display mode for large vectors.
29620 @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
29621 inverse, determinant, and transpose, and vector cross product.
29623 @key{SUM} replaces a vector by the sum of its elements. It is
29624 equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
29625 @key{PROD} computes the product of the elements of a vector, and
29626 @key{MAX} computes the maximum of all the elements of a vector.
29628 @key{INV SUM} computes the alternating sum of the first element
29629 minus the second, plus the third, minus the fourth, and so on.
29630 @key{INV MAX} computes the minimum of the vector elements.
29632 @key{HYP SUM} computes the mean of the vector elements.
29633 @key{HYP PROD} computes the sample standard deviation.
29634 @key{HYP MAX} computes the median.
29636 @key{MAP*} multiplies two vectors elementwise. It is equivalent
29637 to the @kbd{V M *} command. @key{MAP^} computes powers elementwise.
29638 The arguments must be vectors of equal length, or one must be a vector
29639 and the other must be a plain number. For example, @kbd{2 MAP^} squares
29640 all the elements of a vector.
29642 @key{MAP$} maps the formula on the top of the stack across the
29643 vector in the second-to-top position. If the formula contains
29644 several variables, Calc takes that many vectors starting at the
29645 second-to-top position and matches them to the variables in
29646 alphabetical order. The result is a vector of the same size as
29647 the input vectors, whose elements are the formula evaluated with
29648 the variables set to the various sets of numbers in those vectors.
29649 For example, you could simulate @key{MAP^} using @key{MAP$} with
29650 the formula @samp{x^y}.
29652 The @kbd{"x"} key pushes the variable name @expr{x} onto the
29653 stack. To build the formula @expr{x^2 + 6}, you would use the
29654 key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be
29655 suitable for use with the @key{MAP$} key described above.
29656 With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
29657 @kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and
29658 @expr{t}, respectively.
29660 @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
29661 @section Modes Menu
29665 |----+----+----+----+----+----5
29666 |FLT |FIX |SCI |ENG |GRP | |
29667 |----+----+----+----+----+----|
29668 |RAD |DEG |FRAC|POLR|SYMB|PREC|
29669 |----+----+----+----+----+----|
29670 |SWAP|RLL3|RLL4|OVER|STO |RCL |
29671 |----+----+----+----+----+----|
29676 The keys in this menu manipulate modes, variables, and the stack.
29678 The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
29679 floating-point, fixed-point, scientific, or engineering notation.
29680 @key{FIX} displays two digits after the decimal by default; the
29681 others display full precision. With the @key{INV} prefix, these
29682 keys pop a number-of-digits argument from the stack.
29684 The @key{GRP} key turns grouping of digits with commas on or off.
29685 @kbd{INV GRP} enables grouping to the right of the decimal point as
29686 well as to the left.
29688 The @key{RAD} and @key{DEG} keys switch between radians and degrees
29689 for trigonometric functions.
29691 The @key{FRAC} key turns Fraction mode on or off. This affects
29692 whether commands like @kbd{/} with integer arguments produce
29693 fractional or floating-point results.
29695 The @key{POLR} key turns Polar mode on or off, determining whether
29696 polar or rectangular complex numbers are used by default.
29698 The @key{SYMB} key turns Symbolic mode on or off, in which
29699 operations that would produce inexact floating-point results
29700 are left unevaluated as algebraic formulas.
29702 The @key{PREC} key selects the current precision. Answer with
29703 the keyboard or with the keypad digit and @key{ENTER} keys.
29705 The @key{SWAP} key exchanges the top two stack elements.
29706 The @key{RLL3} key rotates the top three stack elements upwards.
29707 The @key{RLL4} key rotates the top four stack elements upwards.
29708 The @key{OVER} key duplicates the second-to-top stack element.
29710 The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
29711 @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the
29712 @key{STO} or @key{RCL} key, then one of the ten digits. (Named
29713 variables are not available in Keypad mode.) You can also use,
29714 for example, @kbd{STO + 3} to add to register 3.
29716 @node Embedded Mode, Programming, Keypad Mode, Top
29717 @chapter Embedded Mode
29720 Embedded mode in Calc provides an alternative to copying numbers
29721 and formulas back and forth between editing buffers and the Calc
29722 stack. In Embedded mode, your editing buffer becomes temporarily
29723 linked to the stack and this copying is taken care of automatically.
29726 * Basic Embedded Mode::
29727 * More About Embedded Mode::
29728 * Assignments in Embedded Mode::
29729 * Mode Settings in Embedded Mode::
29730 * Customizing Embedded Mode::
29733 @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
29734 @section Basic Embedded Mode
29738 @pindex calc-embedded
29739 To enter Embedded mode, position the Emacs point (cursor) on a
29740 formula in any buffer and press @kbd{M-# e} (@code{calc-embedded}).
29741 Note that @kbd{M-# e} is not to be used in the Calc stack buffer
29742 like most Calc commands, but rather in regular editing buffers that
29743 are visiting your own files.
29745 Calc normally scans backward and forward in the buffer for the
29746 nearest opening and closing @dfn{formula delimiters}. The simplest
29747 delimiters are blank lines. Other delimiters that Embedded mode
29752 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
29753 @samp{\[ \]}, and @samp{\( \)};
29755 Lines beginning with @samp{\begin} and @samp{\end};
29757 Lines beginning with @samp{@@} (Texinfo delimiters).
29759 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
29761 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
29764 @xref{Customizing Embedded Mode}, to see how to make Calc recognize
29765 your own favorite delimiters. Delimiters like @samp{$ $} can appear
29766 on their own separate lines or in-line with the formula.
29768 If you give a positive or negative numeric prefix argument, Calc
29769 instead uses the current point as one end of the formula, and moves
29770 forward or backward (respectively) by that many lines to find the
29771 other end. Explicit delimiters are not necessary in this case.
29773 With a prefix argument of zero, Calc uses the current region
29774 (delimited by point and mark) instead of formula delimiters.
29777 @pindex calc-embedded-word
29778 With a prefix argument of @kbd{C-u} only, Calc scans for the first
29779 non-numeric character (i.e., the first character that is not a
29780 digit, sign, decimal point, or upper- or lower-case @samp{e})
29781 forward and backward to delimit the formula. @kbd{M-# w}
29782 (@code{calc-embedded-word}) is equivalent to @kbd{C-u M-# e}.
29784 When you enable Embedded mode for a formula, Calc reads the text
29785 between the delimiters and tries to interpret it as a Calc formula.
29786 It's best if the current Calc language mode is correct for the
29787 formula, but Calc can generally identify @TeX{} formulas and
29788 Big-style formulas even if the language mode is wrong. If Calc
29789 can't make sense of the formula, it beeps and refuses to enter
29790 Embedded mode. But if the current language is wrong, Calc can
29791 sometimes parse the formula successfully (but incorrectly);
29792 for example, the C expression @samp{atan(a[1])} can be parsed
29793 in Normal language mode, but the @code{atan} won't correspond to
29794 the built-in @code{arctan} function, and the @samp{a[1]} will be
29795 interpreted as @samp{a} times the vector @samp{[1]}!
29797 If you press @kbd{M-# e} or @kbd{M-# w} to activate an embedded
29798 formula which is blank, say with the cursor on the space between
29799 the two delimiters @samp{$ $}, Calc will immediately prompt for
29800 an algebraic entry.
29802 Only one formula in one buffer can be enabled at a time. If you
29803 move to another area of the current buffer and give Calc commands,
29804 Calc turns Embedded mode off for the old formula and then tries
29805 to restart Embedded mode at the new position. Other buffers are
29806 not affected by Embedded mode.
29808 When Embedded mode begins, Calc pushes the current formula onto
29809 the stack. No Calc stack window is created; however, Calc copies
29810 the top-of-stack position into the original buffer at all times.
29811 You can create a Calc window by hand with @kbd{M-# o} if you
29812 find you need to see the entire stack.
29814 For example, typing @kbd{M-# e} while somewhere in the formula
29815 @samp{n>2} in the following line enables Embedded mode on that
29819 We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
29823 The formula @expr{n>2} will be pushed onto the Calc stack, and
29824 the top of stack will be copied back into the editing buffer.
29825 This means that spaces will appear around the @samp{>} symbol
29826 to match Calc's usual display style:
29829 We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
29833 No spaces have appeared around the @samp{+} sign because it's
29834 in a different formula, one which we have not yet touched with
29837 Now that Embedded mode is enabled, keys you type in this buffer
29838 are interpreted as Calc commands. At this point we might use
29839 the ``commute'' command @kbd{j C} to reverse the inequality.
29840 This is a selection-based command for which we first need to
29841 move the cursor onto the operator (@samp{>} in this case) that
29842 needs to be commuted.
29845 We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
29848 The @kbd{M-# o} command is a useful way to open a Calc window
29849 without actually selecting that window. Giving this command
29850 verifies that @samp{2 < n} is also on the Calc stack. Typing
29851 @kbd{17 @key{RET}} would produce:
29854 We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
29858 with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
29859 at this point will exchange the two stack values and restore
29860 @samp{2 < n} to the embedded formula. Even though you can't
29861 normally see the stack in Embedded mode, it is still there and
29862 it still operates in the same way. But, as with old-fashioned
29863 RPN calculators, you can only see the value at the top of the
29864 stack at any given time (unless you use @kbd{M-# o}).
29866 Typing @kbd{M-# e} again turns Embedded mode off. The Calc
29867 window reveals that the formula @w{@samp{2 < n}} is automatically
29868 removed from the stack, but the @samp{17} is not. Entering
29869 Embedded mode always pushes one thing onto the stack, and
29870 leaving Embedded mode always removes one thing. Anything else
29871 that happens on the stack is entirely your business as far as
29872 Embedded mode is concerned.
29874 If you press @kbd{M-# e} in the wrong place by accident, it is
29875 possible that Calc will be able to parse the nearby text as a
29876 formula and will mangle that text in an attempt to redisplay it
29877 ``properly'' in the current language mode. If this happens,
29878 press @kbd{M-# e} again to exit Embedded mode, then give the
29879 regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
29880 the text back the way it was before Calc edited it. Note that Calc's
29881 own Undo command (typed before you turn Embedded mode back off)
29882 will not do you any good, because as far as Calc is concerned
29883 you haven't done anything with this formula yet.
29885 @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
29886 @section More About Embedded Mode
29889 When Embedded mode ``activates'' a formula, i.e., when it examines
29890 the formula for the first time since the buffer was created or
29891 loaded, Calc tries to sense the language in which the formula was
29892 written. If the formula contains any @TeX{}-like @samp{\} sequences,
29893 it is parsed (i.e., read) in @TeX{} mode. If the formula appears to
29894 be written in multi-line Big mode, it is parsed in Big mode. Otherwise,
29895 it is parsed according to the current language mode.
29897 Note that Calc does not change the current language mode according
29898 to what it finds. Even though it can read a @TeX{} formula when
29899 not in @TeX{} mode, it will immediately rewrite this formula using
29900 whatever language mode is in effect. You must then type @kbd{d T}
29901 to switch Calc permanently into @TeX{} mode if that is what you
29909 @pindex calc-show-plain
29910 Calc's parser is unable to read certain kinds of formulas. For
29911 example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
29912 specify matrix display styles which the parser is unable to
29913 recognize as matrices. The @kbd{d p} (@code{calc-show-plain})
29914 command turns on a mode in which a ``plain'' version of a
29915 formula is placed in front of the fully-formatted version.
29916 When Calc reads a formula that has such a plain version in
29917 front, it reads the plain version and ignores the formatted
29920 Plain formulas are preceded and followed by @samp{%%%} signs
29921 by default. This notation has the advantage that the @samp{%}
29922 character begins a comment in @TeX{}, so if your formula is
29923 embedded in a @TeX{} document its plain version will be
29924 invisible in the final printed copy. @xref{Customizing
29925 Embedded Mode}, to see how to change the ``plain'' formula
29926 delimiters, say to something that @dfn{eqn} or some other
29927 formatter will treat as a comment.
29929 There are several notations which Calc's parser for ``big''
29930 formatted formulas can't yet recognize. In particular, it can't
29931 read the large symbols for @code{sum}, @code{prod}, and @code{integ},
29932 and it can't handle @samp{=>} with the righthand argument omitted.
29933 Also, Calc won't recognize special formats you have defined with
29934 the @kbd{Z C} command (@pxref{User-Defined Compositions}). In
29935 these cases it is important to use ``plain'' mode to make sure
29936 Calc will be able to read your formula later.
29938 Another example where ``plain'' mode is important is if you have
29939 specified a float mode with few digits of precision. Normally
29940 any digits that are computed but not displayed will simply be
29941 lost when you save and re-load your embedded buffer, but ``plain''
29942 mode allows you to make sure that the complete number is present
29943 in the file as well as the rounded-down number.
29949 Embedded buffers remember active formulas for as long as they
29950 exist in Emacs memory. Suppose you have an embedded formula
29951 which is @cpi{} to the normal 12 decimal places, and then
29952 type @w{@kbd{C-u 5 d n}} to display only five decimal places.
29953 If you then type @kbd{d n}, all 12 places reappear because the
29954 full number is still there on the Calc stack. More surprisingly,
29955 even if you exit Embedded mode and later re-enter it for that
29956 formula, typing @kbd{d n} will restore all 12 places because
29957 each buffer remembers all its active formulas. However, if you
29958 save the buffer in a file and reload it in a new Emacs session,
29959 all non-displayed digits will have been lost unless you used
29966 In some applications of Embedded mode, you will want to have a
29967 sequence of copies of a formula that show its evolution as you
29968 work on it. For example, you might want to have a sequence
29969 like this in your file (elaborating here on the example from
29970 the ``Getting Started'' chapter):
29979 @r{(the derivative of }ln(ln(x))@r{)}
29981 whose value at x = 2 is
29991 @pindex calc-embedded-duplicate
29992 The @kbd{M-# d} (@code{calc-embedded-duplicate}) command is a
29993 handy way to make sequences like this. If you type @kbd{M-# d},
29994 the formula under the cursor (which may or may not have Embedded
29995 mode enabled for it at the time) is copied immediately below and
29996 Embedded mode is then enabled for that copy.
29998 For this example, you would start with just
30007 and press @kbd{M-# d} with the cursor on this formula. The result
30020 with the second copy of the formula enabled in Embedded mode.
30021 You can now press @kbd{a d x @key{RET}} to take the derivative, and
30022 @kbd{M-# d M-# d} to make two more copies of the derivative.
30023 To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
30024 the last formula, then move up to the second-to-last formula
30025 and type @kbd{2 s l x @key{RET}}.
30027 Finally, you would want to press @kbd{M-# e} to exit Embedded
30028 mode, then go up and insert the necessary text in between the
30029 various formulas and numbers.
30037 @pindex calc-embedded-new-formula
30038 The @kbd{M-# f} (@code{calc-embedded-new-formula}) command
30039 creates a new embedded formula at the current point. It inserts
30040 some default delimiters, which are usually just blank lines,
30041 and then does an algebraic entry to get the formula (which is
30042 then enabled for Embedded mode). This is just shorthand for
30043 typing the delimiters yourself, positioning the cursor between
30044 the new delimiters, and pressing @kbd{M-# e}. The key sequence
30045 @kbd{M-# '} is equivalent to @kbd{M-# f}.
30049 @pindex calc-embedded-next
30050 @pindex calc-embedded-previous
30051 The @kbd{M-# n} (@code{calc-embedded-next}) and @kbd{M-# p}
30052 (@code{calc-embedded-previous}) commands move the cursor to the
30053 next or previous active embedded formula in the buffer. They
30054 can take positive or negative prefix arguments to move by several
30055 formulas. Note that these commands do not actually examine the
30056 text of the buffer looking for formulas; they only see formulas
30057 which have previously been activated in Embedded mode. In fact,
30058 @kbd{M-# n} and @kbd{M-# p} are a useful way to tell which
30059 embedded formulas are currently active. Also, note that these
30060 commands do not enable Embedded mode on the next or previous
30061 formula, they just move the cursor. (By the way, @kbd{M-# n} is
30062 not as awkward to type as it may seem, because @kbd{M-#} ignores
30063 Shift and Meta on the second keystroke: @kbd{M-# M-N} can be typed
30064 by holding down Shift and Meta and alternately typing two keys.)
30067 @pindex calc-embedded-edit
30068 The @kbd{M-# `} (@code{calc-embedded-edit}) command edits the
30069 embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
30070 Embedded mode does not have to be enabled for this to work. Press
30071 @kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel.
30073 @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
30074 @section Assignments in Embedded Mode
30077 The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
30078 are especially useful in Embedded mode. They allow you to make
30079 a definition in one formula, then refer to that definition in
30080 other formulas embedded in the same buffer.
30082 An embedded formula which is an assignment to a variable, as in
30089 records @expr{5} as the stored value of @code{foo} for the
30090 purposes of Embedded mode operations in the current buffer. It
30091 does @emph{not} actually store @expr{5} as the ``global'' value
30092 of @code{foo}, however. Regular Calc operations, and Embedded
30093 formulas in other buffers, will not see this assignment.
30095 One way to use this assigned value is simply to create an
30096 Embedded formula elsewhere that refers to @code{foo}, and to press
30097 @kbd{=} in that formula. However, this permanently replaces the
30098 @code{foo} in the formula with its current value. More interesting
30099 is to use @samp{=>} elsewhere:
30105 @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
30107 If you move back and change the assignment to @code{foo}, any
30108 @samp{=>} formulas which refer to it are automatically updated.
30116 The obvious question then is, @emph{how} can one easily change the
30117 assignment to @code{foo}? If you simply select the formula in
30118 Embedded mode and type 17, the assignment itself will be replaced
30119 by the 17. The effect on the other formula will be that the
30120 variable @code{foo} becomes unassigned:
30128 The right thing to do is first to use a selection command (@kbd{j 2}
30129 will do the trick) to select the righthand side of the assignment.
30130 Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
30131 Subformulas}, to see how this works).
30134 @pindex calc-embedded-select
30135 The @kbd{M-# j} (@code{calc-embedded-select}) command provides an
30136 easy way to operate on assignments. It is just like @kbd{M-# e},
30137 except that if the enabled formula is an assignment, it uses
30138 @kbd{j 2} to select the righthand side. If the enabled formula
30139 is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
30140 A formula can also be a combination of both:
30143 bar := foo + 3 => 20
30147 in which case @kbd{M-# j} will select the middle part (@samp{foo + 3}).
30149 The formula is automatically deselected when you leave Embedded
30154 @pindex calc-embedded-update
30155 Another way to change the assignment to @code{foo} would simply be
30156 to edit the number using regular Emacs editing rather than Embedded
30157 mode. Then, we have to find a way to get Embedded mode to notice
30158 the change. The @kbd{M-# u} or @kbd{M-# =}
30159 (@code{calc-embedded-update-formula}) command is a convenient way
30168 Pressing @kbd{M-# u} is much like pressing @kbd{M-# e = M-# e}, that
30169 is, temporarily enabling Embedded mode for the formula under the
30170 cursor and then evaluating it with @kbd{=}. But @kbd{M-# u} does
30171 not actually use @kbd{M-# e}, and in fact another formula somewhere
30172 else can be enabled in Embedded mode while you use @kbd{M-# u} and
30173 that formula will not be disturbed.
30175 With a numeric prefix argument, @kbd{M-# u} updates all active
30176 @samp{=>} formulas in the buffer. Formulas which have not yet
30177 been activated in Embedded mode, and formulas which do not have
30178 @samp{=>} as their top-level operator, are not affected by this.
30179 (This is useful only if you have used @kbd{m C}; see below.)
30181 With a plain @kbd{C-u} prefix, @kbd{C-u M-# u} updates only in the
30182 region between mark and point rather than in the whole buffer.
30184 @kbd{M-# u} is also a handy way to activate a formula, such as an
30185 @samp{=>} formula that has freshly been typed in or loaded from a
30189 @pindex calc-embedded-activate
30190 The @kbd{M-# a} (@code{calc-embedded-activate}) command scans
30191 through the current buffer and activates all embedded formulas
30192 that contain @samp{:=} or @samp{=>} symbols. This does not mean
30193 that Embedded mode is actually turned on, but only that the
30194 formulas' positions are registered with Embedded mode so that
30195 the @samp{=>} values can be properly updated as assignments are
30198 It is a good idea to type @kbd{M-# a} right after loading a file
30199 that uses embedded @samp{=>} operators. Emacs includes a nifty
30200 ``buffer-local variables'' feature that you can use to do this
30201 automatically. The idea is to place near the end of your file
30202 a few lines that look like this:
30205 --- Local Variables: ---
30206 --- eval:(calc-embedded-activate) ---
30211 where the leading and trailing @samp{---} can be replaced by
30212 any suitable strings (which must be the same on all three lines)
30213 or omitted altogether; in a @TeX{} file, @samp{%} would be a good
30214 leading string and no trailing string would be necessary. In a
30215 C program, @samp{/*} and @samp{*/} would be good leading and
30218 When Emacs loads a file into memory, it checks for a Local Variables
30219 section like this one at the end of the file. If it finds this
30220 section, it does the specified things (in this case, running
30221 @kbd{M-# a} automatically) before editing of the file begins.
30222 The Local Variables section must be within 3000 characters of the
30223 end of the file for Emacs to find it, and it must be in the last
30224 page of the file if the file has any page separators.
30225 @xref{File Variables, , Local Variables in Files, emacs, the
30228 Note that @kbd{M-# a} does not update the formulas it finds.
30229 To do this, type, say, @kbd{M-1 M-# u} after @w{@kbd{M-# a}}.
30230 Generally this should not be a problem, though, because the
30231 formulas will have been up-to-date already when the file was
30234 Normally, @kbd{M-# a} activates all the formulas it finds, but
30235 any previous active formulas remain active as well. With a
30236 positive numeric prefix argument, @kbd{M-# a} first deactivates
30237 all current active formulas, then actives the ones it finds in
30238 its scan of the buffer. With a negative prefix argument,
30239 @kbd{M-# a} simply deactivates all formulas.
30241 Embedded mode has two symbols, @samp{Active} and @samp{~Active},
30242 which it puts next to the major mode name in a buffer's mode line.
30243 It puts @samp{Active} if it has reason to believe that all
30244 formulas in the buffer are active, because you have typed @kbd{M-# a}
30245 and Calc has not since had to deactivate any formulas (which can
30246 happen if Calc goes to update an @samp{=>} formula somewhere because
30247 a variable changed, and finds that the formula is no longer there
30248 due to some kind of editing outside of Embedded mode). Calc puts
30249 @samp{~Active} in the mode line if some, but probably not all,
30250 formulas in the buffer are active. This happens if you activate
30251 a few formulas one at a time but never use @kbd{M-# a}, or if you
30252 used @kbd{M-# a} but then Calc had to deactivate a formula
30253 because it lost track of it. If neither of these symbols appears
30254 in the mode line, no embedded formulas are active in the buffer
30255 (e.g., before Embedded mode has been used, or after a @kbd{M-- M-# a}).
30257 Embedded formulas can refer to assignments both before and after them
30258 in the buffer. If there are several assignments to a variable, the
30259 nearest preceding assignment is used if there is one, otherwise the
30260 following assignment is used.
30274 As well as simple variables, you can also assign to subscript
30275 expressions of the form @samp{@var{var}_@var{number}} (as in
30276 @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
30277 Assignments to other kinds of objects can be represented by Calc,
30278 but the automatic linkage between assignments and references works
30279 only for plain variables and these two kinds of subscript expressions.
30281 If there are no assignments to a given variable, the global
30282 stored value for the variable is used (@pxref{Storing Variables}),
30283 or, if no value is stored, the variable is left in symbolic form.
30284 Note that global stored values will be lost when the file is saved
30285 and loaded in a later Emacs session, unless you have used the
30286 @kbd{s p} (@code{calc-permanent-variable}) command to save them;
30287 @pxref{Operations on Variables}.
30289 The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
30290 recomputation of @samp{=>} forms on and off. If you turn automatic
30291 recomputation off, you will have to use @kbd{M-# u} to update these
30292 formulas manually after an assignment has been changed. If you
30293 plan to change several assignments at once, it may be more efficient
30294 to type @kbd{m C}, change all the assignments, then use @kbd{M-1 M-# u}
30295 to update the entire buffer afterwards. The @kbd{m C} command also
30296 controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
30297 Operator}. When you turn automatic recomputation back on, the
30298 stack will be updated but the Embedded buffer will not; you must
30299 use @kbd{M-# u} to update the buffer by hand.
30301 @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
30302 @section Mode Settings in Embedded Mode
30305 Embedded mode has a rather complicated mechanism for handling mode
30306 settings in Embedded formulas. It is possible to put annotations
30307 in the file that specify mode settings either global to the entire
30308 file or local to a particular formula or formulas. In the latter
30309 case, different modes can be specified for use when a formula
30310 is the enabled Embedded mode formula.
30312 When you give any mode-setting command, like @kbd{m f} (for Fraction
30313 mode) or @kbd{d s} (for scientific notation), Embedded mode adds
30314 a line like the following one to the file just before the opening
30315 delimiter of the formula.
30318 % [calc-mode: fractions: t]
30319 % [calc-mode: float-format: (sci 0)]
30322 When Calc interprets an embedded formula, it scans the text before
30323 the formula for mode-setting annotations like these and sets the
30324 Calc buffer to match these modes. Modes not explicitly described
30325 in the file are not changed. Calc scans all the way to the top of
30326 the file, or up to a line of the form
30333 which you can insert at strategic places in the file if this backward
30334 scan is getting too slow, or just to provide a barrier between one
30335 ``zone'' of mode settings and another.
30337 If the file contains several annotations for the same mode, the
30338 closest one before the formula is used. Annotations after the
30339 formula are never used (except for global annotations, described
30342 The scan does not look for the leading @samp{% }, only for the
30343 square brackets and the text they enclose. You can edit the mode
30344 annotations to a style that works better in context if you wish.
30345 @xref{Customizing Embedded Mode}, to see how to change the style
30346 that Calc uses when it generates the annotations. You can write
30347 mode annotations into the file yourself if you know the syntax;
30348 the easiest way to find the syntax for a given mode is to let
30349 Calc write the annotation for it once and see what it does.
30351 If you give a mode-changing command for a mode that already has
30352 a suitable annotation just above the current formula, Calc will
30353 modify that annotation rather than generating a new, conflicting
30356 Mode annotations have three parts, separated by colons. (Spaces
30357 after the colons are optional.) The first identifies the kind
30358 of mode setting, the second is a name for the mode itself, and
30359 the third is the value in the form of a Lisp symbol, number,
30360 or list. Annotations with unrecognizable text in the first or
30361 second parts are ignored. The third part is not checked to make
30362 sure the value is of a legal type or range; if you write an
30363 annotation by hand, be sure to give a proper value or results
30364 will be unpredictable. Mode-setting annotations are case-sensitive.
30366 While Embedded mode is enabled, the word @code{Local} appears in
30367 the mode line. This is to show that mode setting commands generate
30368 annotations that are ``local'' to the current formula or set of
30369 formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command
30370 causes Calc to generate different kinds of annotations. Pressing
30371 @kbd{m R} repeatedly cycles through the possible modes.
30373 @code{LocEdit} and @code{LocPerm} modes generate annotations
30374 that look like this, respectively:
30377 % [calc-edit-mode: float-format: (sci 0)]
30378 % [calc-perm-mode: float-format: (sci 5)]
30381 The first kind of annotation will be used only while a formula
30382 is enabled in Embedded mode. The second kind will be used only
30383 when the formula is @emph{not} enabled. (Whether the formula
30384 is ``active'' or not, i.e., whether Calc has seen this formula
30385 yet, is not relevant here.)
30387 @code{Global} mode generates an annotation like this at the end
30391 % [calc-global-mode: fractions t]
30394 Global mode annotations affect all formulas throughout the file,
30395 and may appear anywhere in the file. This allows you to tuck your
30396 mode annotations somewhere out of the way, say, on a new page of
30397 the file, as long as those mode settings are suitable for all
30398 formulas in the file.
30400 Enabling a formula with @kbd{M-# e} causes a fresh scan for local
30401 mode annotations; you will have to use this after adding annotations
30402 above a formula by hand to get the formula to notice them. Updating
30403 a formula with @kbd{M-# u} will also re-scan the local modes, but
30404 global modes are only re-scanned by @kbd{M-# a}.
30406 Another way that modes can get out of date is if you add a local
30407 mode annotation to a formula that has another formula after it.
30408 In this example, we have used the @kbd{d s} command while the
30409 first of the two embedded formulas is active. But the second
30410 formula has not changed its style to match, even though by the
30411 rules of reading annotations the @samp{(sci 0)} applies to it, too.
30414 % [calc-mode: float-format: (sci 0)]
30420 We would have to go down to the other formula and press @kbd{M-# u}
30421 on it in order to get it to notice the new annotation.
30423 Two more mode-recording modes selectable by @kbd{m R} are @code{Save}
30424 (which works even outside of Embedded mode), in which mode settings
30425 are recorded permanently in your Calc init file (the file given by the
30426 variable @code{calc-settings-file}, typically @file{~/.calc.el})
30427 rather than by annotating the current document, and no-recording
30428 mode (where there is no symbol like @code{Save} or @code{Local} in
30429 the mode line), in which mode-changing commands do not leave any
30430 annotations at all.
30432 When Embedded mode is not enabled, mode-recording modes except
30433 for @code{Save} have no effect.
30435 @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
30436 @section Customizing Embedded Mode
30439 You can modify Embedded mode's behavior by setting various Lisp
30440 variables described here. Use @kbd{M-x set-variable} or
30441 @kbd{M-x edit-options} to adjust a variable on the fly, or
30442 put a suitable @code{setq} statement in your Calc init file (or
30443 @file{~/.emacs}) to set a variable permanently. (Another possibility would
30444 be to use a file-local variable annotation at the end of the
30445 file; @pxref{File Variables, , Local Variables in Files, emacs, the
30448 While none of these variables will be buffer-local by default, you
30449 can make any of them local to any Embedded mode buffer. (Their
30450 values in the @samp{*Calculator*} buffer are never used.)
30452 @vindex calc-embedded-open-formula
30453 The @code{calc-embedded-open-formula} variable holds a regular
30454 expression for the opening delimiter of a formula. @xref{Regexp Search,
30455 , Regular Expression Search, emacs, the Emacs manual}, to see
30456 how regular expressions work. Basically, a regular expression is a
30457 pattern that Calc can search for. A regular expression that considers
30458 blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
30459 @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this
30460 regular expression is not completely plain, let's go through it
30463 The surrounding @samp{" "} marks quote the text between them as a
30464 Lisp string. If you left them off, @code{set-variable} or
30465 @code{edit-options} would try to read the regular expression as a
30468 The most obvious property of this regular expression is that it
30469 contains indecently many backslashes. There are actually two levels
30470 of backslash usage going on here. First, when Lisp reads a quoted
30471 string, all pairs of characters beginning with a backslash are
30472 interpreted as special characters. Here, @code{\n} changes to a
30473 new-line character, and @code{\\} changes to a single backslash.
30474 So the actual regular expression seen by Calc is
30475 @samp{\`\|^ @r{(newline)} \|\$\$?}.
30477 Regular expressions also consider pairs beginning with backslash
30478 to have special meanings. Sometimes the backslash is used to quote
30479 a character that otherwise would have a special meaning in a regular
30480 expression, like @samp{$}, which normally means ``end-of-line,''
30481 or @samp{?}, which means that the preceding item is optional. So
30482 @samp{\$\$?} matches either one or two dollar signs.
30484 The other codes in this regular expression are @samp{^}, which matches
30485 ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
30486 which matches ``beginning-of-buffer.'' So the whole pattern means
30487 that a formula begins at the beginning of the buffer, or on a newline
30488 that occurs at the beginning of a line (i.e., a blank line), or at
30489 one or two dollar signs.
30491 The default value of @code{calc-embedded-open-formula} looks just
30492 like this example, with several more alternatives added on to
30493 recognize various other common kinds of delimiters.
30495 By the way, the reason to use @samp{^\n} rather than @samp{^$}
30496 or @samp{\n\n}, which also would appear to match blank lines,
30497 is that the former expression actually ``consumes'' only one
30498 newline character as @emph{part of} the delimiter, whereas the
30499 latter expressions consume zero or two newlines, respectively.
30500 The former choice gives the most natural behavior when Calc
30501 must operate on a whole formula including its delimiters.
30503 See the Emacs manual for complete details on regular expressions.
30504 But just for your convenience, here is a list of all characters
30505 which must be quoted with backslash (like @samp{\$}) to avoid
30506 some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note
30507 the backslash in this list; for example, to match @samp{\[} you
30508 must use @code{"\\\\\\["}. An exercise for the reader is to
30509 account for each of these six backslashes!)
30511 @vindex calc-embedded-close-formula
30512 The @code{calc-embedded-close-formula} variable holds a regular
30513 expression for the closing delimiter of a formula. A closing
30514 regular expression to match the above example would be
30515 @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the
30516 other one, except it now uses @samp{\'} (``end-of-buffer'') and
30517 @samp{\n$} (newline occurring at end of line, yet another way
30518 of describing a blank line that is more appropriate for this
30521 @vindex calc-embedded-open-word
30522 @vindex calc-embedded-close-word
30523 The @code{calc-embedded-open-word} and @code{calc-embedded-close-word}
30524 variables are similar expressions used when you type @kbd{M-# w}
30525 instead of @kbd{M-# e} to enable Embedded mode.
30527 @vindex calc-embedded-open-plain
30528 The @code{calc-embedded-open-plain} variable is a string which
30529 begins a ``plain'' formula written in front of the formatted
30530 formula when @kbd{d p} mode is turned on. Note that this is an
30531 actual string, not a regular expression, because Calc must be able
30532 to write this string into a buffer as well as to recognize it.
30533 The default string is @code{"%%% "} (note the trailing space).
30535 @vindex calc-embedded-close-plain
30536 The @code{calc-embedded-close-plain} variable is a string which
30537 ends a ``plain'' formula. The default is @code{" %%%\n"}. Without
30538 the trailing newline here, the first line of a Big mode formula
30539 that followed might be shifted over with respect to the other lines.
30541 @vindex calc-embedded-open-new-formula
30542 The @code{calc-embedded-open-new-formula} variable is a string
30543 which is inserted at the front of a new formula when you type
30544 @kbd{M-# f}. Its default value is @code{"\n\n"}. If this
30545 string begins with a newline character and the @kbd{M-# f} is
30546 typed at the beginning of a line, @kbd{M-# f} will skip this
30547 first newline to avoid introducing unnecessary blank lines in
30550 @vindex calc-embedded-close-new-formula
30551 The @code{calc-embedded-close-new-formula} variable is the corresponding
30552 string which is inserted at the end of a new formula. Its default
30553 value is also @code{"\n\n"}. The final newline is omitted by
30554 @w{@kbd{M-# f}} if typed at the end of a line. (It follows that if
30555 @kbd{M-# f} is typed on a blank line, both a leading opening
30556 newline and a trailing closing newline are omitted.)
30558 @vindex calc-embedded-announce-formula
30559 The @code{calc-embedded-announce-formula} variable is a regular
30560 expression which is sure to be followed by an embedded formula.
30561 The @kbd{M-# a} command searches for this pattern as well as for
30562 @samp{=>} and @samp{:=} operators. Note that @kbd{M-# a} will
30563 not activate just anything surrounded by formula delimiters; after
30564 all, blank lines are considered formula delimiters by default!
30565 But if your language includes a delimiter which can only occur
30566 actually in front of a formula, you can take advantage of it here.
30567 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which
30568 checks for @samp{%Embed} followed by any number of lines beginning
30569 with @samp{%} and a space. This last is important to make Calc
30570 consider mode annotations part of the pattern, so that the formula's
30571 opening delimiter really is sure to follow the pattern.
30573 @vindex calc-embedded-open-mode
30574 The @code{calc-embedded-open-mode} variable is a string (not a
30575 regular expression) which should precede a mode annotation.
30576 Calc never scans for this string; Calc always looks for the
30577 annotation itself. But this is the string that is inserted before
30578 the opening bracket when Calc adds an annotation on its own.
30579 The default is @code{"% "}.
30581 @vindex calc-embedded-close-mode
30582 The @code{calc-embedded-close-mode} variable is a string which
30583 follows a mode annotation written by Calc. Its default value
30584 is simply a newline, @code{"\n"}. If you change this, it is a
30585 good idea still to end with a newline so that mode annotations
30586 will appear on lines by themselves.
30588 @node Programming, Installation, Embedded Mode, Top
30589 @chapter Programming
30592 There are several ways to ``program'' the Emacs Calculator, depending
30593 on the nature of the problem you need to solve.
30597 @dfn{Keyboard macros} allow you to record a sequence of keystrokes
30598 and play them back at a later time. This is just the standard Emacs
30599 keyboard macro mechanism, dressed up with a few more features such
30600 as loops and conditionals.
30603 @dfn{Algebraic definitions} allow you to use any formula to define a
30604 new function. This function can then be used in algebraic formulas or
30605 as an interactive command.
30608 @dfn{Rewrite rules} are discussed in the section on algebra commands.
30609 @xref{Rewrite Rules}. If you put your rewrite rules in the variable
30610 @code{EvalRules}, they will be applied automatically to all Calc
30611 results in just the same way as an internal ``rule'' is applied to
30612 evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}.
30615 @dfn{Lisp} is the programming language that Calc (and most of Emacs)
30616 is written in. If the above techniques aren't powerful enough, you
30617 can write Lisp functions to do anything that built-in Calc commands
30618 can do. Lisp code is also somewhat faster than keyboard macros or
30623 Programming features are available through the @kbd{z} and @kbd{Z}
30624 prefix keys. New commands that you define are two-key sequences
30625 beginning with @kbd{z}. Commands for managing these definitions
30626 use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing})
30627 command is described elsewhere; @pxref{Troubleshooting Commands}.
30628 The @kbd{Z C} (@code{calc-user-define-composition}) command is also
30629 described elsewhere; @pxref{User-Defined Compositions}.)
30632 * Creating User Keys::
30633 * Keyboard Macros::
30634 * Invocation Macros::
30635 * Algebraic Definitions::
30636 * Lisp Definitions::
30639 @node Creating User Keys, Keyboard Macros, Programming, Programming
30640 @section Creating User Keys
30644 @pindex calc-user-define
30645 Any Calculator command may be bound to a key using the @kbd{Z D}
30646 (@code{calc-user-define}) command. Actually, it is bound to a two-key
30647 sequence beginning with the lower-case @kbd{z} prefix.
30649 The @kbd{Z D} command first prompts for the key to define. For example,
30650 press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then
30651 prompted for the name of the Calculator command that this key should
30652 run. For example, the @code{calc-sincos} command is not normally
30653 available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the
30654 @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain
30655 in effect for the rest of this Emacs session, or until you redefine
30656 @kbd{z s} to be something else.
30658 You can actually bind any Emacs command to a @kbd{z} key sequence by
30659 backspacing over the @samp{calc-} when you are prompted for the command name.
30661 As with any other prefix key, you can type @kbd{z ?} to see a list of
30662 all the two-key sequences you have defined that start with @kbd{z}.
30663 Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
30665 User keys are typically letters, but may in fact be any key.
30666 (@key{META}-keys are not permitted, nor are a terminal's special
30667 function keys which generate multi-character sequences when pressed.)
30668 You can define different commands on the shifted and unshifted versions
30669 of a letter if you wish.
30672 @pindex calc-user-undefine
30673 The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
30674 For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
30675 key we defined above.
30678 @pindex calc-user-define-permanent
30679 @cindex Storing user definitions
30680 @cindex Permanent user definitions
30681 @cindex Calc init file, user-defined commands
30682 The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
30683 binding permanent so that it will remain in effect even in future Emacs
30684 sessions. (It does this by adding a suitable bit of Lisp code into
30685 your Calc init file; that is, the file given by the variable
30686 @code{calc-settings-file}, typically @file{~/.calc.el}.) For example,
30687 @kbd{Z P s} would register our @code{sincos} command permanently. If
30688 you later wish to unregister this command you must edit your Calc init
30689 file by hand. (@xref{General Mode Commands}, for a way to tell Calc to
30690 use a different file for the Calc init file.)
30692 The @kbd{Z P} command also saves the user definition, if any, for the
30693 command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user
30694 key could invoke a command, which in turn calls an algebraic function,
30695 which might have one or more special display formats. A single @kbd{Z P}
30696 command will save all of these definitions.
30697 To save an algebraic function, type @kbd{'} (the apostrophe)
30698 when prompted for a key, and type the function name. To save a command
30699 without its key binding, type @kbd{M-x} and enter a function name. (The
30700 @samp{calc-} prefix will automatically be inserted for you.)
30701 (If the command you give implies a function, the function will be saved,
30702 and if the function has any display formats, those will be saved, but
30703 not the other way around: Saving a function will not save any commands
30704 or key bindings associated with the function.)
30707 @pindex calc-user-define-edit
30708 @cindex Editing user definitions
30709 The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
30710 of a user key. This works for keys that have been defined by either
30711 keyboard macros or formulas; further details are contained in the relevant
30712 following sections.
30714 @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
30715 @section Programming with Keyboard Macros
30719 @cindex Programming with keyboard macros
30720 @cindex Keyboard macros
30721 The easiest way to ``program'' the Emacs Calculator is to use standard
30722 keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From
30723 this point on, keystrokes you type will be saved away as well as
30724 performing their usual functions. Press @kbd{C-x )} to end recording.
30725 Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
30726 execute your keyboard macro by replaying the recorded keystrokes.
30727 @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
30730 When you use @kbd{X} to invoke a keyboard macro, the entire macro is
30731 treated as a single command by the undo and trail features. The stack
30732 display buffer is not updated during macro execution, but is instead
30733 fixed up once the macro completes. Thus, commands defined with keyboard
30734 macros are convenient and efficient. The @kbd{C-x e} command, on the
30735 other hand, invokes the keyboard macro with no special treatment: Each
30736 command in the macro will record its own undo information and trail entry,
30737 and update the stack buffer accordingly. If your macro uses features
30738 outside of Calc's control to operate on the contents of the Calc stack
30739 buffer, or if it includes Undo, Redo, or last-arguments commands, you
30740 must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
30741 at all times. You could also consider using @kbd{K} (@code{calc-keep-args})
30742 instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
30744 Calc extends the standard Emacs keyboard macros in several ways.
30745 Keyboard macros can be used to create user-defined commands. Keyboard
30746 macros can include conditional and iteration structures, somewhat
30747 analogous to those provided by a traditional programmable calculator.
30750 * Naming Keyboard Macros::
30751 * Conditionals in Macros::
30752 * Loops in Macros::
30753 * Local Values in Macros::
30754 * Queries in Macros::
30757 @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
30758 @subsection Naming Keyboard Macros
30762 @pindex calc-user-define-kbd-macro
30763 Once you have defined a keyboard macro, you can bind it to a @kbd{z}
30764 key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
30765 This command prompts first for a key, then for a command name. For
30766 example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
30767 define a keyboard macro which negates the top two numbers on the stack
30768 (@key{TAB} swaps the top two stack elements). Now you can type
30769 @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
30770 sequence. The default command name (if you answer the second prompt with
30771 just the @key{RET} key as in this example) will be something like
30772 @samp{calc-User-n}. The keyboard macro will now be available as both
30773 @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more
30774 descriptive command name if you wish.
30776 Macros defined by @kbd{Z K} act like single commands; they are executed
30777 in the same way as by the @kbd{X} key. If you wish to define the macro
30778 as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
30779 give a negative prefix argument to @kbd{Z K}.
30781 Once you have bound your keyboard macro to a key, you can use
30782 @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}.
30784 @cindex Keyboard macros, editing
30785 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
30786 been defined by a keyboard macro tries to use the @code{edmacro} package
30787 edit the macro. Type @kbd{C-c C-c} to finish editing and update
30788 the definition stored on the key, or, to cancel the edit, kill the
30789 buffer with @kbd{C-x k}.
30790 The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC},
30791 @code{DEL}, and @code{NUL} must be entered as these three character
30792 sequences, written in all uppercase, as must the prefixes @code{C-} and
30793 @code{M-}. Spaces and line breaks are ignored. Other characters are
30794 copied verbatim into the keyboard macro. Basically, the notation is the
30795 same as is used in all of this manual's examples, except that the manual
30796 takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}},
30797 we take it for granted that it is clear we really mean
30798 @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}.
30801 @pindex read-kbd-macro
30802 The @kbd{M-# m} (@code{read-kbd-macro}) command reads an Emacs ``region''
30803 of spelled-out keystrokes and defines it as the current keyboard macro.
30804 It is a convenient way to define a keyboard macro that has been stored
30805 in a file, or to define a macro without executing it at the same time.
30807 @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
30808 @subsection Conditionals in Keyboard Macros
30813 @pindex calc-kbd-if
30814 @pindex calc-kbd-else
30815 @pindex calc-kbd-else-if
30816 @pindex calc-kbd-end-if
30817 @cindex Conditional structures
30818 The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
30819 commands allow you to put simple tests in a keyboard macro. When Calc
30820 sees the @kbd{Z [}, it pops an object from the stack and, if the object is
30821 a non-zero value, continues executing keystrokes. But if the object is
30822 zero, or if it is not provably nonzero, Calc skips ahead to the matching
30823 @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for
30824 performing tests which conveniently produce 1 for true and 0 for false.
30826 For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
30827 function in the form of a keyboard macro. This macro duplicates the
30828 number on the top of the stack, pushes zero and compares using @kbd{a <}
30829 (@code{calc-less-than}), then, if the number was less than zero,
30830 executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign
30831 command is skipped.
30833 To program this macro, type @kbd{C-x (}, type the above sequence of
30834 keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be
30835 executed while you are making the definition as well as when you later
30836 re-execute the macro by typing @kbd{X}. Thus you should make sure a
30837 suitable number is on the stack before defining the macro so that you
30838 don't get a stack-underflow error during the definition process.
30840 Conditionals can be nested arbitrarily. However, there should be exactly
30841 one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
30844 The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
30845 two keystroke sequences. The general format is @kbd{@var{cond} Z [
30846 @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true
30847 (i.e., if the top of stack contains a non-zero number after @var{cond}
30848 has been executed), the @var{then-part} will be executed and the
30849 @var{else-part} will be skipped. Otherwise, the @var{then-part} will
30850 be skipped and the @var{else-part} will be executed.
30853 The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
30854 between any number of alternatives. For example,
30855 @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
30856 @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
30857 otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
30858 it will execute @var{part3}.
30860 More precisely, @kbd{Z [} pops a number and conditionally skips to the
30861 next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when
30862 actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}.
30863 @kbd{Z |} pops a number and conditionally skips to the next matching
30864 @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
30865 equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
30868 Calc's conditional and looping constructs work by scanning the
30869 keyboard macro for occurrences of character sequences like @samp{Z:}
30870 and @samp{Z]}. One side-effect of this is that if you use these
30871 constructs you must be careful that these character pairs do not
30872 occur by accident in other parts of the macros. Since Calc rarely
30873 uses shift-@kbd{Z} for any purpose except as a prefix character, this
30874 is not likely to be a problem. Another side-effect is that it will
30875 not work to define your own custom key bindings for these commands.
30876 Only the standard shift-@kbd{Z} bindings will work correctly.
30879 If Calc gets stuck while skipping characters during the definition of a
30880 macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g}
30881 actually adds a @kbd{C-g} keystroke to the macro.)
30883 @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
30884 @subsection Loops in Keyboard Macros
30889 @pindex calc-kbd-repeat
30890 @pindex calc-kbd-end-repeat
30891 @cindex Looping structures
30892 @cindex Iterative structures
30893 The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
30894 (@code{calc-kbd-end-repeat}) commands pop a number from the stack,
30895 which must be an integer, then repeat the keystrokes between the brackets
30896 the specified number of times. If the integer is zero or negative, the
30897 body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >}
30898 computes two to a nonnegative integer power. First, we push 1 on the
30899 stack and then swap the integer argument back to the top. The @kbd{Z <}
30900 pops that argument leaving the 1 back on top of the stack. Then, we
30901 repeat a multiply-by-two step however many times.
30903 Once again, the keyboard macro is executed as it is being entered.
30904 In this case it is especially important to set up reasonable initial
30905 conditions before making the definition: Suppose the integer 1000 just
30906 happened to be sitting on the stack before we typed the above definition!
30907 Another approach is to enter a harmless dummy definition for the macro,
30908 then go back and edit in the real one with a @kbd{Z E} command. Yet
30909 another approach is to type the macro as written-out keystroke names
30910 in a buffer, then use @kbd{M-# m} (@code{read-kbd-macro}) to read the
30915 The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
30916 of a keyboard macro loop prematurely. It pops an object from the stack;
30917 if that object is true (a non-zero number), control jumps out of the
30918 innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
30919 after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no
30920 effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
30925 @pindex calc-kbd-for
30926 @pindex calc-kbd-end-for
30927 The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
30928 commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
30929 value of the counter available inside the loop. The general layout is
30930 @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (}
30931 command pops initial and final values from the stack. It then creates
30932 a temporary internal counter and initializes it with the value @var{init}.
30933 The @kbd{Z (} command then repeatedly pushes the counter value onto the
30934 stack and executes @var{body} and @var{step}, adding @var{step} to the
30935 counter each time until the loop finishes.
30937 @cindex Summations (by keyboard macros)
30938 By default, the loop finishes when the counter becomes greater than (or
30939 less than) @var{final}, assuming @var{initial} is less than (greater
30940 than) @var{final}. If @var{initial} is equal to @var{final}, the body
30941 executes exactly once. The body of the loop always executes at least
30942 once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
30943 squares of the integers from 1 to 10, in steps of 1.
30945 If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
30946 forced to use upward-counting conventions. In this case, if @var{initial}
30947 is greater than @var{final} the body will not be executed at all.
30948 Note that @var{step} may still be negative in this loop; the prefix
30949 argument merely constrains the loop-finished test. Likewise, a prefix
30950 argument of @mathit{-1} forces downward-counting conventions.
30954 @pindex calc-kbd-loop
30955 @pindex calc-kbd-end-loop
30956 The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
30957 (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
30958 @kbd{Z >}, except that they do not pop a count from the stack---they
30959 effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}}
30960 loop ought to include at least one @kbd{Z /} to make sure the loop
30961 doesn't run forever. (If any error message occurs which causes Emacs
30962 to beep, the keyboard macro will also be halted; this is a standard
30963 feature of Emacs. You can also generally press @kbd{C-g} to halt a
30964 running keyboard macro, although not all versions of Unix support
30967 The conditional and looping constructs are not actually tied to
30968 keyboard macros, but they are most often used in that context.
30969 For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
30970 ten copies of 23 onto the stack. This can be typed ``live'' just
30971 as easily as in a macro definition.
30973 @xref{Conditionals in Macros}, for some additional notes about
30974 conditional and looping commands.
30976 @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
30977 @subsection Local Values in Macros
30980 @cindex Local variables
30981 @cindex Restoring saved modes
30982 Keyboard macros sometimes want to operate under known conditions
30983 without affecting surrounding conditions. For example, a keyboard
30984 macro may wish to turn on Fraction mode, or set a particular
30985 precision, independent of the user's normal setting for those
30990 @pindex calc-kbd-push
30991 @pindex calc-kbd-pop
30992 Macros also sometimes need to use local variables. Assignments to
30993 local variables inside the macro should not affect any variables
30994 outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
30995 (@code{calc-kbd-pop}) commands give you both of these capabilities.
30997 When you type @kbd{Z `} (with a backquote or accent grave character),
30998 the values of various mode settings are saved away. The ten ``quick''
30999 variables @code{q0} through @code{q9} are also saved. When
31000 you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
31001 Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
31003 If a keyboard macro halts due to an error in between a @kbd{Z `} and
31004 a @kbd{Z '}, the saved values will be restored correctly even though
31005 the macro never reaches the @kbd{Z '} command. Thus you can use
31006 @kbd{Z `} and @kbd{Z '} without having to worry about what happens
31007 in exceptional conditions.
31009 If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
31010 you into a ``recursive edit.'' You can tell you are in a recursive
31011 edit because there will be extra square brackets in the mode line,
31012 as in @samp{[(Calculator)]}. These brackets will go away when you
31013 type the matching @kbd{Z '} command. The modes and quick variables
31014 will be saved and restored in just the same way as if actual keyboard
31015 macros were involved.
31017 The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
31018 and binary word size, the angular mode (Deg, Rad, or HMS), the
31019 simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
31020 Matrix or Scalar mode, Fraction mode, and the current complex mode
31021 (Polar or Rectangular). The ten ``quick'' variables' values (or lack
31022 thereof) are also saved.
31024 Most mode-setting commands act as toggles, but with a numeric prefix
31025 they force the mode either on (positive prefix) or off (negative
31026 or zero prefix). Since you don't know what the environment might
31027 be when you invoke your macro, it's best to use prefix arguments
31028 for all mode-setting commands inside the macro.
31030 In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
31031 listed above to their default values. As usual, the matching @kbd{Z '}
31032 will restore the modes to their settings from before the @kbd{C-u Z `}.
31033 Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode
31034 to its default (off) but leaves the other modes the same as they were
31035 outside the construct.
31037 The contents of the stack and trail, values of non-quick variables, and
31038 other settings such as the language mode and the various display modes,
31039 are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
31041 @node Queries in Macros, , Local Values in Macros, Keyboard Macros
31042 @subsection Queries in Keyboard Macros
31046 @pindex calc-kbd-report
31047 The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
31048 message including the value on the top of the stack. You are prompted
31049 to enter a string. That string, along with the top-of-stack value,
31050 is displayed unless @kbd{m w} (@code{calc-working}) has been used
31051 to turn such messages off.
31054 @pindex calc-kbd-query
31055 The @kbd{Z #} (@code{calc-kbd-query}) command displays a prompt message
31056 (which you enter during macro definition), then does an algebraic entry
31057 which takes its input from the keyboard, even during macro execution.
31058 This command allows your keyboard macros to accept numbers or formulas
31059 as interactive input. All the normal conventions of algebraic input,
31060 including the use of @kbd{$} characters, are supported.
31062 @xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of
31063 @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
31064 keyboard input during a keyboard macro. In particular, you can use
31065 @kbd{C-x q} to enter a recursive edit, which allows the user to perform
31066 any Calculator operations interactively before pressing @kbd{C-M-c} to
31067 return control to the keyboard macro.
31069 @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
31070 @section Invocation Macros
31074 @pindex calc-user-invocation
31075 @pindex calc-user-define-invocation
31076 Calc provides one special keyboard macro, called up by @kbd{M-# z}
31077 (@code{calc-user-invocation}), that is intended to allow you to define
31078 your own special way of starting Calc. To define this ``invocation
31079 macro,'' create the macro in the usual way with @kbd{C-x (} and
31080 @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
31081 There is only one invocation macro, so you don't need to type any
31082 additional letters after @kbd{Z I}. From now on, you can type
31083 @kbd{M-# z} at any time to execute your invocation macro.
31085 For example, suppose you find yourself often grabbing rectangles of
31086 numbers into Calc and multiplying their columns. You can do this
31087 by typing @kbd{M-# r} to grab, and @kbd{V R : *} to multiply columns.
31088 To make this into an invocation macro, just type @kbd{C-x ( M-# r
31089 V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data,
31090 just mark the data in its buffer in the usual way and type @kbd{M-# z}.
31092 Invocation macros are treated like regular Emacs keyboard macros;
31093 all the special features described above for @kbd{Z K}-style macros
31094 do not apply. @kbd{M-# z} is just like @kbd{C-x e}, except that it
31095 uses the macro that was last stored by @kbd{Z I}. (In fact, the
31096 macro does not even have to have anything to do with Calc!)
31098 The @kbd{m m} command saves the last invocation macro defined by
31099 @kbd{Z I} along with all the other Calc mode settings.
31100 @xref{General Mode Commands}.
31102 @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
31103 @section Programming with Formulas
31107 @pindex calc-user-define-formula
31108 @cindex Programming with algebraic formulas
31109 Another way to create a new Calculator command uses algebraic formulas.
31110 The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
31111 formula at the top of the stack as the definition for a key. This
31112 command prompts for five things: The key, the command name, the function
31113 name, the argument list, and the behavior of the command when given
31114 non-numeric arguments.
31116 For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
31117 @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this
31118 formula on the @kbd{z m} key sequence. The next prompt is for a command
31119 name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
31120 for the new command. If you simply press @key{RET}, a default name like
31121 @code{calc-User-m} will be constructed. In our example, suppose we enter
31122 @kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
31124 If you want to give the formula a long-style name only, you can press
31125 @key{SPC} or @key{RET} when asked which single key to use. For example
31126 @kbd{Z F @key{RET} spam @key{RET}} defines the new command as
31127 @kbd{M-x calc-spam}, with no keyboard equivalent.
31129 The third prompt is for an algebraic function name. The default is to
31130 use the same name as the command name but without the @samp{calc-}
31131 prefix. (If this is of the form @samp{User-m}, the hyphen is removed so
31132 it won't be taken for a minus sign in algebraic formulas.)
31133 This is the name you will use if you want to enter your
31134 new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}.
31135 Then the new function can be invoked by pushing two numbers on the
31136 stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
31137 formula @samp{yow(x,y)}.
31139 The fourth prompt is for the function's argument list. This is used to
31140 associate values on the stack with the variables that appear in the formula.
31141 The default is a list of all variables which appear in the formula, sorted
31142 into alphabetical order. In our case, the default would be @samp{(a b)}.
31143 This means that, when the user types @kbd{z m}, the Calculator will remove
31144 two numbers from the stack, substitute these numbers for @samp{a} and
31145 @samp{b} (respectively) in the formula, then simplify the formula and
31146 push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m}
31147 would replace the 10 and 100 on the stack with the number 210, which is
31148 @expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula
31149 @samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and
31150 @expr{b=100} in the definition.
31152 You can rearrange the order of the names before pressing @key{RET} to
31153 control which stack positions go to which variables in the formula. If
31154 you remove a variable from the argument list, that variable will be left
31155 in symbolic form by the command. Thus using an argument list of @samp{(b)}
31156 for our function would cause @kbd{10 z m} to replace the 10 on the stack
31157 with the formula @samp{a + 20}. If we had used an argument list of
31158 @samp{(b a)}, the result with inputs 10 and 100 would have been 120.
31160 You can also put a nameless function on the stack instead of just a
31161 formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}.
31162 In this example, the command will be defined by the formula @samp{a + 2 b}
31163 using the argument list @samp{(a b)}.
31165 The final prompt is a y-or-n question concerning what to do if symbolic
31166 arguments are given to your function. If you answer @kbd{y}, then
31167 executing @kbd{z m} (using the original argument list @samp{(a b)}) with
31168 arguments @expr{10} and @expr{x} will leave the function in symbolic
31169 form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n},
31170 then the formula will always be expanded, even for non-constant
31171 arguments: @samp{10 + 2 x}. If you never plan to feed algebraic
31172 formulas to your new function, it doesn't matter how you answer this
31175 If you answered @kbd{y} to this question you can still cause a function
31176 call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
31177 Also, Calc will expand the function if necessary when you take a
31178 derivative or integral or solve an equation involving the function.
31181 @pindex calc-get-user-defn
31182 Once you have defined a formula on a key, you can retrieve this formula
31183 with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a
31184 key, and this command pushes the formula that was used to define that
31185 key onto the stack. Actually, it pushes a nameless function that
31186 specifies both the argument list and the defining formula. You will get
31187 an error message if the key is undefined, or if the key was not defined
31188 by a @kbd{Z F} command.
31190 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
31191 been defined by a formula uses a variant of the @code{calc-edit} command
31192 to edit the defining formula. Press @kbd{C-c C-c} to finish editing and
31193 store the new formula back in the definition, or kill the buffer with
31195 cancel the edit. (The argument list and other properties of the
31196 definition are unchanged; to adjust the argument list, you can use
31197 @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
31198 then re-execute the @kbd{Z F} command.)
31200 As usual, the @kbd{Z P} command records your definition permanently.
31201 In this case it will permanently record all three of the relevant
31202 definitions: the key, the command, and the function.
31204 You may find it useful to turn off the default simplifications with
31205 @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
31206 used as a function definition. For example, the formula @samp{deriv(a^2,v)}
31207 which might be used to define a new function @samp{dsqr(a,v)} will be
31208 ``simplified'' to 0 immediately upon entry since @code{deriv} considers
31209 @expr{a} to be constant with respect to @expr{v}. Turning off
31210 default simplifications cures this problem: The definition will be stored
31211 in symbolic form without ever activating the @code{deriv} function. Press
31212 @kbd{m D} to turn the default simplifications back on afterwards.
31214 @node Lisp Definitions, , Algebraic Definitions, Programming
31215 @section Programming with Lisp
31218 The Calculator can be programmed quite extensively in Lisp. All you
31219 do is write a normal Lisp function definition, but with @code{defmath}
31220 in place of @code{defun}. This has the same form as @code{defun}, but it
31221 automagically replaces calls to standard Lisp functions like @code{+} and
31222 @code{zerop} with calls to the corresponding functions in Calc's own library.
31223 Thus you can write natural-looking Lisp code which operates on all of the
31224 standard Calculator data types. You can then use @kbd{Z D} if you wish to
31225 bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command
31226 will not edit a Lisp-based definition.
31228 Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section
31229 assumes a familiarity with Lisp programming concepts; if you do not know
31230 Lisp, you may find keyboard macros or rewrite rules to be an easier way
31231 to program the Calculator.
31233 This section first discusses ways to write commands, functions, or
31234 small programs to be executed inside of Calc. Then it discusses how
31235 your own separate programs are able to call Calc from the outside.
31236 Finally, there is a list of internal Calc functions and data structures
31237 for the true Lisp enthusiast.
31240 * Defining Functions::
31241 * Defining Simple Commands::
31242 * Defining Stack Commands::
31243 * Argument Qualifiers::
31244 * Example Definitions::
31246 * Calling Calc from Your Programs::
31250 @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
31251 @subsection Defining New Functions
31255 The @code{defmath} function (actually a Lisp macro) is like @code{defun}
31256 except that code in the body of the definition can make use of the full
31257 range of Calculator data types. The prefix @samp{calcFunc-} is added
31258 to the specified name to get the actual Lisp function name. As a simple
31262 (defmath myfact (n)
31264 (* n (myfact (1- n)))
31269 This actually expands to the code,
31272 (defun calcFunc-myfact (n)
31274 (math-mul n (calcFunc-myfact (math-add n -1)))
31279 This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
31281 The @samp{myfact} function as it is defined above has the bug that an
31282 expression @samp{myfact(a+b)} will be simplified to 1 because the
31283 formula @samp{a+b} is not considered to be @code{posp}. A robust
31284 factorial function would be written along the following lines:
31287 (defmath myfact (n)
31289 (* n (myfact (1- n)))
31292 nil))) ; this could be simplified as: (and (= n 0) 1)
31295 If a function returns @code{nil}, it is left unsimplified by the Calculator
31296 (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)}
31297 will be simplified to @samp{myfact(a+3)} but no further. Beware that every
31298 time the Calculator reexamines this formula it will attempt to resimplify
31299 it, so your function ought to detect the returning-@code{nil} case as
31300 efficiently as possible.
31302 The following standard Lisp functions are treated by @code{defmath}:
31303 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
31304 @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
31305 @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
31306 @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for
31307 @code{math-nearly-equal}, which is useful in implementing Taylor series.
31309 For other functions @var{func}, if a function by the name
31310 @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
31311 name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
31312 is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
31313 used on the assumption that this is a to-be-defined math function. Also, if
31314 the function name is quoted as in @samp{('integerp a)} the function name is
31315 always used exactly as written (but not quoted).
31317 Variable names have @samp{var-} prepended to them unless they appear in
31318 the function's argument list or in an enclosing @code{let}, @code{let*},
31319 @code{for}, or @code{foreach} form,
31320 or their names already contain a @samp{-} character. Thus a reference to
31321 @samp{foo} is the same as a reference to @samp{var-foo}.
31323 A few other Lisp extensions are available in @code{defmath} definitions:
31327 The @code{elt} function accepts any number of index variables.
31328 Note that Calc vectors are stored as Lisp lists whose first
31329 element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
31330 the second element of vector @code{v}, and @samp{(elt m i j)}
31331 yields one element of a Calc matrix.
31334 The @code{setq} function has been extended to act like the Common
31335 Lisp @code{setf} function. (The name @code{setf} is recognized as
31336 a synonym of @code{setq}.) Specifically, the first argument of
31337 @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
31338 in which case the effect is to store into the specified
31339 element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x}
31340 into one element of a matrix.
31343 A @code{for} looping construct is available. For example,
31344 @samp{(for ((i 0 10)) body)} executes @code{body} once for each
31345 binding of @expr{i} from zero to 10. This is like a @code{let}
31346 form in that @expr{i} is temporarily bound to the loop count
31347 without disturbing its value outside the @code{for} construct.
31348 Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
31349 are also available. For each value of @expr{i} from zero to 10,
31350 @expr{j} counts from 0 to @expr{i-1} in steps of two. Note that
31351 @code{for} has the same general outline as @code{let*}, except
31352 that each element of the header is a list of three or four
31353 things, not just two.
31356 The @code{foreach} construct loops over elements of a list.
31357 For example, @samp{(foreach ((x (cdr v))) body)} executes
31358 @code{body} with @expr{x} bound to each element of Calc vector
31359 @expr{v} in turn. The purpose of @code{cdr} here is to skip over
31360 the initial @code{vec} symbol in the vector.
31363 The @code{break} function breaks out of the innermost enclosing
31364 @code{while}, @code{for}, or @code{foreach} loop. If given a
31365 value, as in @samp{(break x)}, this value is returned by the
31366 loop. (Lisp loops otherwise always return @code{nil}.)
31369 The @code{return} function prematurely returns from the enclosing
31370 function. For example, @samp{(return (+ x y))} returns @expr{x+y}
31371 as the value of a function. You can use @code{return} anywhere
31372 inside the body of the function.
31375 Non-integer numbers (and extremely large integers) cannot be included
31376 directly into a @code{defmath} definition. This is because the Lisp
31377 reader will fail to parse them long before @code{defmath} ever gets control.
31378 Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic
31379 formula can go between the quotes. For example,
31382 (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
31390 (defun calcFunc-sqexp (x)
31391 (and (math-numberp x)
31392 (calcFunc-exp (math-mul x '(float 5 -1)))))
31395 Note the use of @code{numberp} as a guard to ensure that the argument is
31396 a number first, returning @code{nil} if not. The exponential function
31397 could itself have been included in the expression, if we had preferred:
31398 @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion
31399 step of @code{myfact} could have been written
31405 A good place to put your @code{defmath} commands is your Calc init file
31406 (the file given by @code{calc-settings-file}, typically
31407 @file{~/.calc.el}), which will not be loaded until Calc starts.
31408 If a file named @file{.emacs} exists in your home directory, Emacs reads
31409 and executes the Lisp forms in this file as it starts up. While it may
31410 seem reasonable to put your favorite @code{defmath} commands there,
31411 this has the unfortunate side-effect that parts of the Calculator must be
31412 loaded in to process the @code{defmath} commands whether or not you will
31413 actually use the Calculator! If you want to put the @code{defmath}
31414 commands there (for example, if you redefine @code{calc-settings-file}
31415 to be @file{.emacs}), a better effect can be had by writing
31418 (put 'calc-define 'thing '(progn
31425 @vindex calc-define
31426 The @code{put} function adds a @dfn{property} to a symbol. Each Lisp
31427 symbol has a list of properties associated with it. Here we add a
31428 property with a name of @code{thing} and a @samp{(progn ...)} form as
31429 its value. When Calc starts up, and at the start of every Calc command,
31430 the property list for the symbol @code{calc-define} is checked and the
31431 values of any properties found are evaluated as Lisp forms. The
31432 properties are removed as they are evaluated. The property names
31433 (like @code{thing}) are not used; you should choose something like the
31434 name of your project so as not to conflict with other properties.
31436 The net effect is that you can put the above code in your @file{.emacs}
31437 file and it will not be executed until Calc is loaded. Or, you can put
31438 that same code in another file which you load by hand either before or
31439 after Calc itself is loaded.
31441 The properties of @code{calc-define} are evaluated in the same order
31442 that they were added. They can assume that the Calc modules @file{calc.el},
31443 @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
31444 that the @samp{*Calculator*} buffer will be the current buffer.
31446 If your @code{calc-define} property only defines algebraic functions,
31447 you can be sure that it will have been evaluated before Calc tries to
31448 call your function, even if the file defining the property is loaded
31449 after Calc is loaded. But if the property defines commands or key
31450 sequences, it may not be evaluated soon enough. (Suppose it defines the
31451 new command @code{tweak-calc}; the user can load your file, then type
31452 @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To
31453 protect against this situation, you can put
31456 (run-hooks 'calc-check-defines)
31459 @findex calc-check-defines
31461 at the end of your file. The @code{calc-check-defines} function is what
31462 looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
31463 has the advantage that it is quietly ignored if @code{calc-check-defines}
31464 is not yet defined because Calc has not yet been loaded.
31466 Examples of things that ought to be enclosed in a @code{calc-define}
31467 property are @code{defmath} calls, @code{define-key} calls that modify
31468 the Calc key map, and any calls that redefine things defined inside Calc.
31469 Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
31471 @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
31472 @subsection Defining New Simple Commands
31475 @findex interactive
31476 If a @code{defmath} form contains an @code{interactive} clause, it defines
31477 a Calculator command. Actually such a @code{defmath} results in @emph{two}
31478 function definitions: One, a @samp{calcFunc-} function as was just described,
31479 with the @code{interactive} clause removed. Two, a @samp{calc-} function
31480 with a suitable @code{interactive} clause and some sort of wrapper to make
31481 the command work in the Calc environment.
31483 In the simple case, the @code{interactive} clause has the same form as
31484 for normal Emacs Lisp commands:
31487 (defmath increase-precision (delta)
31488 "Increase precision by DELTA." ; This is the "documentation string"
31489 (interactive "p") ; Register this as a M-x-able command
31490 (setq calc-internal-prec (+ calc-internal-prec delta)))
31493 This expands to the pair of definitions,
31496 (defun calc-increase-precision (delta)
31497 "Increase precision by DELTA."
31500 (setq calc-internal-prec (math-add calc-internal-prec delta))))
31502 (defun calcFunc-increase-precision (delta)
31503 "Increase precision by DELTA."
31504 (setq calc-internal-prec (math-add calc-internal-prec delta)))
31508 where in this case the latter function would never really be used! Note
31509 that since the Calculator stores small integers as plain Lisp integers,
31510 the @code{math-add} function will work just as well as the native
31511 @code{+} even when the intent is to operate on native Lisp integers.
31513 @findex calc-wrapper
31514 The @samp{calc-wrapper} call invokes a macro which surrounds the body of
31515 the function with code that looks roughly like this:
31518 (let ((calc-command-flags nil))
31521 (calc-select-buffer)
31522 @emph{body of function}
31523 @emph{renumber stack}
31524 @emph{clear} Working @emph{message})
31525 @emph{realign cursor and window}
31526 @emph{clear Inverse, Hyperbolic, and Keep Args flags}
31527 @emph{update Emacs mode line}))
31530 @findex calc-select-buffer
31531 The @code{calc-select-buffer} function selects the @samp{*Calculator*}
31532 buffer if necessary, say, because the command was invoked from inside
31533 the @samp{*Calc Trail*} window.
31535 @findex calc-set-command-flag
31536 You can call, for example, @code{(calc-set-command-flag 'no-align)} to
31537 set the above-mentioned command flags. Calc routines recognize the
31538 following command flags:
31542 Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
31543 after this command completes. This is set by routines like
31546 @item clear-message
31547 Calc should call @samp{(message "")} if this command completes normally
31548 (to clear a ``Working@dots{}'' message out of the echo area).
31551 Do not move the cursor back to the @samp{.} top-of-stack marker.
31553 @item position-point
31554 Use the variables @code{calc-position-point-line} and
31555 @code{calc-position-point-column} to position the cursor after
31556 this command finishes.
31559 Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
31560 and @code{calc-keep-args-flag} at the end of this command.
31563 Switch to buffer @samp{*Calc Edit*} after this command.
31566 Do not move trail pointer to end of trail when something is recorded
31572 @vindex calc-Y-help-msgs
31573 Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
31574 extensions to Calc. There are no built-in commands that work with
31575 this prefix key; you must call @code{define-key} from Lisp (probably
31576 from inside a @code{calc-define} property) to add to it. Initially only
31577 @kbd{Y ?} is defined; it takes help messages from a list of strings
31578 (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All
31579 other undefined keys except for @kbd{Y} are reserved for use by
31580 future versions of Calc.
31582 If you are writing a Calc enhancement which you expect to give to
31583 others, it is best to minimize the number of @kbd{Y}-key sequences
31584 you use. In fact, if you have more than one key sequence you should
31585 consider defining three-key sequences with a @kbd{Y}, then a key that
31586 stands for your package, then a third key for the particular command
31587 within your package.
31589 Users may wish to install several Calc enhancements, and it is possible
31590 that several enhancements will choose to use the same key. In the
31591 example below, a variable @code{inc-prec-base-key} has been defined
31592 to contain the key that identifies the @code{inc-prec} package. Its
31593 value is initially @code{"P"}, but a user can change this variable
31594 if necessary without having to modify the file.
31596 Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
31597 command that increases the precision, and a @kbd{Y P D} command that
31598 decreases the precision.
31601 ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91.
31602 ;;; (Include copyright or copyleft stuff here.)
31604 (defvar inc-prec-base-key "P"
31605 "Base key for inc-prec.el commands.")
31607 (put 'calc-define 'inc-prec '(progn
31609 (define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
31610 'increase-precision)
31611 (define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
31612 'decrease-precision)
31614 (setq calc-Y-help-msgs
31615 (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
31618 (defmath increase-precision (delta)
31619 "Increase precision by DELTA."
31621 (setq calc-internal-prec (+ calc-internal-prec delta)))
31623 (defmath decrease-precision (delta)
31624 "Decrease precision by DELTA."
31626 (setq calc-internal-prec (- calc-internal-prec delta)))
31628 )) ; end of calc-define property
31630 (run-hooks 'calc-check-defines)
31633 @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
31634 @subsection Defining New Stack-Based Commands
31637 To define a new computational command which takes and/or leaves arguments
31638 on the stack, a special form of @code{interactive} clause is used.
31641 (interactive @var{num} @var{tag})
31645 where @var{num} is an integer, and @var{tag} is a string. The effect is
31646 to pop @var{num} values off the stack, resimplify them by calling
31647 @code{calc-normalize}, and hand them to your function according to the
31648 function's argument list. Your function may include @code{&optional} and
31649 @code{&rest} parameters, so long as calling the function with @var{num}
31650 parameters is legal.
31652 Your function must return either a number or a formula in a form
31653 acceptable to Calc, or a list of such numbers or formulas. These value(s)
31654 are pushed onto the stack when the function completes. They are also
31655 recorded in the Calc Trail buffer on a line beginning with @var{tag},
31656 a string of (normally) four characters or less. If you omit @var{tag}
31657 or use @code{nil} as a tag, the result is not recorded in the trail.
31659 As an example, the definition
31662 (defmath myfact (n)
31663 "Compute the factorial of the integer at the top of the stack."
31664 (interactive 1 "fact")
31666 (* n (myfact (1- n)))
31671 is a version of the factorial function shown previously which can be used
31672 as a command as well as an algebraic function. It expands to
31675 (defun calc-myfact ()
31676 "Compute the factorial of the integer at the top of the stack."
31679 (calc-enter-result 1 "fact"
31680 (cons 'calcFunc-myfact (calc-top-list-n 1)))))
31682 (defun calcFunc-myfact (n)
31683 "Compute the factorial of the integer at the top of the stack."
31685 (math-mul n (calcFunc-myfact (math-add n -1)))
31686 (and (math-zerop n) 1)))
31689 @findex calc-slow-wrapper
31690 The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
31691 that automatically puts up a @samp{Working...} message before the
31692 computation begins. (This message can be turned off by the user
31693 with an @kbd{m w} (@code{calc-working}) command.)
31695 @findex calc-top-list-n
31696 The @code{calc-top-list-n} function returns a list of the specified number
31697 of values from the top of the stack. It resimplifies each value by
31698 calling @code{calc-normalize}. If its argument is zero it returns an
31699 empty list. It does not actually remove these values from the stack.
31701 @findex calc-enter-result
31702 The @code{calc-enter-result} function takes an integer @var{num} and string
31703 @var{tag} as described above, plus a third argument which is either a
31704 Calculator data object or a list of such objects. These objects are
31705 resimplified and pushed onto the stack after popping the specified number
31706 of values from the stack. If @var{tag} is non-@code{nil}, the values
31707 being pushed are also recorded in the trail.
31709 Note that if @code{calcFunc-myfact} returns @code{nil} this represents
31710 ``leave the function in symbolic form.'' To return an actual empty list,
31711 in the sense that @code{calc-enter-result} will push zero elements back
31712 onto the stack, you should return the special value @samp{'(nil)}, a list
31713 containing the single symbol @code{nil}.
31715 The @code{interactive} declaration can actually contain a limited
31716 Emacs-style code string as well which comes just before @var{num} and
31717 @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in
31720 (defmath foo (a b &optional c)
31721 (interactive "p" 2 "foo")
31725 In this example, the command @code{calc-foo} will evaluate the expression
31726 @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
31727 executed with a numeric prefix argument of @expr{n}.
31729 The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
31730 code as used with @code{defun}). It uses the numeric prefix argument as the
31731 number of objects to remove from the stack and pass to the function.
31732 In this case, the integer @var{num} serves as a default number of
31733 arguments to be used when no prefix is supplied.
31735 @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
31736 @subsection Argument Qualifiers
31739 Anywhere a parameter name can appear in the parameter list you can also use
31740 an @dfn{argument qualifier}. Thus the general form of a definition is:
31743 (defmath @var{name} (@var{param} @var{param...}
31744 &optional @var{param} @var{param...}
31750 where each @var{param} is either a symbol or a list of the form
31753 (@var{qual} @var{param})
31756 The following qualifiers are recognized:
31761 The argument must not be an incomplete vector, interval, or complex number.
31762 (This is rarely needed since the Calculator itself will never call your
31763 function with an incomplete argument. But there is nothing stopping your
31764 own Lisp code from calling your function with an incomplete argument.)
31768 The argument must be an integer. If it is an integer-valued float
31769 it will be accepted but converted to integer form. Non-integers and
31770 formulas are rejected.
31774 Like @samp{integer}, but the argument must be non-negative.
31778 Like @samp{integer}, but the argument must fit into a native Lisp integer,
31779 which on most systems means less than 2^23 in absolute value. The
31780 argument is converted into Lisp-integer form if necessary.
31784 The argument is converted to floating-point format if it is a number or
31785 vector. If it is a formula it is left alone. (The argument is never
31786 actually rejected by this qualifier.)
31789 The argument must satisfy predicate @var{pred}, which is one of the
31790 standard Calculator predicates. @xref{Predicates}.
31792 @item not-@var{pred}
31793 The argument must @emph{not} satisfy predicate @var{pred}.
31799 (defmath foo (a (constp (not-matrixp b)) &optional (float c)
31808 (defun calcFunc-foo (a b &optional c &rest d)
31809 (and (math-matrixp b)
31810 (math-reject-arg b 'not-matrixp))
31811 (or (math-constp b)
31812 (math-reject-arg b 'constp))
31813 (and c (setq c (math-check-float c)))
31814 (setq d (mapcar 'math-check-integer d))
31819 which performs the necessary checks and conversions before executing the
31820 body of the function.
31822 @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
31823 @subsection Example Definitions
31826 This section includes some Lisp programming examples on a larger scale.
31827 These programs make use of some of the Calculator's internal functions;
31831 * Bit Counting Example::
31835 @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
31836 @subsubsection Bit-Counting
31843 Calc does not include a built-in function for counting the number of
31844 ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u}
31845 to convert the integer to a set, and @kbd{V #} to count the elements of
31846 that set; let's write a function that counts the bits without having to
31847 create an intermediate set.
31850 (defmath bcount ((natnum n))
31851 (interactive 1 "bcnt")
31855 (setq count (1+ count)))
31856 (setq n (lsh n -1)))
31861 When this is expanded by @code{defmath}, it will become the following
31862 Emacs Lisp function:
31865 (defun calcFunc-bcount (n)
31866 (setq n (math-check-natnum n))
31868 (while (math-posp n)
31870 (setq count (math-add count 1)))
31871 (setq n (calcFunc-lsh n -1)))
31875 If the input numbers are large, this function involves a fair amount
31876 of arithmetic. A binary right shift is essentially a division by two;
31877 recall that Calc stores integers in decimal form so bit shifts must
31878 involve actual division.
31880 To gain a bit more efficiency, we could divide the integer into
31881 @var{n}-bit chunks, each of which can be handled quickly because
31882 they fit into Lisp integers. It turns out that Calc's arithmetic
31883 routines are especially fast when dividing by an integer less than
31884 1000, so we can set @var{n = 9} bits and use repeated division by 512:
31887 (defmath bcount ((natnum n))
31888 (interactive 1 "bcnt")
31890 (while (not (fixnump n))
31891 (let ((qr (idivmod n 512)))
31892 (setq count (+ count (bcount-fixnum (cdr qr)))
31894 (+ count (bcount-fixnum n))))
31896 (defun bcount-fixnum (n)
31899 (setq count (+ count (logand n 1))
31905 Note that the second function uses @code{defun}, not @code{defmath}.
31906 Because this function deals only with native Lisp integers (``fixnums''),
31907 it can use the actual Emacs @code{+} and related functions rather
31908 than the slower but more general Calc equivalents which @code{defmath}
31911 The @code{idivmod} function does an integer division, returning both
31912 the quotient and the remainder at once. Again, note that while it
31913 might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
31914 more efficient ways to split off the bottom nine bits of @code{n},
31915 actually they are less efficient because each operation is really
31916 a division by 512 in disguise; @code{idivmod} allows us to do the
31917 same thing with a single division by 512.
31919 @node Sine Example, , Bit Counting Example, Example Definitions
31920 @subsubsection The Sine Function
31927 A somewhat limited sine function could be defined as follows, using the
31928 well-known Taylor series expansion for
31929 @texline @math{\sin x}:
31930 @infoline @samp{sin(x)}:
31933 (defmath mysin ((float (anglep x)))
31934 (interactive 1 "mysn")
31935 (setq x (to-radians x)) ; Convert from current angular mode.
31936 (let ((sum x) ; Initial term of Taylor expansion of sin.
31938 (nfact 1) ; "nfact" equals "n" factorial at all times.
31939 (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
31940 (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution.
31941 (working "mysin" sum) ; Display "Working" message, if enabled.
31942 (setq nfact (* nfact (1- n) n)
31944 newsum (+ sum (/ x nfact)))
31945 (if (~= newsum sum) ; If newsum is "nearly equal to" sum,
31946 (break)) ; then we are done.
31951 The actual @code{sin} function in Calc works by first reducing the problem
31952 to a sine or cosine of a nonnegative number less than @cpiover{4}. This
31953 ensures that the Taylor series will converge quickly. Also, the calculation
31954 is carried out with two extra digits of precision to guard against cumulative
31955 round-off in @samp{sum}. Finally, complex arguments are allowed and handled
31956 by a separate algorithm.
31959 (defmath mysin ((float (scalarp x)))
31960 (interactive 1 "mysn")
31961 (setq x (to-radians x)) ; Convert from current angular mode.
31962 (with-extra-prec 2 ; Evaluate with extra precision.
31963 (cond ((complexp x)
31966 (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0.
31967 (t (mysin-raw x))))))
31969 (defmath mysin-raw (x)
31971 (mysin-raw (% x (two-pi)))) ; Now x < 7.
31973 (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2.
31975 (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4.
31976 ((< x (- (pi-over-4)))
31977 (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4,
31978 (t (mysin-series x)))) ; so the series will be efficient.
31982 where @code{mysin-complex} is an appropriate function to handle complex
31983 numbers, @code{mysin-series} is the routine to compute the sine Taylor
31984 series as before, and @code{mycos-raw} is a function analogous to
31985 @code{mysin-raw} for cosines.
31987 The strategy is to ensure that @expr{x} is nonnegative before calling
31988 @code{mysin-raw}. This function then recursively reduces its argument
31989 to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each
31990 test, and particularly the first comparison against 7, is designed so
31991 that small roundoff errors cannot produce an infinite loop. (Suppose
31992 we compared with @samp{(two-pi)} instead; if due to roundoff problems
31993 the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
31994 recursion could result!) We use modulo only for arguments that will
31995 clearly get reduced, knowing that the next rule will catch any reductions
31996 that this rule misses.
31998 If a program is being written for general use, it is important to code
31999 it carefully as shown in this second example. For quick-and-dirty programs,
32000 when you know that your own use of the sine function will never encounter
32001 a large argument, a simpler program like the first one shown is fine.
32003 @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
32004 @subsection Calling Calc from Your Lisp Programs
32007 A later section (@pxref{Internals}) gives a full description of
32008 Calc's internal Lisp functions. It's not hard to call Calc from
32009 inside your programs, but the number of these functions can be daunting.
32010 So Calc provides one special ``programmer-friendly'' function called
32011 @code{calc-eval} that can be made to do just about everything you
32012 need. It's not as fast as the low-level Calc functions, but it's
32013 much simpler to use!
32015 It may seem that @code{calc-eval} itself has a daunting number of
32016 options, but they all stem from one simple operation.
32018 In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
32019 string @code{"1+2"} as if it were a Calc algebraic entry and returns
32020 the result formatted as a string: @code{"3"}.
32022 Since @code{calc-eval} is on the list of recommended @code{autoload}
32023 functions, you don't need to make any special preparations to load
32024 Calc before calling @code{calc-eval} the first time. Calc will be
32025 loaded and initialized for you.
32027 All the Calc modes that are currently in effect will be used when
32028 evaluating the expression and formatting the result.
32035 @subsubsection Additional Arguments to @code{calc-eval}
32038 If the input string parses to a list of expressions, Calc returns
32039 the results separated by @code{", "}. You can specify a different
32040 separator by giving a second string argument to @code{calc-eval}:
32041 @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
32043 The ``separator'' can also be any of several Lisp symbols which
32044 request other behaviors from @code{calc-eval}. These are discussed
32047 You can give additional arguments to be substituted for
32048 @samp{$}, @samp{$$}, and so on in the main expression. For
32049 example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
32050 expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
32051 (assuming Fraction mode is not in effect). Note the @code{nil}
32052 used as a placeholder for the item-separator argument.
32059 @subsubsection Error Handling
32062 If @code{calc-eval} encounters an error, it returns a list containing
32063 the character position of the error, plus a suitable message as a
32064 string. Note that @samp{1 / 0} is @emph{not} an error by Calc's
32065 standards; it simply returns the string @code{"1 / 0"} which is the
32066 division left in symbolic form. But @samp{(calc-eval "1/")} will
32067 return the list @samp{(2 "Expected a number")}.
32069 If you bind the variable @code{calc-eval-error} to @code{t}
32070 using a @code{let} form surrounding the call to @code{calc-eval},
32071 errors instead call the Emacs @code{error} function which aborts
32072 to the Emacs command loop with a beep and an error message.
32074 If you bind this variable to the symbol @code{string}, error messages
32075 are returned as strings instead of lists. The character position is
32078 As a courtesy to other Lisp code which may be using Calc, be sure
32079 to bind @code{calc-eval-error} using @code{let} rather than changing
32080 it permanently with @code{setq}.
32087 @subsubsection Numbers Only
32090 Sometimes it is preferable to treat @samp{1 / 0} as an error
32091 rather than returning a symbolic result. If you pass the symbol
32092 @code{num} as the second argument to @code{calc-eval}, results
32093 that are not constants are treated as errors. The error message
32094 reported is the first @code{calc-why} message if there is one,
32095 or otherwise ``Number expected.''
32097 A result is ``constant'' if it is a number, vector, or other
32098 object that does not include variables or function calls. If it
32099 is a vector, the components must themselves be constants.
32106 @subsubsection Default Modes
32109 If the first argument to @code{calc-eval} is a list whose first
32110 element is a formula string, then @code{calc-eval} sets all the
32111 various Calc modes to their default values while the formula is
32112 evaluated and formatted. For example, the precision is set to 12
32113 digits, digit grouping is turned off, and the Normal language
32116 This same principle applies to the other options discussed below.
32117 If the first argument would normally be @var{x}, then it can also
32118 be the list @samp{(@var{x})} to use the default mode settings.
32120 If there are other elements in the list, they are taken as
32121 variable-name/value pairs which override the default mode
32122 settings. Look at the documentation at the front of the
32123 @file{calc.el} file to find the names of the Lisp variables for
32124 the various modes. The mode settings are restored to their
32125 original values when @code{calc-eval} is done.
32127 For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
32128 computes the sum of two numbers, requiring a numeric result, and
32129 using default mode settings except that the precision is 8 instead
32130 of the default of 12.
32132 It's usually best to use this form of @code{calc-eval} unless your
32133 program actually considers the interaction with Calc's mode settings
32134 to be a feature. This will avoid all sorts of potential ``gotchas'';
32135 consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
32136 when the user has left Calc in Symbolic mode or No-Simplify mode.
32138 As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
32139 checks if the number in string @expr{a} is less than the one in
32140 string @expr{b}. Without using a list, the integer 1 might
32141 come out in a variety of formats which would be hard to test for
32142 conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But
32143 see ``Predicates'' mode, below.)
32150 @subsubsection Raw Numbers
32153 Normally all input and output for @code{calc-eval} is done with strings.
32154 You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
32155 in place of @samp{(+ a b)}, but this is very inefficient since the
32156 numbers must be converted to and from string format as they are passed
32157 from one @code{calc-eval} to the next.
32159 If the separator is the symbol @code{raw}, the result will be returned
32160 as a raw Calc data structure rather than a string. You can read about
32161 how these objects look in the following sections, but usually you can
32162 treat them as ``black box'' objects with no important internal
32165 There is also a @code{rawnum} symbol, which is a combination of
32166 @code{raw} (returning a raw Calc object) and @code{num} (signaling
32167 an error if that object is not a constant).
32169 You can pass a raw Calc object to @code{calc-eval} in place of a
32170 string, either as the formula itself or as one of the @samp{$}
32171 arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
32172 addition function that operates on raw Calc objects. Of course
32173 in this case it would be easier to call the low-level @code{math-add}
32174 function in Calc, if you can remember its name.
32176 In particular, note that a plain Lisp integer is acceptable to Calc
32177 as a raw object. (All Lisp integers are accepted on input, but
32178 integers of more than six decimal digits are converted to ``big-integer''
32179 form for output. @xref{Data Type Formats}.)
32181 When it comes time to display the object, just use @samp{(calc-eval a)}
32182 to format it as a string.
32184 It is an error if the input expression evaluates to a list of
32185 values. The separator symbol @code{list} is like @code{raw}
32186 except that it returns a list of one or more raw Calc objects.
32188 Note that a Lisp string is not a valid Calc object, nor is a list
32189 containing a string. Thus you can still safely distinguish all the
32190 various kinds of error returns discussed above.
32197 @subsubsection Predicates
32200 If the separator symbol is @code{pred}, the result of the formula is
32201 treated as a true/false value; @code{calc-eval} returns @code{t} or
32202 @code{nil}, respectively. A value is considered ``true'' if it is a
32203 non-zero number, or false if it is zero or if it is not a number.
32205 For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
32206 one value is less than another.
32208 As usual, it is also possible for @code{calc-eval} to return one of
32209 the error indicators described above. Lisp will interpret such an
32210 indicator as ``true'' if you don't check for it explicitly. If you
32211 wish to have an error register as ``false'', use something like
32212 @samp{(eq (calc-eval ...) t)}.
32219 @subsubsection Variable Values
32222 Variables in the formula passed to @code{calc-eval} are not normally
32223 replaced by their values. If you wish this, you can use the
32224 @code{evalv} function (@pxref{Algebraic Manipulation}). For example,
32225 if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
32226 @code{var-a}), then @samp{(calc-eval "a+pi")} will return the
32227 formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
32228 will return @code{"7.14159265359"}.
32230 To store in a Calc variable, just use @code{setq} to store in the
32231 corresponding Lisp variable. (This is obtained by prepending
32232 @samp{var-} to the Calc variable name.) Calc routines will
32233 understand either string or raw form values stored in variables,
32234 although raw data objects are much more efficient. For example,
32235 to increment the Calc variable @code{a}:
32238 (setq var-a (calc-eval "evalv(a+1)" 'raw))
32246 @subsubsection Stack Access
32249 If the separator symbol is @code{push}, the formula argument is
32250 evaluated (with possible @samp{$} expansions, as usual). The
32251 result is pushed onto the Calc stack. The return value is @code{nil}
32252 (unless there is an error from evaluating the formula, in which
32253 case the return value depends on @code{calc-eval-error} in the
32256 If the separator symbol is @code{pop}, the first argument to
32257 @code{calc-eval} must be an integer instead of a string. That
32258 many values are popped from the stack and thrown away. A negative
32259 argument deletes the entry at that stack level. The return value
32260 is the number of elements remaining in the stack after popping;
32261 @samp{(calc-eval 0 'pop)} is a good way to measure the size of
32264 If the separator symbol is @code{top}, the first argument to
32265 @code{calc-eval} must again be an integer. The value at that
32266 stack level is formatted as a string and returned. Thus
32267 @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the
32268 integer is out of range, @code{nil} is returned.
32270 The separator symbol @code{rawtop} is just like @code{top} except
32271 that the stack entry is returned as a raw Calc object instead of
32274 In all of these cases the first argument can be made a list in
32275 order to force the default mode settings, as described above.
32276 Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
32277 second-to-top stack entry, formatted as a string using the default
32278 instead of current display modes, except that the radix is
32279 hexadecimal instead of decimal.
32281 It is, of course, polite to put the Calc stack back the way you
32282 found it when you are done, unless the user of your program is
32283 actually expecting it to affect the stack.
32285 Note that you do not actually have to switch into the @samp{*Calculator*}
32286 buffer in order to use @code{calc-eval}; it temporarily switches into
32287 the stack buffer if necessary.
32294 @subsubsection Keyboard Macros
32297 If the separator symbol is @code{macro}, the first argument must be a
32298 string of characters which Calc can execute as a sequence of keystrokes.
32299 This switches into the Calc buffer for the duration of the macro.
32300 For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
32301 vector @samp{[1,2,3,4,5]} on the stack and then replaces it
32302 with the sum of those numbers. Note that @samp{\r} is the Lisp
32303 notation for the carriage-return, @key{RET}, character.
32305 If your keyboard macro wishes to pop the stack, @samp{\C-d} is
32306 safer than @samp{\177} (the @key{DEL} character) because some
32307 installations may have switched the meanings of @key{DEL} and
32308 @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for
32309 ``pop-stack'' regardless of key mapping.
32311 If you provide a third argument to @code{calc-eval}, evaluation
32312 of the keyboard macro will leave a record in the Trail using
32313 that argument as a tag string. Normally the Trail is unaffected.
32315 The return value in this case is always @code{nil}.
32322 @subsubsection Lisp Evaluation
32325 Finally, if the separator symbol is @code{eval}, then the Lisp
32326 @code{eval} function is called on the first argument, which must
32327 be a Lisp expression rather than a Calc formula. Remember to
32328 quote the expression so that it is not evaluated until inside
32331 The difference from plain @code{eval} is that @code{calc-eval}
32332 switches to the Calc buffer before evaluating the expression.
32333 For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
32334 will correctly affect the buffer-local Calc precision variable.
32336 An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
32337 This is evaluating a call to the function that is normally invoked
32338 by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
32339 Note that this function will leave a message in the echo area as
32340 a side effect. Also, all Calc functions switch to the Calc buffer
32341 automatically if not invoked from there, so the above call is
32342 also equivalent to @samp{(calc-precision 17)} by itself.
32343 In all cases, Calc uses @code{save-excursion} to switch back to
32344 your original buffer when it is done.
32346 As usual the first argument can be a list that begins with a Lisp
32347 expression to use default instead of current mode settings.
32349 The result of @code{calc-eval} in this usage is just the result
32350 returned by the evaluated Lisp expression.
32357 @subsubsection Example
32360 @findex convert-temp
32361 Here is a sample Emacs command that uses @code{calc-eval}. Suppose
32362 you have a document with lots of references to temperatures on the
32363 Fahrenheit scale, say ``98.6 F'', and you wish to convert these
32364 references to Centigrade. The following command does this conversion.
32365 Place the Emacs cursor right after the letter ``F'' and invoke the
32366 command to change ``98.6 F'' to ``37 C''. Or, if the temperature is
32367 already in Centigrade form, the command changes it back to Fahrenheit.
32370 (defun convert-temp ()
32373 (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
32374 (let* ((top1 (match-beginning 1))
32375 (bot1 (match-end 1))
32376 (number (buffer-substring top1 bot1))
32377 (top2 (match-beginning 2))
32378 (bot2 (match-end 2))
32379 (type (buffer-substring top2 bot2)))
32380 (if (equal type "F")
32382 number (calc-eval "($ - 32)*5/9" nil number))
32384 number (calc-eval "$*9/5 + 32" nil number)))
32386 (delete-region top2 bot2)
32387 (insert-before-markers type)
32389 (delete-region top1 bot1)
32390 (if (string-match "\\.$" number) ; change "37." to "37"
32391 (setq number (substring number 0 -1)))
32395 Note the use of @code{insert-before-markers} when changing between
32396 ``F'' and ``C'', so that the character winds up before the cursor
32397 instead of after it.
32399 @node Internals, , Calling Calc from Your Programs, Lisp Definitions
32400 @subsection Calculator Internals
32403 This section describes the Lisp functions defined by the Calculator that
32404 may be of use to user-written Calculator programs (as described in the
32405 rest of this chapter). These functions are shown by their names as they
32406 conventionally appear in @code{defmath}. Their full Lisp names are
32407 generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
32408 apparent names. (Names that begin with @samp{calc-} are already in
32409 their full Lisp form.) You can use the actual full names instead if you
32410 prefer them, or if you are calling these functions from regular Lisp.
32412 The functions described here are scattered throughout the various
32413 Calc component files. Note that @file{calc.el} includes @code{autoload}s
32414 for only a few component files; when Calc wants to call an advanced
32415 function it calls @samp{(calc-extensions)} first; this function
32416 autoloads @file{calc-ext.el}, which in turn autoloads all the functions
32417 in the remaining component files.
32419 Because @code{defmath} itself uses the extensions, user-written code
32420 generally always executes with the extensions already loaded, so
32421 normally you can use any Calc function and be confident that it will
32422 be autoloaded for you when necessary. If you are doing something
32423 special, check carefully to make sure each function you are using is
32424 from @file{calc.el} or its components, and call @samp{(calc-extensions)}
32425 before using any function based in @file{calc-ext.el} if you can't
32426 prove this file will already be loaded.
32429 * Data Type Formats::
32430 * Interactive Lisp Functions::
32431 * Stack Lisp Functions::
32433 * Computational Lisp Functions::
32434 * Vector Lisp Functions::
32435 * Symbolic Lisp Functions::
32436 * Formatting Lisp Functions::
32440 @node Data Type Formats, Interactive Lisp Functions, Internals, Internals
32441 @subsubsection Data Type Formats
32444 Integers are stored in either of two ways, depending on their magnitude.
32445 Integers less than one million in absolute value are stored as standard
32446 Lisp integers. This is the only storage format for Calc data objects
32447 which is not a Lisp list.
32449 Large integers are stored as lists of the form @samp{(bigpos @var{d0}
32450 @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or
32451 @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers
32452 @mathit{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer
32453 from 0 to 999. The least significant digit is @var{d0}; the last digit,
32454 @var{dn}, which is always nonzero, is the most significant digit. For
32455 example, the integer @mathit{-12345678} is stored as @samp{(bigneg 678 345 12)}.
32457 The distinction between small and large integers is entirely hidden from
32458 the user. In @code{defmath} definitions, the Lisp predicate @code{integerp}
32459 returns true for either kind of integer, and in general both big and small
32460 integers are accepted anywhere the word ``integer'' is used in this manual.
32461 If the distinction must be made, native Lisp integers are called @dfn{fixnums}
32462 and large integers are called @dfn{bignums}.
32464 Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
32465 where @var{n} is an integer (big or small) numerator, @var{d} is an
32466 integer denominator greater than one, and @var{n} and @var{d} are relatively
32467 prime. Note that fractions where @var{d} is one are automatically converted
32468 to plain integers by all math routines; fractions where @var{d} is negative
32469 are normalized by negating the numerator and denominator.
32471 Floating-point numbers are stored in the form, @samp{(float @var{mant}
32472 @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
32473 @samp{10^@var{p}} in absolute value (@var{p} represents the current
32474 precision), and @var{exp} (the ``exponent'') is a fixnum. The value of
32475 the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number
32476 @mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints
32477 are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
32478 except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
32479 always nonzero. (If the rightmost digit is zero, the number is
32480 rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)
32482 Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
32483 @var{im})}, where @var{re} and @var{im} are each real numbers, either
32484 integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}.
32485 The @var{im} part is nonzero; complex numbers with zero imaginary
32486 components are converted to real numbers automatically.
32488 Polar complex numbers are stored in the form @samp{(polar @var{r}
32489 @var{theta})}, where @var{r} is a positive real value and @var{theta}
32490 is a real value or HMS form representing an angle. This angle is
32491 usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
32492 or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
32493 If the angle is 0 the value is converted to a real number automatically.
32494 (If the angle is 180 degrees, the value is usually also converted to a
32495 negative real number.)
32497 Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
32498 @var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
32499 a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
32500 float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
32501 in the range @samp{[0 ..@: 60)}.
32503 Date forms are stored as @samp{(date @var{n})}, where @var{n} is
32504 a real number that counts days since midnight on the morning of
32505 January 1, 1 AD. If @var{n} is an integer, this is a pure date
32506 form. If @var{n} is a fraction or float, this is a date/time form.
32508 Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
32509 positive real number or HMS form, and @var{n} is a real number or HMS
32510 form in the range @samp{[0 ..@: @var{m})}.
32512 Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
32513 is the mean value and @var{sigma} is the standard deviation. Each
32514 component is either a number, an HMS form, or a symbolic object
32515 (a variable or function call). If @var{sigma} is zero, the value is
32516 converted to a plain real number. If @var{sigma} is negative or
32517 complex, it is automatically normalized to be a positive real.
32519 Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
32520 where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
32521 @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask}
32522 is a binary integer where 1 represents the fact that the interval is
32523 closed on the high end, and 2 represents the fact that it is closed on
32524 the low end. (Thus 3 represents a fully closed interval.) The interval
32525 @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
32526 intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
32527 represent empty intervals. If @var{hi} is less than @var{lo}, the interval
32528 is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
32530 Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
32531 is the first element of the vector, @var{v2} is the second, and so on.
32532 An empty vector is stored as @samp{(vec)}. A matrix is simply a vector
32533 where all @var{v}'s are themselves vectors of equal lengths. Note that
32534 Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
32535 generally unused by Calc data structures.
32537 Variables are stored as @samp{(var @var{name} @var{sym})}, where
32538 @var{name} is a Lisp symbol whose print name is used as the visible name
32539 of the variable, and @var{sym} is a Lisp symbol in which the variable's
32540 value is actually stored. Thus, @samp{(var pi var-pi)} represents the
32541 special constant @samp{pi}. Almost always, the form is @samp{(var
32542 @var{v} var-@var{v})}. If the variable name was entered with @code{#}
32543 signs (which are converted to hyphens internally), the form is
32544 @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
32545 contains @code{#} characters, and @var{v} is a symbol that contains
32546 @code{-} characters instead. The value of a variable is the Calc
32547 object stored in its @var{sym} symbol's value cell. If the symbol's
32548 value cell is void or if it contains @code{nil}, the variable has no
32549 value. Special constants have the form @samp{(special-const
32550 @var{value})} stored in their value cell, where @var{value} is a formula
32551 which is evaluated when the constant's value is requested. Variables
32552 which represent units are not stored in any special way; they are units
32553 only because their names appear in the units table. If the value
32554 cell contains a string, it is parsed to get the variable's value when
32555 the variable is used.
32557 A Lisp list with any other symbol as the first element is a function call.
32558 The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
32559 and @code{|} represent special binary operators; these lists are always
32560 of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
32561 sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
32562 right. The symbol @code{neg} represents unary negation; this list is always
32563 of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a
32564 function that would be displayed in function-call notation; the symbol
32565 @var{func} is in general always of the form @samp{calcFunc-@var{name}}.
32566 The function cell of the symbol @var{func} should contain a Lisp function
32567 for evaluating a call to @var{func}. This function is passed the remaining
32568 elements of the list (themselves already evaluated) as arguments; such
32569 functions should return @code{nil} or call @code{reject-arg} to signify
32570 that they should be left in symbolic form, or they should return a Calc
32571 object which represents their value, or a list of such objects if they
32572 wish to return multiple values. (The latter case is allowed only for
32573 functions which are the outer-level call in an expression whose value is
32574 about to be pushed on the stack; this feature is considered obsolete
32575 and is not used by any built-in Calc functions.)
32577 @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
32578 @subsubsection Interactive Functions
32581 The functions described here are used in implementing interactive Calc
32582 commands. Note that this list is not exhaustive! If there is an
32583 existing command that behaves similarly to the one you want to define,
32584 you may find helpful tricks by checking the source code for that command.
32586 @defun calc-set-command-flag flag
32587 Set the command flag @var{flag}. This is generally a Lisp symbol, but
32588 may in fact be anything. The effect is to add @var{flag} to the list
32589 stored in the variable @code{calc-command-flags}, unless it is already
32590 there. @xref{Defining Simple Commands}.
32593 @defun calc-clear-command-flag flag
32594 If @var{flag} appears among the list of currently-set command flags,
32595 remove it from that list.
32598 @defun calc-record-undo rec
32599 Add the ``undo record'' @var{rec} to the list of steps to take if the
32600 current operation should need to be undone. Stack push and pop functions
32601 automatically call @code{calc-record-undo}, so the kinds of undo records
32602 you might need to create take the form @samp{(set @var{sym} @var{value})},
32603 which says that the Lisp variable @var{sym} was changed and had previously
32604 contained @var{value}; @samp{(store @var{var} @var{value})} which says that
32605 the Calc variable @var{var} (a string which is the name of the symbol that
32606 contains the variable's value) was stored and its previous value was
32607 @var{value} (either a Calc data object, or @code{nil} if the variable was
32608 previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
32609 which means that to undo requires calling the function @samp{(@var{undo}
32610 @var{args} @dots{})} and, if the undo is later redone, calling
32611 @samp{(@var{redo} @var{args} @dots{})}.
32614 @defun calc-record-why msg args
32615 Record the error or warning message @var{msg}, which is normally a string.
32616 This message will be replayed if the user types @kbd{w} (@code{calc-why});
32617 if the message string begins with a @samp{*}, it is considered important
32618 enough to display even if the user doesn't type @kbd{w}. If one or more
32619 @var{args} are present, the displayed message will be of the form,
32620 @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
32621 formatted on the assumption that they are either strings or Calc objects of
32622 some sort. If @var{msg} is a symbol, it is the name of a Calc predicate
32623 (such as @code{integerp} or @code{numvecp}) which the arguments did not
32624 satisfy; it is expanded to a suitable string such as ``Expected an
32625 integer.'' The @code{reject-arg} function calls @code{calc-record-why}
32626 automatically; @pxref{Predicates}.
32629 @defun calc-is-inverse
32630 This predicate returns true if the current command is inverse,
32631 i.e., if the Inverse (@kbd{I} key) flag was set.
32634 @defun calc-is-hyperbolic
32635 This predicate is the analogous function for the @kbd{H} key.
32638 @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
32639 @subsubsection Stack-Oriented Functions
32642 The functions described here perform various operations on the Calc
32643 stack and trail. They are to be used in interactive Calc commands.
32645 @defun calc-push-list vals n
32646 Push the Calc objects in list @var{vals} onto the stack at stack level
32647 @var{n}. If @var{n} is omitted it defaults to 1, so that the elements
32648 are pushed at the top of the stack. If @var{n} is greater than 1, the
32649 elements will be inserted into the stack so that the last element will
32650 end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
32651 The elements of @var{vals} are assumed to be valid Calc objects, and
32652 are not evaluated, rounded, or renormalized in any way. If @var{vals}
32653 is an empty list, nothing happens.
32655 The stack elements are pushed without any sub-formula selections.
32656 You can give an optional third argument to this function, which must
32657 be a list the same size as @var{vals} of selections. Each selection
32658 must be @code{eq} to some sub-formula of the corresponding formula
32659 in @var{vals}, or @code{nil} if that formula should have no selection.
32662 @defun calc-top-list n m
32663 Return a list of the @var{n} objects starting at level @var{m} of the
32664 stack. If @var{m} is omitted it defaults to 1, so that the elements are
32665 taken from the top of the stack. If @var{n} is omitted, it also
32666 defaults to 1, so that the top stack element (in the form of a
32667 one-element list) is returned. If @var{m} is greater than 1, the
32668 @var{m}th stack element will be at the end of the list, the @var{m}+1st
32669 element will be next-to-last, etc. If @var{n} or @var{m} are out of
32670 range, the command is aborted with a suitable error message. If @var{n}
32671 is zero, the function returns an empty list. The stack elements are not
32672 evaluated, rounded, or renormalized.
32674 If any stack elements contain selections, and selections have not
32675 been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
32676 this function returns the selected portions rather than the entire
32677 stack elements. It can be given a third ``selection-mode'' argument
32678 which selects other behaviors. If it is the symbol @code{t}, then
32679 a selection in any of the requested stack elements produces an
32680 ``illegal operation on selections'' error. If it is the symbol @code{full},
32681 the whole stack entry is always returned regardless of selections.
32682 If it is the symbol @code{sel}, the selected portion is always returned,
32683 or @code{nil} if there is no selection. (This mode ignores the @kbd{j e}
32684 command.) If the symbol is @code{entry}, the complete stack entry in
32685 list form is returned; the first element of this list will be the whole
32686 formula, and the third element will be the selection (or @code{nil}).
32689 @defun calc-pop-stack n m
32690 Remove the specified elements from the stack. The parameters @var{n}
32691 and @var{m} are defined the same as for @code{calc-top-list}. The return
32692 value of @code{calc-pop-stack} is uninteresting.
32694 If there are any selected sub-formulas among the popped elements, and
32695 @kbd{j e} has not been used to disable selections, this produces an
32696 error without changing the stack. If you supply an optional third
32697 argument of @code{t}, the stack elements are popped even if they
32698 contain selections.
32701 @defun calc-record-list vals tag
32702 This function records one or more results in the trail. The @var{vals}
32703 are a list of strings or Calc objects. The @var{tag} is the four-character
32704 tag string to identify the values. If @var{tag} is omitted, a blank tag
32708 @defun calc-normalize n
32709 This function takes a Calc object and ``normalizes'' it. At the very
32710 least this involves re-rounding floating-point values according to the
32711 current precision and other similar jobs. Also, unless the user has
32712 selected No-Simplify mode (@pxref{Simplification Modes}), this involves
32713 actually evaluating a formula object by executing the function calls
32714 it contains, and possibly also doing algebraic simplification, etc.
32717 @defun calc-top-list-n n m
32718 This function is identical to @code{calc-top-list}, except that it calls
32719 @code{calc-normalize} on the values that it takes from the stack. They
32720 are also passed through @code{check-complete}, so that incomplete
32721 objects will be rejected with an error message. All computational
32722 commands should use this in preference to @code{calc-top-list}; the only
32723 standard Calc commands that operate on the stack without normalizing
32724 are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
32725 This function accepts the same optional selection-mode argument as
32726 @code{calc-top-list}.
32729 @defun calc-top-n m
32730 This function is a convenient form of @code{calc-top-list-n} in which only
32731 a single element of the stack is taken and returned, rather than a list
32732 of elements. This also accepts an optional selection-mode argument.
32735 @defun calc-enter-result n tag vals
32736 This function is a convenient interface to most of the above functions.
32737 The @var{vals} argument should be either a single Calc object, or a list
32738 of Calc objects; the object or objects are normalized, and the top @var{n}
32739 stack entries are replaced by the normalized objects. If @var{tag} is
32740 non-@code{nil}, the normalized objects are also recorded in the trail.
32741 A typical stack-based computational command would take the form,
32744 (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
32745 (calc-top-list-n @var{n})))
32748 If any of the @var{n} stack elements replaced contain sub-formula
32749 selections, and selections have not been disabled by @kbd{j e},
32750 this function takes one of two courses of action. If @var{n} is
32751 equal to the number of elements in @var{vals}, then each element of
32752 @var{vals} is spliced into the corresponding selection; this is what
32753 happens when you use the @key{TAB} key, or when you use a unary
32754 arithmetic operation like @code{sqrt}. If @var{vals} has only one
32755 element but @var{n} is greater than one, there must be only one
32756 selection among the top @var{n} stack elements; the element from
32757 @var{vals} is spliced into that selection. This is what happens when
32758 you use a binary arithmetic operation like @kbd{+}. Any other
32759 combination of @var{n} and @var{vals} is an error when selections
32763 @defun calc-unary-op tag func arg
32764 This function implements a unary operator that allows a numeric prefix
32765 argument to apply the operator over many stack entries. If the prefix
32766 argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
32767 as outlined above. Otherwise, it maps the function over several stack
32768 elements; @pxref{Prefix Arguments}. For example,
32771 (defun calc-zeta (arg)
32773 (calc-unary-op "zeta" 'calcFunc-zeta arg))
32777 @defun calc-binary-op tag func arg ident unary
32778 This function implements a binary operator, analogously to
32779 @code{calc-unary-op}. The optional @var{ident} and @var{unary}
32780 arguments specify the behavior when the prefix argument is zero or
32781 one, respectively. If the prefix is zero, the value @var{ident}
32782 is pushed onto the stack, if specified, otherwise an error message
32783 is displayed. If the prefix is one, the unary function @var{unary}
32784 is applied to the top stack element, or, if @var{unary} is not
32785 specified, nothing happens. When the argument is two or more,
32786 the binary function @var{func} is reduced across the top @var{arg}
32787 stack elements; when the argument is negative, the function is
32788 mapped between the next-to-top @mathit{-@var{arg}} stack elements and the
32792 @defun calc-stack-size
32793 Return the number of elements on the stack as an integer. This count
32794 does not include elements that have been temporarily hidden by stack
32795 truncation; @pxref{Truncating the Stack}.
32798 @defun calc-cursor-stack-index n
32799 Move the point to the @var{n}th stack entry. If @var{n} is zero, this
32800 will be the @samp{.} line. If @var{n} is from 1 to the current stack size,
32801 this will be the beginning of the first line of that stack entry's display.
32802 If line numbers are enabled, this will move to the first character of the
32803 line number, not the stack entry itself.
32806 @defun calc-substack-height n
32807 Return the number of lines between the beginning of the @var{n}th stack
32808 entry and the bottom of the buffer. If @var{n} is zero, this
32809 will be one (assuming no stack truncation). If all stack entries are
32810 one line long (i.e., no matrices are displayed), the return value will
32811 be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big
32812 mode, the return value includes the blank lines that separate stack
32816 @defun calc-refresh
32817 Erase the @code{*Calculator*} buffer and reformat its contents from memory.
32818 This must be called after changing any parameter, such as the current
32819 display radix, which might change the appearance of existing stack
32820 entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing
32821 is suppressed, but a flag is set so that the entire stack will be refreshed
32822 rather than just the top few elements when the macro finishes.)
32825 @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
32826 @subsubsection Predicates
32829 The functions described here are predicates, that is, they return a
32830 true/false value where @code{nil} means false and anything else means
32831 true. These predicates are expanded by @code{defmath}, for example,
32832 from @code{zerop} to @code{math-zerop}. In many cases they correspond
32833 to native Lisp functions by the same name, but are extended to cover
32834 the full range of Calc data types.
32837 Returns true if @var{x} is numerically zero, in any of the Calc data
32838 types. (Note that for some types, such as error forms and intervals,
32839 it never makes sense to return true.) In @code{defmath}, the expression
32840 @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
32841 and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
32845 Returns true if @var{x} is negative. This accepts negative real numbers
32846 of various types, negative HMS and date forms, and intervals in which
32847 all included values are negative. In @code{defmath}, the expression
32848 @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
32849 and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
32853 Returns true if @var{x} is positive (and non-zero). For complex
32854 numbers, none of these three predicates will return true.
32857 @defun looks-negp x
32858 Returns true if @var{x} is ``negative-looking.'' This returns true if
32859 @var{x} is a negative number, or a formula with a leading minus sign
32860 such as @samp{-a/b}. In other words, this is an object which can be
32861 made simpler by calling @code{(- @var{x})}.
32865 Returns true if @var{x} is an integer of any size.
32869 Returns true if @var{x} is a native Lisp integer.
32873 Returns true if @var{x} is a nonnegative integer of any size.
32876 @defun fixnatnump x
32877 Returns true if @var{x} is a nonnegative Lisp integer.
32880 @defun num-integerp x
32881 Returns true if @var{x} is numerically an integer, i.e., either a
32882 true integer or a float with no significant digits to the right of
32886 @defun messy-integerp x
32887 Returns true if @var{x} is numerically, but not literally, an integer.
32888 A value is @code{num-integerp} if it is @code{integerp} or
32889 @code{messy-integerp} (but it is never both at once).
32892 @defun num-natnump x
32893 Returns true if @var{x} is numerically a nonnegative integer.
32897 Returns true if @var{x} is an even integer.
32900 @defun looks-evenp x
32901 Returns true if @var{x} is an even integer, or a formula with a leading
32902 multiplicative coefficient which is an even integer.
32906 Returns true if @var{x} is an odd integer.
32910 Returns true if @var{x} is a rational number, i.e., an integer or a
32915 Returns true if @var{x} is a real number, i.e., an integer, fraction,
32916 or floating-point number.
32920 Returns true if @var{x} is a real number or HMS form.
32924 Returns true if @var{x} is a float, or a complex number, error form,
32925 interval, date form, or modulo form in which at least one component
32930 Returns true if @var{x} is a rectangular or polar complex number
32931 (but not a real number).
32934 @defun rect-complexp x
32935 Returns true if @var{x} is a rectangular complex number.
32938 @defun polar-complexp x
32939 Returns true if @var{x} is a polar complex number.
32943 Returns true if @var{x} is a real number or a complex number.
32947 Returns true if @var{x} is a real or complex number or an HMS form.
32951 Returns true if @var{x} is a vector (this simply checks if its argument
32952 is a list whose first element is the symbol @code{vec}).
32956 Returns true if @var{x} is a number or vector.
32960 Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
32961 all of the same size.
32964 @defun square-matrixp x
32965 Returns true if @var{x} is a square matrix.
32969 Returns true if @var{x} is any numeric Calc object, including real and
32970 complex numbers, HMS forms, date forms, error forms, intervals, and
32971 modulo forms. (Note that error forms and intervals may include formulas
32972 as their components; see @code{constp} below.)
32976 Returns true if @var{x} is an object or a vector. This also accepts
32977 incomplete objects, but it rejects variables and formulas (except as
32978 mentioned above for @code{objectp}).
32982 Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
32983 i.e., one whose components cannot be regarded as sub-formulas. This
32984 includes variables, and all @code{objectp} types except error forms
32989 Returns true if @var{x} is constant, i.e., a real or complex number,
32990 HMS form, date form, or error form, interval, or vector all of whose
32991 components are @code{constp}.
32995 Returns true if @var{x} is numerically less than @var{y}. Returns false
32996 if @var{x} is greater than or equal to @var{y}, or if the order is
32997 undefined or cannot be determined. Generally speaking, this works
32998 by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In
32999 @code{defmath}, the expression @samp{(< x y)} will automatically be
33000 converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
33001 and @code{>=} are similarly converted in terms of @code{lessp}.
33005 Returns true if @var{x} comes before @var{y} in a canonical ordering
33006 of Calc objects. If @var{x} and @var{y} are both real numbers, this
33007 will be the same as @code{lessp}. But whereas @code{lessp} considers
33008 other types of objects to be unordered, @code{beforep} puts any two
33009 objects into a definite, consistent order. The @code{beforep}
33010 function is used by the @kbd{V S} vector-sorting command, and also
33011 by @kbd{a s} to put the terms of a product into canonical order:
33012 This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}.
33016 This is the standard Lisp @code{equal} predicate; it returns true if
33017 @var{x} and @var{y} are structurally identical. This is the usual way
33018 to compare numbers for equality, but note that @code{equal} will treat
33019 0 and 0.0 as different.
33022 @defun math-equal x y
33023 Returns true if @var{x} and @var{y} are numerically equal, either because
33024 they are @code{equal}, or because their difference is @code{zerop}. In
33025 @code{defmath}, the expression @samp{(= x y)} will automatically be
33026 converted to @samp{(math-equal x y)}.
33029 @defun equal-int x n
33030 Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
33031 is a fixnum which is not a multiple of 10. This will automatically be
33032 used by @code{defmath} in place of the more general @code{math-equal}
33036 @defun nearly-equal x y
33037 Returns true if @var{x} and @var{y}, as floating-point numbers, are
33038 equal except possibly in the last decimal place. For example,
33039 314.159 and 314.166 are considered nearly equal if the current
33040 precision is 6 (since they differ by 7 units), but not if the current
33041 precision is 7 (since they differ by 70 units). Most functions which
33042 use series expansions use @code{with-extra-prec} to evaluate the
33043 series with 2 extra digits of precision, then use @code{nearly-equal}
33044 to decide when the series has converged; this guards against cumulative
33045 error in the series evaluation without doing extra work which would be
33046 lost when the result is rounded back down to the current precision.
33047 In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
33048 The @var{x} and @var{y} can be numbers of any kind, including complex.
33051 @defun nearly-zerop x y
33052 Returns true if @var{x} is nearly zero, compared to @var{y}. This
33053 checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
33054 to @var{y} itself, to within the current precision, in other words,
33055 if adding @var{x} to @var{y} would have a negligible effect on @var{y}
33056 due to roundoff error. @var{X} may be a real or complex number, but
33057 @var{y} must be real.
33061 Return true if the formula @var{x} represents a true value in
33062 Calc, not Lisp, terms. It tests if @var{x} is a non-zero number
33063 or a provably non-zero formula.
33066 @defun reject-arg val pred
33067 Abort the current function evaluation due to unacceptable argument values.
33068 This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
33069 Lisp error which @code{normalize} will trap. The net effect is that the
33070 function call which led here will be left in symbolic form.
33073 @defun inexact-value
33074 If Symbolic mode is enabled, this will signal an error that causes
33075 @code{normalize} to leave the formula in symbolic form, with the message
33076 ``Inexact result.'' (This function has no effect when not in Symbolic mode.)
33077 Note that if your function calls @samp{(sin 5)} in Symbolic mode, the
33078 @code{sin} function will call @code{inexact-value}, which will cause your
33079 function to be left unsimplified. You may instead wish to call
33080 @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will
33081 return the formula @samp{sin(5)} to your function.
33085 This signals an error that will be reported as a floating-point overflow.
33089 This signals a floating-point underflow.
33092 @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
33093 @subsubsection Computational Functions
33096 The functions described here do the actual computational work of the
33097 Calculator. In addition to these, note that any function described in
33098 the main body of this manual may be called from Lisp; for example, if
33099 the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
33100 this means @code{calc-sqrt} is an interactive stack-based square-root
33101 command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
33102 is the actual Lisp function for taking square roots.
33104 The functions @code{math-add}, @code{math-sub}, @code{math-mul},
33105 @code{math-div}, @code{math-mod}, and @code{math-neg} are not included
33106 in this list, since @code{defmath} allows you to write native Lisp
33107 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
33108 respectively, instead.
33110 @defun normalize val
33111 (Full form: @code{math-normalize}.)
33112 Reduce the value @var{val} to standard form. For example, if @var{val}
33113 is a fixnum, it will be converted to a bignum if it is too large, and
33114 if @var{val} is a bignum it will be normalized by clipping off trailing
33115 (i.e., most-significant) zero digits and converting to a fixnum if it is
33116 small. All the various data types are similarly converted to their standard
33117 forms. Variables are left alone, but function calls are actually evaluated
33118 in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
33121 If a function call fails, because the function is void or has the wrong
33122 number of parameters, or because it returns @code{nil} or calls
33123 @code{reject-arg} or @code{inexact-result}, @code{normalize} returns
33124 the formula still in symbolic form.
33126 If the current simplification mode is ``none'' or ``numeric arguments
33127 only,'' @code{normalize} will act appropriately. However, the more
33128 powerful simplification modes (like Algebraic Simplification) are
33129 not handled by @code{normalize}. They are handled by @code{calc-normalize},
33130 which calls @code{normalize} and possibly some other routines, such
33131 as @code{simplify} or @code{simplify-units}. Programs generally will
33132 never call @code{calc-normalize} except when popping or pushing values
33136 @defun evaluate-expr expr
33137 Replace all variables in @var{expr} that have values with their values,
33138 then use @code{normalize} to simplify the result. This is what happens
33139 when you press the @kbd{=} key interactively.
33142 @defmac with-extra-prec n body
33143 Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
33144 digits. This is a macro which expands to
33148 (let ((calc-internal-prec (+ calc-internal-prec @var{n})))
33152 The surrounding call to @code{math-normalize} causes a floating-point
33153 result to be rounded down to the original precision afterwards. This
33154 is important because some arithmetic operations assume a number's
33155 mantissa contains no more digits than the current precision allows.
33158 @defun make-frac n d
33159 Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling
33160 @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
33163 @defun make-float mant exp
33164 Build a floating-point value out of @var{mant} and @var{exp}, both
33165 of which are arbitrary integers. This function will return a
33166 properly normalized float value, or signal an overflow or underflow
33167 if @var{exp} is out of range.
33170 @defun make-sdev x sigma
33171 Build an error form out of @var{x} and the absolute value of @var{sigma}.
33172 If @var{sigma} is zero, the result is the number @var{x} directly.
33173 If @var{sigma} is negative or complex, its absolute value is used.
33174 If @var{x} or @var{sigma} is not a valid type of object for use in
33175 error forms, this calls @code{reject-arg}.
33178 @defun make-intv mask lo hi
33179 Build an interval form out of @var{mask} (which is assumed to be an
33180 integer from 0 to 3), and the limits @var{lo} and @var{hi}. If
33181 @var{lo} is greater than @var{hi}, an empty interval form is returned.
33182 This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
33185 @defun sort-intv mask lo hi
33186 Build an interval form, similar to @code{make-intv}, except that if
33187 @var{lo} is less than @var{hi} they are simply exchanged, and the
33188 bits of @var{mask} are swapped accordingly.
33191 @defun make-mod n m
33192 Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo
33193 forms do not allow formulas as their components, if @var{n} or @var{m}
33194 is not a real number or HMS form the result will be a formula which
33195 is a call to @code{makemod}, the algebraic version of this function.
33199 Convert @var{x} to floating-point form. Integers and fractions are
33200 converted to numerically equivalent floats; components of complex
33201 numbers, vectors, HMS forms, date forms, error forms, intervals, and
33202 modulo forms are recursively floated. If the argument is a variable
33203 or formula, this calls @code{reject-arg}.
33207 Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if
33208 @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
33209 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
33210 undefined or cannot be determined.
33214 Return the number of digits of integer @var{n}, effectively
33215 @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is
33216 considered to have zero digits.
33219 @defun scale-int x n
33220 Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}}
33221 digits with truncation toward zero.
33224 @defun scale-rounding x n
33225 Like @code{scale-int}, except that a right shift rounds to the nearest
33226 integer rather than truncating.
33230 Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
33231 If @var{n} is outside the permissible range for Lisp integers (usually
33232 24 binary bits) the result is undefined.
33236 Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
33239 @defun quotient x y
33240 Divide integer @var{x} by integer @var{y}; return an integer quotient
33241 and discard the remainder. If @var{x} or @var{y} is negative, the
33242 direction of rounding is undefined.
33246 Perform an integer division; if @var{x} and @var{y} are both nonnegative
33247 integers, this uses the @code{quotient} function, otherwise it computes
33248 @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but
33249 slower than for @code{quotient}.
33253 Divide integer @var{x} by integer @var{y}; return the integer remainder
33254 and discard the quotient. Like @code{quotient}, this works only for
33255 integer arguments and is not well-defined for negative arguments.
33256 For a more well-defined result, use @samp{(% @var{x} @var{y})}.
33260 Divide integer @var{x} by integer @var{y}; return a cons cell whose
33261 @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
33262 is @samp{(imod @var{x} @var{y})}.
33266 Compute @var{x} to the power @var{y}. In @code{defmath} code, this can
33267 also be written @samp{(^ @var{x} @var{y})} or
33268 @w{@samp{(expt @var{x} @var{y})}}.
33271 @defun abs-approx x
33272 Compute a fast approximation to the absolute value of @var{x}. For
33273 example, for a rectangular complex number the result is the sum of
33274 the absolute values of the components.
33280 @findex pi-over-180
33281 @findex sqrt-two-pi
33287 The function @samp{(pi)} computes @samp{pi} to the current precision.
33288 Other related constant-generating functions are @code{two-pi},
33289 @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
33290 @code{e}, @code{sqrt-e}, @code{ln-2}, and @code{ln-10}. Each function
33291 returns a floating-point value in the current precision, and each uses
33292 caching so that all calls after the first are essentially free.
33295 @defmac math-defcache @var{func} @var{initial} @var{form}
33296 This macro, usually used as a top-level call like @code{defun} or
33297 @code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
33298 It defines a function @code{func} which returns the requested value;
33299 if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
33300 form which serves as an initial value for the cache. If @var{func}
33301 is called when the cache is empty or does not have enough digits to
33302 satisfy the current precision, the Lisp expression @var{form} is evaluated
33303 with the current precision increased by four, and the result minus its
33304 two least significant digits is stored in the cache. For example,
33305 calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
33306 digits, rounds it down to 32 digits for future use, then rounds it
33307 again to 30 digits for use in the present request.
33310 @findex half-circle
33311 @findex quarter-circle
33312 @defun full-circle symb
33313 If the current angular mode is Degrees or HMS, this function returns the
33314 integer 360. In Radians mode, this function returns either the
33315 corresponding value in radians to the current precision, or the formula
33316 @samp{2*pi}, depending on the Symbolic mode. There are also similar
33317 function @code{half-circle} and @code{quarter-circle}.
33320 @defun power-of-2 n
33321 Compute two to the integer power @var{n}, as a (potentially very large)
33322 integer. Powers of two are cached, so only the first call for a
33323 particular @var{n} is expensive.
33326 @defun integer-log2 n
33327 Compute the base-2 logarithm of @var{n}, which must be an integer which
33328 is a power of two. If @var{n} is not a power of two, this function will
33332 @defun div-mod a b m
33333 Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if
33334 there is no solution, or if any of the arguments are not integers.
33337 @defun pow-mod a b m
33338 Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a},
33339 @var{b}, and @var{m} are integers, this uses an especially efficient
33340 algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}.
33344 Compute the integer square root of @var{n}. This is the square root
33345 of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
33346 If @var{n} is itself an integer, the computation is especially efficient.
33349 @defun to-hms a ang
33350 Convert the argument @var{a} into an HMS form. If @var{ang} is specified,
33351 it is the angular mode in which to interpret @var{a}, either @code{deg}
33352 or @code{rad}. Otherwise, the current angular mode is used. If @var{a}
33353 is already an HMS form it is returned as-is.
33356 @defun from-hms a ang
33357 Convert the HMS form @var{a} into a real number. If @var{ang} is specified,
33358 it is the angular mode in which to express the result, otherwise the
33359 current angular mode is used. If @var{a} is already a real number, it
33363 @defun to-radians a
33364 Convert the number or HMS form @var{a} to radians from the current
33368 @defun from-radians a
33369 Convert the number @var{a} from radians to the current angular mode.
33370 If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
33373 @defun to-radians-2 a
33374 Like @code{to-radians}, except that in Symbolic mode a degrees to
33375 radians conversion yields a formula like @samp{@var{a}*pi/180}.
33378 @defun from-radians-2 a
33379 Like @code{from-radians}, except that in Symbolic mode a radians to
33380 degrees conversion yields a formula like @samp{@var{a}*180/pi}.
33383 @defun random-digit
33384 Produce a random base-1000 digit in the range 0 to 999.
33387 @defun random-digits n
33388 Produce a random @var{n}-digit integer; this will be an integer
33389 in the interval @samp{[0, 10^@var{n})}.
33392 @defun random-float
33393 Produce a random float in the interval @samp{[0, 1)}.
33396 @defun prime-test n iters
33397 Determine whether the integer @var{n} is prime. Return a list which has
33398 one of these forms: @samp{(nil @var{f})} means the number is non-prime
33399 because it was found to be divisible by @var{f}; @samp{(nil)} means it
33400 was found to be non-prime by table look-up (so no factors are known);
33401 @samp{(nil unknown)} means it is definitely non-prime but no factors
33402 are known because @var{n} was large enough that Fermat's probabilistic
33403 test had to be used; @samp{(t)} means the number is definitely prime;
33404 and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
33405 iterations, is @var{p} percent sure that the number is prime. The
33406 @var{iters} parameter is the number of Fermat iterations to use, in the
33407 case that this is necessary. If @code{prime-test} returns ``maybe,''
33408 you can call it again with the same @var{n} to get a greater certainty;
33409 @code{prime-test} remembers where it left off.
33412 @defun to-simple-fraction f
33413 If @var{f} is a floating-point number which can be represented exactly
33414 as a small rational number. return that number, else return @var{f}.
33415 For example, 0.75 would be converted to 3:4. This function is very
33419 @defun to-fraction f tol
33420 Find a rational approximation to floating-point number @var{f} to within
33421 a specified tolerance @var{tol}; this corresponds to the algebraic
33422 function @code{frac}, and can be rather slow.
33425 @defun quarter-integer n
33426 If @var{n} is an integer or integer-valued float, this function
33427 returns zero. If @var{n} is a half-integer (i.e., an integer plus
33428 @mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer,
33429 it returns 1 or 3. If @var{n} is anything else, this function
33430 returns @code{nil}.
33433 @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
33434 @subsubsection Vector Functions
33437 The functions described here perform various operations on vectors and
33440 @defun math-concat x y
33441 Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
33442 in a symbolic formula. @xref{Building Vectors}.
33445 @defun vec-length v
33446 Return the length of vector @var{v}. If @var{v} is not a vector, the
33447 result is zero. If @var{v} is a matrix, this returns the number of
33448 rows in the matrix.
33451 @defun mat-dimens m
33452 Determine the dimensions of vector or matrix @var{m}. If @var{m} is not
33453 a vector, the result is an empty list. If @var{m} is a plain vector
33454 but not a matrix, the result is a one-element list containing the length
33455 of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns,
33456 the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors
33457 produce lists of more than two dimensions. Note that the object
33458 @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
33459 and is treated by this and other Calc routines as a plain vector of two
33463 @defun dimension-error
33464 Abort the current function with a message of ``Dimension error.''
33465 The Calculator will leave the function being evaluated in symbolic
33466 form; this is really just a special case of @code{reject-arg}.
33469 @defun build-vector args
33470 Return a Calc vector with @var{args} as elements.
33471 For example, @samp{(build-vector 1 2 3)} returns the Calc vector
33472 @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
33475 @defun make-vec obj dims
33476 Return a Calc vector or matrix all of whose elements are equal to
33477 @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
33481 @defun row-matrix v
33482 If @var{v} is a plain vector, convert it into a row matrix, i.e.,
33483 a matrix whose single row is @var{v}. If @var{v} is already a matrix,
33487 @defun col-matrix v
33488 If @var{v} is a plain vector, convert it into a column matrix, i.e., a
33489 matrix with each element of @var{v} as a separate row. If @var{v} is
33490 already a matrix, leave it alone.
33494 Map the Lisp function @var{f} over the Calc vector @var{v}. For example,
33495 @samp{(map-vec 'math-floor v)} returns a vector of the floored components
33499 @defun map-vec-2 f a b
33500 Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
33501 If @var{a} and @var{b} are vectors of equal length, the result is a
33502 vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
33503 for each pair of elements @var{ai} and @var{bi}. If either @var{a} or
33504 @var{b} is a scalar, it is matched with each value of the other vector.
33505 For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
33506 with each element increased by one. Note that using @samp{'+} would not
33507 work here, since @code{defmath} does not expand function names everywhere,
33508 just where they are in the function position of a Lisp expression.
33511 @defun reduce-vec f v
33512 Reduce the function @var{f} over the vector @var{v}. For example, if
33513 @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
33514 If @var{v} is a matrix, this reduces over the rows of @var{v}.
33517 @defun reduce-cols f m
33518 Reduce the function @var{f} over the columns of matrix @var{m}. For
33519 example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
33520 is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
33524 Return the @var{n}th row of matrix @var{m}. This is equivalent to
33525 @samp{(elt m n)}. For a slower but safer version, use @code{mrow}.
33526 (@xref{Extracting Elements}.)
33530 Return the @var{n}th column of matrix @var{m}, in the form of a vector.
33531 The arguments are not checked for correctness.
33534 @defun mat-less-row m n
33535 Return a copy of matrix @var{m} with its @var{n}th row deleted. The
33536 number @var{n} must be in range from 1 to the number of rows in @var{m}.
33539 @defun mat-less-col m n
33540 Return a copy of matrix @var{m} with its @var{n}th column deleted.
33544 Return the transpose of matrix @var{m}.
33547 @defun flatten-vector v
33548 Flatten nested vector @var{v} into a vector of scalars. For example,
33549 if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
33552 @defun copy-matrix m
33553 If @var{m} is a matrix, return a copy of @var{m}. This maps
33554 @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
33555 element of the result matrix will be @code{eq} to the corresponding
33556 element of @var{m}, but none of the @code{cons} cells that make up
33557 the structure of the matrix will be @code{eq}. If @var{m} is a plain
33558 vector, this is the same as @code{copy-sequence}.
33561 @defun swap-rows m r1 r2
33562 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In
33563 other words, unlike most of the other functions described here, this
33564 function changes @var{m} itself rather than building up a new result
33565 matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
33566 is true, with the side effect of exchanging the first two rows of
33570 @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
33571 @subsubsection Symbolic Functions
33574 The functions described here operate on symbolic formulas in the
33577 @defun calc-prepare-selection num
33578 Prepare a stack entry for selection operations. If @var{num} is
33579 omitted, the stack entry containing the cursor is used; otherwise,
33580 it is the number of the stack entry to use. This function stores
33581 useful information about the current stack entry into a set of
33582 variables. @code{calc-selection-cache-num} contains the number of
33583 the stack entry involved (equal to @var{num} if you specified it);
33584 @code{calc-selection-cache-entry} contains the stack entry as a
33585 list (such as @code{calc-top-list} would return with @code{entry}
33586 as the selection mode); and @code{calc-selection-cache-comp} contains
33587 a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
33588 which allows Calc to relate cursor positions in the buffer with
33589 their corresponding sub-formulas.
33591 A slight complication arises in the selection mechanism because
33592 formulas may contain small integers. For example, in the vector
33593 @samp{[1, 2, 1]} the first and last elements are @code{eq} to each
33594 other; selections are recorded as the actual Lisp object that
33595 appears somewhere in the tree of the whole formula, but storing
33596 @code{1} would falsely select both @code{1}'s in the vector. So
33597 @code{calc-prepare-selection} also checks the stack entry and
33598 replaces any plain integers with ``complex number'' lists of the form
33599 @samp{(cplx @var{n} 0)}. This list will be displayed the same as a
33600 plain @var{n} and the change will be completely invisible to the
33601 user, but it will guarantee that no two sub-formulas of the stack
33602 entry will be @code{eq} to each other. Next time the stack entry
33603 is involved in a computation, @code{calc-normalize} will replace
33604 these lists with plain numbers again, again invisibly to the user.
33607 @defun calc-encase-atoms x
33608 This modifies the formula @var{x} to ensure that each part of the
33609 formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
33610 described above. This function may use @code{setcar} to modify
33611 the formula in-place.
33614 @defun calc-find-selected-part
33615 Find the smallest sub-formula of the current formula that contains
33616 the cursor. This assumes @code{calc-prepare-selection} has been
33617 called already. If the cursor is not actually on any part of the
33618 formula, this returns @code{nil}.
33621 @defun calc-change-current-selection selection
33622 Change the currently prepared stack element's selection to
33623 @var{selection}, which should be @code{eq} to some sub-formula
33624 of the stack element, or @code{nil} to unselect the formula.
33625 The stack element's appearance in the Calc buffer is adjusted
33626 to reflect the new selection.
33629 @defun calc-find-nth-part expr n
33630 Return the @var{n}th sub-formula of @var{expr}. This function is used
33631 by the selection commands, and (unless @kbd{j b} has been used) treats
33632 sums and products as flat many-element formulas. Thus if @var{expr}
33633 is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
33634 @var{n} equal to four will return @samp{d}.
33637 @defun calc-find-parent-formula expr part
33638 Return the sub-formula of @var{expr} which immediately contains
33639 @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
33640 is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
33641 will return @samp{(c+1)*d}. If @var{part} turns out not to be a
33642 sub-formula of @var{expr}, the function returns @code{nil}. If
33643 @var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
33644 This function does not take associativity into account.
33647 @defun calc-find-assoc-parent-formula expr part
33648 This is the same as @code{calc-find-parent-formula}, except that
33649 (unless @kbd{j b} has been used) it continues widening the selection
33650 to contain a complete level of the formula. Given @samp{a} from
33651 @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
33652 return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
33653 return the whole expression.
33656 @defun calc-grow-assoc-formula expr part
33657 This expands sub-formula @var{part} of @var{expr} to encompass a
33658 complete level of the formula. If @var{part} and its immediate
33659 parent are not compatible associative operators, or if @kbd{j b}
33660 has been used, this simply returns @var{part}.
33663 @defun calc-find-sub-formula expr part
33664 This finds the immediate sub-formula of @var{expr} which contains
33665 @var{part}. It returns an index @var{n} such that
33666 @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
33667 If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
33668 If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This
33669 function does not take associativity into account.
33672 @defun calc-replace-sub-formula expr old new
33673 This function returns a copy of formula @var{expr}, with the
33674 sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
33677 @defun simplify expr
33678 Simplify the expression @var{expr} by applying various algebraic rules.
33679 This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This
33680 always returns a copy of the expression; the structure @var{expr} points
33681 to remains unchanged in memory.
33683 More precisely, here is what @code{simplify} does: The expression is
33684 first normalized and evaluated by calling @code{normalize}. If any
33685 @code{AlgSimpRules} have been defined, they are then applied. Then
33686 the expression is traversed in a depth-first, bottom-up fashion; at
33687 each level, any simplifications that can be made are made until no
33688 further changes are possible. Once the entire formula has been
33689 traversed in this way, it is compared with the original formula (from
33690 before the call to @code{normalize}) and, if it has changed,
33691 the entire procedure is repeated (starting with @code{normalize})
33692 until no further changes occur. Usually only two iterations are
33693 needed:@: one to simplify the formula, and another to verify that no
33694 further simplifications were possible.
33697 @defun simplify-extended expr
33698 Simplify the expression @var{expr}, with additional rules enabled that
33699 help do a more thorough job, while not being entirely ``safe'' in all
33700 circumstances. (For example, this mode will simplify @samp{sqrt(x^2)}
33701 to @samp{x}, which is only valid when @var{x} is positive.) This is
33702 implemented by temporarily binding the variable @code{math-living-dangerously}
33703 to @code{t} (using a @code{let} form) and calling @code{simplify}.
33704 Dangerous simplification rules are written to check this variable
33705 before taking any action.
33708 @defun simplify-units expr
33709 Simplify the expression @var{expr}, treating variable names as units
33710 whenever possible. This works by binding the variable
33711 @code{math-simplifying-units} to @code{t} while calling @code{simplify}.
33714 @defmac math-defsimplify funcs body
33715 Register a new simplification rule; this is normally called as a top-level
33716 form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol
33717 (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
33718 applied to the formulas which are calls to the specified function. Or,
33719 @var{funcs} can be a list of such symbols; the rule applies to all
33720 functions on the list. The @var{body} is written like the body of a
33721 function with a single argument called @code{expr}. The body will be
33722 executed with @code{expr} bound to a formula which is a call to one of
33723 the functions @var{funcs}. If the function body returns @code{nil}, or
33724 if it returns a result @code{equal} to the original @code{expr}, it is
33725 ignored and Calc goes on to try the next simplification rule that applies.
33726 If the function body returns something different, that new formula is
33727 substituted for @var{expr} in the original formula.
33729 At each point in the formula, rules are tried in the order of the
33730 original calls to @code{math-defsimplify}; the search stops after the
33731 first rule that makes a change. Thus later rules for that same
33732 function will not have a chance to trigger until the next iteration
33733 of the main @code{simplify} loop.
33735 Note that, since @code{defmath} is not being used here, @var{body} must
33736 be written in true Lisp code without the conveniences that @code{defmath}
33737 provides. If you prefer, you can have @var{body} simply call another
33738 function (defined with @code{defmath}) which does the real work.
33740 The arguments of a function call will already have been simplified
33741 before any rules for the call itself are invoked. Since a new argument
33742 list is consed up when this happens, this means that the rule's body is
33743 allowed to rearrange the function's arguments destructively if that is
33744 convenient. Here is a typical example of a simplification rule:
33747 (math-defsimplify calcFunc-arcsinh
33748 (or (and (math-looks-negp (nth 1 expr))
33749 (math-neg (list 'calcFunc-arcsinh
33750 (math-neg (nth 1 expr)))))
33751 (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
33752 (or math-living-dangerously
33753 (math-known-realp (nth 1 (nth 1 expr))))
33754 (nth 1 (nth 1 expr)))))
33757 This is really a pair of rules written with one @code{math-defsimplify}
33758 for convenience; the first replaces @samp{arcsinh(-x)} with
33759 @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
33760 replaces @samp{arcsinh(sinh(x))} with @samp{x}.
33763 @defun common-constant-factor expr
33764 Check @var{expr} to see if it is a sum of terms all multiplied by the
33765 same rational value. If so, return this value. If not, return @code{nil}.
33766 For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
33767 3 is a common factor of all the terms.
33770 @defun cancel-common-factor expr factor
33771 Assuming @var{expr} is a sum with @var{factor} as a common factor,
33772 divide each term of the sum by @var{factor}. This is done by
33773 destructively modifying parts of @var{expr}, on the assumption that
33774 it is being used by a simplification rule (where such things are
33775 allowed; see above). For example, consider this built-in rule for
33779 (math-defsimplify calcFunc-sqrt
33780 (let ((fac (math-common-constant-factor (nth 1 expr))))
33781 (and fac (not (eq fac 1))
33782 (math-mul (math-normalize (list 'calcFunc-sqrt fac))
33784 (list 'calcFunc-sqrt
33785 (math-cancel-common-factor
33786 (nth 1 expr) fac)))))))
33790 @defun frac-gcd a b
33791 Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
33792 rational numbers. This is the fraction composed of the GCD of the
33793 numerators of @var{a} and @var{b}, over the GCD of the denominators.
33794 It is used by @code{common-constant-factor}. Note that the standard
33795 @code{gcd} function uses the LCM to combine the denominators.
33798 @defun map-tree func expr many
33799 Try applying Lisp function @var{func} to various sub-expressions of
33800 @var{expr}. Initially, call @var{func} with @var{expr} itself as an
33801 argument. If this returns an expression which is not @code{equal} to
33802 @var{expr}, apply @var{func} again until eventually it does return
33803 @var{expr} with no changes. Then, if @var{expr} is a function call,
33804 recursively apply @var{func} to each of the arguments. This keeps going
33805 until no changes occur anywhere in the expression; this final expression
33806 is returned by @code{map-tree}. Note that, unlike simplification rules,
33807 @var{func} functions may @emph{not} make destructive changes to
33808 @var{expr}. If a third argument @var{many} is provided, it is an
33809 integer which says how many times @var{func} may be applied; the
33810 default, as described above, is infinitely many times.
33813 @defun compile-rewrites rules
33814 Compile the rewrite rule set specified by @var{rules}, which should
33815 be a formula that is either a vector or a variable name. If the latter,
33816 the compiled rules are saved so that later @code{compile-rules} calls
33817 for that same variable can return immediately. If there are problems
33818 with the rules, this function calls @code{error} with a suitable
33822 @defun apply-rewrites expr crules heads
33823 Apply the compiled rewrite rule set @var{crules} to the expression
33824 @var{expr}. This will make only one rewrite and only checks at the
33825 top level of the expression. The result @code{nil} if no rules
33826 matched, or if the only rules that matched did not actually change
33827 the expression. The @var{heads} argument is optional; if is given,
33828 it should be a list of all function names that (may) appear in
33829 @var{expr}. The rewrite compiler tags each rule with the
33830 rarest-looking function name in the rule; if you specify @var{heads},
33831 @code{apply-rewrites} can use this information to narrow its search
33832 down to just a few rules in the rule set.
33835 @defun rewrite-heads expr
33836 Compute a @var{heads} list for @var{expr} suitable for use with
33837 @code{apply-rewrites}, as discussed above.
33840 @defun rewrite expr rules many
33841 This is an all-in-one rewrite function. It compiles the rule set
33842 specified by @var{rules}, then uses @code{map-tree} to apply the
33843 rules throughout @var{expr} up to @var{many} (default infinity)
33847 @defun match-patterns pat vec not-flag
33848 Given a Calc vector @var{vec} and an uncompiled pattern set or
33849 pattern set variable @var{pat}, this function returns a new vector
33850 of all elements of @var{vec} which do (or don't, if @var{not-flag} is
33851 non-@code{nil}) match any of the patterns in @var{pat}.
33854 @defun deriv expr var value symb
33855 Compute the derivative of @var{expr} with respect to variable @var{var}
33856 (which may actually be any sub-expression). If @var{value} is specified,
33857 the derivative is evaluated at the value of @var{var}; otherwise, the
33858 derivative is left in terms of @var{var}. If the expression contains
33859 functions for which no derivative formula is known, new derivative
33860 functions are invented by adding primes to the names; @pxref{Calculus}.
33861 However, if @var{symb} is non-@code{nil}, the presence of undifferentiable
33862 functions in @var{expr} instead cancels the whole differentiation, and
33863 @code{deriv} returns @code{nil} instead.
33865 Derivatives of an @var{n}-argument function can be defined by
33866 adding a @code{math-derivative-@var{n}} property to the property list
33867 of the symbol for the function's derivative, which will be the
33868 function name followed by an apostrophe. The value of the property
33869 should be a Lisp function; it is called with the same arguments as the
33870 original function call that is being differentiated. It should return
33871 a formula for the derivative. For example, the derivative of @code{ln}
33875 (put 'calcFunc-ln\' 'math-derivative-1
33876 (function (lambda (u) (math-div 1 u))))
33879 The two-argument @code{log} function has two derivatives,
33881 (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx
33882 (function (lambda (x b) ... )))
33883 (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db
33884 (function (lambda (x b) ... )))
33888 @defun tderiv expr var value symb
33889 Compute the total derivative of @var{expr}. This is the same as
33890 @code{deriv}, except that variables other than @var{var} are not
33891 assumed to be constant with respect to @var{var}.
33894 @defun integ expr var low high
33895 Compute the integral of @var{expr} with respect to @var{var}.
33896 @xref{Calculus}, for further details.
33899 @defmac math-defintegral funcs body
33900 Define a rule for integrating a function or functions of one argument;
33901 this macro is very similar in format to @code{math-defsimplify}.
33902 The main difference is that here @var{body} is the body of a function
33903 with a single argument @code{u} which is bound to the argument to the
33904 function being integrated, not the function call itself. Also, the
33905 variable of integration is available as @code{math-integ-var}. If
33906 evaluation of the integral requires doing further integrals, the body
33907 should call @samp{(math-integral @var{x})} to find the integral of
33908 @var{x} with respect to @code{math-integ-var}; this function returns
33909 @code{nil} if the integral could not be done. Some examples:
33912 (math-defintegral calcFunc-conj
33913 (let ((int (math-integral u)))
33915 (list 'calcFunc-conj int))))
33917 (math-defintegral calcFunc-cos
33918 (and (equal u math-integ-var)
33919 (math-from-radians-2 (list 'calcFunc-sin u))))
33922 In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
33923 relying on the general integration-by-substitution facility to handle
33924 cosines of more complicated arguments. An integration rule should return
33925 @code{nil} if it can't do the integral; if several rules are defined for
33926 the same function, they are tried in order until one returns a non-@code{nil}
33930 @defmac math-defintegral-2 funcs body
33931 Define a rule for integrating a function or functions of two arguments.
33932 This is exactly analogous to @code{math-defintegral}, except that @var{body}
33933 is written as the body of a function with two arguments, @var{u} and
33937 @defun solve-for lhs rhs var full
33938 Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
33939 the variable @var{var} on the lefthand side; return the resulting righthand
33940 side, or @code{nil} if the equation cannot be solved. The variable
33941 @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that
33942 the return value is a formula which does not contain @var{var}; this is
33943 different from the user-level @code{solve} and @code{finv} functions,
33944 which return a rearranged equation or a functional inverse, respectively.
33945 If @var{full} is non-@code{nil}, a full solution including dummy signs
33946 and dummy integers will be produced. User-defined inverses are provided
33947 as properties in a manner similar to derivatives:
33950 (put 'calcFunc-ln 'math-inverse
33951 (function (lambda (x) (list 'calcFunc-exp x))))
33954 This function can call @samp{(math-solve-get-sign @var{x})} to create
33955 a new arbitrary sign variable, returning @var{x} times that sign, and
33956 @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
33957 variable multiplied by @var{x}. These functions simply return @var{x}
33958 if the caller requested a non-``full'' solution.
33961 @defun solve-eqn expr var full
33962 This version of @code{solve-for} takes an expression which will
33963 typically be an equation or inequality. (If it is not, it will be
33964 interpreted as the equation @samp{@var{expr} = 0}.) It returns an
33965 equation or inequality, or @code{nil} if no solution could be found.
33968 @defun solve-system exprs vars full
33969 This function solves a system of equations. Generally, @var{exprs}
33970 and @var{vars} will be vectors of equal length.
33971 @xref{Solving Systems of Equations}, for other options.
33974 @defun expr-contains expr var
33975 Returns a non-@code{nil} value if @var{var} occurs as a subexpression
33978 This function might seem at first to be identical to
33979 @code{calc-find-sub-formula}. The key difference is that
33980 @code{expr-contains} uses @code{equal} to test for matches, whereas
33981 @code{calc-find-sub-formula} uses @code{eq}. In the formula
33982 @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
33983 @code{eq} to each other.
33986 @defun expr-contains-count expr var
33987 Returns the number of occurrences of @var{var} as a subexpression
33988 of @var{expr}, or @code{nil} if there are no occurrences.
33991 @defun expr-depends expr var
33992 Returns true if @var{expr} refers to any variable the occurs in @var{var}.
33993 In other words, it checks if @var{expr} and @var{var} have any variables
33997 @defun expr-contains-vars expr
33998 Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
33999 contains only constants and functions with constant arguments.
34002 @defun expr-subst expr old new
34003 Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
34004 by @var{new}. This treats @code{lambda} forms specially with respect
34005 to the dummy argument variables, so that the effect is always to return
34006 @var{expr} evaluated at @var{old} = @var{new}.
34009 @defun multi-subst expr old new
34010 This is like @code{expr-subst}, except that @var{old} and @var{new}
34011 are lists of expressions to be substituted simultaneously. If one
34012 list is shorter than the other, trailing elements of the longer list
34016 @defun expr-weight expr
34017 Returns the ``weight'' of @var{expr}, basically a count of the total
34018 number of objects and function calls that appear in @var{expr}. For
34019 ``primitive'' objects, this will be one.
34022 @defun expr-height expr
34023 Returns the ``height'' of @var{expr}, which is the deepest level to
34024 which function calls are nested. (Note that @samp{@var{a} + @var{b}}
34025 counts as a function call.) For primitive objects, this returns zero.
34028 @defun polynomial-p expr var
34029 Check if @var{expr} is a polynomial in variable (or sub-expression)
34030 @var{var}. If so, return the degree of the polynomial, that is, the
34031 highest power of @var{var} that appears in @var{expr}. For example,
34032 for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns
34033 @code{nil} unless @var{expr}, when expanded out by @kbd{a x}
34034 (@code{calc-expand}), would consist of a sum of terms in which @var{var}
34035 appears only raised to nonnegative integer powers. Note that if
34036 @var{var} does not occur in @var{expr}, then @var{expr} is considered
34037 a polynomial of degree 0.
34040 @defun is-polynomial expr var degree loose
34041 Check if @var{expr} is a polynomial in variable or sub-expression
34042 @var{var}, and, if so, return a list representation of the polynomial
34043 where the elements of the list are coefficients of successive powers of
34044 @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
34045 list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
34046 produce the list @samp{(1 2 1)}. The highest element of the list will
34047 be non-zero, with the special exception that if @var{expr} is the
34048 constant zero, the returned value will be @samp{(0)}. Return @code{nil}
34049 if @var{expr} is not a polynomial in @var{var}. If @var{degree} is
34050 specified, this will not consider polynomials of degree higher than that
34051 value. This is a good precaution because otherwise an input of
34052 @samp{(x+1)^1000} will cause a huge coefficient list to be built. If
34053 @var{loose} is non-@code{nil}, then a looser definition of a polynomial
34054 is used in which coefficients are no longer required not to depend on
34055 @var{var}, but are only required not to take the form of polynomials
34056 themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose
34057 polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
34058 x))}. The result will never be @code{nil} in loose mode, since any
34059 expression can be interpreted as a ``constant'' loose polynomial.
34062 @defun polynomial-base expr pred
34063 Check if @var{expr} is a polynomial in any variable that occurs in it;
34064 if so, return that variable. (If @var{expr} is a multivariate polynomial,
34065 this chooses one variable arbitrarily.) If @var{pred} is specified, it should
34066 be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
34067 and which should return true if @code{mpb-top-expr} (a global name for
34068 the original @var{expr}) is a suitable polynomial in @var{subexpr}.
34069 The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
34070 you can use @var{pred} to specify additional conditions. Or, you could
34071 have @var{pred} build up a list of every suitable @var{subexpr} that
34075 @defun poly-simplify poly
34076 Simplify polynomial coefficient list @var{poly} by (destructively)
34077 clipping off trailing zeros.
34080 @defun poly-mix a ac b bc
34081 Mix two polynomial lists @var{a} and @var{b} (in the form returned by
34082 @code{is-polynomial}) in a linear combination with coefficient expressions
34083 @var{ac} and @var{bc}. The result is a (not necessarily simplified)
34084 polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.
34087 @defun poly-mul a b
34088 Multiply two polynomial coefficient lists @var{a} and @var{b}. The
34089 result will be in simplified form if the inputs were simplified.
34092 @defun build-polynomial-expr poly var
34093 Construct a Calc formula which represents the polynomial coefficient
34094 list @var{poly} applied to variable @var{var}. The @kbd{a c}
34095 (@code{calc-collect}) command uses @code{is-polynomial} to turn an
34096 expression into a coefficient list, then @code{build-polynomial-expr}
34097 to turn the list back into an expression in regular form.
34100 @defun check-unit-name var
34101 Check if @var{var} is a variable which can be interpreted as a unit
34102 name. If so, return the units table entry for that unit. This
34103 will be a list whose first element is the unit name (not counting
34104 prefix characters) as a symbol and whose second element is the
34105 Calc expression which defines the unit. (Refer to the Calc sources
34106 for details on the remaining elements of this list.) If @var{var}
34107 is not a variable or is not a unit name, return @code{nil}.
34110 @defun units-in-expr-p expr sub-exprs
34111 Return true if @var{expr} contains any variables which can be
34112 interpreted as units. If @var{sub-exprs} is @code{t}, the entire
34113 expression is searched. If @var{sub-exprs} is @code{nil}, this
34114 checks whether @var{expr} is directly a units expression.
34117 @defun single-units-in-expr-p expr
34118 Check whether @var{expr} contains exactly one units variable. If so,
34119 return the units table entry for the variable. If @var{expr} does
34120 not contain any units, return @code{nil}. If @var{expr} contains
34121 two or more units, return the symbol @code{wrong}.
34124 @defun to-standard-units expr which
34125 Convert units expression @var{expr} to base units. If @var{which}
34126 is @code{nil}, use Calc's native base units. Otherwise, @var{which}
34127 can specify a units system, which is a list of two-element lists,
34128 where the first element is a Calc base symbol name and the second
34129 is an expression to substitute for it.
34132 @defun remove-units expr
34133 Return a copy of @var{expr} with all units variables replaced by ones.
34134 This expression is generally normalized before use.
34137 @defun extract-units expr
34138 Return a copy of @var{expr} with everything but units variables replaced
34142 @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
34143 @subsubsection I/O and Formatting Functions
34146 The functions described here are responsible for parsing and formatting
34147 Calc numbers and formulas.
34149 @defun calc-eval str sep arg1 arg2 @dots{}
34150 This is the simplest interface to the Calculator from another Lisp program.
34151 @xref{Calling Calc from Your Programs}.
34154 @defun read-number str
34155 If string @var{str} contains a valid Calc number, either integer,
34156 fraction, float, or HMS form, this function parses and returns that
34157 number. Otherwise, it returns @code{nil}.
34160 @defun read-expr str
34161 Read an algebraic expression from string @var{str}. If @var{str} does
34162 not have the form of a valid expression, return a list of the form
34163 @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
34164 into @var{str} of the general location of the error, and @var{msg} is
34165 a string describing the problem.
34168 @defun read-exprs str
34169 Read a list of expressions separated by commas, and return it as a
34170 Lisp list. If an error occurs in any expressions, an error list as
34171 shown above is returned instead.
34174 @defun calc-do-alg-entry initial prompt no-norm
34175 Read an algebraic formula or formulas using the minibuffer. All
34176 conventions of regular algebraic entry are observed. The return value
34177 is a list of Calc formulas; there will be more than one if the user
34178 entered a list of values separated by commas. The result is @code{nil}
34179 if the user presses Return with a blank line. If @var{initial} is
34180 given, it is a string which the minibuffer will initially contain.
34181 If @var{prompt} is given, it is the prompt string to use; the default
34182 is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will
34183 be returned exactly as parsed; otherwise, they will be passed through
34184 @code{calc-normalize} first.
34186 To support the use of @kbd{$} characters in the algebraic entry, use
34187 @code{let} to bind @code{calc-dollar-values} to a list of the values
34188 to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
34189 @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used}
34190 will have been changed to the highest number of consecutive @kbd{$}s
34191 that actually appeared in the input.
34194 @defun format-number a
34195 Convert the real or complex number or HMS form @var{a} to string form.
34198 @defun format-flat-expr a prec
34199 Convert the arbitrary Calc number or formula @var{a} to string form,
34200 in the style used by the trail buffer and the @code{calc-edit} command.
34201 This is a simple format designed
34202 mostly to guarantee the string is of a form that can be re-parsed by
34203 @code{read-expr}. Most formatting modes, such as digit grouping,
34204 complex number format, and point character, are ignored to ensure the
34205 result will be re-readable. The @var{prec} parameter is normally 0; if
34206 you pass a large integer like 1000 instead, the expression will be
34207 surrounded by parentheses unless it is a plain number or variable name.
34210 @defun format-nice-expr a width
34211 This is like @code{format-flat-expr} (with @var{prec} equal to 0),
34212 except that newlines will be inserted to keep lines down to the
34213 specified @var{width}, and vectors that look like matrices or rewrite
34214 rules are written in a pseudo-matrix format. The @code{calc-edit}
34215 command uses this when only one stack entry is being edited.
34218 @defun format-value a width
34219 Convert the Calc number or formula @var{a} to string form, using the
34220 format seen in the stack buffer. Beware the string returned may
34221 not be re-readable by @code{read-expr}, for example, because of digit
34222 grouping. Multi-line objects like matrices produce strings that
34223 contain newline characters to separate the lines. The @var{w}
34224 parameter, if given, is the target window size for which to format
34225 the expressions. If @var{w} is omitted, the width of the Calculator
34229 @defun compose-expr a prec
34230 Format the Calc number or formula @var{a} according to the current
34231 language mode, returning a ``composition.'' To learn about the
34232 structure of compositions, see the comments in the Calc source code.
34233 You can specify the format of a given type of function call by putting
34234 a @code{math-compose-@var{lang}} property on the function's symbol,
34235 whose value is a Lisp function that takes @var{a} and @var{prec} as
34236 arguments and returns a composition. Here @var{lang} is a language
34237 mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
34238 @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
34239 In Big mode, Calc actually tries @code{math-compose-big} first, then
34240 tries @code{math-compose-normal}. If this property does not exist,
34241 or if the function returns @code{nil}, the function is written in the
34242 normal function-call notation for that language.
34245 @defun composition-to-string c w
34246 Convert a composition structure returned by @code{compose-expr} into
34247 a string. Multi-line compositions convert to strings containing
34248 newline characters. The target window size is given by @var{w}.
34249 The @code{format-value} function basically calls @code{compose-expr}
34250 followed by @code{composition-to-string}.
34253 @defun comp-width c
34254 Compute the width in characters of composition @var{c}.
34257 @defun comp-height c
34258 Compute the height in lines of composition @var{c}.
34261 @defun comp-ascent c
34262 Compute the portion of the height of composition @var{c} which is on or
34263 above the baseline. For a one-line composition, this will be one.
34266 @defun comp-descent c
34267 Compute the portion of the height of composition @var{c} which is below
34268 the baseline. For a one-line composition, this will be zero.
34271 @defun comp-first-char c
34272 If composition @var{c} is a ``flat'' composition, return the first
34273 (leftmost) character of the composition as an integer. Otherwise,
34277 @defun comp-last-char c
34278 If composition @var{c} is a ``flat'' composition, return the last
34279 (rightmost) character, otherwise return @code{nil}.
34282 @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
34283 @comment @subsubsection Lisp Variables
34286 @comment (This section is currently unfinished.)
34288 @node Hooks, , Formatting Lisp Functions, Internals
34289 @subsubsection Hooks
34292 Hooks are variables which contain Lisp functions (or lists of functions)
34293 which are called at various times. Calc defines a number of hooks
34294 that help you to customize it in various ways. Calc uses the Lisp
34295 function @code{run-hooks} to invoke the hooks shown below. Several
34296 other customization-related variables are also described here.
34298 @defvar calc-load-hook
34299 This hook is called at the end of @file{calc.el}, after the file has
34300 been loaded, before any functions in it have been called, but after
34301 @code{calc-mode-map} and similar variables have been set up.
34304 @defvar calc-ext-load-hook
34305 This hook is called at the end of @file{calc-ext.el}.
34308 @defvar calc-start-hook
34309 This hook is called as the last step in a @kbd{M-x calc} command.
34310 At this point, the Calc buffer has been created and initialized if
34311 necessary, the Calc window and trail window have been created,
34312 and the ``Welcome to Calc'' message has been displayed.
34315 @defvar calc-mode-hook
34316 This hook is called when the Calc buffer is being created. Usually
34317 this will only happen once per Emacs session. The hook is called
34318 after Emacs has switched to the new buffer, the mode-settings file
34319 has been read if necessary, and all other buffer-local variables
34320 have been set up. After this hook returns, Calc will perform a
34321 @code{calc-refresh} operation, set up the mode line display, then
34322 evaluate any deferred @code{calc-define} properties that have not
34323 been evaluated yet.
34326 @defvar calc-trail-mode-hook
34327 This hook is called when the Calc Trail buffer is being created.
34328 It is called as the very last step of setting up the Trail buffer.
34329 Like @code{calc-mode-hook}, this will normally happen only once
34333 @defvar calc-end-hook
34334 This hook is called by @code{calc-quit}, generally because the user
34335 presses @kbd{q} or @kbd{M-# c} while in Calc. The Calc buffer will
34336 be the current buffer. The hook is called as the very first
34337 step, before the Calc window is destroyed.
34340 @defvar calc-window-hook
34341 If this hook exists, it is called to create the Calc window.
34342 Upon return, this new Calc window should be the current window.
34343 (The Calc buffer will already be the current buffer when the
34344 hook is called.) If the hook is not defined, Calc will
34345 generally use @code{split-window}, @code{set-window-buffer},
34346 and @code{select-window} to create the Calc window.
34349 @defvar calc-trail-window-hook
34350 If this hook exists, it is called to create the Calc Trail window.
34351 The variable @code{calc-trail-buffer} will contain the buffer
34352 which the window should use. Unlike @code{calc-window-hook},
34353 this hook must @emph{not} switch into the new window.
34356 @defvar calc-edit-mode-hook
34357 This hook is called by @code{calc-edit} (and the other ``edit''
34358 commands) when the temporary editing buffer is being created.
34359 The buffer will have been selected and set up to be in
34360 @code{calc-edit-mode}, but will not yet have been filled with
34361 text. (In fact it may still have leftover text from a previous
34362 @code{calc-edit} command.)
34365 @defvar calc-mode-save-hook
34366 This hook is called by the @code{calc-save-modes} command,
34367 after Calc's own mode features have been inserted into the
34368 Calc init file and just before the ``End of mode settings''
34369 message is inserted.
34372 @defvar calc-reset-hook
34373 This hook is called after @kbd{M-# 0} (@code{calc-reset}) has
34374 reset all modes. The Calc buffer will be the current buffer.
34377 @defvar calc-other-modes
34378 This variable contains a list of strings. The strings are
34379 concatenated at the end of the modes portion of the Calc
34380 mode line (after standard modes such as ``Deg'', ``Inv'' and
34381 ``Hyp''). Each string should be a short, single word followed
34382 by a space. The variable is @code{nil} by default.
34385 @defvar calc-mode-map
34386 This is the keymap that is used by Calc mode. The best time
34387 to adjust it is probably in a @code{calc-mode-hook}. If the
34388 Calc extensions package (@file{calc-ext.el}) has not yet been
34389 loaded, many of these keys will be bound to @code{calc-missing-key},
34390 which is a command that loads the extensions package and
34391 ``retypes'' the key. If your @code{calc-mode-hook} rebinds
34392 one of these keys, it will probably be overridden when the
34393 extensions are loaded.
34396 @defvar calc-digit-map
34397 This is the keymap that is used during numeric entry. Numeric
34398 entry uses the minibuffer, but this map binds every non-numeric
34399 key to @code{calcDigit-nondigit} which generally calls
34400 @code{exit-minibuffer} and ``retypes'' the key.
34403 @defvar calc-alg-ent-map
34404 This is the keymap that is used during algebraic entry. This is
34405 mostly a copy of @code{minibuffer-local-map}.
34408 @defvar calc-store-var-map
34409 This is the keymap that is used during entry of variable names for
34410 commands like @code{calc-store} and @code{calc-recall}. This is
34411 mostly a copy of @code{minibuffer-local-completion-map}.
34414 @defvar calc-edit-mode-map
34415 This is the (sparse) keymap used by @code{calc-edit} and other
34416 temporary editing commands. It binds @key{RET}, @key{LFD},
34417 and @kbd{C-c C-c} to @code{calc-edit-finish}.
34420 @defvar calc-mode-var-list
34421 This is a list of variables which are saved by @code{calc-save-modes}.
34422 Each entry is a list of two items, the variable (as a Lisp symbol)
34423 and its default value. When modes are being saved, each variable
34424 is compared with its default value (using @code{equal}) and any
34425 non-default variables are written out.
34428 @defvar calc-local-var-list
34429 This is a list of variables which should be buffer-local to the
34430 Calc buffer. Each entry is a variable name (as a Lisp symbol).
34431 These variables also have their default values manipulated by
34432 the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
34433 Since @code{calc-mode-hook} is called after this list has been
34434 used the first time, your hook should add a variable to the
34435 list and also call @code{make-local-variable} itself.
34438 @node Installation, Reporting Bugs, Programming, Top
34439 @appendix Installation
34442 As of Calc 2.02g, Calc is integrated with GNU Emacs, and thus requires
34443 no separate installation of its Lisp files and this manual.
34445 @appendixsec The GNUPLOT Program
34448 Calc's graphing commands use the GNUPLOT program. If you have GNUPLOT
34449 but you must type some command other than @file{gnuplot} to get it,
34450 you should add a command to set the Lisp variable @code{calc-gnuplot-name}
34451 to the appropriate file name. You may also need to change the variables
34452 @code{calc-gnuplot-plot-command} and @code{calc-gnuplot-print-command} in
34453 order to get correct displays and hardcopies, respectively, of your
34461 @appendixsec Printed Documentation
34464 Because the Calc manual is so large, you should only make a printed
34465 copy if you really need it. To print the manual, you will need the
34466 @TeX{} typesetting program (this is a free program by Donald Knuth
34467 at Stanford University) as well as the @file{texindex} program and
34468 @file{texinfo.tex} file, both of which can be obtained from the FSF
34469 as part of the @code{texinfo} package.
34471 To print the Calc manual in one huge 470 page tome, you will need the
34472 source code to this manual, @file{calc.texi}, available as part of the
34473 Emacs source. Once you have this file, type @kbd{texi2dvi calc.texi}.
34474 Alternatively, change to the @file{man} subdirectory of the Emacs
34475 source distribution, and type @kbd{make calc.dvi}. (Don't worry if you
34476 get some ``overfull box'' warnings while @TeX{} runs.)
34478 The result will be a device-independent output file called
34479 @file{calc.dvi}, which you must print in whatever way is right
34480 for your system. On many systems, the command is
34493 @c the bumpoddpages macro was deleted
34495 @cindex Marginal notes, adjusting
34496 Marginal notes for each function and key sequence normally alternate
34497 between the left and right sides of the page, which is correct if the
34498 manual is going to be bound as double-sided pages. Near the top of
34499 the file @file{calc.texi} you will find alternate definitions of
34500 the @code{\bumpoddpages} macro that put the marginal notes always on
34501 the same side, best if you plan to be binding single-sided pages.
34504 @appendixsec Settings File
34507 @vindex calc-settings-file
34508 Another variable you might want to set is @code{calc-settings-file},
34509 which holds the file name in which commands like @kbd{m m} and @kbd{Z P}
34510 store ``permanent'' definitions. The default value for this variable
34511 is @code{"~/.calc.el"}. If @code{calc-settings-file} is not your user
34512 init file (typically @file{~/.emacs}) and if the variable
34513 @code{calc-loaded-settings-file} is @code{nil}, then Calc will
34514 automatically load your settings file (if it exists) the first time
34522 @appendixsec Testing the Installation
34525 To test your installation of Calc, start a new Emacs and type @kbd{M-# c}
34526 to make sure the autoloads and key bindings work. Type @kbd{M-# i}
34527 to make sure Calc can find its Info documentation. Press @kbd{q} to
34528 exit the Info system and @kbd{M-# c} to re-enter the Calculator.
34529 Type @kbd{20 S} to compute the sine of 20 degrees; this will test the
34530 autoloading of the extensions modules. The result should be
34531 0.342020143326. Finally, press @kbd{M-# c} again to make sure the
34532 Calculator can exit.
34534 You may also wish to test the GNUPLOT interface; to plot a sine wave,
34535 type @kbd{' [0 ..@: 360], sin(x) @key{RET} g f}. Type @kbd{g q} when you
34536 are done viewing the plot.
34538 Calc is now ready to use. If you wish to go through the Calc Tutorial,
34539 press @kbd{M-# t} to begin.
34543 @node Reporting Bugs, Summary, Installation, Top
34544 @appendix Reporting Bugs
34547 If you find a bug in Calc, send e-mail to Jay Belanger,
34550 belanger@@truman.edu
34554 (In the following text, ``I'' refers to the original Calc author, Dave
34557 While I cannot guarantee that I will have time to work on your bug,
34558 I do try to fix bugs quickly whenever I can.
34560 The latest version of Calc is available from Savannah, in the Emacs
34561 CVS tree. See @uref{http://savannah.gnu.org/projects/emacs}.
34563 There is an automatic command @kbd{M-x report-calc-bug} which helps
34564 you to report bugs. This command prompts you for a brief subject
34565 line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to
34566 send your mail. Make sure your subject line indicates that you are
34567 reporting a Calc bug; this command sends mail to the maintainer's
34570 If you have suggestions for additional features for Calc, I would
34571 love to hear them. Some have dared to suggest that Calc is already
34572 top-heavy with features; I really don't see what they're talking
34573 about, so, if you have ideas, send them right in. (I may even have
34574 time to implement them!)
34576 At the front of the source file, @file{calc.el}, is a list of ideas for
34577 future work which I have not had time to do. If any enthusiastic souls
34578 wish to take it upon themselves to work on these, I would be delighted.
34579 Please let me know if you plan to contribute to Calc so I can coordinate
34580 your efforts with mine and those of others. I will do my best to help
34581 you in whatever way I can.
34584 @node Summary, Key Index, Reporting Bugs, Top
34585 @appendix Calc Summary
34588 This section includes a complete list of Calc 2.02 keystroke commands.
34589 Each line lists the stack entries used by the command (top-of-stack
34590 last), the keystrokes themselves, the prompts asked by the command,
34591 and the result of the command (also with top-of-stack last).
34592 The result is expressed using the equivalent algebraic function.
34593 Commands which put no results on the stack show the full @kbd{M-x}
34594 command name in that position. Numbers preceding the result or
34595 command name refer to notes at the end.
34597 Algebraic functions and @kbd{M-x} commands that don't have corresponding
34598 keystrokes are not listed in this summary.
34599 @xref{Command Index}. @xref{Function Index}.
34604 \vskip-2\baselineskip \null
34605 \gdef\sumrow#1{\sumrowx#1\relax}%
34606 \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
34609 \hbox to5em{\sl\hss#1}%
34610 \hbox to5em{\tt#2\hss}%
34611 \hbox to4em{\sl#3\hss}%
34612 \hbox to5em{\rm\hss#4}%
34617 \gdef\sumlpar{{\rm(}}%
34618 \gdef\sumrpar{{\rm)}}%
34619 \gdef\sumcomma{{\rm,\thinspace}}%
34620 \gdef\sumexcl{{\rm!}}%
34621 \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
34622 \gdef\minus#1{{\tt-}}%
34626 @catcode`@(=@active @let(=@sumlpar
34627 @catcode`@)=@active @let)=@sumrpar
34628 @catcode`@,=@active @let,=@sumcomma
34629 @catcode`@!=@active @let!=@sumexcl
34633 @advance@baselineskip-2.5pt
34636 @r{ @: M-# a @: @: 33 @:calc-embedded-activate@:}
34637 @r{ @: M-# b @: @: @:calc-big-or-small@:}
34638 @r{ @: M-# c @: @: @:calc@:}
34639 @r{ @: M-# d @: @: @:calc-embedded-duplicate@:}
34640 @r{ @: M-# e @: @: 34 @:calc-embedded@:}
34641 @r{ @: M-# f @:formula @: @:calc-embedded-new-formula@:}
34642 @r{ @: M-# g @: @: 35 @:calc-grab-region@:}
34643 @r{ @: M-# i @: @: @:calc-info@:}
34644 @r{ @: M-# j @: @: @:calc-embedded-select@:}
34645 @r{ @: M-# k @: @: @:calc-keypad@:}
34646 @r{ @: M-# l @: @: @:calc-load-everything@:}
34647 @r{ @: M-# m @: @: @:read-kbd-macro@:}
34648 @r{ @: M-# n @: @: 4 @:calc-embedded-next@:}
34649 @r{ @: M-# o @: @: @:calc-other-window@:}
34650 @r{ @: M-# p @: @: 4 @:calc-embedded-previous@:}
34651 @r{ @: M-# q @:formula @: @:quick-calc@:}
34652 @r{ @: M-# r @: @: 36 @:calc-grab-rectangle@:}
34653 @r{ @: M-# s @: @: @:calc-info-summary@:}
34654 @r{ @: M-# t @: @: @:calc-tutorial@:}
34655 @r{ @: M-# u @: @: @:calc-embedded-update@:}
34656 @r{ @: M-# w @: @: @:calc-embedded-word@:}
34657 @r{ @: M-# x @: @: @:calc-quit@:}
34658 @r{ @: M-# y @: @:1,28,49 @:calc-copy-to-buffer@:}
34659 @r{ @: M-# z @: @: @:calc-user-invocation@:}
34660 @r{ @: M-# : @: @: 36 @:calc-grab-sum-down@:}
34661 @r{ @: M-# _ @: @: 36 @:calc-grab-sum-across@:}
34662 @r{ @: M-# ` @:editing @: 30 @:calc-embedded-edit@:}
34663 @r{ @: M-# 0 @:(zero) @: @:calc-reset@:}
34666 @r{ @: 0-9 @:number @: @:@:number}
34667 @r{ @: . @:number @: @:@:0.number}
34668 @r{ @: _ @:number @: @:-@:number}
34669 @r{ @: e @:number @: @:@:1e number}
34670 @r{ @: # @:number @: @:@:current-radix@t{#}number}
34671 @r{ @: P @:(in number) @: @:+/-@:}
34672 @r{ @: M @:(in number) @: @:mod@:}
34673 @r{ @: @@ ' " @: (in number)@: @:@:HMS form}
34674 @r{ @: h m s @: (in number)@: @:@:HMS form}
34677 @r{ @: ' @:formula @: 37,46 @:@:formula}
34678 @r{ @: $ @:formula @: 37,46 @:$@:formula}
34679 @r{ @: " @:string @: 37,46 @:@:string}
34682 @r{ a b@: + @: @: 2 @:add@:(a,b) a+b}
34683 @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b}
34684 @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b}
34685 @r{ a b@: / @: @: 2 @:div@:(a,b) a/b}
34686 @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b}
34687 @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)}
34688 @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b}
34689 @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b}
34690 @r{ a b@: : @: @: 2 @:fdiv@:(a,b)}
34691 @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b}
34692 @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a}
34693 @r{ a b@: H | @: @: 2 @:append@:(a,b)}
34694 @r{ a b@: I H | @: @: @:append@:(b,a)}
34695 @r{ a@: & @: @: 1 @:inv@:(a) 1/a}
34696 @r{ a@: ! @: @: 1 @:fact@:(a) a!}
34697 @r{ a@: = @: @: 1 @:evalv@:(a)}
34698 @r{ a@: M-% @: @: @:percent@:(a) a%}
34701 @r{ ... a@: @key{RET} @: @: 1 @:@:... a a}
34702 @r{ ... a@: @key{SPC} @: @: 1 @:@:... a a}
34703 @r{... a b@: @key{TAB} @: @: 3 @:@:... b a}
34704 @r{. a b c@: M-@key{TAB} @: @: 3 @:@:... b c a}
34705 @r{... a b@: @key{LFD} @: @: 1 @:@:... a b a}
34706 @r{ ... a@: @key{DEL} @: @: 1 @:@:...}
34707 @r{... a b@: M-@key{DEL} @: @: 1 @:@:... b}
34708 @r{ @: M-@key{RET} @: @: 4 @:calc-last-args@:}
34709 @r{ a@: ` @:editing @: 1,30 @:calc-edit@:}
34712 @r{ ... a@: C-d @: @: 1 @:@:...}
34713 @r{ @: C-k @: @: 27 @:calc-kill@:}
34714 @r{ @: C-w @: @: 27 @:calc-kill-region@:}
34715 @r{ @: C-y @: @: @:calc-yank@:}
34716 @r{ @: C-_ @: @: 4 @:calc-undo@:}
34717 @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:}
34718 @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:}
34721 @r{ @: [ @: @: @:@:[...}
34722 @r{[.. a b@: ] @: @: @:@:[a,b]}
34723 @r{ @: ( @: @: @:@:(...}
34724 @r{(.. a b@: ) @: @: @:@:(a,b)}
34725 @r{ @: , @: @: @:@:vector or rect complex}
34726 @r{ @: ; @: @: @:@:matrix or polar complex}
34727 @r{ @: .. @: @: @:@:interval}
34730 @r{ @: ~ @: @: @:calc-num-prefix@:}
34731 @r{ @: < @: @: 4 @:calc-scroll-left@:}
34732 @r{ @: > @: @: 4 @:calc-scroll-right@:}
34733 @r{ @: @{ @: @: 4 @:calc-scroll-down@:}
34734 @r{ @: @} @: @: 4 @:calc-scroll-up@:}
34735 @r{ @: ? @: @: @:calc-help@:}
34738 @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a}
34739 @r{ @: o @: @: 4 @:calc-realign@:}
34740 @r{ @: p @:precision @: 31 @:calc-precision@:}
34741 @r{ @: q @: @: @:calc-quit@:}
34742 @r{ @: w @: @: @:calc-why@:}
34743 @r{ @: x @:command @: @:M-x calc-@:command}
34744 @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:}
34747 @r{ a@: A @: @: 1 @:abs@:(a)}
34748 @r{ a b@: B @: @: 2 @:log@:(a,b)}
34749 @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a}
34750 @r{ a@: C @: @: 1 @:cos@:(a)}
34751 @r{ a@: I C @: @: 1 @:arccos@:(a)}
34752 @r{ a@: H C @: @: 1 @:cosh@:(a)}
34753 @r{ a@: I H C @: @: 1 @:arccosh@:(a)}
34754 @r{ @: D @: @: 4 @:calc-redo@:}
34755 @r{ a@: E @: @: 1 @:exp@:(a)}
34756 @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a}
34757 @r{ a@: F @: @: 1,11 @:floor@:(a,d)}
34758 @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)}
34759 @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)}
34760 @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)}
34761 @r{ a@: G @: @: 1 @:arg@:(a)}
34762 @r{ @: H @:command @: 32 @:@:Hyperbolic}
34763 @r{ @: I @:command @: 32 @:@:Inverse}
34764 @r{ a@: J @: @: 1 @:conj@:(a)}
34765 @r{ @: K @:command @: 32 @:@:Keep-args}
34766 @r{ a@: L @: @: 1 @:ln@:(a)}
34767 @r{ a@: H L @: @: 1 @:log10@:(a)}
34768 @r{ @: M @: @: @:calc-more-recursion-depth@:}
34769 @r{ @: I M @: @: @:calc-less-recursion-depth@:}
34770 @r{ a@: N @: @: 5 @:evalvn@:(a)}
34771 @r{ @: P @: @: @:@:pi}
34772 @r{ @: I P @: @: @:@:gamma}
34773 @r{ @: H P @: @: @:@:e}
34774 @r{ @: I H P @: @: @:@:phi}
34775 @r{ a@: Q @: @: 1 @:sqrt@:(a)}
34776 @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2}
34777 @r{ a@: R @: @: 1,11 @:round@:(a,d)}
34778 @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)}
34779 @r{ a@: H R @: @: 1,11 @:fround@:(a,d)}
34780 @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)}
34781 @r{ a@: S @: @: 1 @:sin@:(a)}
34782 @r{ a@: I S @: @: 1 @:arcsin@:(a)}
34783 @r{ a@: H S @: @: 1 @:sinh@:(a)}
34784 @r{ a@: I H S @: @: 1 @:arcsinh@:(a)}
34785 @r{ a@: T @: @: 1 @:tan@:(a)}
34786 @r{ a@: I T @: @: 1 @:arctan@:(a)}
34787 @r{ a@: H T @: @: 1 @:tanh@:(a)}
34788 @r{ a@: I H T @: @: 1 @:arctanh@:(a)}
34789 @r{ @: U @: @: 4 @:calc-undo@:}
34790 @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:}
34793 @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b}
34794 @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b}
34795 @r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b}
34796 @r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b}
34797 @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b}
34798 @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b}
34799 @r{ a b@: a @{ @: @: 2 @:in@:(a,b)}
34800 @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b}
34801 @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b}
34802 @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a}
34803 @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c}
34804 @r{ a@: a . @: @: 1 @:rmeq@:(a)}
34805 @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:}
34808 @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)}
34809 @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)}
34810 @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)}
34811 @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b}
34814 @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)}
34815 @r{ a b@: a % @: @: 2 @:prem@:(a,b)}
34816 @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]}
34817 @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b}
34820 @r{ a@: a a @: @: 1 @:apart@:(a)}
34821 @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)}
34822 @r{ a@: a c @:v @: 38 @:collect@:(a,v)}
34823 @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)}
34824 @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)}
34825 @r{ a@: a e @: @: @:esimplify@:(a)}
34826 @r{ a@: a f @: @: 1 @:factor@:(a)}
34827 @r{ a@: H a f @: @: 1 @:factors@:(a)}
34828 @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)}
34829 @r{ a@: a i @:v @: 38 @:integ@:(a,v)}
34830 @r{ a@: a m @:pats @: 38 @:match@:(a,pats)}
34831 @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)}
34832 @r{ data x@: a p @: @: 28 @:polint@:(data,x)}
34833 @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)}
34834 @r{ a@: a n @: @: 1 @:nrat@:(a)}
34835 @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)}
34836 @r{ a@: a s @: @: @:simplify@:(a)}
34837 @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)}
34838 @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:}
34839 @r{ a@: a x @: @: 4,8 @:expand@:(a)}
34842 @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)}
34843 @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)}
34844 @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)}
34845 @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)}
34846 @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)}
34847 @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)}
34848 @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)}
34849 @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)}
34850 @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)}
34851 @r{ a@: a P @:v @: 38 @:roots@:(a,v)}
34852 @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)}
34853 @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)}
34854 @r{ a@: a S @:v @: 38 @:solve@:(a,v)}
34855 @r{ a@: I a S @:v @: 38 @:finv@:(a,v)}
34856 @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)}
34857 @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)}
34858 @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)}
34859 @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)}
34860 @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)}
34863 @r{ a b@: b a @: @: 9 @:and@:(a,b,w)}
34864 @r{ a@: b c @: @: 9 @:clip@:(a,w)}
34865 @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)}
34866 @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)}
34867 @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)}
34868 @r{ a@: b n @: @: 9 @:not@:(a,w)}
34869 @r{ a b@: b o @: @: 9 @:or@:(a,b,w)}
34870 @r{ v@: b p @: @: 1 @:vpack@:(v)}
34871 @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)}
34872 @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)}
34873 @r{ a@: b t @: @: 10 @:rot@:(a,n,w)}
34874 @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)}
34875 @r{ a@: b u @: @: 1 @:vunpack@:(a)}
34876 @r{ @: b w @:w @: 9,50 @:calc-word-size@:}
34877 @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)}
34880 @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)}
34881 @r{ r n p@: b F @: @: @:fv@:(r,n,p)}
34882 @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)}
34883 @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)}
34884 @r{ v@: b I @: @: 19 @:irr@:(v)}
34885 @r{ v@: I b I @: @: 19 @:irrb@:(v)}
34886 @r{ a@: b L @: @: 10 @:ash@:(a,n,w)}
34887 @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)}
34888 @r{ r n a@: b M @: @: @:pmt@:(r,n,a)}
34889 @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)}
34890 @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)}
34891 @r{ r v@: b N @: @: 19 @:npv@:(r,v)}
34892 @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)}
34893 @r{ r n p@: b P @: @: @:pv@:(r,n,p)}
34894 @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)}
34895 @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)}
34896 @r{ a@: b R @: @: 10 @:rash@:(a,n,w)}
34897 @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)}
34898 @r{ c s l@: b S @: @: @:sln@:(c,s,l)}
34899 @r{ n p a@: b T @: @: @:rate@:(n,p,a)}
34900 @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)}
34901 @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)}
34902 @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)}
34904 @r{ r p a@: b # @: @: @:nper@:(r,p,a)}
34905 @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)}
34906 @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)}
34907 @r{ a b@: b % @: @: @:relch@:(a,b)}
34910 @r{ a@: c c @: @: 5 @:pclean@:(a,p)}
34911 @r{ a@: c 0-9 @: @: @:pclean@:(a,p)}
34912 @r{ a@: H c c @: @: 5 @:clean@:(a,p)}
34913 @r{ a@: H c 0-9 @: @: @:clean@:(a,p)}
34914 @r{ a@: c d @: @: 1 @:deg@:(a)}
34915 @r{ a@: c f @: @: 1 @:pfloat@:(a)}
34916 @r{ a@: H c f @: @: 1 @:float@:(a)}
34917 @r{ a@: c h @: @: 1 @:hms@:(a)}
34918 @r{ a@: c p @: @: @:polar@:(a)}
34919 @r{ a@: I c p @: @: @:rect@:(a)}
34920 @r{ a@: c r @: @: 1 @:rad@:(a)}
34923 @r{ a@: c F @: @: 5 @:pfrac@:(a,p)}
34924 @r{ a@: H c F @: @: 5 @:frac@:(a,p)}
34927 @r{ a@: c % @: @: @:percent@:(a*100)}
34930 @r{ @: d . @:char @: 50 @:calc-point-char@:}
34931 @r{ @: d , @:char @: 50 @:calc-group-char@:}
34932 @r{ @: d < @: @: 13,50 @:calc-left-justify@:}
34933 @r{ @: d = @: @: 13,50 @:calc-center-justify@:}
34934 @r{ @: d > @: @: 13,50 @:calc-right-justify@:}
34935 @r{ @: d @{ @:label @: 50 @:calc-left-label@:}
34936 @r{ @: d @} @:label @: 50 @:calc-right-label@:}
34937 @r{ @: d [ @: @: 4 @:calc-truncate-up@:}
34938 @r{ @: d ] @: @: 4 @:calc-truncate-down@:}
34939 @r{ @: d " @: @: 12,50 @:calc-display-strings@:}
34940 @r{ @: d @key{SPC} @: @: @:calc-refresh@:}
34941 @r{ @: d @key{RET} @: @: 1 @:calc-refresh-top@:}
34944 @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:}
34945 @r{ @: d 2 @: @: 50 @:calc-binary-radix@:}
34946 @r{ @: d 6 @: @: 50 @:calc-hex-radix@:}
34947 @r{ @: d 8 @: @: 50 @:calc-octal-radix@:}
34950 @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:}
34951 @r{ @: d c @: @: 50 @:calc-complex-notation@:}
34952 @r{ @: d d @:format @: 50 @:calc-date-notation@:}
34953 @r{ @: d e @: @: 5,50 @:calc-eng-notation@:}
34954 @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:}
34955 @r{ @: d g @: @:12,13,50 @:calc-group-digits@:}
34956 @r{ @: d h @:format @: 50 @:calc-hms-notation@:}
34957 @r{ @: d i @: @: 50 @:calc-i-notation@:}
34958 @r{ @: d j @: @: 50 @:calc-j-notation@:}
34959 @r{ @: d l @: @: 12,50 @:calc-line-numbering@:}
34960 @r{ @: d n @: @: 5,50 @:calc-normal-notation@:}
34961 @r{ @: d o @:format @: 50 @:calc-over-notation@:}
34962 @r{ @: d p @: @: 12,50 @:calc-show-plain@:}
34963 @r{ @: d r @:radix @: 31,50 @:calc-radix@:}
34964 @r{ @: d s @: @: 5,50 @:calc-sci-notation@:}
34965 @r{ @: d t @: @: 27 @:calc-truncate-stack@:}
34966 @r{ @: d w @: @: 12,13 @:calc-auto-why@:}
34967 @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:}
34970 @r{ @: d B @: @: 50 @:calc-big-language@:}
34971 @r{ @: d C @: @: 50 @:calc-c-language@:}
34972 @r{ @: d E @: @: 50 @:calc-eqn-language@:}
34973 @r{ @: d F @: @: 50 @:calc-fortran-language@:}
34974 @r{ @: d M @: @: 50 @:calc-mathematica-language@:}
34975 @r{ @: d N @: @: 50 @:calc-normal-language@:}
34976 @r{ @: d O @: @: 50 @:calc-flat-language@:}
34977 @r{ @: d P @: @: 50 @:calc-pascal-language@:}
34978 @r{ @: d T @: @: 50 @:calc-tex-language@:}
34979 @r{ @: d U @: @: 50 @:calc-unformatted-language@:}
34980 @r{ @: d W @: @: 50 @:calc-maple-language@:}
34983 @r{ a@: f [ @: @: 4 @:decr@:(a,n)}
34984 @r{ a@: f ] @: @: 4 @:incr@:(a,n)}
34987 @r{ a b@: f b @: @: 2 @:beta@:(a,b)}
34988 @r{ a@: f e @: @: 1 @:erf@:(a)}
34989 @r{ a@: I f e @: @: 1 @:erfc@:(a)}
34990 @r{ a@: f g @: @: 1 @:gamma@:(a)}
34991 @r{ a b@: f h @: @: 2 @:hypot@:(a,b)}
34992 @r{ a@: f i @: @: 1 @:im@:(a)}
34993 @r{ n a@: f j @: @: 2 @:besJ@:(n,a)}
34994 @r{ a b@: f n @: @: 2 @:min@:(a,b)}
34995 @r{ a@: f r @: @: 1 @:re@:(a)}
34996 @r{ a@: f s @: @: 1 @:sign@:(a)}
34997 @r{ a b@: f x @: @: 2 @:max@:(a,b)}
34998 @r{ n a@: f y @: @: 2 @:besY@:(n,a)}
35001 @r{ a@: f A @: @: 1 @:abssqr@:(a)}
35002 @r{ x a b@: f B @: @: @:betaI@:(x,a,b)}
35003 @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)}
35004 @r{ a@: f E @: @: 1 @:expm1@:(a)}
35005 @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)}
35006 @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)}
35007 @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)}
35008 @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)}
35009 @r{ a b@: f I @: @: 2 @:ilog@:(a,b)}
35010 @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a}
35011 @r{ a@: f L @: @: 1 @:lnp1@:(a)}
35012 @r{ a@: f M @: @: 1 @:mant@:(a)}
35013 @r{ a@: f Q @: @: 1 @:isqrt@:(a)}
35014 @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2}
35015 @r{ a n@: f S @: @: 2 @:scf@:(a,n)}
35016 @r{ y x@: f T @: @: @:arctan2@:(y,x)}
35017 @r{ a@: f X @: @: 1 @:xpon@:(a)}
35020 @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:}
35021 @r{ @: g b @: @: 12 @:calc-graph-border@:}
35022 @r{ @: g c @: @: @:calc-graph-clear@:}
35023 @r{ @: g d @: @: 41 @:calc-graph-delete@:}
35024 @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:}
35025 @r{ @: g g @: @: 12 @:calc-graph-grid@:}
35026 @r{ @: g h @:title @: @:calc-graph-header@:}
35027 @r{ @: g j @: @: 4 @:calc-graph-juggle@:}
35028 @r{ @: g k @: @: 12 @:calc-graph-key@:}
35029 @r{ @: g l @: @: 12 @:calc-graph-log-x@:}
35030 @r{ @: g n @:name @: @:calc-graph-name@:}
35031 @r{ @: g p @: @: 42 @:calc-graph-plot@:}
35032 @r{ @: g q @: @: @:calc-graph-quit@:}
35033 @r{ @: g r @:range @: @:calc-graph-range-x@:}
35034 @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:}
35035 @r{ @: g t @:title @: @:calc-graph-title-x@:}
35036 @r{ @: g v @: @: @:calc-graph-view-commands@:}
35037 @r{ @: g x @:display @: @:calc-graph-display@:}
35038 @r{ @: g z @: @: 12 @:calc-graph-zero-x@:}
35041 @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:}
35042 @r{ @: g C @:command @: @:calc-graph-command@:}
35043 @r{ @: g D @:device @: 43,44 @:calc-graph-device@:}
35044 @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:}
35045 @r{ @: g H @: @: 12 @:calc-graph-hide@:}
35046 @r{ @: g K @: @: @:calc-graph-kill@:}
35047 @r{ @: g L @: @: 12 @:calc-graph-log-y@:}
35048 @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:}
35049 @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:}
35050 @r{ @: g P @: @: 42 @:calc-graph-print@:}
35051 @r{ @: g R @:range @: @:calc-graph-range-y@:}
35052 @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:}
35053 @r{ @: g T @:title @: @:calc-graph-title-y@:}
35054 @r{ @: g V @: @: @:calc-graph-view-trail@:}
35055 @r{ @: g X @:format @: @:calc-graph-geometry@:}
35056 @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:}
35059 @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:}
35060 @r{ @: g C-r @:range @: @:calc-graph-range-z@:}
35061 @r{ @: g C-t @:title @: @:calc-graph-title-z@:}
35064 @r{ @: h b @: @: @:calc-describe-bindings@:}
35065 @r{ @: h c @:key @: @:calc-describe-key-briefly@:}
35066 @r{ @: h f @:function @: @:calc-describe-function@:}
35067 @r{ @: h h @: @: @:calc-full-help@:}
35068 @r{ @: h i @: @: @:calc-info@:}
35069 @r{ @: h k @:key @: @:calc-describe-key@:}
35070 @r{ @: h n @: @: @:calc-view-news@:}
35071 @r{ @: h s @: @: @:calc-info-summary@:}
35072 @r{ @: h t @: @: @:calc-tutorial@:}
35073 @r{ @: h v @:var @: @:calc-describe-variable@:}
35076 @r{ @: j 1-9 @: @: @:calc-select-part@:}
35077 @r{ @: j @key{RET} @: @: 27 @:calc-copy-selection@:}
35078 @r{ @: j @key{DEL} @: @: 27 @:calc-del-selection@:}
35079 @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:}
35080 @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:}
35081 @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:}
35084 @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:}
35085 @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:}
35086 @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:}
35087 @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:}
35088 @r{ @: j & @: @: 27 @:calc-sel-invert@:}
35091 @r{ @: j a @: @: 27 @:calc-select-additional@:}
35092 @r{ @: j b @: @: 12 @:calc-break-selections@:}
35093 @r{ @: j c @: @: @:calc-clear-selections@:}
35094 @r{ @: j d @: @: 12,50 @:calc-show-selections@:}
35095 @r{ @: j e @: @: 12 @:calc-enable-selections@:}
35096 @r{ @: j l @: @: 4,27 @:calc-select-less@:}
35097 @r{ @: j m @: @: 4,27 @:calc-select-more@:}
35098 @r{ @: j n @: @: 4 @:calc-select-next@:}
35099 @r{ @: j o @: @: 4,27 @:calc-select-once@:}
35100 @r{ @: j p @: @: 4 @:calc-select-previous@:}
35101 @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:}
35102 @r{ @: j s @: @: 4,27 @:calc-select-here@:}
35103 @r{ @: j u @: @: 27 @:calc-unselect@:}
35104 @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:}
35107 @r{ @: j C @: @: 27 @:calc-sel-commute@:}
35108 @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:}
35109 @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:}
35110 @r{ @: j I @: @: 27 @:calc-sel-isolate@:}
35111 @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)}
35112 @r{ @: j L @: @: 4,27 @:calc-commute-left@:}
35113 @r{ @: j M @: @: 27 @:calc-sel-merge@:}
35114 @r{ @: j N @: @: 27 @:calc-sel-negate@:}
35115 @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:}
35116 @r{ @: j R @: @: 4,27 @:calc-commute-right@:}
35117 @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:}
35118 @r{ @: j U @: @: 27 @:calc-sel-unpack@:}
35121 @r{ @: k a @: @: @:calc-random-again@:}
35122 @r{ n@: k b @: @: 1 @:bern@:(n)}
35123 @r{ n x@: H k b @: @: 2 @:bern@:(n,x)}
35124 @r{ n m@: k c @: @: 2 @:choose@:(n,m)}
35125 @r{ n m@: H k c @: @: 2 @:perm@:(n,m)}
35126 @r{ n@: k d @: @: 1 @:dfact@:(n) n!!}
35127 @r{ n@: k e @: @: 1 @:euler@:(n)}
35128 @r{ n x@: H k e @: @: 2 @:euler@:(n,x)}
35129 @r{ n@: k f @: @: 4 @:prfac@:(n)}
35130 @r{ n m@: k g @: @: 2 @:gcd@:(n,m)}
35131 @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)}
35132 @r{ n m@: k l @: @: 2 @:lcm@:(n,m)}
35133 @r{ n@: k m @: @: 1 @:moebius@:(n)}
35134 @r{ n@: k n @: @: 4 @:nextprime@:(n)}
35135 @r{ n@: I k n @: @: 4 @:prevprime@:(n)}
35136 @r{ n@: k p @: @: 4,28 @:calc-prime-test@:}
35137 @r{ m@: k r @: @: 14 @:random@:(m)}
35138 @r{ n m@: k s @: @: 2 @:stir1@:(n,m)}
35139 @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)}
35140 @r{ n@: k t @: @: 1 @:totient@:(n)}
35143 @r{ n p x@: k B @: @: @:utpb@:(x,n,p)}
35144 @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)}
35145 @r{ v x@: k C @: @: @:utpc@:(x,v)}
35146 @r{ v x@: I k C @: @: @:ltpc@:(x,v)}
35147 @r{ n m@: k E @: @: @:egcd@:(n,m)}
35148 @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)}
35149 @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)}
35150 @r{ m s x@: k N @: @: @:utpn@:(x,m,s)}
35151 @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)}
35152 @r{ m x@: k P @: @: @:utpp@:(x,m)}
35153 @r{ m x@: I k P @: @: @:ltpp@:(x,m)}
35154 @r{ v x@: k T @: @: @:utpt@:(x,v)}
35155 @r{ v x@: I k T @: @: @:ltpt@:(x,v)}
35158 @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:}
35159 @r{ @: m d @: @: @:calc-degrees-mode@:}
35160 @r{ @: m f @: @: 12 @:calc-frac-mode@:}
35161 @r{ @: m g @: @: 52 @:calc-get-modes@:}
35162 @r{ @: m h @: @: @:calc-hms-mode@:}
35163 @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:}
35164 @r{ @: m m @: @: @:calc-save-modes@:}
35165 @r{ @: m p @: @: 12 @:calc-polar-mode@:}
35166 @r{ @: m r @: @: @:calc-radians-mode@:}
35167 @r{ @: m s @: @: 12 @:calc-symbolic-mode@:}
35168 @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:}
35169 @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:}
35170 @r{ @: m w @: @: 13 @:calc-working@:}
35171 @r{ @: m x @: @: @:calc-always-load-extensions@:}
35174 @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:}
35175 @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:}
35176 @r{ @: m C @: @: 12 @:calc-auto-recompute@:}
35177 @r{ @: m D @: @: @:calc-default-simplify-mode@:}
35178 @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:}
35179 @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:}
35180 @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:}
35181 @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:}
35182 @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:}
35183 @r{ @: m S @: @: 12 @:calc-shift-prefix@:}
35184 @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:}
35187 @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:}
35188 @r{ @: s d @:var, decl @: @:calc-declare-variable@:}
35189 @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:}
35190 @r{ @: s i @:buffer @: @:calc-insert-variables@:}
35191 @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)}
35192 @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:}
35193 @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)}
35194 @r{ @: s p @:var @: 29 @:calc-permanent-variable@:}
35195 @r{ @: s r @:var @: 29 @:@:v (recalled value)}
35196 @r{ @: r 0-9 @: @: @:calc-recall-quick@:}
35197 @r{ a@: s s @:var @: 28,29 @:calc-store@:}
35198 @r{ a@: s 0-9 @: @: @:calc-store-quick@:}
35199 @r{ a@: s t @:var @: 29 @:calc-store-into@:}
35200 @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:}
35201 @r{ @: s u @:var @: 29 @:calc-unstore@:}
35202 @r{ a@: s x @:var @: 29 @:calc-store-exchange@:}
35205 @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:}
35206 @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:}
35207 @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:}
35208 @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:}
35209 @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:}
35210 @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:}
35211 @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:}
35212 @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:}
35213 @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:}
35214 @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:}
35215 @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:}
35216 @r{ @: s U @:editing @: 30 @:calc-edit-Units@:}
35217 @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:}
35220 @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)}
35221 @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)}
35222 @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)}
35223 @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)}
35224 @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)}
35225 @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)}
35226 @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)}
35227 @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)}
35228 @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))}
35229 @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @t{:=} b}
35230 @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @t{=>}}
35233 @r{ @: t [ @: @: 4 @:calc-trail-first@:}
35234 @r{ @: t ] @: @: 4 @:calc-trail-last@:}
35235 @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:}
35236 @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:}
35237 @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:}
35240 @r{ @: t b @: @: 4 @:calc-trail-backward@:}
35241 @r{ @: t d @: @: 12,50 @:calc-trail-display@:}
35242 @r{ @: t f @: @: 4 @:calc-trail-forward@:}
35243 @r{ @: t h @: @: @:calc-trail-here@:}
35244 @r{ @: t i @: @: @:calc-trail-in@:}
35245 @r{ @: t k @: @: 4 @:calc-trail-kill@:}
35246 @r{ @: t m @:string @: @:calc-trail-marker@:}
35247 @r{ @: t n @: @: 4 @:calc-trail-next@:}
35248 @r{ @: t o @: @: @:calc-trail-out@:}
35249 @r{ @: t p @: @: 4 @:calc-trail-previous@:}
35250 @r{ @: t r @:string @: @:calc-trail-isearch-backward@:}
35251 @r{ @: t s @:string @: @:calc-trail-isearch-forward@:}
35252 @r{ @: t y @: @: 4 @:calc-trail-yank@:}
35255 @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)}
35256 @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)}
35257 @r{ d@: t D @: @: 15 @:date@:(d)}
35258 @r{ d@: t I @: @: 4 @:incmonth@:(d,n)}
35259 @r{ d@: t J @: @: 16 @:julian@:(d,z)}
35260 @r{ d@: t M @: @: 17 @:newmonth@:(d,n)}
35261 @r{ @: t N @: @: 16 @:now@:(z)}
35262 @r{ d@: t P @:1 @: 31 @:year@:(d)}
35263 @r{ d@: t P @:2 @: 31 @:month@:(d)}
35264 @r{ d@: t P @:3 @: 31 @:day@:(d)}
35265 @r{ d@: t P @:4 @: 31 @:hour@:(d)}
35266 @r{ d@: t P @:5 @: 31 @:minute@:(d)}
35267 @r{ d@: t P @:6 @: 31 @:second@:(d)}
35268 @r{ d@: t P @:7 @: 31 @:weekday@:(d)}
35269 @r{ d@: t P @:8 @: 31 @:yearday@:(d)}
35270 @r{ d@: t P @:9 @: 31 @:time@:(d)}
35271 @r{ d@: t U @: @: 16 @:unixtime@:(d,z)}
35272 @r{ d@: t W @: @: 17 @:newweek@:(d,w)}
35273 @r{ d@: t Y @: @: 17 @:newyear@:(d,n)}
35276 @r{ a b@: t + @: @: 2 @:badd@:(a,b)}
35277 @r{ a b@: t - @: @: 2 @:bsub@:(a,b)}
35280 @r{ @: u a @: @: 12 @:calc-autorange-units@:}
35281 @r{ a@: u b @: @: @:calc-base-units@:}
35282 @r{ a@: u c @:units @: 18 @:calc-convert-units@:}
35283 @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:}
35284 @r{ @: u e @: @: @:calc-explain-units@:}
35285 @r{ @: u g @:unit @: @:calc-get-unit-definition@:}
35286 @r{ @: u p @: @: @:calc-permanent-units@:}
35287 @r{ a@: u r @: @: @:calc-remove-units@:}
35288 @r{ a@: u s @: @: @:usimplify@:(a)}
35289 @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:}
35290 @r{ @: u u @:unit @: @:calc-undefine-unit@:}
35291 @r{ @: u v @: @: @:calc-enter-units-table@:}
35292 @r{ a@: u x @: @: @:calc-extract-units@:}
35293 @r{ a@: u 0-9 @: @: @:calc-quick-units@:}
35296 @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)}
35297 @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)}
35298 @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)}
35299 @r{ v@: u G @: @: 19 @:vgmean@:(v)}
35300 @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)}
35301 @r{ v@: u M @: @: 19 @:vmean@:(v)}
35302 @r{ v@: I u M @: @: 19 @:vmeane@:(v)}
35303 @r{ v@: H u M @: @: 19 @:vmedian@:(v)}
35304 @r{ v@: I H u M @: @: 19 @:vhmean@:(v)}
35305 @r{ v@: u N @: @: 19 @:vmin@:(v)}
35306 @r{ v@: u S @: @: 19 @:vsdev@:(v)}
35307 @r{ v@: I u S @: @: 19 @:vpsdev@:(v)}
35308 @r{ v@: H u S @: @: 19 @:vvar@:(v)}
35309 @r{ v@: I H u S @: @: 19 @:vpvar@:(v)}
35310 @r{ @: u V @: @: @:calc-view-units-table@:}
35311 @r{ v@: u X @: @: 19 @:vmax@:(v)}
35314 @r{ v@: u + @: @: 19 @:vsum@:(v)}
35315 @r{ v@: u * @: @: 19 @:vprod@:(v)}
35316 @r{ v@: u # @: @: 19 @:vcount@:(v)}
35319 @r{ @: V ( @: @: 50 @:calc-vector-parens@:}
35320 @r{ @: V @{ @: @: 50 @:calc-vector-braces@:}
35321 @r{ @: V [ @: @: 50 @:calc-vector-brackets@:}
35322 @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:}
35323 @r{ @: V , @: @: 50 @:calc-vector-commas@:}
35324 @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:}
35325 @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:}
35326 @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:}
35327 @r{ @: V / @: @: 12,50 @:calc-break-vectors@:}
35328 @r{ @: V . @: @: 12,50 @:calc-full-vectors@:}
35331 @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)}
35332 @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)}
35333 @r{ s@: V ~ @: @: 1 @:vcompl@:(s)}
35334 @r{ s@: V # @: @: 1 @:vcard@:(s)}
35335 @r{ s@: V : @: @: 1 @:vspan@:(s)}
35336 @r{ s@: V + @: @: 1 @:rdup@:(s)}
35339 @r{ m@: V & @: @: 1 @:inv@:(m) 1/m}
35342 @r{ v@: v a @:n @: @:arrange@:(v,n)}
35343 @r{ a@: v b @:n @: @:cvec@:(a,n)}
35344 @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)}
35345 @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)}
35346 @r{ m@: v c @:0 @: 31 @:getdiag@:(m)}
35347 @r{ v@: v d @: @: 25 @:diag@:(v,n)}
35348 @r{ v m@: v e @: @: 2 @:vexp@:(v,m)}
35349 @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)}
35350 @r{ v a@: v f @: @: 26 @:find@:(v,a,n)}
35351 @r{ v@: v h @: @: 1 @:head@:(v)}
35352 @r{ v@: I v h @: @: 1 @:tail@:(v)}
35353 @r{ v@: H v h @: @: 1 @:rhead@:(v)}
35354 @r{ v@: I H v h @: @: 1 @:rtail@:(v)}
35355 @r{ @: v i @:n @: 31 @:idn@:(1,n)}
35356 @r{ @: v i @:0 @: 31 @:idn@:(1)}
35357 @r{ h t@: v k @: @: 2 @:cons@:(h,t)}
35358 @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)}
35359 @r{ v@: v l @: @: 1 @:vlen@:(v)}
35360 @r{ v@: H v l @: @: 1 @:mdims@:(v)}
35361 @r{ v m@: v m @: @: 2 @:vmask@:(v,m)}
35362 @r{ v@: v n @: @: 1 @:rnorm@:(v)}
35363 @r{ a b c@: v p @: @: 24 @:calc-pack@:}
35364 @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)}
35365 @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)}
35366 @r{ m@: v r @:0 @: 31 @:getdiag@:(m)}
35367 @r{ v i j@: v s @: @: @:subvec@:(v,i,j)}
35368 @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)}
35369 @r{ m@: v t @: @: 1 @:trn@:(m)}
35370 @r{ v@: v u @: @: 24 @:calc-unpack@:}
35371 @r{ v@: v v @: @: 1 @:rev@:(v)}
35372 @r{ @: v x @:n @: 31 @:index@:(n)}
35373 @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)}
35376 @r{ v@: V A @:op @: 22 @:apply@:(op,v)}
35377 @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)}
35378 @r{ m@: V D @: @: 1 @:det@:(m)}
35379 @r{ s@: V E @: @: 1 @:venum@:(s)}
35380 @r{ s@: V F @: @: 1 @:vfloor@:(s)}
35381 @r{ v@: V G @: @: @:grade@:(v)}
35382 @r{ v@: I V G @: @: @:rgrade@:(v)}
35383 @r{ v@: V H @:n @: 31 @:histogram@:(v,n)}
35384 @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)}
35385 @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)}
35386 @r{ m@: V J @: @: 1 @:ctrn@:(m)}
35387 @r{ m@: V L @: @: 1 @:lud@:(m)}
35388 @r{ v@: V M @:op @: 22,23 @:map@:(op,v)}
35389 @r{ v@: V N @: @: 1 @:cnorm@:(v)}
35390 @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)}
35391 @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)}
35392 @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)}
35393 @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)}
35394 @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)}
35395 @r{ v@: V S @: @: @:sort@:(v)}
35396 @r{ v@: I V S @: @: @:rsort@:(v)}
35397 @r{ m@: V T @: @: 1 @:tr@:(m)}
35398 @r{ v@: V U @:op @: 22 @:accum@:(op,v)}
35399 @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)}
35400 @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)}
35401 @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)}
35402 @r{ s t@: V V @: @: 2 @:vunion@:(s,t)}
35403 @r{ s t@: V X @: @: 2 @:vxor@:(s,t)}
35406 @r{ @: Y @: @: @:@:user commands}
35409 @r{ @: z @: @: @:@:user commands}
35412 @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:}
35413 @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:}
35414 @r{ @: Z : @: @: @:calc-kbd-else@:}
35415 @r{ @: Z ] @: @: @:calc-kbd-end-if@:}
35418 @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:}
35419 @r{ c@: Z / @: @: 45 @:calc-kbd-break@:}
35420 @r{ @: Z @} @: @: @:calc-kbd-end-loop@:}
35421 @r{ n@: Z < @: @: @:calc-kbd-repeat@:}
35422 @r{ @: Z > @: @: @:calc-kbd-end-repeat@:}
35423 @r{ n m@: Z ( @: @: @:calc-kbd-for@:}
35424 @r{ s@: Z ) @: @: @:calc-kbd-end-for@:}
35427 @r{ @: Z C-g @: @: @:@:cancel if/loop command}
35430 @r{ @: Z ` @: @: @:calc-kbd-push@:}
35431 @r{ @: Z ' @: @: @:calc-kbd-pop@:}
35432 @r{ a@: Z = @:message @: 28 @:calc-kbd-report@:}
35433 @r{ @: Z # @:prompt @: @:calc-kbd-query@:}
35436 @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:}
35437 @r{ @: Z D @:key, command @: @:calc-user-define@:}
35438 @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:}
35439 @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:}
35440 @r{ @: Z G @:key @: @:calc-get-user-defn@:}
35441 @r{ @: Z I @: @: @:calc-user-define-invocation@:}
35442 @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:}
35443 @r{ @: Z P @:key @: @:calc-user-define-permanent@:}
35444 @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:}
35445 @r{ @: Z T @: @: 12 @:calc-timing@:}
35446 @r{ @: Z U @:key @: @:calc-user-undefine@:}
35456 Positive prefix arguments apply to @expr{n} stack entries.
35457 Negative prefix arguments apply to the @expr{-n}th stack entry.
35458 A prefix of zero applies to the entire stack. (For @key{LFD} and
35459 @kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
35463 Positive prefix arguments apply to @expr{n} stack entries.
35464 Negative prefix arguments apply to the top stack entry
35465 and the next @expr{-n} stack entries.
35469 Positive prefix arguments rotate top @expr{n} stack entries by one.
35470 Negative prefix arguments rotate the entire stack by @expr{-n}.
35471 A prefix of zero reverses the entire stack.
35475 Prefix argument specifies a repeat count or distance.
35479 Positive prefix arguments specify a precision @expr{p}.
35480 Negative prefix arguments reduce the current precision by @expr{-p}.
35484 A prefix argument is interpreted as an additional step-size parameter.
35485 A plain @kbd{C-u} prefix means to prompt for the step size.
35489 A prefix argument specifies simplification level and depth.
35490 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}.
35494 A negative prefix operates only on the top level of the input formula.
35498 Positive prefix arguments specify a word size of @expr{w} bits, unsigned.
35499 Negative prefix arguments specify a word size of @expr{w} bits, signed.
35503 Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument
35504 cannot be specified in the keyboard version of this command.
35508 From the keyboard, @expr{d} is omitted and defaults to zero.
35512 Mode is toggled; a positive prefix always sets the mode, and a negative
35513 prefix always clears the mode.
35517 Some prefix argument values provide special variations of the mode.
35521 A prefix argument, if any, is used for @expr{m} instead of taking
35522 @expr{m} from the stack. @expr{M} may take any of these values:
35524 {@advance@tableindent10pt
35528 Random integer in the interval @expr{[0 .. m)}.
35530 Random floating-point number in the interval @expr{[0 .. m)}.
35532 Gaussian with mean 1 and standard deviation 0.
35534 Gaussian with specified mean and standard deviation.
35536 Random integer or floating-point number in that interval.
35538 Random element from the vector.
35546 A prefix argument from 1 to 6 specifies number of date components
35547 to remove from the stack. @xref{Date Conversions}.
35551 A prefix argument specifies a time zone; @kbd{C-u} says to take the
35552 time zone number or name from the top of the stack. @xref{Time Zones}.
35556 A prefix argument specifies a day number (0-6, 0-31, or 0-366).
35560 If the input has no units, you will be prompted for both the old and
35565 With a prefix argument, collect that many stack entries to form the
35566 input data set. Each entry may be a single value or a vector of values.
35570 With a prefix argument of 1, take a single
35571 @texline @var{n}@math{\times2}
35572 @infoline @mathit{@var{N}x2}
35573 matrix from the stack instead of two separate data vectors.
35577 The row or column number @expr{n} may be given as a numeric prefix
35578 argument instead. A plain @kbd{C-u} prefix says to take @expr{n}
35579 from the top of the stack. If @expr{n} is a vector or interval,
35580 a subvector/submatrix of the input is created.
35584 The @expr{op} prompt can be answered with the key sequence for the
35585 desired function, or with @kbd{x} or @kbd{z} followed by a function name,
35586 or with @kbd{$} to take a formula from the top of the stack, or with
35587 @kbd{'} and a typed formula. In the last two cases, the formula may
35588 be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
35589 may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
35590 last argument of the created function), or otherwise you will be
35591 prompted for an argument list. The number of vectors popped from the
35592 stack by @kbd{V M} depends on the number of arguments of the function.
35596 One of the mapping direction keys @kbd{_} (horizontal, i.e., map
35597 by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
35598 reduce down), or @kbd{=} (map or reduce by rows) may be used before
35599 entering @expr{op}; these modify the function name by adding the letter
35600 @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
35601 or @code{d} for ``down.''
35605 The prefix argument specifies a packing mode. A nonnegative mode
35606 is the number of items (for @kbd{v p}) or the number of levels
35607 (for @kbd{v u}). A negative mode is as described below. With no
35608 prefix argument, the mode is taken from the top of the stack and
35609 may be an integer or a vector of integers.
35611 {@advance@tableindent-20pt
35615 (@var{2}) Rectangular complex number.
35617 (@var{2}) Polar complex number.
35619 (@var{3}) HMS form.
35621 (@var{2}) Error form.
35623 (@var{2}) Modulo form.
35625 (@var{2}) Closed interval.
35627 (@var{2}) Closed .. open interval.
35629 (@var{2}) Open .. closed interval.
35631 (@var{2}) Open interval.
35633 (@var{2}) Fraction.
35635 (@var{2}) Float with integer mantissa.
35637 (@var{2}) Float with mantissa in @expr{[1 .. 10)}.
35639 (@var{1}) Date form (using date numbers).
35641 (@var{3}) Date form (using year, month, day).
35643 (@var{6}) Date form (using year, month, day, hour, minute, second).
35651 A prefix argument specifies the size @expr{n} of the matrix. With no
35652 prefix argument, @expr{n} is omitted and the size is inferred from
35657 The prefix argument specifies the starting position @expr{n} (default 1).
35661 Cursor position within stack buffer affects this command.
35665 Arguments are not actually removed from the stack by this command.
35669 Variable name may be a single digit or a full name.
35673 Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or
35674 @key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the
35675 buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation
35676 of the result of the edit.
35680 The number prompted for can also be provided as a prefix argument.
35684 Press this key a second time to cancel the prefix.
35688 With a negative prefix, deactivate all formulas. With a positive
35689 prefix, deactivate and then reactivate from scratch.
35693 Default is to scan for nearest formula delimiter symbols. With a
35694 prefix of zero, formula is delimited by mark and point. With a
35695 non-zero prefix, formula is delimited by scanning forward or
35696 backward by that many lines.
35700 Parse the region between point and mark as a vector. A nonzero prefix
35701 parses @var{n} lines before or after point as a vector. A zero prefix
35702 parses the current line as a vector. A @kbd{C-u} prefix parses the
35703 region between point and mark as a single formula.
35707 Parse the rectangle defined by point and mark as a matrix. A positive
35708 prefix @var{n} divides the rectangle into columns of width @var{n}.
35709 A zero or @kbd{C-u} prefix parses each line as one formula. A negative
35710 prefix suppresses special treatment of bracketed portions of a line.
35714 A numeric prefix causes the current language mode to be ignored.
35718 Responding to a prompt with a blank line answers that and all
35719 later prompts by popping additional stack entries.
35723 Answer for @expr{v} may also be of the form @expr{v = v_0} or
35728 With a positive prefix argument, stack contains many @expr{y}'s and one
35729 common @expr{x}. With a zero prefix, stack contains a vector of
35730 @expr{y}s and a common @expr{x}. With a negative prefix, stack
35731 contains many @expr{[x,y]} vectors. (For 3D plots, substitute
35732 @expr{z} for @expr{y} and @expr{x,y} for @expr{x}.)
35736 With any prefix argument, all curves in the graph are deleted.
35740 With a positive prefix, refines an existing plot with more data points.
35741 With a negative prefix, forces recomputation of the plot data.
35745 With any prefix argument, set the default value instead of the
35746 value for this graph.
35750 With a negative prefix argument, set the value for the printer.
35754 Condition is considered ``true'' if it is a nonzero real or complex
35755 number, or a formula whose value is known to be nonzero; it is ``false''
35760 Several formulas separated by commas are pushed as multiple stack
35761 entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
35762 delimiters may be omitted. The notation @kbd{$$$} refers to the value
35763 in stack level three, and causes the formula to replace the top three
35764 stack levels. The notation @kbd{$3} refers to stack level three without
35765 causing that value to be removed from the stack. Use @key{LFD} in place
35766 of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
35767 to evaluate variables.
35771 The variable is replaced by the formula shown on the right. The
35772 Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
35774 @texline @math{x \coloneq a-x}.
35775 @infoline @expr{x := a-x}.
35779 Press @kbd{?} repeatedly to see how to choose a model. Answer the
35780 variables prompt with @expr{iv} or @expr{iv;pv} to specify
35781 independent and parameter variables. A positive prefix argument
35782 takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
35783 and a vector from the stack.
35787 With a plain @kbd{C-u} prefix, replace the current region of the
35788 destination buffer with the yanked text instead of inserting.
35792 All stack entries are reformatted; the @kbd{H} prefix inhibits this.
35793 The @kbd{I} prefix sets the mode temporarily, redraws the top stack
35794 entry, then restores the original setting of the mode.
35798 A negative prefix sets the default 3D resolution instead of the
35799 default 2D resolution.
35803 This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
35804 @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
35805 @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12
35806 grabs the @var{n}th mode value only.
35810 (Space is provided below for you to keep your own written notes.)
35818 @node Key Index, Command Index, Summary, Top
35819 @unnumbered Index of Key Sequences
35823 @node Command Index, Function Index, Key Index, Top
35824 @unnumbered Index of Calculator Commands
35826 Since all Calculator commands begin with the prefix @samp{calc-}, the
35827 @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
35828 types @samp{calc-} for you. Thus, @kbd{x last-args} is short for
35829 @kbd{M-x calc-last-args}.
35833 @node Function Index, Concept Index, Command Index, Top
35834 @unnumbered Index of Algebraic Functions
35836 This is a list of built-in functions and operators usable in algebraic
35837 expressions. Their full Lisp names are derived by adding the prefix
35838 @samp{calcFunc-}, as in @code{calcFunc-sqrt}.
35840 All functions except those noted with ``*'' have corresponding
35841 Calc keystrokes and can also be found in the Calc Summary.
35846 @node Concept Index, Variable Index, Function Index, Top
35847 @unnumbered Concept Index
35851 @node Variable Index, Lisp Function Index, Concept Index, Top
35852 @unnumbered Index of Variables
35854 The variables in this list that do not contain dashes are accessible
35855 as Calc variables. Add a @samp{var-} prefix to get the name of the
35856 corresponding Lisp variable.
35858 The remaining variables are Lisp variables suitable for @code{setq}ing
35859 in your Calc init file or @file{.emacs} file.
35863 @node Lisp Function Index, , Variable Index, Top
35864 @unnumbered Index of Lisp Math Functions
35866 The following functions are meant to be used with @code{defmath}, not
35867 @code{defun} definitions. For names that do not start with @samp{calc-},
35868 the corresponding full Lisp name is derived by adding a prefix of
35882 arch-tag: 77a71809-fa4d-40be-b2cc-da3e8fb137c0