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.1 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.
22 @alias infoline=comment
35 @alias texline=comment
36 @macro infoline{stuff}
52 % Suggested by Karl Berry <karl@@freefriends.org>
53 \gdef\!{\mskip-\thinmuskip}
56 @c Fix some other things specifically for this manual.
59 @mathcode`@:=`@: @c Make Calc fractions come out right in math mode
61 \gdef\coloneq{\mathrel{\mathord:\mathord=}}
63 \gdef\beforedisplay{\vskip-10pt}
64 \gdef\afterdisplay{\vskip-5pt}
65 \gdef\beforedisplayh{\vskip-25pt}
66 \gdef\afterdisplayh{\vskip-10pt}
68 @newdimen@kyvpos @kyvpos=0pt
69 @newdimen@kyhpos @kyhpos=0pt
70 @newcount@calcclubpenalty @calcclubpenalty=1000
73 @newtoks@calcoldeverypar @calcoldeverypar=@everypar
74 @everypar={@calceverypar@the@calcoldeverypar}
75 @ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi
76 @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
77 @catcode`@\=0 \catcode`\@=11
79 \catcode`\@=0 @catcode`@\=@active
84 This file documents Calc, the GNU Emacs calculator.
86 Copyright @copyright{} 1990, 1991, 2001, 2002, 2003, 2004,
87 2005, 2006, 2007 Free Software Foundation, Inc.
90 Permission is granted to copy, distribute and/or modify this document
91 under the terms of the GNU Free Documentation License, Version 1.2 or
92 any later version published by the Free Software Foundation; with the
93 Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the
94 Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover
95 Texts as in (a) below. A copy of the license is included in the section
96 entitled ``GNU Free Documentation License.''
98 (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
99 this GNU Manual, like GNU software. Copies published by the Free
100 Software Foundation raise funds for GNU development.''
106 * Calc: (calc). Advanced desk calculator and mathematical tool.
111 @center @titlefont{Calc Manual}
113 @center GNU Emacs Calc Version 2.1
116 @center Dave Gillespie
117 @center daveg@@synaptics.com
120 @vskip 0pt plus 1filll
121 Copyright @copyright{} 1990, 1991, 2001, 2002, 2003, 2004,
122 2005, 2006, 2007 Free Software Foundation, Inc.
135 @node Top, Getting Started, (dir), (dir)
136 @chapter The GNU Emacs Calculator
139 @dfn{Calc} is an advanced desk calculator and mathematical tool
140 written by Dave Gillespie that runs as part of the GNU Emacs environment.
142 This manual, also written (mostly) by Dave Gillespie, is divided into
143 three major parts: ``Getting Started,'' the ``Calc Tutorial,'' and the
144 ``Calc Reference.'' The Tutorial introduces all the major aspects of
145 Calculator use in an easy, hands-on way. The remainder of the manual is
146 a complete reference to the features of the Calculator.
150 For help in the Emacs Info system (which you are using to read this
151 file), type @kbd{?}. (You can also type @kbd{h} to run through a
152 longer Info tutorial.)
156 * Getting Started:: General description and overview.
158 * Interactive Tutorial::
160 * Tutorial:: A step-by-step introduction for beginners.
162 * Introduction:: Introduction to the Calc reference manual.
163 * Data Types:: Types of objects manipulated by Calc.
164 * Stack and Trail:: Manipulating the stack and trail buffers.
165 * Mode Settings:: Adjusting display format and other modes.
166 * Arithmetic:: Basic arithmetic functions.
167 * Scientific Functions:: Transcendentals and other scientific functions.
168 * Matrix Functions:: Operations on vectors and matrices.
169 * Algebra:: Manipulating expressions algebraically.
170 * Units:: Operations on numbers with units.
171 * Store and Recall:: Storing and recalling variables.
172 * Graphics:: Commands for making graphs of data.
173 * Kill and Yank:: Moving data into and out of Calc.
174 * Keypad Mode:: Operating Calc from a keypad.
175 * Embedded Mode:: Working with formulas embedded in a file.
176 * Programming:: Calc as a programmable calculator.
178 * Copying:: How you can copy and share Calc.
179 * GNU Free Documentation License:: The license for this documentation.
180 * Customizing Calc:: Customizing Calc.
181 * Reporting Bugs:: How to report bugs and make suggestions.
183 * Summary:: Summary of Calc commands and functions.
185 * Key Index:: The standard Calc key sequences.
186 * Command Index:: The interactive Calc commands.
187 * Function Index:: Functions (in algebraic formulas).
188 * Concept Index:: General concepts.
189 * Variable Index:: Variables used by Calc (both user and internal).
190 * Lisp Function Index:: Internal Lisp math functions.
194 @node Getting Started, Interactive Tutorial, Top, Top
197 @node Getting Started, Tutorial, Top, Top
199 @chapter Getting Started
201 This chapter provides a general overview of Calc, the GNU Emacs
202 Calculator: What it is, how to start it and how to exit from it,
203 and what are the various ways that it can be used.
207 * About This Manual::
208 * Notations Used in This Manual::
209 * Demonstration of Calc::
211 * History and Acknowledgements::
214 @node What is Calc, About This Manual, Getting Started, Getting Started
215 @section What is Calc?
218 @dfn{Calc} is an advanced calculator and mathematical tool that runs as
219 part of the GNU Emacs environment. Very roughly based on the HP-28/48
220 series of calculators, its many features include:
224 Choice of algebraic or RPN (stack-based) entry of calculations.
227 Arbitrary precision integers and floating-point numbers.
230 Arithmetic on rational numbers, complex numbers (rectangular and polar),
231 error forms with standard deviations, open and closed intervals, vectors
232 and matrices, dates and times, infinities, sets, quantities with units,
233 and algebraic formulas.
236 Mathematical operations such as logarithms and trigonometric functions.
239 Programmer's features (bitwise operations, non-decimal numbers).
242 Financial functions such as future value and internal rate of return.
245 Number theoretical features such as prime factorization and arithmetic
246 modulo @var{m} for any @var{m}.
249 Algebraic manipulation features, including symbolic calculus.
252 Moving data to and from regular editing buffers.
255 Embedded mode for manipulating Calc formulas and data directly
256 inside any editing buffer.
259 Graphics using GNUPLOT, a versatile (and free) plotting program.
262 Easy programming using keyboard macros, algebraic formulas,
263 algebraic rewrite rules, or extended Emacs Lisp.
266 Calc tries to include a little something for everyone; as a result it is
267 large and might be intimidating to the first-time user. If you plan to
268 use Calc only as a traditional desk calculator, all you really need to
269 read is the ``Getting Started'' chapter of this manual and possibly the
270 first few sections of the tutorial. As you become more comfortable with
271 the program you can learn its additional features. Calc does not
272 have the scope and depth of a fully-functional symbolic math package,
273 but Calc has the advantages of convenience, portability, and freedom.
275 @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
276 @section About This Manual
279 This document serves as a complete description of the GNU Emacs
280 Calculator. It works both as an introduction for novices, and as
281 a reference for experienced users. While it helps to have some
282 experience with GNU Emacs in order to get the most out of Calc,
283 this manual ought to be readable even if you don't know or use Emacs
286 The manual is divided into three major parts:@: the ``Getting
287 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
288 and the Calc reference manual (the remaining chapters and appendices).
290 @c This manual has been printed in two volumes, the @dfn{Tutorial} and the
291 @c @dfn{Reference}. Both volumes include a copy of the ``Getting Started''
294 If you are in a hurry to use Calc, there is a brief ``demonstration''
295 below which illustrates the major features of Calc in just a couple of
296 pages. If you don't have time to go through the full tutorial, this
297 will show you everything you need to know to begin.
298 @xref{Demonstration of Calc}.
300 The tutorial chapter walks you through the various parts of Calc
301 with lots of hands-on examples and explanations. If you are new
302 to Calc and you have some time, try going through at least the
303 beginning of the tutorial. The tutorial includes about 70 exercises
304 with answers. These exercises give you some guided practice with
305 Calc, as well as pointing out some interesting and unusual ways
308 The reference section discusses Calc in complete depth. You can read
309 the reference from start to finish if you want to learn every aspect
310 of Calc. Or, you can look in the table of contents or the Concept
311 Index to find the parts of the manual that discuss the things you
314 @cindex Marginal notes
315 Every Calc keyboard command is listed in the Calc Summary, and also
316 in the Key Index. Algebraic functions, @kbd{M-x} commands, and
317 variables also have their own indices.
319 @infoline In the printed manual, each
320 paragraph that is referenced in the Key or Function Index is marked
321 in the margin with its index entry.
323 @c [fix-ref Help Commands]
324 You can access this manual on-line at any time within Calc by
325 pressing the @kbd{h i} key sequence. Outside of the Calc window,
326 you can press @kbd{C-x * i} to read the manual on-line. Also, you
327 can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{C-x * t},
328 or to the Summary by pressing @kbd{h s} or @kbd{C-x * s}. Within Calc,
329 you can also go to the part of the manual describing any Calc key,
330 function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v},
331 respectively. @xref{Help Commands}.
334 The Calc manual can be printed, but because the manual is so large, you
335 should only make a printed copy if you really need it. To print the
336 manual, you will need the @TeX{} typesetting program (this is a free
337 program by Donald Knuth at Stanford University) as well as the
338 @file{texindex} program and @file{texinfo.tex} file, both of which can
339 be obtained from the FSF as part of the @code{texinfo} package.
340 To print the Calc manual in one huge tome, you will need the
341 source code to this manual, @file{calc.texi}, available as part of the
342 Emacs source. Once you have this file, type @kbd{texi2dvi calc.texi}.
343 Alternatively, change to the @file{man} subdirectory of the Emacs
344 source distribution, and type @kbd{make calc.dvi}. (Don't worry if you
345 get some ``overfull box'' warnings while @TeX{} runs.)
346 The result will be a device-independent output file called
347 @file{calc.dvi}, which you must print in whatever way is right
348 for your system. On many systems, the command is
361 @c Printed copies of this manual are also available from the Free Software
364 @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
365 @section Notations Used in This Manual
368 This section describes the various notations that are used
369 throughout the Calc manual.
371 In keystroke sequences, uppercase letters mean you must hold down
372 the shift key while typing the letter. Keys pressed with Control
373 held down are shown as @kbd{C-x}. Keys pressed with Meta held down
374 are shown as @kbd{M-x}. Other notations are @key{RET} for the
375 Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
376 @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.
377 The @key{DEL} key is called Backspace on some keyboards, it is
378 whatever key you would use to correct a simple typing error when
379 regularly using Emacs.
381 (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
382 the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
383 If you don't have a Meta key, look for Alt or Extend Char. You can
384 also press @key{ESC} or @kbd{C-[} first to get the same effect, so
385 that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
387 Sometimes the @key{RET} key is not shown when it is ``obvious''
388 that you must press @key{RET} to proceed. For example, the @key{RET}
389 is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
391 Commands are generally shown like this: @kbd{p} (@code{calc-precision})
392 or @kbd{C-x * k} (@code{calc-keypad}). This means that the command is
393 normally used by pressing the @kbd{p} key or @kbd{C-x * k} key sequence,
394 but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
396 Commands that correspond to functions in algebraic notation
397 are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means
398 the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
399 the corresponding function in an algebraic-style formula would
400 be @samp{cos(@var{x})}.
402 A few commands don't have key equivalents: @code{calc-sincos}
405 @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
406 @section A Demonstration of Calc
409 @cindex Demonstration of Calc
410 This section will show some typical small problems being solved with
411 Calc. The focus is more on demonstration than explanation, but
412 everything you see here will be covered more thoroughly in the
415 To begin, start Emacs if necessary (usually the command @code{emacs}
416 does this), and type @kbd{C-x * c} to start the
417 Calculator. (You can also use @kbd{M-x calc} if this doesn't work.
418 @xref{Starting Calc}, for various ways of starting the Calculator.)
420 Be sure to type all the sample input exactly, especially noting the
421 difference between lower-case and upper-case letters. Remember,
422 @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
423 Delete, and Space keys.
425 @strong{RPN calculation.} In RPN, you type the input number(s) first,
426 then the command to operate on the numbers.
429 Type @kbd{2 @key{RET} 3 + Q} to compute
430 @texline @math{\sqrt{2+3} = 2.2360679775}.
431 @infoline the square root of 2+3, which is 2.2360679775.
434 Type @kbd{P 2 ^} to compute
435 @texline @math{\pi^2 = 9.86960440109}.
436 @infoline the value of `pi' squared, 9.86960440109.
439 Type @key{TAB} to exchange the order of these two results.
442 Type @kbd{- I H S} to subtract these results and compute the Inverse
443 Hyperbolic sine of the difference, 2.72996136574.
446 Type @key{DEL} to erase this result.
448 @strong{Algebraic calculation.} You can also enter calculations using
449 conventional ``algebraic'' notation. To enter an algebraic formula,
450 use the apostrophe key.
453 Type @kbd{' sqrt(2+3) @key{RET}} to compute
454 @texline @math{\sqrt{2+3}}.
455 @infoline the square root of 2+3.
458 Type @kbd{' pi^2 @key{RET}} to enter
459 @texline @math{\pi^2}.
460 @infoline `pi' squared.
461 To evaluate this symbolic formula as a number, type @kbd{=}.
464 Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
465 result from the most-recent and compute the Inverse Hyperbolic sine.
467 @strong{Keypad mode.} If you are using the X window system, press
468 @w{@kbd{C-x * k}} to get Keypad mode. (If you don't use X, skip to
472 Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
473 ``buttons'' using your left mouse button.
476 Click on @key{PI}, @key{2}, and @tfn{y^x}.
479 Click on @key{INV}, then @key{ENTER} to swap the two results.
482 Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
485 Click on @key{<-} to erase the result, then click @key{OFF} to turn
486 the Keypad Calculator off.
488 @strong{Grabbing data.} Type @kbd{C-x * x} if necessary to exit Calc.
489 Now select the following numbers as an Emacs region: ``Mark'' the
490 front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
491 then move to the other end of the list. (Either get this list from
492 the on-line copy of this manual, accessed by @w{@kbd{C-x * i}}, or just
493 type these numbers into a scratch file.) Now type @kbd{C-x * g} to
494 ``grab'' these numbers into Calc.
505 The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
506 Type @w{@kbd{V R +}} to compute the sum of these numbers.
509 Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
510 the product of the numbers.
513 You can also grab data as a rectangular matrix. Place the cursor on
514 the upper-leftmost @samp{1} and set the mark, then move to just after
515 the lower-right @samp{8} and press @kbd{C-x * r}.
518 Type @kbd{v t} to transpose this
519 @texline @math{3\times2}
522 @texline @math{2\times3}
524 matrix. Type @w{@kbd{v u}} to unpack the rows into two separate
525 vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums
526 of the two original columns. (There is also a special
527 grab-and-sum-columns command, @kbd{C-x * :}.)
529 @strong{Units conversion.} Units are entered algebraically.
530 Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
531 Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}.
533 @strong{Date arithmetic.} Type @kbd{t N} to get the current date and
534 time. Type @kbd{90 +} to find the date 90 days from now. Type
535 @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
536 many weeks have passed since then.
538 @strong{Algebra.} Algebraic entries can also include formulas
539 or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
540 to enter a pair of equations involving three variables.
541 (Note the leading apostrophe in this example; also, note that the space
542 between @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve
543 these equations for the variables @expr{x} and @expr{y}.
546 Type @kbd{d B} to view the solutions in more readable notation.
547 Type @w{@kbd{d C}} to view them in C language notation, @kbd{d T}
548 to view them in the notation for the @TeX{} typesetting system,
549 and @kbd{d L} to view them in the notation for the La@TeX{} typesetting
550 system. Type @kbd{d N} to return to normal notation.
553 Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas.
554 (That's a letter @kbd{l}, not a numeral @kbd{1}.)
557 @strong{Help functions.} You can read about any command in the on-line
558 manual. Type @kbd{C-x * c} to return to Calc after each of these
559 commands: @kbd{h k t N} to read about the @kbd{t N} command,
560 @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
561 @kbd{h s} to read the Calc summary.
564 @strong{Help functions.} You can read about any command in the on-line
565 manual. Remember to type the letter @kbd{l}, then @kbd{C-x * c}, to
566 return here after each of these commands: @w{@kbd{h k t N}} to read
567 about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
568 @code{sqrt} function, and @kbd{h s} to read the Calc summary.
571 Press @key{DEL} repeatedly to remove any leftover results from the stack.
572 To exit from Calc, press @kbd{q} or @kbd{C-x * c} again.
574 @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
578 Calc has several user interfaces that are specialized for
579 different kinds of tasks. As well as Calc's standard interface,
580 there are Quick mode, Keypad mode, and Embedded mode.
584 * The Standard Interface::
585 * Quick Mode Overview::
586 * Keypad Mode Overview::
587 * Standalone Operation::
588 * Embedded Mode Overview::
589 * Other C-x * Commands::
592 @node Starting Calc, The Standard Interface, Using Calc, Using Calc
593 @subsection Starting Calc
596 On most systems, you can type @kbd{C-x *} to start the Calculator.
597 The key sequence @kbd{C-x *} is bound to the command @code{calc-dispatch},
598 which can be rebound if convenient (@pxref{Customizing Calc}).
600 When you press @kbd{C-x *}, Emacs waits for you to press a second key to
601 complete the command. In this case, you will follow @kbd{C-x *} with a
602 letter (upper- or lower-case, it doesn't matter for @kbd{C-x *}) that says
603 which Calc interface you want to use.
605 To get Calc's standard interface, type @kbd{C-x * c}. To get
606 Keypad mode, type @kbd{C-x * k}. Type @kbd{C-x * ?} to get a brief
607 list of the available options, and type a second @kbd{?} to get
610 To ease typing, @kbd{C-x * *} also works to start Calc. It starts the
611 same interface (either @kbd{C-x * c} or @w{@kbd{C-x * k}}) that you last
612 used, selecting the @kbd{C-x * c} interface by default.
614 If @kbd{C-x *} doesn't work for you, you can always type explicit
615 commands like @kbd{M-x calc} (for the standard user interface) or
616 @w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x}
617 (that's Meta with the letter @kbd{x}), then, at the prompt,
618 type the full command (like @kbd{calc-keypad}) and press Return.
620 The same commands (like @kbd{C-x * c} or @kbd{C-x * *}) that start
621 the Calculator also turn it off if it is already on.
623 @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
624 @subsection The Standard Calc Interface
627 @cindex Standard user interface
628 Calc's standard interface acts like a traditional RPN calculator,
629 operated by the normal Emacs keyboard. When you type @kbd{C-x * c}
630 to start the Calculator, the Emacs screen splits into two windows
631 with the file you were editing on top and Calc on the bottom.
637 --**-Emacs: myfile (Fundamental)----All----------------------
638 --- Emacs Calculator Mode --- |Emacs Calculator Trail
646 --%%-Calc: 12 Deg (Calculator)----All----- --%%-Emacs: *Calc Trail*
650 In this figure, the mode-line for @file{myfile} has moved up and the
651 ``Calculator'' window has appeared below it. As you can see, Calc
652 actually makes two windows side-by-side. The lefthand one is
653 called the @dfn{stack window} and the righthand one is called the
654 @dfn{trail window.} The stack holds the numbers involved in the
655 calculation you are currently performing. The trail holds a complete
656 record of all calculations you have done. In a desk calculator with
657 a printer, the trail corresponds to the paper tape that records what
660 In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
661 were first entered into the Calculator, then the 2 and 4 were
662 multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}.
663 (The @samp{>} symbol shows that this was the most recent calculation.)
664 The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack.
666 Most Calculator commands deal explicitly with the stack only, but
667 there is a set of commands that allow you to search back through
668 the trail and retrieve any previous result.
670 Calc commands use the digits, letters, and punctuation keys.
671 Shifted (i.e., upper-case) letters are different from lowercase
672 letters. Some letters are @dfn{prefix} keys that begin two-letter
673 commands. For example, @kbd{e} means ``enter exponent'' and shifted
674 @kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix
675 the letter ``e'' takes on very different meanings: @kbd{d e} means
676 ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
678 There is nothing stopping you from switching out of the Calc
679 window and back into your editing window, say by using the Emacs
680 @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is
681 inside a regular window, Emacs acts just like normal. When the
682 cursor is in the Calc stack or trail windows, keys are interpreted
685 When you quit by pressing @kbd{C-x * c} a second time, the Calculator
686 windows go away but the actual Stack and Trail are not gone, just
687 hidden. When you press @kbd{C-x * c} once again you will get the
688 same stack and trail contents you had when you last used the
691 The Calculator does not remember its state between Emacs sessions.
692 Thus if you quit Emacs and start it again, @kbd{C-x * c} will give you
693 a fresh stack and trail. There is a command (@kbd{m m}) that lets
694 you save your favorite mode settings between sessions, though.
695 One of the things it saves is which user interface (standard or
696 Keypad) you last used; otherwise, a freshly started Emacs will
697 always treat @kbd{C-x * *} the same as @kbd{C-x * c}.
699 The @kbd{q} key is another equivalent way to turn the Calculator off.
701 If you type @kbd{C-x * b} first and then @kbd{C-x * c}, you get a
702 full-screen version of Calc (@code{full-calc}) in which the stack and
703 trail windows are still side-by-side but are now as tall as the whole
704 Emacs screen. When you press @kbd{q} or @kbd{C-x * c} again to quit,
705 the file you were editing before reappears. The @kbd{C-x * b} key
706 switches back and forth between ``big'' full-screen mode and the
707 normal partial-screen mode.
709 Finally, @kbd{C-x * o} (@code{calc-other-window}) is like @kbd{C-x * c}
710 except that the Calc window is not selected. The buffer you were
711 editing before remains selected instead. @kbd{C-x * o} is a handy
712 way to switch out of Calc momentarily to edit your file; type
713 @kbd{C-x * c} to switch back into Calc when you are done.
715 @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
716 @subsection Quick Mode (Overview)
719 @dfn{Quick mode} is a quick way to use Calc when you don't need the
720 full complexity of the stack and trail. To use it, type @kbd{C-x * q}
721 (@code{quick-calc}) in any regular editing buffer.
723 Quick mode is very simple: It prompts you to type any formula in
724 standard algebraic notation (like @samp{4 - 2/3}) and then displays
725 the result at the bottom of the Emacs screen (@mathit{3.33333333333}
726 in this case). You are then back in the same editing buffer you
727 were in before, ready to continue editing or to type @kbd{C-x * q}
728 again to do another quick calculation. The result of the calculation
729 will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
730 at this point will yank the result into your editing buffer.
732 Calc mode settings affect Quick mode, too, though you will have to
733 go into regular Calc (with @kbd{C-x * c}) to change the mode settings.
735 @c [fix-ref Quick Calculator mode]
736 @xref{Quick Calculator}, for further information.
738 @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
739 @subsection Keypad Mode (Overview)
742 @dfn{Keypad mode} is a mouse-based interface to the Calculator.
743 It is designed for use with terminals that support a mouse. If you
744 don't have a mouse, you will have to operate Keypad mode with your
745 arrow keys (which is probably more trouble than it's worth).
747 Type @kbd{C-x * k} to turn Keypad mode on or off. Once again you
748 get two new windows, this time on the righthand side of the screen
749 instead of at the bottom. The upper window is the familiar Calc
750 Stack; the lower window is a picture of a typical calculator keypad.
754 \advance \dimen0 by 24\baselineskip%
755 \ifdim \dimen0>\pagegoal \vfill\eject \fi%
760 |--- Emacs Calculator Mode ---
764 |--%%-Calc: 12 Deg (Calcul
765 |----+-----Calc 2.1------+----1
766 |FLR |CEIL|RND |TRNC|CLN2|FLT |
767 |----+----+----+----+----+----|
768 | LN |EXP | |ABS |IDIV|MOD |
769 |----+----+----+----+----+----|
770 |SIN |COS |TAN |SQRT|y^x |1/x |
771 |----+----+----+----+----+----|
772 | ENTER |+/- |EEX |UNDO| <- |
773 |-----+---+-+--+--+-+---++----|
774 | INV | 7 | 8 | 9 | / |
775 |-----+-----+-----+-----+-----|
776 | HYP | 4 | 5 | 6 | * |
777 |-----+-----+-----+-----+-----|
778 |EXEC | 1 | 2 | 3 | - |
779 |-----+-----+-----+-----+-----|
780 | OFF | 0 | . | PI | + |
781 |-----+-----+-----+-----+-----+
785 Keypad mode is much easier for beginners to learn, because there
786 is no need to memorize lots of obscure key sequences. But not all
787 commands in regular Calc are available on the Keypad. You can
788 always switch the cursor into the Calc stack window to use
789 standard Calc commands if you need. Serious Calc users, though,
790 often find they prefer the standard interface over Keypad mode.
792 To operate the Calculator, just click on the ``buttons'' of the
793 keypad using your left mouse button. To enter the two numbers
794 shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
795 add them together you would then click @kbd{+} (to get 12.3 on
798 If you click the right mouse button, the top three rows of the
799 keypad change to show other sets of commands, such as advanced
800 math functions, vector operations, and operations on binary
803 Because Keypad mode doesn't use the regular keyboard, Calc leaves
804 the cursor in your original editing buffer. You can type in
805 this buffer in the usual way while also clicking on the Calculator
806 keypad. One advantage of Keypad mode is that you don't need an
807 explicit command to switch between editing and calculating.
809 If you press @kbd{C-x * b} first, you get a full-screen Keypad mode
810 (@code{full-calc-keypad}) with three windows: The keypad in the lower
811 left, the stack in the lower right, and the trail on top.
813 @c [fix-ref Keypad Mode]
814 @xref{Keypad Mode}, for further information.
816 @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
817 @subsection Standalone Operation
820 @cindex Standalone Operation
821 If you are not in Emacs at the moment but you wish to use Calc,
822 you must start Emacs first. If all you want is to run Calc, you
823 can give the commands:
833 emacs -f full-calc-keypad
837 which run a full-screen Calculator (as if by @kbd{C-x * b C-x * c}) or
838 a full-screen X-based Calculator (as if by @kbd{C-x * b C-x * k}).
839 In standalone operation, quitting the Calculator (by pressing
840 @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
843 @node Embedded Mode Overview, Other C-x * Commands, Standalone Operation, Using Calc
844 @subsection Embedded Mode (Overview)
847 @dfn{Embedded mode} is a way to use Calc directly from inside an
848 editing buffer. Suppose you have a formula written as part of a
862 and you wish to have Calc compute and format the derivative for
863 you and store this derivative in the buffer automatically. To
864 do this with Embedded mode, first copy the formula down to where
865 you want the result to be:
879 Now, move the cursor onto this new formula and press @kbd{C-x * e}.
880 Calc will read the formula (using the surrounding blank lines to
881 tell how much text to read), then push this formula (invisibly)
882 onto the Calc stack. The cursor will stay on the formula in the
883 editing buffer, but the buffer's mode line will change to look
884 like the Calc mode line (with mode indicators like @samp{12 Deg}
885 and so on). Even though you are still in your editing buffer,
886 the keyboard now acts like the Calc keyboard, and any new result
887 you get is copied from the stack back into the buffer. To take
888 the derivative, you would type @kbd{a d x @key{RET}}.
902 To make this look nicer, you might want to press @kbd{d =} to center
903 the formula, and even @kbd{d B} to use Big display mode.
912 % [calc-mode: justify: center]
913 % [calc-mode: language: big]
921 Calc has added annotations to the file to help it remember the modes
922 that were used for this formula. They are formatted like comments
923 in the @TeX{} typesetting language, just in case you are using @TeX{} or
924 La@TeX{}. (In this example @TeX{} is not being used, so you might want
925 to move these comments up to the top of the file or otherwise put them
928 As an extra flourish, we can add an equation number using a
929 righthand label: Type @kbd{d @} (1) @key{RET}}.
933 % [calc-mode: justify: center]
934 % [calc-mode: language: big]
935 % [calc-mode: right-label: " (1)"]
943 To leave Embedded mode, type @kbd{C-x * e} again. The mode line
944 and keyboard will revert to the way they were before.
946 The related command @kbd{C-x * w} operates on a single word, which
947 generally means a single number, inside text. It uses any
948 non-numeric characters rather than blank lines to delimit the
949 formula it reads. Here's an example of its use:
952 A slope of one-third corresponds to an angle of 1 degrees.
955 Place the cursor on the @samp{1}, then type @kbd{C-x * w} to enable
956 Embedded mode on that number. Now type @kbd{3 /} (to get one-third),
957 and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
958 then @w{@kbd{C-x * w}} again to exit Embedded mode.
961 A slope of one-third corresponds to an angle of 18.4349488229 degrees.
964 @c [fix-ref Embedded Mode]
965 @xref{Embedded Mode}, for full details.
967 @node Other C-x * Commands, , Embedded Mode Overview, Using Calc
968 @subsection Other @kbd{C-x *} Commands
971 Two more Calc-related commands are @kbd{C-x * g} and @kbd{C-x * r},
972 which ``grab'' data from a selected region of a buffer into the
973 Calculator. The region is defined in the usual Emacs way, by
974 a ``mark'' placed at one end of the region, and the Emacs
975 cursor or ``point'' placed at the other.
977 The @kbd{C-x * g} command reads the region in the usual left-to-right,
978 top-to-bottom order. The result is packaged into a Calc vector
979 of numbers and placed on the stack. Calc (in its standard
980 user interface) is then started. Type @kbd{v u} if you want
981 to unpack this vector into separate numbers on the stack. Also,
982 @kbd{C-u C-x * g} interprets the region as a single number or
985 The @kbd{C-x * r} command reads a rectangle, with the point and
986 mark defining opposite corners of the rectangle. The result
987 is a matrix of numbers on the Calculator stack.
989 Complementary to these is @kbd{C-x * y}, which ``yanks'' the
990 value at the top of the Calc stack back into an editing buffer.
991 If you type @w{@kbd{C-x * y}} while in such a buffer, the value is
992 yanked at the current position. If you type @kbd{C-x * y} while
993 in the Calc buffer, Calc makes an educated guess as to which
994 editing buffer you want to use. The Calc window does not have
995 to be visible in order to use this command, as long as there
996 is something on the Calc stack.
998 Here, for reference, is the complete list of @kbd{C-x *} commands.
999 The shift, control, and meta keys are ignored for the keystroke
1000 following @kbd{C-x *}.
1003 Commands for turning Calc on and off:
1007 Turn Calc on or off, employing the same user interface as last time.
1009 @item =, +, -, /, \, &, #
1010 Alternatives for @kbd{*}.
1013 Turn Calc on or off using its standard bottom-of-the-screen
1014 interface. If Calc is already turned on but the cursor is not
1015 in the Calc window, move the cursor into the window.
1018 Same as @kbd{C}, but don't select the new Calc window. If
1019 Calc is already turned on and the cursor is in the Calc window,
1020 move it out of that window.
1023 Control whether @kbd{C-x * c} and @kbd{C-x * k} use the full screen.
1026 Use Quick mode for a single short calculation.
1029 Turn Calc Keypad mode on or off.
1032 Turn Calc Embedded mode on or off at the current formula.
1035 Turn Calc Embedded mode on or off, select the interesting part.
1038 Turn Calc Embedded mode on or off at the current word (number).
1041 Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
1044 Quit Calc; turn off standard, Keypad, or Embedded mode if on.
1045 (This is like @kbd{q} or @key{OFF} inside of Calc.)
1052 Commands for moving data into and out of the Calculator:
1056 Grab the region into the Calculator as a vector.
1059 Grab the rectangular region into the Calculator as a matrix.
1062 Grab the rectangular region and compute the sums of its columns.
1065 Grab the rectangular region and compute the sums of its rows.
1068 Yank a value from the Calculator into the current editing buffer.
1075 Commands for use with Embedded mode:
1079 ``Activate'' the current buffer. Locate all formulas that
1080 contain @samp{:=} or @samp{=>} symbols and record their locations
1081 so that they can be updated automatically as variables are changed.
1084 Duplicate the current formula immediately below and select
1088 Insert a new formula at the current point.
1091 Move the cursor to the next active formula in the buffer.
1094 Move the cursor to the previous active formula in the buffer.
1097 Update (i.e., as if by the @kbd{=} key) the formula at the current point.
1100 Edit (as if by @code{calc-edit}) the formula at the current point.
1107 Miscellaneous commands:
1111 Run the Emacs Info system to read the Calc manual.
1112 (This is the same as @kbd{h i} inside of Calc.)
1115 Run the Emacs Info system to read the Calc Tutorial.
1118 Run the Emacs Info system to read the Calc Summary.
1121 Load Calc entirely into memory. (Normally the various parts
1122 are loaded only as they are needed.)
1125 Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
1126 and record them as the current keyboard macro.
1129 (This is the ``zero'' digit key.) Reset the Calculator to
1130 its initial state: Empty stack, and initial mode settings.
1133 @node History and Acknowledgements, , Using Calc, Getting Started
1134 @section History and Acknowledgements
1137 Calc was originally started as a two-week project to occupy a lull
1138 in the author's schedule. Basically, a friend asked if I remembered
1140 @texline @math{2^{32}}.
1141 @infoline @expr{2^32}.
1142 I didn't offhand, but I said, ``that's easy, just call up an
1143 @code{xcalc}.'' @code{Xcalc} duly reported that the answer to our
1144 question was @samp{4.294967e+09}---with no way to see the full ten
1145 digits even though we knew they were there in the program's memory! I
1146 was so annoyed, I vowed to write a calculator of my own, once and for
1149 I chose Emacs Lisp, a) because I had always been curious about it
1150 and b) because, being only a text editor extension language after
1151 all, Emacs Lisp would surely reach its limits long before the project
1152 got too far out of hand.
1154 To make a long story short, Emacs Lisp turned out to be a distressingly
1155 solid implementation of Lisp, and the humble task of calculating
1156 turned out to be more open-ended than one might have expected.
1158 Emacs Lisp didn't have built-in floating point math (now it does), so
1160 simulated in software. In fact, Emacs integers will only comfortably
1161 fit six decimal digits or so---not enough for a decent calculator. So
1162 I had to write my own high-precision integer code as well, and once I had
1163 this I figured that arbitrary-size integers were just as easy as large
1164 integers. Arbitrary floating-point precision was the logical next step.
1165 Also, since the large integer arithmetic was there anyway it seemed only
1166 fair to give the user direct access to it, which in turn made it practical
1167 to support fractions as well as floats. All these features inspired me
1168 to look around for other data types that might be worth having.
1170 Around this time, my friend Rick Koshi showed me his nifty new HP-28
1171 calculator. It allowed the user to manipulate formulas as well as
1172 numerical quantities, and it could also operate on matrices. I
1173 decided that these would be good for Calc to have, too. And once
1174 things had gone this far, I figured I might as well take a look at
1175 serious algebra systems for further ideas. Since these systems did
1176 far more than I could ever hope to implement, I decided to focus on
1177 rewrite rules and other programming features so that users could
1178 implement what they needed for themselves.
1180 Rick complained that matrices were hard to read, so I put in code to
1181 format them in a 2D style. Once these routines were in place, Big mode
1182 was obligatory. Gee, what other language modes would be useful?
1184 Scott Hemphill and Allen Knutson, two friends with a strong mathematical
1185 bent, contributed ideas and algorithms for a number of Calc features
1186 including modulo forms, primality testing, and float-to-fraction conversion.
1188 Units were added at the eager insistence of Mass Sivilotti. Later,
1189 Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
1190 expert assistance with the units table. As far as I can remember, the
1191 idea of using algebraic formulas and variables to represent units dates
1192 back to an ancient article in Byte magazine about muMath, an early
1193 algebra system for microcomputers.
1195 Many people have contributed to Calc by reporting bugs and suggesting
1196 features, large and small. A few deserve special mention: Tim Peters,
1197 who helped develop the ideas that led to the selection commands, rewrite
1198 rules, and many other algebra features;
1199 @texline Fran\c{c}ois
1201 Pinard, who contributed an early prototype of the Calc Summary appendix
1202 as well as providing valuable suggestions in many other areas of Calc;
1203 Carl Witty, whose eagle eyes discovered many typographical and factual
1204 errors in the Calc manual; Tim Kay, who drove the development of
1205 Embedded mode; Ove Ewerlid, who made many suggestions relating to the
1206 algebra commands and contributed some code for polynomial operations;
1207 Randal Schwartz, who suggested the @code{calc-eval} function; Robert
1208 J. Chassell, who suggested the Calc Tutorial and exercises; and Juha
1209 Sarlin, who first worked out how to split Calc into quickly-loading
1210 parts. Bob Weiner helped immensely with the Lucid Emacs port.
1212 @cindex Bibliography
1213 @cindex Knuth, Art of Computer Programming
1214 @cindex Numerical Recipes
1215 @c Should these be expanded into more complete references?
1216 Among the books used in the development of Calc were Knuth's @emph{Art
1217 of Computer Programming} (especially volume II, @emph{Seminumerical
1218 Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
1219 and Vetterling; Bevington's @emph{Data Reduction and Error Analysis
1220 for the Physical Sciences}; @emph{Concrete Mathematics} by Graham,
1221 Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the
1222 @emph{CRC Standard Math Tables} (William H. Beyer, ed.); and
1223 Abramowitz and Stegun's venerable @emph{Handbook of Mathematical
1224 Functions}. Also, of course, Calc could not have been written without
1225 the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and
1228 Final thanks go to Richard Stallman, without whose fine implementations
1229 of the Emacs editor, language, and environment, Calc would have been
1230 finished in two weeks.
1235 @c This node is accessed by the `C-x * t' command.
1236 @node Interactive Tutorial, Tutorial, Getting Started, Top
1240 Some brief instructions on using the Emacs Info system for this tutorial:
1242 Press the space bar and Delete keys to go forward and backward in a
1243 section by screenfuls (or use the regular Emacs scrolling commands
1246 Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
1247 If the section has a @dfn{menu}, press a digit key like @kbd{1}
1248 or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to
1249 go back up from a sub-section to the menu it is part of.
1251 Exercises in the tutorial all have cross-references to the
1252 appropriate page of the ``answers'' section. Press @kbd{f}, then
1253 the exercise number, to see the answer to an exercise. After
1254 you have followed a cross-reference, you can press the letter
1255 @kbd{l} to return to where you were before.
1257 You can press @kbd{?} at any time for a brief summary of Info commands.
1259 Press @kbd{1} now to enter the first section of the Tutorial.
1265 @node Tutorial, Introduction, Interactive Tutorial, Top
1268 @node Tutorial, Introduction, Getting Started, Top
1273 This chapter explains how to use Calc and its many features, in
1274 a step-by-step, tutorial way. You are encouraged to run Calc and
1275 work along with the examples as you read (@pxref{Starting Calc}).
1276 If you are already familiar with advanced calculators, you may wish
1278 to skip on to the rest of this manual.
1280 @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
1282 @c [fix-ref Embedded Mode]
1283 This tutorial describes the standard user interface of Calc only.
1284 The Quick mode and Keypad mode interfaces are fairly
1285 self-explanatory. @xref{Embedded Mode}, for a description of
1286 the Embedded mode interface.
1288 The easiest way to read this tutorial on-line is to have two windows on
1289 your Emacs screen, one with Calc and one with the Info system. (If you
1290 have a printed copy of the manual you can use that instead.) Press
1291 @kbd{C-x * c} to turn Calc on or to switch into the Calc window, and
1292 press @kbd{C-x * i} to start the Info system or to switch into its window.
1294 This tutorial is designed to be done in sequence. But the rest of this
1295 manual does not assume you have gone through the tutorial. The tutorial
1296 does not cover everything in the Calculator, but it touches on most
1300 You may wish to print out a copy of the Calc Summary and keep notes on
1301 it as you learn Calc. @xref{About This Manual}, to see how to make a
1302 printed summary. @xref{Summary}.
1305 The Calc Summary at the end of the reference manual includes some blank
1306 space for your own use. You may wish to keep notes there as you learn
1312 * Arithmetic Tutorial::
1313 * Vector/Matrix Tutorial::
1315 * Algebra Tutorial::
1316 * Programming Tutorial::
1318 * Answers to Exercises::
1321 @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
1322 @section Basic Tutorial
1325 In this section, we learn how RPN and algebraic-style calculations
1326 work, how to undo and redo an operation done by mistake, and how
1327 to control various modes of the Calculator.
1330 * RPN Tutorial:: Basic operations with the stack.
1331 * Algebraic Tutorial:: Algebraic entry; variables.
1332 * Undo Tutorial:: If you make a mistake: Undo and the trail.
1333 * Modes Tutorial:: Common mode-setting commands.
1336 @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
1337 @subsection RPN Calculations and the Stack
1339 @cindex RPN notation
1342 Calc normally uses RPN notation. You may be familiar with the RPN
1343 system from Hewlett-Packard calculators, FORTH, or PostScript.
1344 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1349 Calc normally uses RPN notation. You may be familiar with the RPN
1350 system from Hewlett-Packard calculators, FORTH, or PostScript.
1351 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1355 The central component of an RPN calculator is the @dfn{stack}. A
1356 calculator stack is like a stack of dishes. New dishes (numbers) are
1357 added at the top of the stack, and numbers are normally only removed
1358 from the top of the stack.
1362 In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands}
1363 and the @expr{+} is the @dfn{operator}. In an RPN calculator you always
1364 enter the operands first, then the operator. Each time you type a
1365 number, Calc adds or @dfn{pushes} it onto the top of the Stack.
1366 When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
1367 number of operands from the stack and pushes back the result.
1369 Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
1370 @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to
1371 the @key{ENTER} key on traditional RPN calculators.) Try this now if
1372 you wish; type @kbd{C-x * c} to switch into the Calc window (you can type
1373 @kbd{C-x * c} again or @kbd{C-x * o} to switch back to the Tutorial window).
1374 The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
1375 The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
1376 and pushes the result (5) back onto the stack. Here's how the stack
1377 will look at various points throughout the calculation:
1385 C-x * c 2 @key{RET} 3 @key{RET} + @key{DEL}
1389 The @samp{.} symbol is a marker that represents the top of the stack.
1390 Note that the ``top'' of the stack is really shown at the bottom of
1391 the Stack window. This may seem backwards, but it turns out to be
1392 less distracting in regular use.
1394 @cindex Stack levels
1395 @cindex Levels of stack
1396 The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
1397 numbers}. Old RPN calculators always had four stack levels called
1398 @expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow
1399 as large as you like, so it uses numbers instead of letters. Some
1400 stack-manipulation commands accept a numeric argument that says
1401 which stack level to work on. Normal commands like @kbd{+} always
1402 work on the top few levels of the stack.
1404 @c [fix-ref Truncating the Stack]
1405 The Stack buffer is just an Emacs buffer, and you can move around in
1406 it using the regular Emacs motion commands. But no matter where the
1407 cursor is, even if you have scrolled the @samp{.} marker out of
1408 view, most Calc commands always move the cursor back down to level 1
1409 before doing anything. It is possible to move the @samp{.} marker
1410 upwards through the stack, temporarily ``hiding'' some numbers from
1411 commands like @kbd{+}. This is called @dfn{stack truncation} and
1412 we will not cover it in this tutorial; @pxref{Truncating the Stack},
1413 if you are interested.
1415 You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
1416 @key{RET} +}. That's because if you type any operator name or
1417 other non-numeric key when you are entering a number, the Calculator
1418 automatically enters that number and then does the requested command.
1419 Thus @kbd{2 @key{RET} 3 +} will work just as well.
1421 Examples in this tutorial will often omit @key{RET} even when the
1422 stack displays shown would only happen if you did press @key{RET}:
1435 Here, after pressing @kbd{3} the stack would really show @samp{1: 2}
1436 with @samp{Calc:@: 3} in the minibuffer. In these situations, you can
1437 press the optional @key{RET} to see the stack as the figure shows.
1439 (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises
1440 at various points. Try them if you wish. Answers to all the exercises
1441 are located at the end of the Tutorial chapter. Each exercise will
1442 include a cross-reference to its particular answer. If you are
1443 reading with the Emacs Info system, press @kbd{f} and the
1444 exercise number to go to the answer, then the letter @kbd{l} to
1445 return to where you were.)
1448 Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2
1449 @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for
1450 multiplication.) Figure it out by hand, then try it with Calc to see
1451 if you're right. @xref{RPN Answer 1, 1}. (@bullet{})
1453 (@bullet{}) @strong{Exercise 2.} Compute
1454 @texline @math{(2\times4) + (7\times9.4) + {5\over4}}
1455 @infoline @expr{2*4 + 7*9.5 + 5/4}
1456 using the stack. @xref{RPN Answer 2, 2}. (@bullet{})
1458 The @key{DEL} key is called Backspace on some keyboards. It is
1459 whatever key you would use to correct a simple typing error when
1460 regularly using Emacs. The @key{DEL} key pops and throws away the
1461 top value on the stack. (You can still get that value back from
1462 the Trail if you should need it later on.) There are many places
1463 in this tutorial where we assume you have used @key{DEL} to erase the
1464 results of the previous example at the beginning of a new example.
1465 In the few places where it is really important to use @key{DEL} to
1466 clear away old results, the text will remind you to do so.
1468 (It won't hurt to let things accumulate on the stack, except that
1469 whenever you give a display-mode-changing command Calc will have to
1470 spend a long time reformatting such a large stack.)
1472 Since the @kbd{-} key is also an operator (it subtracts the top two
1473 stack elements), how does one enter a negative number? Calc uses
1474 the @kbd{_} (underscore) key to act like the minus sign in a number.
1475 So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
1476 will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
1478 You can also press @kbd{n}, which means ``change sign.'' It changes
1479 the number at the top of the stack (or the number being entered)
1480 from positive to negative or vice-versa: @kbd{5 n @key{RET}}.
1482 @cindex Duplicating a stack entry
1483 If you press @key{RET} when you're not entering a number, the effect
1484 is to duplicate the top number on the stack. Consider this calculation:
1488 1: 3 2: 3 1: 9 2: 9 1: 81
1492 3 @key{RET} @key{RET} * @key{RET} *
1497 (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
1498 to raise 3 to the fourth power.)
1500 The space-bar key (denoted @key{SPC} here) performs the same function
1501 as @key{RET}; you could replace all three occurrences of @key{RET} in
1502 the above example with @key{SPC} and the effect would be the same.
1504 @cindex Exchanging stack entries
1505 Another stack manipulation key is @key{TAB}. This exchanges the top
1506 two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +}
1507 to get 5, and then you realize what you really wanted to compute
1508 was @expr{20 / (2+3)}.
1512 1: 5 2: 5 2: 20 1: 4
1516 2 @key{RET} 3 + 20 @key{TAB} /
1521 Planning ahead, the calculation would have gone like this:
1525 1: 20 2: 20 3: 20 2: 20 1: 4
1530 20 @key{RET} 2 @key{RET} 3 + /
1534 A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
1535 @key{TAB}). It rotates the top three elements of the stack upward,
1536 bringing the object in level 3 to the top.
1540 1: 10 2: 10 3: 10 3: 20 3: 30
1541 . 1: 20 2: 20 2: 30 2: 10
1545 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB}
1549 (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
1550 on the stack. Figure out how to add one to the number in level 2
1551 without affecting the rest of the stack. Also figure out how to add
1552 one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{})
1554 Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
1555 arguments from the stack and push a result. Operations like @kbd{n} and
1556 @kbd{Q} (square root) pop a single number and push the result. You can
1557 think of them as simply operating on the top element of the stack.
1561 1: 3 1: 9 2: 9 1: 25 1: 5
1565 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q
1570 (Note that capital @kbd{Q} means to hold down the Shift key while
1571 typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.)
1573 @cindex Pythagorean Theorem
1574 Here we've used the Pythagorean Theorem to determine the hypotenuse of a
1575 right triangle. Calc actually has a built-in command for that called
1576 @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
1577 We can still enter it by its full name using @kbd{M-x} notation:
1585 3 @key{RET} 4 @key{RET} M-x calc-hypot
1589 All Calculator commands begin with the word @samp{calc-}. Since it
1590 gets tiring to type this, Calc provides an @kbd{x} key which is just
1591 like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
1600 3 @key{RET} 4 @key{RET} x hypot
1604 What happens if you take the square root of a negative number?
1608 1: 4 1: -4 1: (0, 2)
1616 The notation @expr{(a, b)} represents a complex number.
1617 Complex numbers are more traditionally written @expr{a + b i};
1618 Calc can display in this format, too, but for now we'll stick to the
1619 @expr{(a, b)} notation.
1621 If you don't know how complex numbers work, you can safely ignore this
1622 feature. Complex numbers only arise from operations that would be
1623 errors in a calculator that didn't have complex numbers. (For example,
1624 taking the square root or logarithm of a negative number produces a
1627 Complex numbers are entered in the notation shown. The @kbd{(} and
1628 @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
1632 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3)
1640 You can perform calculations while entering parts of incomplete objects.
1641 However, an incomplete object cannot actually participate in a calculation:
1645 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ...
1655 Adding 5 to an incomplete object makes no sense, so the last command
1656 produces an error message and leaves the stack the same.
1658 Incomplete objects can't participate in arithmetic, but they can be
1659 moved around by the regular stack commands.
1663 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3)
1664 1: 3 2: 3 2: ( ... 2 .
1668 2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} )
1673 Note that the @kbd{,} (comma) key did not have to be used here.
1674 When you press @kbd{)} all the stack entries between the incomplete
1675 entry and the top are collected, so there's never really a reason
1676 to use the comma. It's up to you.
1678 (@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)},
1679 your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened?
1680 (Joe thought of a clever way to correct his mistake in only two
1681 keystrokes, but it didn't quite work. Try it to find out why.)
1682 @xref{RPN Answer 4, 4}. (@bullet{})
1684 Vectors are entered the same way as complex numbers, but with square
1685 brackets in place of parentheses. We'll meet vectors again later in
1688 Any Emacs command can be given a @dfn{numeric prefix argument} by
1689 typing a series of @key{META}-digits beforehand. If @key{META} is
1690 awkward for you, you can instead type @kbd{C-u} followed by the
1691 necessary digits. Numeric prefix arguments can be negative, as in
1692 @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric
1693 prefix arguments in a variety of ways. For example, a numeric prefix
1694 on the @kbd{+} operator adds any number of stack entries at once:
1698 1: 10 2: 10 3: 10 3: 10 1: 60
1699 . 1: 20 2: 20 2: 20 .
1703 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 +
1707 For stack manipulation commands like @key{RET}, a positive numeric
1708 prefix argument operates on the top @var{n} stack entries at once. A
1709 negative argument operates on the entry in level @var{n} only. An
1710 argument of zero operates on the entire stack. In this example, we copy
1711 the second-to-top element of the stack:
1715 1: 10 2: 10 3: 10 3: 10 4: 10
1716 . 1: 20 2: 20 2: 20 3: 20
1721 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET}
1725 @cindex Clearing the stack
1726 @cindex Emptying the stack
1727 Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
1728 (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
1731 @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
1732 @subsection Algebraic-Style Calculations
1735 If you are not used to RPN notation, you may prefer to operate the
1736 Calculator in Algebraic mode, which is closer to the way
1737 non-RPN calculators work. In Algebraic mode, you enter formulas
1738 in traditional @expr{2+3} notation.
1740 @strong{Warning:} Note that @samp{/} has lower precedence than
1741 @samp{*}, so that @samp{a/b*c} is interpreted as @samp{a/(b*c)}. See
1744 You don't really need any special ``mode'' to enter algebraic formulas.
1745 You can enter a formula at any time by pressing the apostrophe (@kbd{'})
1746 key. Answer the prompt with the desired formula, then press @key{RET}.
1747 The formula is evaluated and the result is pushed onto the RPN stack.
1748 If you don't want to think in RPN at all, you can enter your whole
1749 computation as a formula, read the result from the stack, then press
1750 @key{DEL} to delete it from the stack.
1752 Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
1753 The result should be the number 9.
1755 Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
1756 @samp{/}, and @samp{^}. You can use parentheses to make the order
1757 of evaluation clear. In the absence of parentheses, @samp{^} is
1758 evaluated first, then @samp{*}, then @samp{/}, then finally
1759 @samp{+} and @samp{-}. For example, the expression
1762 2 + 3*4*5 / 6*7^8 - 9
1769 2 + ((3*4*5) / (6*(7^8)) - 9
1773 or, in large mathematical notation,
1788 $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
1793 The result of this expression will be the number @mathit{-6.99999826533}.
1795 Calc's order of evaluation is the same as for most computer languages,
1796 except that @samp{*} binds more strongly than @samp{/}, as the above
1797 example shows. As in normal mathematical notation, the @samp{*} symbol
1798 can often be omitted: @samp{2 a} is the same as @samp{2*a}.
1800 Operators at the same level are evaluated from left to right, except
1801 that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is
1802 equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent
1803 to @samp{2^(3^4)} (a very large integer; try it!).
1805 If you tire of typing the apostrophe all the time, there is
1806 Algebraic mode, where Calc automatically senses
1807 when you are about to type an algebraic expression. To enter this
1808 mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator
1809 should appear in the Calc window's mode line.)
1811 Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
1813 In Algebraic mode, when you press any key that would normally begin
1814 entering a number (such as a digit, a decimal point, or the @kbd{_}
1815 key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
1818 Functions which do not have operator symbols like @samp{+} and @samp{*}
1819 must be entered in formulas using function-call notation. For example,
1820 the function name corresponding to the square-root key @kbd{Q} is
1821 @code{sqrt}. To compute a square root in a formula, you would use
1822 the notation @samp{sqrt(@var{x})}.
1824 Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should
1825 be @expr{0.16227766017}.
1827 Note that if the formula begins with a function name, you need to use
1828 the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin}
1829 out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
1830 command, and the @kbd{csin} will be taken as the name of the rewrite
1833 Some people prefer to enter complex numbers and vectors in algebraic
1834 form because they find RPN entry with incomplete objects to be too
1835 distracting, even though they otherwise use Calc as an RPN calculator.
1837 Still in Algebraic mode, type:
1841 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1)
1842 . 1: (1, -2) . 1: 1 .
1845 (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} +
1849 Algebraic mode allows us to enter complex numbers without pressing
1850 an apostrophe first, but it also means we need to press @key{RET}
1851 after every entry, even for a simple number like @expr{1}.
1853 (You can type @kbd{C-u m a} to enable a special Incomplete Algebraic
1854 mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even
1855 though regular numeric keys still use RPN numeric entry. There is also
1856 Total Algebraic mode, started by typing @kbd{m t}, in which all
1857 normal keys begin algebraic entry. You must then use the @key{META} key
1858 to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic
1859 mode, @kbd{M-q} to quit, etc.)
1861 If you're still in Algebraic mode, press @kbd{m a} again to turn it off.
1863 Actual non-RPN calculators use a mixture of algebraic and RPN styles.
1864 In general, operators of two numbers (like @kbd{+} and @kbd{*})
1865 use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
1866 use RPN form. Also, a non-RPN calculator allows you to see the
1867 intermediate results of a calculation as you go along. You can
1868 accomplish this in Calc by performing your calculation as a series
1869 of algebraic entries, using the @kbd{$} sign to tie them together.
1870 In an algebraic formula, @kbd{$} represents the number on the top
1871 of the stack. Here, we perform the calculation
1872 @texline @math{\sqrt{2\times4+1}},
1873 @infoline @expr{sqrt(2*4+1)},
1874 which on a traditional calculator would be done by pressing
1875 @kbd{2 * 4 + 1 =} and then the square-root key.
1882 ' 2*4 @key{RET} $+1 @key{RET} Q
1887 Notice that we didn't need to press an apostrophe for the @kbd{$+1},
1888 because the dollar sign always begins an algebraic entry.
1890 (@bullet{}) @strong{Exercise 1.} How could you get the same effect as
1891 pressing @kbd{Q} but using an algebraic entry instead? How about
1892 if the @kbd{Q} key on your keyboard were broken?
1893 @xref{Algebraic Answer 1, 1}. (@bullet{})
1895 The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
1896 entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
1898 Algebraic formulas can include @dfn{variables}. To store in a
1899 variable, press @kbd{s s}, then type the variable name, then press
1900 @key{RET}. (There are actually two flavors of store command:
1901 @kbd{s s} stores a number in a variable but also leaves the number
1902 on the stack, while @w{@kbd{s t}} removes a number from the stack and
1903 stores it in the variable.) A variable name should consist of one
1904 or more letters or digits, beginning with a letter.
1908 1: 17 . 1: a + a^2 1: 306
1911 17 s t a @key{RET} ' a+a^2 @key{RET} =
1916 The @kbd{=} key @dfn{evaluates} a formula by replacing all its
1917 variables by the values that were stored in them.
1919 For RPN calculations, you can recall a variable's value on the
1920 stack either by entering its name as a formula and pressing @kbd{=},
1921 or by using the @kbd{s r} command.
1925 1: 17 2: 17 3: 17 2: 17 1: 306
1926 . 1: 17 2: 17 1: 289 .
1930 s r a @key{RET} ' a @key{RET} = 2 ^ +
1934 If you press a single digit for a variable name (as in @kbd{s t 3}, you
1935 get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
1936 They are ``quick'' simply because you don't have to type the letter
1937 @code{q} or the @key{RET} after their names. In fact, you can type
1938 simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
1939 @kbd{t 3} and @w{@kbd{r 3}}.
1941 Any variables in an algebraic formula for which you have not stored
1942 values are left alone, even when you evaluate the formula.
1946 1: 2 a + 2 b 1: 34 + 2 b
1953 Calls to function names which are undefined in Calc are also left
1954 alone, as are calls for which the value is undefined.
1958 1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
1961 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
1966 In this example, the first call to @code{log10} works, but the other
1967 calls are not evaluated. In the second call, the logarithm is
1968 undefined for that value of the argument; in the third, the argument
1969 is symbolic, and in the fourth, there are too many arguments. In the
1970 fifth case, there is no function called @code{foo}. You will see a
1971 ``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
1972 Press the @kbd{w} (``why'') key to see any other messages that may
1973 have arisen from the last calculation. In this case you will get
1974 ``logarithm of zero,'' then ``number expected: @code{x}''. Calc
1975 automatically displays the first message only if the message is
1976 sufficiently important; for example, Calc considers ``wrong number
1977 of arguments'' and ``logarithm of zero'' to be important enough to
1978 report automatically, while a message like ``number expected: @code{x}''
1979 will only show up if you explicitly press the @kbd{w} key.
1981 (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y},
1982 stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
1983 @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)},
1984 expecting @samp{10 (1+y)}, but it didn't work. Why not?
1985 @xref{Algebraic Answer 2, 2}. (@bullet{})
1987 (@bullet{}) @strong{Exercise 3.} What result would you expect
1988 @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}?
1989 @xref{Algebraic Answer 3, 3}. (@bullet{})
1991 One interesting way to work with variables is to use the
1992 @dfn{evaluates-to} (@samp{=>}) operator. It works like this:
1993 Enter a formula algebraically in the usual way, but follow
1994 the formula with an @samp{=>} symbol. (There is also an @kbd{s =}
1995 command which builds an @samp{=>} formula using the stack.) On
1996 the stack, you will see two copies of the formula with an @samp{=>}
1997 between them. The lefthand formula is exactly like you typed it;
1998 the righthand formula has been evaluated as if by typing @kbd{=}.
2002 2: 2 + 3 => 5 2: 2 + 3 => 5
2003 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b
2006 ' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET}
2011 Notice that the instant we stored a new value in @code{a}, all
2012 @samp{=>} operators already on the stack that referred to @expr{a}
2013 were updated to use the new value. With @samp{=>}, you can push a
2014 set of formulas on the stack, then change the variables experimentally
2015 to see the effects on the formulas' values.
2017 You can also ``unstore'' a variable when you are through with it:
2022 1: 2 a + 2 b => 2 a + 2 b
2029 We will encounter formulas involving variables and functions again
2030 when we discuss the algebra and calculus features of the Calculator.
2032 @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
2033 @subsection Undo and Redo
2036 If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
2037 the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
2038 and restart Calc (@kbd{C-x * * C-x * *}) to make sure things start off
2039 with a clean slate. Now:
2043 1: 2 2: 2 1: 8 2: 2 1: 6
2051 You can undo any number of times. Calc keeps a complete record of
2052 all you have done since you last opened the Calc window. After the
2053 above example, you could type:
2065 You can also type @kbd{D} to ``redo'' a command that you have undone
2070 . 1: 2 2: 2 1: 6 1: 6
2079 It was not possible to redo past the @expr{6}, since that was placed there
2080 by something other than an undo command.
2083 You can think of undo and redo as a sort of ``time machine.'' Press
2084 @kbd{U} to go backward in time, @kbd{D} to go forward. If you go
2085 backward and do something (like @kbd{*}) then, as any science fiction
2086 reader knows, you have changed your future and you cannot go forward
2087 again. Thus, the inability to redo past the @expr{6} even though there
2088 was an earlier undo command.
2090 You can always recall an earlier result using the Trail. We've ignored
2091 the trail so far, but it has been faithfully recording everything we
2092 did since we loaded the Calculator. If the Trail is not displayed,
2093 press @kbd{t d} now to turn it on.
2095 Let's try grabbing an earlier result. The @expr{8} we computed was
2096 undone by a @kbd{U} command, and was lost even to Redo when we pressed
2097 @kbd{*}, but it's still there in the trail. There should be a little
2098 @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
2099 entry. If there isn't, press @kbd{t ]} to reset the trail pointer.
2100 Now, press @w{@kbd{t p}} to move the arrow onto the line containing
2101 @expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
2104 If you press @kbd{t ]} again, you will see that even our Yank command
2105 went into the trail.
2107 Let's go further back in time. Earlier in the tutorial we computed
2108 a huge integer using the formula @samp{2^3^4}. We don't remember
2109 what it was, but the first digits were ``241''. Press @kbd{t r}
2110 (which stands for trail-search-reverse), then type @kbd{241}.
2111 The trail cursor will jump back to the next previous occurrence of
2112 the string ``241'' in the trail. This is just a regular Emacs
2113 incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
2114 continue the search forwards or backwards as you like.
2116 To finish the search, press @key{RET}. This halts the incremental
2117 search and leaves the trail pointer at the thing we found. Now we
2118 can type @kbd{t y} to yank that number onto the stack. If we hadn't
2119 remembered the ``241'', we could simply have searched for @kbd{2^3^4},
2120 then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
2122 You may have noticed that all the trail-related commands begin with
2123 the letter @kbd{t}. (The store-and-recall commands, on the other hand,
2124 all began with @kbd{s}.) Calc has so many commands that there aren't
2125 enough keys for all of them, so various commands are grouped into
2126 two-letter sequences where the first letter is called the @dfn{prefix}
2127 key. If you type a prefix key by accident, you can press @kbd{C-g}
2128 to cancel it. (In fact, you can press @kbd{C-g} to cancel almost
2129 anything in Emacs.) To get help on a prefix key, press that key
2130 followed by @kbd{?}. Some prefixes have several lines of help,
2131 so you need to press @kbd{?} repeatedly to see them all.
2132 You can also type @kbd{h h} to see all the help at once.
2134 Try pressing @kbd{t ?} now. You will see a line of the form,
2137 trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t-
2141 The word ``trail'' indicates that the @kbd{t} prefix key contains
2142 trail-related commands. Each entry on the line shows one command,
2143 with a single capital letter showing which letter you press to get
2144 that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
2145 @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?}
2146 again to see more @kbd{t}-prefix commands. Notice that the commands
2147 are roughly divided (by semicolons) into related groups.
2149 When you are in the help display for a prefix key, the prefix is
2150 still active. If you press another key, like @kbd{y} for example,
2151 it will be interpreted as a @kbd{t y} command. If all you wanted
2152 was to look at the help messages, press @kbd{C-g} afterwards to cancel
2155 One more way to correct an error is by editing the stack entries.
2156 The actual Stack buffer is marked read-only and must not be edited
2157 directly, but you can press @kbd{`} (the backquote or accent grave)
2158 to edit a stack entry.
2160 Try entering @samp{3.141439} now. If this is supposed to represent
2161 @cpi{}, it's got several errors. Press @kbd{`} to edit this number.
2162 Now use the normal Emacs cursor motion and editing keys to change
2163 the second 4 to a 5, and to transpose the 3 and the 9. When you
2164 press @key{RET}, the number on the stack will be replaced by your
2165 new number. This works for formulas, vectors, and all other types
2166 of values you can put on the stack. The @kbd{`} key also works
2167 during entry of a number or algebraic formula.
2169 @node Modes Tutorial, , Undo Tutorial, Basic Tutorial
2170 @subsection Mode-Setting Commands
2173 Calc has many types of @dfn{modes} that affect the way it interprets
2174 your commands or the way it displays data. We have already seen one
2175 mode, namely Algebraic mode. There are many others, too; we'll
2176 try some of the most common ones here.
2178 Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
2179 Notice the @samp{12} on the Calc window's mode line:
2182 --%%-Calc: 12 Deg (Calculator)----All------
2186 Most of the symbols there are Emacs things you don't need to worry
2187 about, but the @samp{12} and the @samp{Deg} are mode indicators.
2188 The @samp{12} means that calculations should always be carried to
2189 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /},
2190 we get @expr{0.142857142857} with exactly 12 digits, not counting
2191 leading and trailing zeros.
2193 You can set the precision to anything you like by pressing @kbd{p},
2194 then entering a suitable number. Try pressing @kbd{p 30 @key{RET}},
2195 then doing @kbd{1 @key{RET} 7 /} again:
2200 2: 0.142857142857142857142857142857
2205 Although the precision can be set arbitrarily high, Calc always
2206 has to have @emph{some} value for the current precision. After
2207 all, the true value @expr{1/7} is an infinitely repeating decimal;
2208 Calc has to stop somewhere.
2210 Of course, calculations are slower the more digits you request.
2211 Press @w{@kbd{p 12}} now to set the precision back down to the default.
2213 Calculations always use the current precision. For example, even
2214 though we have a 30-digit value for @expr{1/7} on the stack, if
2215 we use it in a calculation in 12-digit mode it will be rounded
2216 down to 12 digits before it is used. Try it; press @key{RET} to
2217 duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET}
2218 key didn't round the number, because it doesn't do any calculation.
2219 But the instant we pressed @kbd{+}, the number was rounded down.
2224 2: 0.142857142857142857142857142857
2231 In fact, since we added a digit on the left, we had to lose one
2232 digit on the right from even the 12-digit value of @expr{1/7}.
2234 How did we get more than 12 digits when we computed @samp{2^3^4}? The
2235 answer is that Calc makes a distinction between @dfn{integers} and
2236 @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number
2237 that does not contain a decimal point. There is no such thing as an
2238 ``infinitely repeating fraction integer,'' so Calc doesn't have to limit
2239 itself. If you asked for @samp{2^10000} (don't try this!), you would
2240 have to wait a long time but you would eventually get an exact answer.
2241 If you ask for @samp{2.^10000}, you will quickly get an answer which is
2242 correct only to 12 places. The decimal point tells Calc that it should
2243 use floating-point arithmetic to get the answer, not exact integer
2246 You can use the @kbd{F} (@code{calc-floor}) command to convert a
2247 floating-point value to an integer, and @kbd{c f} (@code{calc-float})
2248 to convert an integer to floating-point form.
2250 Let's try entering that last calculation:
2254 1: 2. 2: 2. 1: 1.99506311689e3010
2258 2.0 @key{RET} 10000 @key{RET} ^
2263 @cindex Scientific notation, entry of
2264 Notice the letter @samp{e} in there. It represents ``times ten to the
2265 power of,'' and is used by Calc automatically whenever writing the
2266 number out fully would introduce more extra zeros than you probably
2267 want to see. You can enter numbers in this notation, too.
2271 1: 2. 2: 2. 1: 1.99506311678e3010
2275 2.0 @key{RET} 1e4 @key{RET} ^
2279 @cindex Round-off errors
2281 Hey, the answer is different! Look closely at the middle columns
2282 of the two examples. In the first, the stack contained the
2283 exact integer @expr{10000}, but in the second it contained
2284 a floating-point value with a decimal point. When you raise a
2285 number to an integer power, Calc uses repeated squaring and
2286 multiplication to get the answer. When you use a floating-point
2287 power, Calc uses logarithms and exponentials. As you can see,
2288 a slight error crept in during one of these methods. Which
2289 one should we trust? Let's raise the precision a bit and find
2294 . 1: 2. 2: 2. 1: 1.995063116880828e3010
2298 p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET}
2303 @cindex Guard digits
2304 Presumably, it doesn't matter whether we do this higher-precision
2305 calculation using an integer or floating-point power, since we
2306 have added enough ``guard digits'' to trust the first 12 digits
2307 no matter what. And the verdict is@dots{} Integer powers were more
2308 accurate; in fact, the result was only off by one unit in the
2311 @cindex Guard digits
2312 Calc does many of its internal calculations to a slightly higher
2313 precision, but it doesn't always bump the precision up enough.
2314 In each case, Calc added about two digits of precision during
2315 its calculation and then rounded back down to 12 digits
2316 afterward. In one case, it was enough; in the other, it
2317 wasn't. If you really need @var{x} digits of precision, it
2318 never hurts to do the calculation with a few extra guard digits.
2320 What if we want guard digits but don't want to look at them?
2321 We can set the @dfn{float format}. Calc supports four major
2322 formats for floating-point numbers, called @dfn{normal},
2323 @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
2324 notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f},
2325 @kbd{d s}, and @kbd{d e}, respectively. In each case, you can
2326 supply a numeric prefix argument which says how many digits
2327 should be displayed. As an example, let's put a few numbers
2328 onto the stack and try some different display modes. First,
2329 use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
2334 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2335 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000
2336 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450
2337 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345
2340 d n M-3 d n d s M-3 d s M-3 d f
2345 Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
2346 to three significant digits, but then when we typed @kbd{d s} all
2347 five significant figures reappeared. The float format does not
2348 affect how numbers are stored, it only affects how they are
2349 displayed. Only the current precision governs the actual rounding
2350 of numbers in the Calculator's memory.
2352 Engineering notation, not shown here, is like scientific notation
2353 except the exponent (the power-of-ten part) is always adjusted to be
2354 a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result
2355 there will be one, two, or three digits before the decimal point.
2357 Whenever you change a display-related mode, Calc redraws everything
2358 in the stack. This may be slow if there are many things on the stack,
2359 so Calc allows you to type shift-@kbd{H} before any mode command to
2360 prevent it from updating the stack. Anything Calc displays after the
2361 mode-changing command will appear in the new format.
2365 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2366 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345.
2367 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45
2368 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345
2371 H d s @key{DEL} U @key{TAB} d @key{SPC} d n
2376 Here the @kbd{H d s} command changes to scientific notation but without
2377 updating the screen. Deleting the top stack entry and undoing it back
2378 causes it to show up in the new format; swapping the top two stack
2379 entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the
2380 whole stack. The @kbd{d n} command changes back to the normal float
2381 format; since it doesn't have an @kbd{H} prefix, it also updates all
2382 the stack entries to be in @kbd{d n} format.
2384 Notice that the integer @expr{12345} was not affected by any
2385 of the float formats. Integers are integers, and are always
2388 @cindex Large numbers, readability
2389 Large integers have their own problems. Let's look back at
2390 the result of @kbd{2^3^4}.
2393 2417851639229258349412352
2397 Quick---how many digits does this have? Try typing @kbd{d g}:
2400 2,417,851,639,229,258,349,412,352
2404 Now how many digits does this have? It's much easier to tell!
2405 We can actually group digits into clumps of any size. Some
2406 people prefer @kbd{M-5 d g}:
2409 24178,51639,22925,83494,12352
2412 Let's see what happens to floating-point numbers when they are grouped.
2413 First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
2414 to get ourselves into trouble. Now, type @kbd{1e13 /}:
2417 24,17851,63922.9258349412352
2421 The integer part is grouped but the fractional part isn't. Now try
2422 @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
2425 24,17851,63922.92583,49412,352
2428 If you find it hard to tell the decimal point from the commas, try
2429 changing the grouping character to a space with @kbd{d , @key{SPC}}:
2432 24 17851 63922.92583 49412 352
2435 Type @kbd{d , ,} to restore the normal grouping character, then
2436 @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to
2437 restore the default precision.
2439 Press @kbd{U} enough times to get the original big integer back.
2440 (Notice that @kbd{U} does not undo each mode-setting command; if
2441 you want to undo a mode-setting command, you have to do it yourself.)
2442 Now, type @kbd{d r 16 @key{RET}}:
2445 16#200000000000000000000
2449 The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
2450 Suddenly it looks pretty simple; this should be no surprise, since we
2451 got this number by computing a power of two, and 16 is a power of 2.
2452 In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
2456 2#1000000000000000000000000000000000000000000000000000000 @dots{}
2460 We don't have enough space here to show all the zeros! They won't
2461 fit on a typical screen, either, so you will have to use horizontal
2462 scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the
2463 stack window left and right by half its width. Another way to view
2464 something large is to press @kbd{`} (back-quote) to edit the top of
2465 stack in a separate window. (Press @kbd{C-c C-c} when you are done.)
2467 You can enter non-decimal numbers using the @kbd{#} symbol, too.
2468 Let's see what the hexadecimal number @samp{5FE} looks like in
2469 binary. Type @kbd{16#5FE} (the letters can be typed in upper or
2470 lower case; they will always appear in upper case). It will also
2471 help to turn grouping on with @kbd{d g}:
2477 Notice that @kbd{d g} groups by fours by default if the display radix
2478 is binary or hexadecimal, but by threes if it is decimal, octal, or any
2481 Now let's see that number in decimal; type @kbd{d r 10}:
2487 Numbers are not @emph{stored} with any particular radix attached. They're
2488 just numbers; they can be entered in any radix, and are always displayed
2489 in whatever radix you've chosen with @kbd{d r}. The current radix applies
2490 to integers, fractions, and floats.
2492 @cindex Roundoff errors, in non-decimal numbers
2493 (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third
2494 as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got
2495 @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied
2496 that by three, he got @samp{3#0.222222...} instead of the expected
2497 @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief,
2498 saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got
2499 @samp{3#0.10000001} (some zeros omitted). What's going on here?
2500 @xref{Modes Answer 1, 1}. (@bullet{})
2502 @cindex Scientific notation, in non-decimal numbers
2503 (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal
2504 modes in the natural way (the exponent is a power of the radix instead of
2505 a power of ten, although the exponent itself is always written in decimal).
2506 Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number
2507 @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}.
2508 What is wrong with this picture? What could we write instead that would
2509 work better? @xref{Modes Answer 2, 2}. (@bullet{})
2511 The @kbd{m} prefix key has another set of modes, relating to the way
2512 Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix
2513 modes generally affect the way things look, @kbd{m}-prefix modes affect
2514 the way they are actually computed.
2516 The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice
2517 the @samp{Deg} indicator in the mode line. This means that if you use
2518 a command that interprets a number as an angle, it will assume the
2519 angle is measured in degrees. For example,
2523 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5
2531 The shift-@kbd{S} command computes the sine of an angle. The sine
2533 @texline @math{\sqrt{2}/2};
2534 @infoline @expr{sqrt(2)/2};
2535 squaring this yields @expr{2/4 = 0.5}. However, there has been a slight
2536 roundoff error because the representation of
2537 @texline @math{\sqrt{2}/2}
2538 @infoline @expr{sqrt(2)/2}
2539 wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers
2540 in this case; it temporarily reduces the precision by one digit while it
2541 re-rounds the number on the top of the stack.
2543 @cindex Roundoff errors, examples
2544 (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine
2545 of 45 degrees as shown above, then, hoping to avoid an inexact
2546 result, he increased the precision to 16 digits before squaring.
2547 What happened? @xref{Modes Answer 3, 3}. (@bullet{})
2549 To do this calculation in radians, we would type @kbd{m r} first.
2550 (The indicator changes to @samp{Rad}.) 45 degrees corresponds to
2551 @cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once
2552 again, this is a shifted capital @kbd{P}. Remember, unshifted
2553 @kbd{p} sets the precision.)
2557 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187
2564 Likewise, inverse trigonometric functions generate results in
2565 either radians or degrees, depending on the current angular mode.
2569 1: 0.707106781187 1: 0.785398163398 1: 45.
2572 .5 Q m r I S m d U I S
2577 Here we compute the Inverse Sine of
2578 @texline @math{\sqrt{0.5}},
2579 @infoline @expr{sqrt(0.5)},
2580 first in radians, then in degrees.
2582 Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
2587 1: 45 1: 0.785398163397 1: 45.
2594 Another interesting mode is @dfn{Fraction mode}. Normally,
2595 dividing two integers produces a floating-point result if the
2596 quotient can't be expressed as an exact integer. Fraction mode
2597 causes integer division to produce a fraction, i.e., a rational
2602 2: 12 1: 1.33333333333 1: 4:3
2606 12 @key{RET} 9 / m f U / m f
2611 In the first case, we get an approximate floating-point result.
2612 In the second case, we get an exact fractional result (four-thirds).
2614 You can enter a fraction at any time using @kbd{:} notation.
2615 (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
2616 because @kbd{/} is already used to divide the top two stack
2617 elements.) Calculations involving fractions will always
2618 produce exact fractional results; Fraction mode only says
2619 what to do when dividing two integers.
2621 @cindex Fractions vs. floats
2622 @cindex Floats vs. fractions
2623 (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact,
2624 why would you ever use floating-point numbers instead?
2625 @xref{Modes Answer 4, 4}. (@bullet{})
2627 Typing @kbd{m f} doesn't change any existing values in the stack.
2628 In the above example, we had to Undo the division and do it over
2629 again when we changed to Fraction mode. But if you use the
2630 evaluates-to operator you can get commands like @kbd{m f} to
2635 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3
2638 ' 12/9 => @key{RET} p 4 @key{RET} m f
2643 In this example, the righthand side of the @samp{=>} operator
2644 on the stack is recomputed when we change the precision, then
2645 again when we change to Fraction mode. All @samp{=>} expressions
2646 on the stack are recomputed every time you change any mode that
2647 might affect their values.
2649 @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
2650 @section Arithmetic Tutorial
2653 In this section, we explore the arithmetic and scientific functions
2654 available in the Calculator.
2656 The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
2657 and @kbd{^}. Each normally takes two numbers from the top of the stack
2658 and pushes back a result. The @kbd{n} and @kbd{&} keys perform
2659 change-sign and reciprocal operations, respectively.
2663 1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
2670 @cindex Binary operators
2671 You can apply a ``binary operator'' like @kbd{+} across any number of
2672 stack entries by giving it a numeric prefix. You can also apply it
2673 pairwise to several stack elements along with the top one if you use
2678 3: 2 1: 9 3: 2 4: 2 3: 12
2679 2: 3 . 2: 3 3: 3 2: 13
2680 1: 4 1: 4 2: 4 1: 14
2684 2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 +
2688 @cindex Unary operators
2689 You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
2690 stack entries with a numeric prefix, too.
2695 2: 3 2: 0.333333333333 2: 3.
2699 2 @key{RET} 3 @key{RET} 4 M-3 & M-2 &
2703 Notice that the results here are left in floating-point form.
2704 We can convert them back to integers by pressing @kbd{F}, the
2705 ``floor'' function. This function rounds down to the next lower
2706 integer. There is also @kbd{R}, which rounds to the nearest
2724 Since dividing-and-flooring (i.e., ``integer quotient'') is such a
2725 common operation, Calc provides a special command for that purpose, the
2726 backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which
2727 computes the remainder that would arise from a @kbd{\} operation, i.e.,
2728 the ``modulo'' of two numbers. For example,
2732 2: 1234 1: 12 2: 1234 1: 34
2736 1234 @key{RET} 100 \ U %
2740 These commands actually work for any real numbers, not just integers.
2744 2: 3.1415 1: 3 2: 3.1415 1: 0.1415
2748 3.1415 @key{RET} 1 \ U %
2752 (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a
2753 frill, since you could always do the same thing with @kbd{/ F}. Think
2754 of a situation where this is not true---@kbd{/ F} would be inadequate.
2755 Now think of a way you could get around the problem if Calc didn't
2756 provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{})
2758 We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
2759 commands. Other commands along those lines are @kbd{C} (cosine),
2760 @kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural
2761 logarithm). These can be modified by the @kbd{I} (inverse) and
2762 @kbd{H} (hyperbolic) prefix keys.
2764 Let's compute the sine and cosine of an angle, and verify the
2766 @texline @math{\sin^2x + \cos^2x = 1}.
2767 @infoline @expr{sin(x)^2 + cos(x)^2 = 1}.
2768 We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}.
2769 With the angular mode set to degrees (type @w{@kbd{m d}}), do:
2773 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
2774 1: -64 1: -0.89879 1: -64 1: 0.43837 .
2777 64 n @key{RET} @key{RET} S @key{TAB} C f h
2782 (For brevity, we're showing only five digits of the results here.
2783 You can of course do these calculations to any precision you like.)
2785 Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
2786 of squares, command.
2789 @texline @math{\displaystyle\tan x = {\sin x \over \cos x}}.
2790 @infoline @expr{tan(x) = sin(x) / cos(x)}.
2794 2: -0.89879 1: -2.0503 1: -64.
2802 A physical interpretation of this calculation is that if you move
2803 @expr{0.89879} units downward and @expr{0.43837} units to the right,
2804 your direction of motion is @mathit{-64} degrees from horizontal. Suppose
2805 we move in the opposite direction, up and to the left:
2809 2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
2810 1: 0.43837 1: -0.43837 . .
2818 How can the angle be the same? The answer is that the @kbd{/} operation
2819 loses information about the signs of its inputs. Because the quotient
2820 is negative, we know exactly one of the inputs was negative, but we
2821 can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which
2822 computes the inverse tangent of the quotient of a pair of numbers.
2823 Since you feed it the two original numbers, it has enough information
2824 to give you a full 360-degree answer.
2828 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
2829 1: -0.43837 . 2: -0.89879 1: -64. .
2833 U U f T M-@key{RET} M-2 n f T -
2838 The resulting angles differ by 180 degrees; in other words, they
2839 point in opposite directions, just as we would expect.
2841 The @key{META}-@key{RET} we used in the third step is the
2842 ``last-arguments'' command. It is sort of like Undo, except that it
2843 restores the arguments of the last command to the stack without removing
2844 the command's result. It is useful in situations like this one,
2845 where we need to do several operations on the same inputs. We could
2846 have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
2847 the top two stack elements right after the @kbd{U U}, then a pair of
2848 @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
2850 A similar identity is supposed to hold for hyperbolic sines and cosines,
2851 except that it is the @emph{difference}
2852 @texline @math{\cosh^2x - \sinh^2x}
2853 @infoline @expr{cosh(x)^2 - sinh(x)^2}
2854 that always equals one. Let's try to verify this identity.
2858 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
2859 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
2862 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^
2867 @cindex Roundoff errors, examples
2868 Something's obviously wrong, because when we subtract these numbers
2869 the answer will clearly be zero! But if you think about it, if these
2870 numbers @emph{did} differ by one, it would be in the 55th decimal
2871 place. The difference we seek has been lost entirely to roundoff
2874 We could verify this hypothesis by doing the actual calculation with,
2875 say, 60 decimal places of precision. This will be slow, but not
2876 enormously so. Try it if you wish; sure enough, the answer is
2877 0.99999, reasonably close to 1.
2879 Of course, a more reasonable way to verify the identity is to use
2880 a more reasonable value for @expr{x}!
2882 @cindex Common logarithm
2883 Some Calculator commands use the Hyperbolic prefix for other purposes.
2884 The logarithm and exponential functions, for example, work to the base
2885 @expr{e} normally but use base-10 instead if you use the Hyperbolic
2890 1: 1000 1: 6.9077 1: 1000 1: 3
2898 First, we mistakenly compute a natural logarithm. Then we undo
2899 and compute a common logarithm instead.
2901 The @kbd{B} key computes a general base-@var{b} logarithm for any
2906 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
2907 1: 10 . . 1: 2.71828 .
2910 1000 @key{RET} 10 B H E H P B
2915 Here we first use @kbd{B} to compute the base-10 logarithm, then use
2916 the ``hyperbolic'' exponential as a cheap hack to recover the number
2917 1000, then use @kbd{B} again to compute the natural logarithm. Note
2918 that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e}
2921 You may have noticed that both times we took the base-10 logarithm
2922 of 1000, we got an exact integer result. Calc always tries to give
2923 an exact rational result for calculations involving rational numbers
2924 where possible. But when we used @kbd{H E}, the result was a
2925 floating-point number for no apparent reason. In fact, if we had
2926 computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
2927 exact integer 1000. But the @kbd{H E} command is rigged to generate
2928 a floating-point result all of the time so that @kbd{1000 H E} will
2929 not waste time computing a thousand-digit integer when all you
2930 probably wanted was @samp{1e1000}.
2932 (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to
2933 the @kbd{B} command for which Calc could find an exact rational
2934 result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{})
2936 The Calculator also has a set of functions relating to combinatorics
2937 and statistics. You may be familiar with the @dfn{factorial} function,
2938 which computes the product of all the integers up to a given number.
2942 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
2950 Recall, the @kbd{c f} command converts the integer or fraction at the
2951 top of the stack to floating-point format. If you take the factorial
2952 of a floating-point number, you get a floating-point result
2953 accurate to the current precision. But if you give @kbd{!} an
2954 exact integer, you get an exact integer result (158 digits long
2957 If you take the factorial of a non-integer, Calc uses a generalized
2958 factorial function defined in terms of Euler's Gamma function
2959 @texline @math{\Gamma(n)}
2960 @infoline @expr{gamma(n)}
2961 (which is itself available as the @kbd{f g} command).
2965 3: 4. 3: 24. 1: 5.5 1: 52.342777847
2966 2: 4.5 2: 52.3427777847 . .
2970 M-3 ! M-0 @key{DEL} 5.5 f g
2975 Here we verify the identity
2976 @texline @math{n! = \Gamma(n+1)}.
2977 @infoline @expr{@var{n}!@: = gamma(@var{n}+1)}.
2979 The binomial coefficient @var{n}-choose-@var{m}
2980 @texline or @math{\displaystyle {n \choose m}}
2982 @texline @math{\displaystyle {n! \over m! \, (n-m)!}}
2983 @infoline @expr{n!@: / m!@: (n-m)!}
2984 for all reals @expr{n} and @expr{m}. The intermediate results in this
2985 formula can become quite large even if the final result is small; the
2986 @kbd{k c} command computes a binomial coefficient in a way that avoids
2987 large intermediate values.
2989 The @kbd{k} prefix key defines several common functions out of
2990 combinatorics and number theory. Here we compute the binomial
2991 coefficient 30-choose-20, then determine its prime factorization.
2995 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
2999 30 @key{RET} 20 k c k f
3004 You can verify these prime factors by using @kbd{v u} to ``unpack''
3005 this vector into 8 separate stack entries, then @kbd{M-8 *} to
3006 multiply them back together. The result is the original number,
3010 Suppose a program you are writing needs a hash table with at least
3011 10000 entries. It's best to use a prime number as the actual size
3012 of a hash table. Calc can compute the next prime number after 10000:
3016 1: 10000 1: 10007 1: 9973
3024 Just for kicks we've also computed the next prime @emph{less} than
3027 @c [fix-ref Financial Functions]
3028 @xref{Financial Functions}, for a description of the Calculator
3029 commands that deal with business and financial calculations (functions
3030 like @code{pv}, @code{rate}, and @code{sln}).
3032 @c [fix-ref Binary Number Functions]
3033 @xref{Binary Functions}, to read about the commands for operating
3034 on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
3036 @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
3037 @section Vector/Matrix Tutorial
3040 A @dfn{vector} is a list of numbers or other Calc data objects.
3041 Calc provides a large set of commands that operate on vectors. Some
3042 are familiar operations from vector analysis. Others simply treat
3043 a vector as a list of objects.
3046 * Vector Analysis Tutorial::
3051 @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
3052 @subsection Vector Analysis
3055 If you add two vectors, the result is a vector of the sums of the
3056 elements, taken pairwise.
3060 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3]
3064 [1,2,3] s 1 [7 6 0] s 2 +
3069 Note that we can separate the vector elements with either commas or
3070 spaces. This is true whether we are using incomplete vectors or
3071 algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these
3072 vectors so we can easily reuse them later.
3074 If you multiply two vectors, the result is the sum of the products
3075 of the elements taken pairwise. This is called the @dfn{dot product}
3089 The dot product of two vectors is equal to the product of their
3090 lengths times the cosine of the angle between them. (Here the vector
3091 is interpreted as a line from the origin @expr{(0,0,0)} to the
3092 specified point in three-dimensional space.) The @kbd{A}
3093 (absolute value) command can be used to compute the length of a
3098 3: 19 3: 19 1: 0.550782 1: 56.579
3099 2: [1, 2, 3] 2: 3.741657 . .
3100 1: [7, 6, 0] 1: 9.219544
3103 M-@key{RET} M-2 A * / I C
3108 First we recall the arguments to the dot product command, then
3109 we compute the absolute values of the top two stack entries to
3110 obtain the lengths of the vectors, then we divide the dot product
3111 by the product of the lengths to get the cosine of the angle.
3112 The inverse cosine finds that the angle between the vectors
3113 is about 56 degrees.
3115 @cindex Cross product
3116 @cindex Perpendicular vectors
3117 The @dfn{cross product} of two vectors is a vector whose length
3118 is the product of the lengths of the inputs times the sine of the
3119 angle between them, and whose direction is perpendicular to both
3120 input vectors. Unlike the dot product, the cross product is
3121 defined only for three-dimensional vectors. Let's double-check
3122 our computation of the angle using the cross product.
3126 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579
3127 1: [7, 6, 0] 2: [1, 2, 3] . .
3131 r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S
3136 First we recall the original vectors and compute their cross product,
3137 which we also store for later reference. Now we divide the vector
3138 by the product of the lengths of the original vectors. The length of
3139 this vector should be the sine of the angle; sure enough, it is!
3141 @c [fix-ref General Mode Commands]
3142 Vector-related commands generally begin with the @kbd{v} prefix key.
3143 Some are uppercase letters and some are lowercase. To make it easier
3144 to type these commands, the shift-@kbd{V} prefix key acts the same as
3145 the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all
3146 prefix keys have this property.)
3148 If we take the dot product of two perpendicular vectors we expect
3149 to get zero, since the cosine of 90 degrees is zero. Let's check
3150 that the cross product is indeed perpendicular to both inputs:
3154 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0
3155 1: [-18, 21, -8] . 1: [-18, 21, -8] .
3158 r 1 r 3 * @key{DEL} r 2 r 3 *
3162 @cindex Normalizing a vector
3163 @cindex Unit vectors
3164 (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the
3165 stack, what keystrokes would you use to @dfn{normalize} the
3166 vector, i.e., to reduce its length to one without changing its
3167 direction? @xref{Vector Answer 1, 1}. (@bullet{})
3169 (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be
3170 at any of several positions along a ruler. You have a list of
3171 those positions in the form of a vector, and another list of the
3172 probabilities for the particle to be at the corresponding positions.
3173 Find the average position of the particle.
3174 @xref{Vector Answer 2, 2}. (@bullet{})
3176 @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
3177 @subsection Matrices
3180 A @dfn{matrix} is just a vector of vectors, all the same length.
3181 This means you can enter a matrix using nested brackets. You can
3182 also use the semicolon character to enter a matrix. We'll show
3187 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3188 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3191 [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET}
3196 We'll be using this matrix again, so type @kbd{s 4} to save it now.
3198 Note that semicolons work with incomplete vectors, but they work
3199 better in algebraic entry. That's why we use the apostrophe in
3202 When two matrices are multiplied, the lefthand matrix must have
3203 the same number of columns as the righthand matrix has rows.
3204 Row @expr{i}, column @expr{j} of the result is effectively the
3205 dot product of row @expr{i} of the left matrix by column @expr{j}
3206 of the right matrix.
3208 If we try to duplicate this matrix and multiply it by itself,
3209 the dimensions are wrong and the multiplication cannot take place:
3213 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ]
3214 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3222 Though rather hard to read, this is a formula which shows the product
3223 of two matrices. The @samp{*} function, having invalid arguments, has
3224 been left in symbolic form.
3226 We can multiply the matrices if we @dfn{transpose} one of them first.
3230 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ]
3231 [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ]
3232 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ]
3237 U v t * U @key{TAB} *
3241 Matrix multiplication is not commutative; indeed, switching the
3242 order of the operands can even change the dimensions of the result
3243 matrix, as happened here!
3245 If you multiply a plain vector by a matrix, it is treated as a
3246 single row or column depending on which side of the matrix it is
3247 on. The result is a plain vector which should also be interpreted
3248 as a row or column as appropriate.
3252 2: [ [ 1, 2, 3 ] 1: [14, 32]
3261 Multiplying in the other order wouldn't work because the number of
3262 rows in the matrix is different from the number of elements in the
3265 (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows
3267 @texline @math{2\times3}
3269 matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns
3270 to get @expr{[5, 7, 9]}.
3271 @xref{Matrix Answer 1, 1}. (@bullet{})
3273 @cindex Identity matrix
3274 An @dfn{identity matrix} is a square matrix with ones along the
3275 diagonal and zeros elsewhere. It has the property that multiplication
3276 by an identity matrix, on the left or on the right, always produces
3277 the original matrix.
3281 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3282 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3283 . 1: [ [ 1, 0, 0 ] .
3288 r 4 v i 3 @key{RET} *
3292 If a matrix is square, it is often possible to find its @dfn{inverse},
3293 that is, a matrix which, when multiplied by the original matrix, yields
3294 an identity matrix. The @kbd{&} (reciprocal) key also computes the
3295 inverse of a matrix.
3299 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ]
3300 [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ]
3301 [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ]
3309 The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
3310 matrices together. Here we have used it to add a new row onto
3311 our matrix to make it square.
3313 We can multiply these two matrices in either order to get an identity.
3317 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ]
3318 [ 0., 1., 0. ] [ 0., 1., 0. ]
3319 [ 0., 0., 1. ] ] [ 0., 0., 1. ] ]
3322 M-@key{RET} * U @key{TAB} *
3326 @cindex Systems of linear equations
3327 @cindex Linear equations, systems of
3328 Matrix inverses are related to systems of linear equations in algebra.
3329 Suppose we had the following set of equations:
3343 $$ \openup1\jot \tabskip=0pt plus1fil
3344 \halign to\displaywidth{\tabskip=0pt
3345 $\hfil#$&$\hfil{}#{}$&
3346 $\hfil#$&$\hfil{}#{}$&
3347 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3356 This can be cast into the matrix equation,
3361 [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ]
3362 [ 4, 5, 6 ] * [ b ] = [ 2 ]
3363 [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ]
3370 $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
3372 \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
3377 We can solve this system of equations by multiplying both sides by the
3378 inverse of the matrix. Calc can do this all in one step:
3382 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333]
3393 The result is the @expr{[a, b, c]} vector that solves the equations.
3394 (Dividing by a square matrix is equivalent to multiplying by its
3397 Let's verify this solution:
3401 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.]
3404 1: [-12.6, 15.2, -3.93333]
3412 Note that we had to be careful about the order in which we multiplied
3413 the matrix and vector. If we multiplied in the other order, Calc would
3414 assume the vector was a row vector in order to make the dimensions
3415 come out right, and the answer would be incorrect. If you
3416 don't feel safe letting Calc take either interpretation of your
3417 vectors, use explicit
3418 @texline @math{N\times1}
3421 @texline @math{1\times N}
3423 matrices instead. In this case, you would enter the original column
3424 vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
3426 (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make
3427 vectors and matrices that include variables. Solve the following
3428 system of equations to get expressions for @expr{x} and @expr{y}
3429 in terms of @expr{a} and @expr{b}.
3442 $$ \eqalign{ x &+ a y = 6 \cr
3449 @xref{Matrix Answer 2, 2}. (@bullet{})
3451 @cindex Least-squares for over-determined systems
3452 @cindex Over-determined systems of equations
3453 (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined''
3454 if it has more equations than variables. It is often the case that
3455 there are no values for the variables that will satisfy all the
3456 equations at once, but it is still useful to find a set of values
3457 which ``nearly'' satisfy all the equations. In terms of matrix equations,
3458 you can't solve @expr{A X = B} directly because the matrix @expr{A}
3459 is not square for an over-determined system. Matrix inversion works
3460 only for square matrices. One common trick is to multiply both sides
3461 on the left by the transpose of @expr{A}:
3463 @samp{trn(A)*A*X = trn(A)*B}.
3467 $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
3470 @texline @math{A^T A}
3471 @infoline @expr{trn(A)*A}
3472 is a square matrix so a solution is possible. It turns out that the
3473 @expr{X} vector you compute in this way will be a ``least-squares''
3474 solution, which can be regarded as the ``closest'' solution to the set
3475 of equations. Use Calc to solve the following over-determined
3491 $$ \openup1\jot \tabskip=0pt plus1fil
3492 \halign to\displaywidth{\tabskip=0pt
3493 $\hfil#$&$\hfil{}#{}$&
3494 $\hfil#$&$\hfil{}#{}$&
3495 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3499 2a&+&4b&+&6c&=11 \cr}
3505 @xref{Matrix Answer 3, 3}. (@bullet{})
3507 @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
3508 @subsection Vectors as Lists
3512 Although Calc has a number of features for manipulating vectors and
3513 matrices as mathematical objects, you can also treat vectors as
3514 simple lists of values. For example, we saw that the @kbd{k f}
3515 command returns a vector which is a list of the prime factors of a
3518 You can pack and unpack stack entries into vectors:
3522 3: 10 1: [10, 20, 30] 3: 10
3531 You can also build vectors out of consecutive integers, or out
3532 of many copies of a given value:
3536 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4]
3537 . 1: 17 1: [17, 17, 17, 17]
3540 v x 4 @key{RET} 17 v b 4 @key{RET}
3544 You can apply an operator to every element of a vector using the
3549 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68]
3557 In the first step, we multiply the vector of integers by the vector
3558 of 17's elementwise. In the second step, we raise each element to
3559 the power two. (The general rule is that both operands must be
3560 vectors of the same length, or else one must be a vector and the
3561 other a plain number.) In the final step, we take the square root
3564 (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two
3566 @texline @math{2^{-4}}
3567 @infoline @expr{2^-4}
3568 to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{})
3570 You can also @dfn{reduce} a binary operator across a vector.
3571 For example, reducing @samp{*} computes the product of all the
3572 elements in the vector:
3576 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123
3584 In this example, we decompose 123123 into its prime factors, then
3585 multiply those factors together again to yield the original number.
3587 We could compute a dot product ``by hand'' using mapping and
3592 2: [1, 2, 3] 1: [7, 12, 0] 1: 19
3601 Recalling two vectors from the previous section, we compute the
3602 sum of pairwise products of the elements to get the same answer
3603 for the dot product as before.
3605 A slight variant of vector reduction is the @dfn{accumulate} operation,
3606 @kbd{V U}. This produces a vector of the intermediate results from
3607 a corresponding reduction. Here we compute a table of factorials:
3611 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720]
3614 v x 6 @key{RET} V U *
3618 Calc allows vectors to grow as large as you like, although it gets
3619 rather slow if vectors have more than about a hundred elements.
3620 Actually, most of the time is spent formatting these large vectors
3621 for display, not calculating on them. Try the following experiment
3622 (if your computer is very fast you may need to substitute a larger
3627 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ...
3630 v x 500 @key{RET} 1 V M +
3634 Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
3635 experiment again. In @kbd{v .} mode, long vectors are displayed
3636 ``abbreviated'' like this:
3640 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501]
3643 v x 500 @key{RET} 1 V M +
3648 (where now the @samp{...} is actually part of the Calc display).
3649 You will find both operations are now much faster. But notice that
3650 even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
3651 Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
3652 experiment one more time. Operations on long vectors are now quite
3653 fast! (But of course if you use @kbd{t .} you will lose the ability
3654 to get old vectors back using the @kbd{t y} command.)
3656 An easy way to view a full vector when @kbd{v .} mode is active is
3657 to press @kbd{`} (back-quote) to edit the vector; editing always works
3658 with the full, unabbreviated value.
3660 @cindex Least-squares for fitting a straight line
3661 @cindex Fitting data to a line
3662 @cindex Line, fitting data to
3663 @cindex Data, extracting from buffers
3664 @cindex Columns of data, extracting
3665 As a larger example, let's try to fit a straight line to some data,
3666 using the method of least squares. (Calc has a built-in command for
3667 least-squares curve fitting, but we'll do it by hand here just to
3668 practice working with vectors.) Suppose we have the following list
3669 of values in a file we have loaded into Emacs:
3696 If you are reading this tutorial in printed form, you will find it
3697 easiest to press @kbd{C-x * i} to enter the on-line Info version of
3698 the manual and find this table there. (Press @kbd{g}, then type
3699 @kbd{List Tutorial}, to jump straight to this section.)
3701 Position the cursor at the upper-left corner of this table, just
3702 to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark.
3703 (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
3704 Now position the cursor to the lower-right, just after the @expr{1.354}.
3705 You have now defined this region as an Emacs ``rectangle.'' Still
3706 in the Info buffer, type @kbd{C-x * r}. This command
3707 (@code{calc-grab-rectangle}) will pop you back into the Calculator, with
3708 the contents of the rectangle you specified in the form of a matrix.
3712 1: [ [ 1.34, 0.234 ]
3719 (You may wish to use @kbd{v .} mode to abbreviate the display of this
3722 We want to treat this as a pair of lists. The first step is to
3723 transpose this matrix into a pair of rows. Remember, a matrix is
3724 just a vector of vectors. So we can unpack the matrix into a pair
3725 of row vectors on the stack.
3729 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ]
3730 [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ]
3738 Let's store these in quick variables 1 and 2, respectively.
3742 1: [1.34, 1.41, 1.49, ... ] .
3750 (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
3751 stored value from the stack.)
3753 In a least squares fit, the slope @expr{m} is given by the formula
3757 m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
3763 $$ m = {N \sum x y - \sum x \sum y \over
3764 N \sum x^2 - \left( \sum x \right)^2} $$
3770 @texline @math{\sum x}
3771 @infoline @expr{sum(x)}
3772 represents the sum of all the values of @expr{x}. While there is an
3773 actual @code{sum} function in Calc, it's easier to sum a vector using a
3774 simple reduction. First, let's compute the four different sums that
3782 r 1 V R + t 3 r 1 2 V M ^ V R + t 4
3789 1: 13.613 1: 33.36554
3792 r 2 V R + t 5 r 1 r 2 V M * V R + t 6
3798 These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
3799 respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and
3804 These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
3805 respectively. (We could have used \kbd{*} to compute $\sum x^2$ and
3809 Finally, we also need @expr{N}, the number of data points. This is just
3810 the length of either of our lists.
3822 (That's @kbd{v} followed by a lower-case @kbd{l}.)
3824 Now we grind through the formula:
3828 1: 633.94526 2: 633.94526 1: 67.23607
3832 r 7 r 6 * r 3 r 5 * -
3839 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679
3840 1: 1862.0057 2: 1862.0057 1: 128.9488 .
3844 r 7 r 4 * r 3 2 ^ - / t 8
3848 That gives us the slope @expr{m}. The y-intercept @expr{b} can now
3849 be found with the simple formula,
3853 b = (sum(y) - m sum(x)) / N
3859 $$ b = {\sum y - m \sum x \over N} $$
3866 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978
3870 r 5 r 8 r 3 * - r 7 / t 9
3874 Let's ``plot'' this straight line approximation,
3875 @texline @math{y \approx m x + b},
3876 @infoline @expr{m x + b},
3877 and compare it with the original data.
3881 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ]
3889 Notice that multiplying a vector by a constant, and adding a constant
3890 to a vector, can be done without mapping commands since these are
3891 common operations from vector algebra. As far as Calc is concerned,
3892 we've just been doing geometry in 19-dimensional space!
3894 We can subtract this vector from our original @expr{y} vector to get
3895 a feel for the error of our fit. Let's find the maximum error:
3899 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897
3907 First we compute a vector of differences, then we take the absolute
3908 values of these differences, then we reduce the @code{max} function
3909 across the vector. (The @code{max} function is on the two-key sequence
3910 @kbd{f x}; because it is so common to use @code{max} in a vector
3911 operation, the letters @kbd{X} and @kbd{N} are also accepted for
3912 @code{max} and @code{min} in this context. In general, you answer
3913 the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
3914 invokes the function you want. You could have typed @kbd{V R f x} or
3915 even @kbd{V R x max @key{RET}} if you had preferred.)
3917 If your system has the GNUPLOT program, you can see graphs of your
3918 data and your straight line to see how well they match. (If you have
3919 GNUPLOT 3.0 or higher, the following instructions will work regardless
3920 of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems
3921 may require additional steps to view the graphs.)
3923 Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}''
3924 vectors onto the stack and press @kbd{g f}. This ``fast'' graphing
3925 command does everything you need to do for simple, straightforward
3930 2: [1.34, 1.41, 1.49, ... ]
3931 1: [0.234, 0.298, 0.402, ... ]
3938 If all goes well, you will shortly get a new window containing a graph
3939 of the data. (If not, contact your GNUPLOT or Calc installer to find
3940 out what went wrong.) In the X window system, this will be a separate
3941 graphics window. For other kinds of displays, the default is to
3942 display the graph in Emacs itself using rough character graphics.
3943 Press @kbd{q} when you are done viewing the character graphics.
3945 Next, let's add the line we got from our least-squares fit.
3947 (If you are reading this tutorial on-line while running Calc, typing
3948 @kbd{g a} may cause the tutorial to disappear from its window and be
3949 replaced by a buffer named @samp{*Gnuplot Commands*}. The tutorial
3950 will reappear when you terminate GNUPLOT by typing @kbd{g q}.)
3955 2: [1.34, 1.41, 1.49, ... ]
3956 1: [0.273, 0.309, 0.351, ... ]
3959 @key{DEL} r 0 g a g p
3963 It's not very useful to get symbols to mark the data points on this
3964 second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q}
3965 when you are done to remove the X graphics window and terminate GNUPLOT.
3967 (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do
3968 least squares fitting to a general system of equations. Our 19 data
3969 points are really 19 equations of the form @expr{y_i = m x_i + b} for
3970 different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method
3971 to solve for @expr{m} and @expr{b}, duplicating the above result.
3972 @xref{List Answer 2, 2}. (@bullet{})
3974 @cindex Geometric mean
3975 (@bullet{}) @strong{Exercise 3.} If the input data do not form a
3976 rectangle, you can use @w{@kbd{C-x * g}} (@code{calc-grab-region})
3977 to grab the data the way Emacs normally works with regions---it reads
3978 left-to-right, top-to-bottom, treating line breaks the same as spaces.
3979 Use this command to find the geometric mean of the following numbers.
3980 (The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
3989 The @kbd{C-x * g} command accepts numbers separated by spaces or commas,
3990 with or without surrounding vector brackets.
3991 @xref{List Answer 3, 3}. (@bullet{})
3994 As another example, a theorem about binomial coefficients tells
3995 us that the alternating sum of binomial coefficients
3996 @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
3997 on up to @var{n}-choose-@var{n},
3998 always comes out to zero. Let's verify this
4002 As another example, a theorem about binomial coefficients tells
4003 us that the alternating sum of binomial coefficients
4004 ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
4005 always comes out to zero. Let's verify this
4011 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6]
4021 1: [1, -6, 15, -20, 15, -6, 1] 1: 0
4024 V M ' (-1)^$ choose(6,$) @key{RET} V R +
4028 The @kbd{V M '} command prompts you to enter any algebraic expression
4029 to define the function to map over the vector. The symbol @samp{$}
4030 inside this expression represents the argument to the function.
4031 The Calculator applies this formula to each element of the vector,
4032 substituting each element's value for the @samp{$} sign(s) in turn.
4034 To define a two-argument function, use @samp{$$} for the first
4035 argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is
4036 equivalent to @kbd{V M -}. This is analogous to regular algebraic
4037 entry, where @samp{$$} would refer to the next-to-top stack entry
4038 and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
4039 would act exactly like @kbd{-}.
4041 Notice that the @kbd{V M '} command has recorded two things in the
4042 trail: The result, as usual, and also a funny-looking thing marked
4043 @samp{oper} that represents the operator function you typed in.
4044 The function is enclosed in @samp{< >} brackets, and the argument is
4045 denoted by a @samp{#} sign. If there were several arguments, they
4046 would be shown as @samp{#1}, @samp{#2}, and so on. (For example,
4047 @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
4048 trail.) This object is a ``nameless function''; you can use nameless
4049 @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
4050 Nameless function notation has the interesting, occasionally useful
4051 property that a nameless function is not actually evaluated until
4052 it is used. For example, @kbd{V M ' $+random(2.0)} evaluates
4053 @samp{random(2.0)} once and adds that random number to all elements
4054 of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
4055 @samp{random(2.0)} separately for each vector element.
4057 Another group of operators that are often useful with @kbd{V M} are
4058 the relational operators: @kbd{a =}, for example, compares two numbers
4059 and gives the result 1 if they are equal, or 0 if not. Similarly,
4060 @w{@kbd{a <}} checks for one number being less than another.
4062 Other useful vector operations include @kbd{v v}, to reverse a
4063 vector end-for-end; @kbd{V S}, to sort the elements of a vector
4064 into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
4065 one row or column of a matrix, or (in both cases) to extract one
4066 element of a plain vector. With a negative argument, @kbd{v r}
4067 and @kbd{v c} instead delete one row, column, or vector element.
4069 @cindex Divisor functions
4070 (@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function}
4074 is the sum of the @expr{k}th powers of all the divisors of an
4075 integer @expr{n}. Figure out a method for computing the divisor
4076 function for reasonably small values of @expr{n}. As a test,
4077 the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
4078 @xref{List Answer 4, 4}. (@bullet{})
4080 @cindex Square-free numbers
4081 @cindex Duplicate values in a list
4082 (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a
4083 list of prime factors for a number. Sometimes it is important to
4084 know that a number is @dfn{square-free}, i.e., that no prime occurs
4085 more than once in its list of prime factors. Find a sequence of
4086 keystrokes to tell if a number is square-free; your method should
4087 leave 1 on the stack if it is, or 0 if it isn't.
4088 @xref{List Answer 5, 5}. (@bullet{})
4090 @cindex Triangular lists
4091 (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks
4092 like the following diagram. (You may wish to use the @kbd{v /}
4093 command to enable multi-line display of vectors.)
4102 [1, 2, 3, 4, 5, 6] ]
4107 @xref{List Answer 6, 6}. (@bullet{})
4109 (@bullet{}) @strong{Exercise 7.} Build the following list of lists.
4117 [10, 11, 12, 13, 14],
4118 [15, 16, 17, 18, 19, 20] ]
4123 @xref{List Answer 7, 7}. (@bullet{})
4125 @cindex Maximizing a function over a list of values
4126 @c [fix-ref Numerical Solutions]
4127 (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's
4128 @texline @math{J_1(x)}
4130 function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25.
4131 Find the value of @expr{x} (from among the above set of values) for
4132 which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method,
4133 i.e., just reading along the list by hand to find the largest value
4134 is not allowed! (There is an @kbd{a X} command which does this kind
4135 of thing automatically; @pxref{Numerical Solutions}.)
4136 @xref{List Answer 8, 8}. (@bullet{})
4138 @cindex Digits, vectors of
4139 (@bullet{}) @strong{Exercise 9.} You are given an integer in the range
4140 @texline @math{0 \le N < 10^m}
4141 @infoline @expr{0 <= N < 10^m}
4142 for @expr{m=12} (i.e., an integer of less than
4143 twelve digits). Convert this integer into a vector of @expr{m}
4144 digits, each in the range from 0 to 9. In vector-of-digits notation,
4145 add one to this integer to produce a vector of @expr{m+1} digits
4146 (since there could be a carry out of the most significant digit).
4147 Convert this vector back into a regular integer. A good integer
4148 to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{})
4150 (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use
4151 @kbd{V R a =} to test if all numbers in a list were equal. What
4152 happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{})
4154 (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one
4155 is @cpi{}. The area of the
4156 @texline @math{2\times2}
4158 square that encloses that circle is 4. So if we throw @var{n} darts at
4159 random points in the square, about @cpiover{4} of them will land inside
4160 the circle. This gives us an entertaining way to estimate the value of
4161 @cpi{}. The @w{@kbd{k r}}
4162 command picks a random number between zero and the value on the stack.
4163 We could get a random floating-point number between @mathit{-1} and 1 by typing
4164 @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in
4165 this square, then use vector mapping and reduction to count how many
4166 points lie inside the unit circle. Hint: Use the @kbd{v b} command.
4167 @xref{List Answer 11, 11}. (@bullet{})
4169 @cindex Matchstick problem
4170 (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides
4171 another way to calculate @cpi{}. Say you have an infinite field
4172 of vertical lines with a spacing of one inch. Toss a one-inch matchstick
4173 onto the field. The probability that the matchstick will land crossing
4174 a line turns out to be
4175 @texline @math{2/\pi}.
4176 @infoline @expr{2/pi}.
4177 Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun,
4178 the probability that the GCD (@w{@kbd{k g}}) of two large integers is
4180 @texline @math{6/\pi^2}.
4181 @infoline @expr{6/pi^2}.
4182 That provides yet another way to estimate @cpi{}.)
4183 @xref{List Answer 12, 12}. (@bullet{})
4185 (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in
4186 double-quote marks, @samp{"hello"}, creates a vector of the numerical
4187 (ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}).
4188 Sometimes it is convenient to compute a @dfn{hash code} of a string,
4189 which is just an integer that represents the value of that string.
4190 Two equal strings have the same hash code; two different strings
4191 @dfn{probably} have different hash codes. (For example, Calc has
4192 over 400 function names, but Emacs can quickly find the definition for
4193 any given name because it has sorted the functions into ``buckets'' by
4194 their hash codes. Sometimes a few names will hash into the same bucket,
4195 but it is easier to search among a few names than among all the names.)
4196 One popular hash function is computed as follows: First set @expr{h = 0}.
4197 Then, for each character from the string in turn, set @expr{h = 3h + c_i}
4198 where @expr{c_i} is the character's ASCII code. If we have 511 buckets,
4199 we then take the hash code modulo 511 to get the bucket number. Develop a
4200 simple command or commands for converting string vectors into hash codes.
4201 The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
4202 511 is 121. @xref{List Answer 13, 13}. (@bullet{})
4204 (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U}
4205 commands do nested function evaluations. @kbd{H V U} takes a starting
4206 value and a number of steps @var{n} from the stack; it then applies the
4207 function you give to the starting value 0, 1, 2, up to @var{n} times
4208 and returns a vector of the results. Use this command to create a
4209 ``random walk'' of 50 steps. Start with the two-dimensional point
4210 @expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1
4211 in both @expr{x} and @expr{y}; then take another step, and so on. Use the
4212 @kbd{g f} command to display this random walk. Now modify your random
4213 walk to walk a unit distance, but in a random direction, at each step.
4214 (Hint: The @code{sincos} function returns a vector of the cosine and
4215 sine of an angle.) @xref{List Answer 14, 14}. (@bullet{})
4217 @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
4218 @section Types Tutorial
4221 Calc understands a variety of data types as well as simple numbers.
4222 In this section, we'll experiment with each of these types in turn.
4224 The numbers we've been using so far have mainly been either @dfn{integers}
4225 or @dfn{floats}. We saw that floats are usually a good approximation to
4226 the mathematical concept of real numbers, but they are only approximations
4227 and are susceptible to roundoff error. Calc also supports @dfn{fractions},
4228 which can exactly represent any rational number.
4232 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414
4236 10 ! 49 @key{RET} : 2 + &
4241 The @kbd{:} command divides two integers to get a fraction; @kbd{/}
4242 would normally divide integers to get a floating-point result.
4243 Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
4244 since the @kbd{:} would otherwise be interpreted as part of a
4245 fraction beginning with 49.
4247 You can convert between floating-point and fractional format using
4248 @kbd{c f} and @kbd{c F}:
4252 1: 1.35027217629e-5 1: 7:518414
4259 The @kbd{c F} command replaces a floating-point number with the
4260 ``simplest'' fraction whose floating-point representation is the
4261 same, to within the current precision.
4265 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113
4268 P c F @key{DEL} p 5 @key{RET} P c F
4272 (@bullet{}) @strong{Exercise 1.} A calculation has produced the
4273 result 1.26508260337. You suspect it is the square root of the
4274 product of @cpi{} and some rational number. Is it? (Be sure
4275 to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{})
4277 @dfn{Complex numbers} can be stored in both rectangular and polar form.
4281 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.)
4289 The square root of @mathit{-9} is by default rendered in rectangular form
4290 (@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a
4291 phase angle of 90 degrees). All the usual arithmetic and scientific
4292 operations are defined on both types of complex numbers.
4294 Another generalized kind of number is @dfn{infinity}. Infinity
4295 isn't really a number, but it can sometimes be treated like one.
4296 Calc uses the symbol @code{inf} to represent positive infinity,
4297 i.e., a value greater than any real number. Naturally, you can
4298 also write @samp{-inf} for minus infinity, a value less than any
4299 real number. The word @code{inf} can only be input using
4304 2: inf 2: -inf 2: -inf 2: -inf 1: nan
4305 1: -17 1: -inf 1: -inf 1: inf .
4308 ' inf @key{RET} 17 n * @key{RET} 72 + A +
4313 Since infinity is infinitely large, multiplying it by any finite
4314 number (like @mathit{-17}) has no effect, except that since @mathit{-17}
4315 is negative, it changes a plus infinity to a minus infinity.
4316 (``A huge positive number, multiplied by @mathit{-17}, yields a huge
4317 negative number.'') Adding any finite number to infinity also
4318 leaves it unchanged. Taking an absolute value gives us plus
4319 infinity again. Finally, we add this plus infinity to the minus
4320 infinity we had earlier. If you work it out, you might expect
4321 the answer to be @mathit{-72} for this. But the 72 has been completely
4322 lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
4323 the finite difference between them, if any, is undetectable.
4324 So we say the result is @dfn{indeterminate}, which Calc writes
4325 with the symbol @code{nan} (for Not A Number).
4327 Dividing by zero is normally treated as an error, but you can get
4328 Calc to write an answer in terms of infinity by pressing @kbd{m i}
4329 to turn on Infinite mode.
4333 3: nan 2: nan 2: nan 2: nan 1: nan
4334 2: 1 1: 1 / 0 1: uinf 1: uinf .
4338 1 @key{RET} 0 / m i U / 17 n * +
4343 Dividing by zero normally is left unevaluated, but after @kbd{m i}
4344 it instead gives an infinite result. The answer is actually
4345 @code{uinf}, ``undirected infinity.'' If you look at a graph of
4346 @expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward
4347 plus infinity as you approach zero from above, but toward minus
4348 infinity as you approach from below. Since we said only @expr{1 / 0},
4349 Calc knows that the answer is infinite but not in which direction.
4350 That's what @code{uinf} means. Notice that multiplying @code{uinf}
4351 by a negative number still leaves plain @code{uinf}; there's no
4352 point in saying @samp{-uinf} because the sign of @code{uinf} is
4353 unknown anyway. Finally, we add @code{uinf} to our @code{nan},
4354 yielding @code{nan} again. It's easy to see that, because
4355 @code{nan} means ``totally unknown'' while @code{uinf} means
4356 ``unknown sign but known to be infinite,'' the more mysterious
4357 @code{nan} wins out when it is combined with @code{uinf}, or, for
4358 that matter, with anything else.
4360 (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer
4361 for each of these formulas: @samp{inf / inf}, @samp{exp(inf)},
4362 @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
4363 @samp{abs(uinf)}, @samp{ln(0)}.
4364 @xref{Types Answer 2, 2}. (@bullet{})
4366 (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan},
4367 which stands for an unknown value. Can @code{nan} stand for
4368 a complex number? Can it stand for infinity?
4369 @xref{Types Answer 3, 3}. (@bullet{})
4371 @dfn{HMS forms} represent a value in terms of hours, minutes, and
4376 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2.
4377 . . 1: 1@@ 45' 0." .
4380 2@@ 30' @key{RET} 1 + @key{RET} 2 / /
4384 HMS forms can also be used to hold angles in degrees, minutes, and
4389 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721
4397 First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
4398 form, then we take the sine of that angle. Note that the trigonometric
4399 functions will accept HMS forms directly as input.
4402 (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is
4403 47 minutes and 26 seconds long, and contains 17 songs. What is the
4404 average length of a song on @emph{Abbey Road}? If the Extended Disco
4405 Version of @emph{Abbey Road} added 20 seconds to the length of each
4406 song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{})
4408 A @dfn{date form} represents a date, or a date and time. Dates must
4409 be entered using algebraic entry. Date forms are surrounded by
4410 @samp{< >} symbols; most standard formats for dates are recognized.
4414 2: <Sun Jan 13, 1991> 1: 2.25
4415 1: <6:00pm Thu Jan 10, 1991> .
4418 ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} -
4423 In this example, we enter two dates, then subtract to find the
4424 number of days between them. It is also possible to add an
4425 HMS form or a number (of days) to a date form to get another
4430 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991>
4437 @c [fix-ref Date Arithmetic]
4439 The @kbd{t N} (``now'') command pushes the current date and time on the
4440 stack; then we add two days, ten hours and five minutes to the date and
4441 time. Other date-and-time related commands include @kbd{t J}, which
4442 does Julian day conversions, @kbd{t W}, which finds the beginning of
4443 the week in which a date form lies, and @kbd{t I}, which increments a
4444 date by one or several months. @xref{Date Arithmetic}, for more.
4446 (@bullet{}) @strong{Exercise 5.} How many days until the next
4447 Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{})
4449 (@bullet{}) @strong{Exercise 6.} How many leap years will there be
4450 between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{})
4452 @cindex Slope and angle of a line
4453 @cindex Angle and slope of a line
4454 An @dfn{error form} represents a mean value with an attached standard
4455 deviation, or error estimate. Suppose our measurements indicate that
4456 a certain telephone pole is about 30 meters away, with an estimated
4457 error of 1 meter, and 8 meters tall, with an estimated error of 0.2
4458 meters. What is the slope of a line from here to the top of the
4459 pole, and what is the equivalent angle in degrees?
4463 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594
4467 8 p .2 @key{RET} 30 p 1 / I T
4472 This means that the angle is about 15 degrees, and, assuming our
4473 original error estimates were valid standard deviations, there is about
4474 a 60% chance that the result is correct within 0.59 degrees.
4476 @cindex Torus, volume of
4477 (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is
4478 @texline @math{2 \pi^2 R r^2}
4479 @infoline @w{@expr{2 pi^2 R r^2}}
4480 where @expr{R} is the radius of the circle that
4481 defines the center of the tube and @expr{r} is the radius of the tube
4482 itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to
4483 within 5 percent. What is the volume and the relative uncertainty of
4484 the volume? @xref{Types Answer 7, 7}. (@bullet{})
4486 An @dfn{interval form} represents a range of values. While an
4487 error form is best for making statistical estimates, intervals give
4488 you exact bounds on an answer. Suppose we additionally know that
4489 our telephone pole is definitely between 28 and 31 meters away,
4490 and that it is between 7.7 and 8.1 meters tall.
4494 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1]
4498 [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T
4503 If our bounds were correct, then the angle to the top of the pole
4504 is sure to lie in the range shown.
4506 The square brackets around these intervals indicate that the endpoints
4507 themselves are allowable values. In other words, the distance to the
4508 telephone pole is between 28 and 31, @emph{inclusive}. You can also
4509 make an interval that is exclusive of its endpoints by writing
4510 parentheses instead of square brackets. You can even make an interval
4511 which is inclusive (``closed'') on one end and exclusive (``open'') on
4516 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3)
4520 [ 1 .. 10 ) & [ 2 .. 3 ) *
4525 The Calculator automatically keeps track of which end values should
4526 be open and which should be closed. You can also make infinite or
4527 semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
4530 (@bullet{}) @strong{Exercise 8.} What answer would you expect from
4531 @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What
4532 about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
4533 zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}?
4534 @xref{Types Answer 8, 8}. (@bullet{})
4536 (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number
4537 are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same
4538 answer. Would you expect this still to hold true for interval forms?
4539 If not, which of these will result in a larger interval?
4540 @xref{Types Answer 9, 9}. (@bullet{})
4542 A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
4543 For example, arithmetic involving time is generally done modulo 12
4548 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24
4551 17 M 24 @key{RET} 10 + n 5 /
4556 In this last step, Calc has divided by 5 modulo 24; i.e., it has found a
4557 new number which, when multiplied by 5 modulo 24, produces the original
4558 number, 21. If @var{m} is prime and the divisor is not a multiple of
4559 @var{m}, it is always possible to find such a number. For non-prime
4560 @var{m} like 24, it is only sometimes possible.
4564 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16
4567 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 %
4572 These two calculations get the same answer, but the first one is
4573 much more efficient because it avoids the huge intermediate value
4574 that arises in the second one.
4576 @cindex Fermat, primality test of
4577 (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat
4579 @texline @w{@math{x^{n-1} \bmod n = 1}}
4580 @infoline @expr{x^(n-1) mod n = 1}
4581 if @expr{n} is a prime number and @expr{x} is an integer less than
4582 @expr{n}. If @expr{n} is @emph{not} a prime number, this will
4583 @emph{not} be true for most values of @expr{x}. Thus we can test
4584 informally if a number is prime by trying this formula for several
4585 values of @expr{x}. Use this test to tell whether the following numbers
4586 are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{})
4588 It is possible to use HMS forms as parts of error forms, intervals,
4589 modulo forms, or as the phase part of a polar complex number.
4590 For example, the @code{calc-time} command pushes the current time
4591 of day on the stack as an HMS/modulo form.
4595 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0"
4603 This calculation tells me it is six hours and 22 minutes until midnight.
4605 (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year
4607 @texline @math{\pi \times 10^7}
4608 @infoline @w{@expr{pi * 10^7}}
4609 seconds. What time will it be that many seconds from right now?
4610 @xref{Types Answer 11, 11}. (@bullet{})
4612 (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging
4613 for the CD release of the Extended Disco Version of @emph{Abbey Road}.
4614 You are told that the songs will actually be anywhere from 20 to 60
4615 seconds longer than the originals. One CD can hold about 75 minutes
4616 of music. Should you order single or double packages?
4617 @xref{Types Answer 12, 12}. (@bullet{})
4619 Another kind of data the Calculator can manipulate is numbers with
4620 @dfn{units}. This isn't strictly a new data type; it's simply an
4621 application of algebraic expressions, where we use variables with
4622 suggestive names like @samp{cm} and @samp{in} to represent units
4623 like centimeters and inches.
4627 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m
4630 ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b
4635 We enter the quantity ``2 inches'' (actually an algebraic expression
4636 which means two times the variable @samp{in}), then we convert it
4637 first to centimeters, then to fathoms, then finally to ``base'' units,
4638 which in this case means meters.
4642 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm
4645 ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET}
4652 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2
4660 Since units expressions are really just formulas, taking the square
4661 root of @samp{acre} is undefined. After all, @code{acre} might be an
4662 algebraic variable that you will someday assign a value. We use the
4663 ``units-simplify'' command to simplify the expression with variables
4664 being interpreted as unit names.
4666 In the final step, we have converted not to a particular unit, but to a
4667 units system. The ``cgs'' system uses centimeters instead of meters
4668 as its standard unit of length.
4670 There is a wide variety of units defined in the Calculator.
4674 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c
4677 ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET}
4682 We express a speed first in miles per hour, then in kilometers per
4683 hour, then again using a slightly more explicit notation, then
4684 finally in terms of fractions of the speed of light.
4686 Temperature conversions are a bit more tricky. There are two ways to
4687 interpret ``20 degrees Fahrenheit''---it could mean an actual
4688 temperature, or it could mean a change in temperature. For normal
4689 units there is no difference, but temperature units have an offset
4690 as well as a scale factor and so there must be two explicit commands
4695 1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC
4698 ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} c f
4703 First we convert a change of 20 degrees Fahrenheit into an equivalent
4704 change in degrees Celsius (or Centigrade). Then, we convert the
4705 absolute temperature 20 degrees Fahrenheit into Celsius. Since
4706 this comes out as an exact fraction, we then convert to floating-point
4707 for easier comparison with the other result.
4709 For simple unit conversions, you can put a plain number on the stack.
4710 Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
4711 When you use this method, you're responsible for remembering which
4712 numbers are in which units:
4716 1: 55 1: 88.5139 1: 8.201407e-8
4719 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET}
4723 To see a complete list of built-in units, type @kbd{u v}. Press
4724 @w{@kbd{C-x * c}} again to re-enter the Calculator when you're done looking
4727 (@bullet{}) @strong{Exercise 13.} How many seconds are there really
4728 in a year? @xref{Types Answer 13, 13}. (@bullet{})
4730 @cindex Speed of light
4731 (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by
4732 the speed of light (and of electricity, which is nearly as fast).
4733 Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
4734 cabinet is one meter across. Is speed of light going to be a
4735 significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{})
4737 (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about
4738 five yards in an hour. He has obtained a supply of Power Pills; each
4739 Power Pill he eats doubles his speed. How many Power Pills can he
4740 swallow and still travel legally on most US highways?
4741 @xref{Types Answer 15, 15}. (@bullet{})
4743 @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
4744 @section Algebra and Calculus Tutorial
4747 This section shows how to use Calc's algebra facilities to solve
4748 equations, do simple calculus problems, and manipulate algebraic
4752 * Basic Algebra Tutorial::
4753 * Rewrites Tutorial::
4756 @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
4757 @subsection Basic Algebra
4760 If you enter a formula in Algebraic mode that refers to variables,
4761 the formula itself is pushed onto the stack. You can manipulate
4762 formulas as regular data objects.
4766 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y)
4769 ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} *
4773 (@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and
4774 @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
4775 Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{})
4777 There are also commands for doing common algebraic operations on
4778 formulas. Continuing with the formula from the last example,
4782 1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y
4790 First we ``expand'' using the distributive law, then we ``collect''
4791 terms involving like powers of @expr{x}.
4793 Let's find the value of this expression when @expr{x} is 2 and @expr{y}
4798 1: 17 x^2 - 6 x^4 + 3 1: -25
4801 1:2 s l y @key{RET} 2 s l x @key{RET}
4806 The @kbd{s l} command means ``let''; it takes a number from the top of
4807 the stack and temporarily assigns it as the value of the variable
4808 you specify. It then evaluates (as if by the @kbd{=} key) the
4809 next expression on the stack. After this command, the variable goes
4810 back to its original value, if any.
4812 (An earlier exercise in this tutorial involved storing a value in the
4813 variable @code{x}; if this value is still there, you will have to
4814 unstore it with @kbd{s u x @key{RET}} before the above example will work
4817 @cindex Maximum of a function using Calculus
4818 Let's find the maximum value of our original expression when @expr{y}
4819 is one-half and @expr{x} ranges over all possible values. We can
4820 do this by taking the derivative with respect to @expr{x} and examining
4821 values of @expr{x} for which the derivative is zero. If the second
4822 derivative of the function at that value of @expr{x} is negative,
4823 the function has a local maximum there.
4827 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3
4830 U @key{DEL} s 1 a d x @key{RET} s 2
4835 Well, the derivative is clearly zero when @expr{x} is zero. To find
4836 the other root(s), let's divide through by @expr{x} and then solve:
4840 1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2
4843 ' x @key{RET} / a x a s
4850 1: 34 - 24 x^2 = 0 1: x = 1.19023
4853 0 a = s 3 a S x @key{RET}
4858 Notice the use of @kbd{a s} to ``simplify'' the formula. When the
4859 default algebraic simplifications don't do enough, you can use
4860 @kbd{a s} to tell Calc to spend more time on the job.
4862 Now we compute the second derivative and plug in our values of @expr{x}:
4866 1: 1.19023 2: 1.19023 2: 1.19023
4867 . 1: 34 x - 24 x^3 1: 34 - 72 x^2
4870 a . r 2 a d x @key{RET} s 4
4875 (The @kbd{a .} command extracts just the righthand side of an equation.
4876 Another method would have been to use @kbd{v u} to unpack the equation
4877 @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
4878 to delete the @samp{x}.)
4882 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34
4886 @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET}
4891 The first of these second derivatives is negative, so we know the function
4892 has a maximum value at @expr{x = 1.19023}. (The function also has a
4893 local @emph{minimum} at @expr{x = 0}.)
4895 When we solved for @expr{x}, we got only one value even though
4896 @expr{34 - 24 x^2 = 0} is a quadratic equation that ought to have
4897 two solutions. The reason is that @w{@kbd{a S}} normally returns a
4898 single ``principal'' solution. If it needs to come up with an
4899 arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}.
4900 If it needs an arbitrary integer, it picks zero. We can get a full
4901 solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
4905 1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023
4908 r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET}
4913 Calc has invented the variable @samp{s1} to represent an unknown sign;
4914 it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used
4915 the ``let'' command to evaluate the expression when the sign is negative.
4916 If we plugged this into our second derivative we would get the same,
4917 negative, answer, so @expr{x = -1.19023} is also a maximum.
4919 To find the actual maximum value, we must plug our two values of @expr{x}
4920 into the original formula.
4924 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3
4928 r 1 r 5 s l @key{RET}
4933 (Here we see another way to use @kbd{s l}; if its input is an equation
4934 with a variable on the lefthand side, then @kbd{s l} treats the equation
4935 like an assignment to that variable if you don't give a variable name.)
4937 It's clear that this will have the same value for either sign of
4938 @code{s1}, but let's work it out anyway, just for the exercise:
4942 2: [-1, 1] 1: [15.04166, 15.04166]
4943 1: 24.08333 s1^2 ... .
4946 [ 1 n , 1 ] @key{TAB} V M $ @key{RET}
4951 Here we have used a vector mapping operation to evaluate the function
4952 at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '}
4953 except that it takes the formula from the top of the stack. The
4954 formula is interpreted as a function to apply across the vector at the
4955 next-to-top stack level. Since a formula on the stack can't contain
4956 @samp{$} signs, Calc assumes the variables in the formula stand for
4957 different arguments. It prompts you for an @dfn{argument list}, giving
4958 the list of all variables in the formula in alphabetical order as the
4959 default list. In this case the default is @samp{(s1)}, which is just
4960 what we want so we simply press @key{RET} at the prompt.
4962 If there had been several different values, we could have used
4963 @w{@kbd{V R X}} to find the global maximum.
4965 Calc has a built-in @kbd{a P} command that solves an equation using
4966 @w{@kbd{H a S}} and returns a vector of all the solutions. It simply
4967 automates the job we just did by hand. Applied to our original
4968 cubic polynomial, it would produce the vector of solutions
4969 @expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command
4970 which finds a local maximum of a function. It uses a numerical search
4971 method rather than examining the derivatives, and thus requires you
4972 to provide some kind of initial guess to show it where to look.)
4974 (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a
4975 polynomial (such as the output of an @kbd{a P} command), what
4976 sequence of commands would you use to reconstruct the original
4977 polynomial? (The answer will be unique to within a constant
4978 multiple; choose the solution where the leading coefficient is one.)
4979 @xref{Algebra Answer 2, 2}. (@bullet{})
4981 The @kbd{m s} command enables Symbolic mode, in which formulas
4982 like @samp{sqrt(5)} that can't be evaluated exactly are left in
4983 symbolic form rather than giving a floating-point approximate answer.
4984 Fraction mode (@kbd{m f}) is also useful when doing algebra.
4988 2: 34 x - 24 x^3 2: 34 x - 24 x^3
4989 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0]
4992 r 2 @key{RET} m s m f a P x @key{RET}
4996 One more mode that makes reading formulas easier is Big mode.
5005 1: [-----, -----, 0]
5014 Here things like powers, square roots, and quotients and fractions
5015 are displayed in a two-dimensional pictorial form. Calc has other
5016 language modes as well, such as C mode, FORTRAN mode, @TeX{} mode
5021 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3
5022 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/
5033 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
5034 1: @{2 \over 3@} \sqrt@{5@}
5037 d T ' 2 \sqrt@{5@} \over 3 @key{RET}
5042 As you can see, language modes affect both entry and display of
5043 formulas. They affect such things as the names used for built-in
5044 functions, the set of arithmetic operators and their precedences,
5045 and notations for vectors and matrices.
5047 Notice that @samp{sqrt(51)} may cause problems with older
5048 implementations of C and FORTRAN, which would require something more
5049 like @samp{sqrt(51.0)}. It is always wise to check over the formulas
5050 produced by the various language modes to make sure they are fully
5053 Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You
5054 may prefer to remain in Big mode, but all the examples in the tutorial
5055 are shown in normal mode.)
5057 @cindex Area under a curve
5058 What is the area under the portion of this curve from @expr{x = 1} to @expr{2}?
5059 This is simply the integral of the function:
5063 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x
5071 We want to evaluate this at our two values for @expr{x} and subtract.
5072 One way to do it is again with vector mapping and reduction:
5076 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666
5077 1: 5.6666 x^3 ... . .
5079 [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5083 (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y}
5085 @texline @math{x \sin \pi x}
5086 @infoline @w{@expr{x sin(pi x)}}
5087 (where the sine is calculated in radians). Find the values of the
5088 integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3,
5091 Calc's integrator can do many simple integrals symbolically, but many
5092 others are beyond its capabilities. Suppose we wish to find the area
5094 @texline @math{\sin x \ln x}
5095 @infoline @expr{sin(x) ln(x)}
5096 over the same range of @expr{x}. If you entered this formula and typed
5097 @kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a
5098 long time but would be unable to find a solution. In fact, there is no
5099 closed-form solution to this integral. Now what do we do?
5101 @cindex Integration, numerical
5102 @cindex Numerical integration
5103 One approach would be to do the integral numerically. It is not hard
5104 to do this by hand using vector mapping and reduction. It is rather
5105 slow, though, since the sine and logarithm functions take a long time.
5106 We can save some time by reducing the working precision.
5110 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9]
5115 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
5120 (Note that we have used the extended version of @kbd{v x}; we could
5121 also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.)
5125 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ]
5129 ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET}
5144 (If you got wildly different results, did you remember to switch
5147 Here we have divided the curve into ten segments of equal width;
5148 approximating these segments as rectangular boxes (i.e., assuming
5149 the curve is nearly flat at that resolution), we compute the areas
5150 of the boxes (height times width), then sum the areas. (It is
5151 faster to sum first, then multiply by the width, since the width
5152 is the same for every box.)
5154 The true value of this integral turns out to be about 0.374, so
5155 we're not doing too well. Let's try another approach.
5159 1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
5162 r 1 a t x=1 @key{RET} 4 @key{RET}
5167 Here we have computed the Taylor series expansion of the function
5168 about the point @expr{x=1}. We can now integrate this polynomial
5169 approximation, since polynomials are easy to integrate.
5173 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761
5176 a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5181 Better! By increasing the precision and/or asking for more terms
5182 in the Taylor series, we can get a result as accurate as we like.
5183 (Taylor series converge better away from singularities in the
5184 function such as the one at @code{ln(0)}, so it would also help to
5185 expand the series about the points @expr{x=2} or @expr{x=1.5} instead
5188 @cindex Simpson's rule
5189 @cindex Integration by Simpson's rule
5190 (@bullet{}) @strong{Exercise 4.} Our first method approximated the
5191 curve by stairsteps of width 0.1; the total area was then the sum
5192 of the areas of the rectangles under these stairsteps. Our second
5193 method approximated the function by a polynomial, which turned out
5194 to be a better approximation than stairsteps. A third method is
5195 @dfn{Simpson's rule}, which is like the stairstep method except
5196 that the steps are not required to be flat. Simpson's rule boils
5197 down to the formula,
5201 (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
5202 + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
5209 \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
5210 \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
5216 where @expr{n} (which must be even) is the number of slices and @expr{h}
5217 is the width of each slice. These are 10 and 0.1 in our example.
5218 For reference, here is the corresponding formula for the stairstep
5223 h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
5224 + f(a+(n-2)*h) + f(a+(n-1)*h))
5230 $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
5231 + f(a+(n-2)h) + f(a+(n-1)h)) $$
5235 Compute the integral from 1 to 2 of
5236 @texline @math{\sin x \ln x}
5237 @infoline @expr{sin(x) ln(x)}
5238 using Simpson's rule with 10 slices.
5239 @xref{Algebra Answer 4, 4}. (@bullet{})
5241 Calc has a built-in @kbd{a I} command for doing numerical integration.
5242 It uses @dfn{Romberg's method}, which is a more sophisticated cousin
5243 of Simpson's rule. In particular, it knows how to keep refining the
5244 result until the current precision is satisfied.
5246 @c [fix-ref Selecting Sub-Formulas]
5247 Aside from the commands we've seen so far, Calc also provides a
5248 large set of commands for operating on parts of formulas. You
5249 indicate the desired sub-formula by placing the cursor on any part
5250 of the formula before giving a @dfn{selection} command. Selections won't
5251 be covered in the tutorial; @pxref{Selecting Subformulas}, for
5252 details and examples.
5254 @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
5255 @c to 2^((n-1)*(r-1)).
5257 @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
5258 @subsection Rewrite Rules
5261 No matter how many built-in commands Calc provided for doing algebra,
5262 there would always be something you wanted to do that Calc didn't have
5263 in its repertoire. So Calc also provides a @dfn{rewrite rule} system
5264 that you can use to define your own algebraic manipulations.
5266 Suppose we want to simplify this trigonometric formula:
5270 1: 1 / cos(x) - sin(x) tan(x)
5273 ' 1/cos(x) - sin(x) tan(x) @key{RET} s 1
5278 If we were simplifying this by hand, we'd probably replace the
5279 @samp{tan} with a @samp{sin/cos} first, then combine over a common
5280 denominator. There is no Calc command to do the former; the @kbd{a n}
5281 algebra command will do the latter but we'll do both with rewrite
5282 rules just for practice.
5284 Rewrite rules are written with the @samp{:=} symbol.
5288 1: 1 / cos(x) - sin(x)^2 / cos(x)
5291 a r tan(a) := sin(a)/cos(a) @key{RET}
5296 (The ``assignment operator'' @samp{:=} has several uses in Calc. All
5297 by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
5298 but when it is given to the @kbd{a r} command, that command interprets
5299 it as a rewrite rule.)
5301 The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
5302 rewrite rule. Calc searches the formula on the stack for parts that
5303 match the pattern. Variables in a rewrite pattern are called
5304 @dfn{meta-variables}, and when matching the pattern each meta-variable
5305 can match any sub-formula. Here, the meta-variable @samp{a} matched
5306 the actual variable @samp{x}.
5308 When the pattern part of a rewrite rule matches a part of the formula,
5309 that part is replaced by the righthand side with all the meta-variables
5310 substituted with the things they matched. So the result is
5311 @samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then
5312 mix this in with the rest of the original formula.
5314 To merge over a common denominator, we can use another simple rule:
5318 1: (1 - sin(x)^2) / cos(x)
5321 a r a/x + b/x := (a+b)/x @key{RET}
5325 This rule points out several interesting features of rewrite patterns.
5326 First, if a meta-variable appears several times in a pattern, it must
5327 match the same thing everywhere. This rule detects common denominators
5328 because the same meta-variable @samp{x} is used in both of the
5331 Second, meta-variable names are independent from variables in the
5332 target formula. Notice that the meta-variable @samp{x} here matches
5333 the subformula @samp{cos(x)}; Calc never confuses the two meanings of
5336 And third, rewrite patterns know a little bit about the algebraic
5337 properties of formulas. The pattern called for a sum of two quotients;
5338 Calc was able to match a difference of two quotients by matching
5339 @samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}.
5341 @c [fix-ref Algebraic Properties of Rewrite Rules]
5342 We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
5343 the rule. It would have worked just the same in all cases. (If we
5344 really wanted the rule to apply only to @samp{+} or only to @samp{-},
5345 we could have used the @code{plain} symbol. @xref{Algebraic Properties
5346 of Rewrite Rules}, for some examples of this.)
5348 One more rewrite will complete the job. We want to use the identity
5349 @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
5350 the identity in a way that matches our formula. The obvious rule
5351 would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows
5352 that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The
5353 latter rule has a more general pattern so it will work in many other
5358 1: (1 + cos(x)^2 - 1) / cos(x) 1: cos(x)
5361 a r sin(x)^2 := 1 - cos(x)^2 @key{RET} a s
5365 You may ask, what's the point of using the most general rule if you
5366 have to type it in every time anyway? The answer is that Calc allows
5367 you to store a rewrite rule in a variable, then give the variable
5368 name in the @kbd{a r} command. In fact, this is the preferred way to
5369 use rewrites. For one, if you need a rule once you'll most likely
5370 need it again later. Also, if the rule doesn't work quite right you
5371 can simply Undo, edit the variable, and run the rule again without
5372 having to retype it.
5376 ' tan(x) := sin(x)/cos(x) @key{RET} s t tsc @key{RET}
5377 ' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET}
5378 ' sin(x)^2 := 1 - cos(x)^2 @key{RET} s t sinsqr @key{RET}
5380 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5383 r 1 a r tsc @key{RET} a r merge @key{RET} a r sinsqr @key{RET} a s
5387 To edit a variable, type @kbd{s e} and the variable name, use regular
5388 Emacs editing commands as necessary, then type @kbd{C-c C-c} to store
5389 the edited value back into the variable.
5390 You can also use @w{@kbd{s e}} to create a new variable if you wish.
5392 Notice that the first time you use each rule, Calc puts up a ``compiling''
5393 message briefly. The pattern matcher converts rules into a special
5394 optimized pattern-matching language rather than using them directly.
5395 This allows @kbd{a r} to apply even rather complicated rules very
5396 efficiently. If the rule is stored in a variable, Calc compiles it
5397 only once and stores the compiled form along with the variable. That's
5398 another good reason to store your rules in variables rather than
5399 entering them on the fly.
5401 (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic
5402 mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
5403 Using a rewrite rule, simplify this formula by multiplying the top and
5404 bottom by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have
5405 to be expanded by the distributive law; do this with another
5406 rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{})
5408 The @kbd{a r} command can also accept a vector of rewrite rules, or
5409 a variable containing a vector of rules.
5413 1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ]
5416 ' [tsc,merge,sinsqr] @key{RET} =
5423 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5426 s t trig @key{RET} r 1 a r trig @key{RET} a s
5430 @c [fix-ref Nested Formulas with Rewrite Rules]
5431 Calc tries all the rules you give against all parts of the formula,
5432 repeating until no further change is possible. (The exact order in
5433 which things are tried is rather complex, but for simple rules like
5434 the ones we've used here the order doesn't really matter.
5435 @xref{Nested Formulas with Rewrite Rules}.)
5437 Calc actually repeats only up to 100 times, just in case your rule set
5438 has gotten into an infinite loop. You can give a numeric prefix argument
5439 to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does
5440 only one rewrite at a time.
5444 1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x)
5447 r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET}
5451 You can type @kbd{M-0 a r} if you want no limit at all on the number
5452 of rewrites that occur.
5454 Rewrite rules can also be @dfn{conditional}. Simply follow the rule
5455 with a @samp{::} symbol and the desired condition. For example,
5459 1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
5462 ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET}
5469 1: 1 + exp(3 pi i) + 1
5472 a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET}
5477 (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
5478 which will be zero only when @samp{k} is an even integer.)
5480 An interesting point is that the variables @samp{pi} and @samp{i}
5481 were matched literally rather than acting as meta-variables.
5482 This is because they are special-constant variables. The special
5483 constants @samp{e}, @samp{phi}, and so on also match literally.
5484 A common error with rewrite
5485 rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
5486 to match any @samp{f} with five arguments but in fact matching
5487 only when the fifth argument is literally @samp{e}!
5489 @cindex Fibonacci numbers
5494 Rewrite rules provide an interesting way to define your own functions.
5495 Suppose we want to define @samp{fib(n)} to produce the @var{n}th
5496 Fibonacci number. The first two Fibonacci numbers are each 1;
5497 later numbers are formed by summing the two preceding numbers in
5498 the sequence. This is easy to express in a set of three rules:
5502 ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib
5507 ' fib(7) @key{RET} a r fib @key{RET}
5511 One thing that is guaranteed about the order that rewrites are tried
5512 is that, for any given subformula, earlier rules in the rule set will
5513 be tried for that subformula before later ones. So even though the
5514 first and third rules both match @samp{fib(1)}, we know the first will
5515 be used preferentially.
5517 This rule set has one dangerous bug: Suppose we apply it to the
5518 formula @samp{fib(x)}? (Don't actually try this.) The third rule
5519 will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
5520 Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
5521 fib(x-4)}, and so on, expanding forever. What we really want is to apply
5522 the third rule only when @samp{n} is an integer greater than two. Type
5523 @w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
5526 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
5534 1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0)
5537 ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET}
5542 We've created a new function, @code{fib}, and a new command,
5543 @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
5544 this formula.'' To make things easier still, we can tell Calc to
5545 apply these rules automatically by storing them in the special
5546 variable @code{EvalRules}.
5550 1: [fib(1) := ...] . 1: [8, 13]
5553 s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET}
5557 It turns out that this rule set has the problem that it does far
5558 more work than it needs to when @samp{n} is large. Consider the
5559 first few steps of the computation of @samp{fib(6)}:
5565 fib(4) + fib(3) + fib(3) + fib(2) =
5566 fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
5571 Note that @samp{fib(3)} appears three times here. Unless Calc's
5572 algebraic simplifier notices the multiple @samp{fib(3)}s and combines
5573 them (and, as it happens, it doesn't), this rule set does lots of
5574 needless recomputation. To cure the problem, type @code{s e EvalRules}
5575 to edit the rules (or just @kbd{s E}, a shorthand command for editing
5576 @code{EvalRules}) and add another condition:
5579 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
5583 If a @samp{:: remember} condition appears anywhere in a rule, then if
5584 that rule succeeds Calc will add another rule that describes that match
5585 to the front of the rule set. (Remembering works in any rule set, but
5586 for technical reasons it is most effective in @code{EvalRules}.) For
5587 example, if the rule rewrites @samp{fib(7)} to something that evaluates
5588 to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
5590 Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
5591 type @kbd{s E} again to see what has happened to the rule set.
5593 With the @code{remember} feature, our rule set can now compute
5594 @samp{fib(@var{n})} in just @var{n} steps. In the process it builds
5595 up a table of all Fibonacci numbers up to @var{n}. After we have
5596 computed the result for a particular @var{n}, we can get it back
5597 (and the results for all smaller @var{n}) later in just one step.
5599 All Calc operations will run somewhat slower whenever @code{EvalRules}
5600 contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to
5601 un-store the variable.
5603 (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate
5604 a problem to reduce the amount of recursion necessary to solve it.
5605 Create a rule that, in about @var{n} simple steps and without recourse
5606 to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
5607 @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
5608 @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is
5609 rather clunky to use, so add a couple more rules to make the ``user
5610 interface'' the same as for our first version: enter @samp{fib(@var{n})},
5611 get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{})
5613 There are many more things that rewrites can do. For example, there
5614 are @samp{&&&} and @samp{|||} pattern operators that create ``and''
5615 and ``or'' combinations of rules. As one really simple example, we
5616 could combine our first two Fibonacci rules thusly:
5619 [fib(1 ||| 2) := 1, fib(n) := ... ]
5623 That means ``@code{fib} of something matching either 1 or 2 rewrites
5626 You can also make meta-variables optional by enclosing them in @code{opt}.
5627 For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
5628 @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x}
5629 matches all of these forms, filling in a default of zero for @samp{a}
5630 and one for @samp{b}.
5632 (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x}
5633 on the stack and tried to use the rule
5634 @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened?
5635 @xref{Rewrites Answer 3, 3}. (@bullet{})
5637 (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a},
5638 divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}.
5639 Now repeat this step over and over. A famous unproved conjecture
5640 is that for any starting @expr{a}, the sequence always eventually
5641 reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of
5642 rules that convert this into @samp{seq(1, @var{n})} where @var{n}
5643 is the number of steps it took the sequence to reach the value 1.
5644 Now enhance the rules to accept @samp{seq(@var{a})} as a starting
5645 configuration, and to stop with just the number @var{n} by itself.
5646 Now make the result be a vector of values in the sequence, from @var{a}
5647 to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
5648 and @var{y}.) For example, rewriting @samp{seq(6)} should yield the
5649 vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
5650 @xref{Rewrites Answer 4, 4}. (@bullet{})
5652 (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function
5653 @samp{nterms(@var{x})} that returns the number of terms in the sum
5654 @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes
5655 is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
5656 so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.)
5657 @xref{Rewrites Answer 5, 5}. (@bullet{})
5659 (@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an
5660 infinite series that exactly equals the value of that function at
5661 values of @expr{x} near zero.
5665 cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
5671 $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
5675 The @kbd{a t} command produces a @dfn{truncated Taylor series} which
5676 is obtained by dropping all the terms higher than, say, @expr{x^2}.
5677 Calc represents the truncated Taylor series as a polynomial in @expr{x}.
5678 Mathematicians often write a truncated series using a ``big-O'' notation
5679 that records what was the lowest term that was truncated.
5683 cos(x) = 1 - x^2 / 2! + O(x^3)
5689 $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
5694 The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small
5695 if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.''
5697 The exercise is to create rewrite rules that simplify sums and products of
5698 power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
5699 For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
5700 on the stack, we want to be able to type @kbd{*} and get the result
5701 @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are
5702 rearranged or if @kbd{a s} needs to be typed after rewriting. (This one
5703 is rather tricky; the solution at the end of this chapter uses 6 rewrite
5704 rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is
5705 a number.) @xref{Rewrites Answer 6, 6}. (@bullet{})
5707 Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
5708 What happens? (Be sure to remove this rule afterward, or you might get
5709 a nasty surprise when you use Calc to balance your checkbook!)
5711 @xref{Rewrite Rules}, for the whole story on rewrite rules.
5713 @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
5714 @section Programming Tutorial
5717 The Calculator is written entirely in Emacs Lisp, a highly extensible
5718 language. If you know Lisp, you can program the Calculator to do
5719 anything you like. Rewrite rules also work as a powerful programming
5720 system. But Lisp and rewrite rules take a while to master, and often
5721 all you want to do is define a new function or repeat a command a few
5722 times. Calc has features that allow you to do these things easily.
5724 One very limited form of programming is defining your own functions.
5725 Calc's @kbd{Z F} command allows you to define a function name and
5726 key sequence to correspond to any formula. Programming commands use
5727 the shift-@kbd{Z} prefix; the user commands they create use the lower
5728 case @kbd{z} prefix.
5732 1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6
5735 ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y
5739 This polynomial is a Taylor series approximation to @samp{exp(x)}.
5740 The @kbd{Z F} command asks a number of questions. The above answers
5741 say that the key sequence for our function should be @kbd{z e}; the
5742 @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
5743 function in algebraic formulas should also be @code{myexp}; the
5744 default argument list @samp{(x)} is acceptable; and finally @kbd{y}
5745 answers the question ``leave it in symbolic form for non-constant
5750 1: 1.3495 2: 1.3495 3: 1.3495
5751 . 1: 1.34986 2: 1.34986
5755 .3 z e .3 E ' a+1 @key{RET} z e
5760 First we call our new @code{exp} approximation with 0.3 as an
5761 argument, and compare it with the true @code{exp} function. Then
5762 we note that, as requested, if we try to give @kbd{z e} an
5763 argument that isn't a plain number, it leaves the @code{myexp}
5764 function call in symbolic form. If we had answered @kbd{n} to the
5765 final question, @samp{myexp(a + 1)} would have evaluated by plugging
5766 in @samp{a + 1} for @samp{x} in the defining formula.
5768 @cindex Sine integral Si(x)
5773 (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function
5774 @texline @math{{\rm Si}(x)}
5775 @infoline @expr{Si(x)}
5776 is defined as the integral of @samp{sin(t)/t} for
5777 @expr{t = 0} to @expr{x} in radians. (It was invented because this
5778 integral has no solution in terms of basic functions; if you give it
5779 to Calc's @kbd{a i} command, it will ponder it for a long time and then
5780 give up.) We can use the numerical integration command, however,
5781 which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
5782 with any integrand @samp{f(t)}. Define a @kbd{z s} command and
5783 @code{Si} function that implement this. You will need to edit the
5784 default argument list a bit. As a test, @samp{Si(1)} should return
5785 0.946083. (If you don't get this answer, you might want to check that
5786 Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if
5787 you reduce the precision to, say, six digits beforehand.)
5788 @xref{Programming Answer 1, 1}. (@bullet{})
5790 The simplest way to do real ``programming'' of Emacs is to define a
5791 @dfn{keyboard macro}. A keyboard macro is simply a sequence of
5792 keystrokes which Emacs has stored away and can play back on demand.
5793 For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
5794 you may wish to program a keyboard macro to type this for you.
5798 1: y = sqrt(x) 1: x = y^2
5801 ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x )
5803 1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1
5806 ' y=cos(x) @key{RET} X
5811 When you type @kbd{C-x (}, Emacs begins recording. But it is also
5812 still ready to execute your keystrokes, so you're really ``training''
5813 Emacs by walking it through the procedure once. When you type
5814 @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to
5815 re-execute the same keystrokes.
5817 You can give a name to your macro by typing @kbd{Z K}.
5821 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y))
5824 Z K x @key{RET} ' y=x^4 @key{RET} z x
5829 Notice that we use shift-@kbd{Z} to define the command, and lower-case
5830 @kbd{z} to call it up.
5832 Keyboard macros can call other macros.
5836 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y
5839 ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X
5843 (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate
5844 the item in level 3 of the stack, without disturbing the rest of
5845 the stack. @xref{Programming Answer 2, 2}. (@bullet{})
5847 (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute
5848 the following functions:
5853 @texline @math{\displaystyle{\sin x \over x}},
5854 @infoline @expr{sin(x) / x},
5855 where @expr{x} is the number on the top of the stack.
5858 Compute the base-@expr{b} logarithm, just like the @kbd{B} key except
5859 the arguments are taken in the opposite order.
5862 Produce a vector of integers from 1 to the integer on the top of
5866 @xref{Programming Answer 3, 3}. (@bullet{})
5868 (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute
5869 the average (mean) value of a list of numbers.
5870 @xref{Programming Answer 4, 4}. (@bullet{})
5872 In many programs, some of the steps must execute several times.
5873 Calc has @dfn{looping} commands that allow this. Loops are useful
5874 inside keyboard macros, but actually work at any time.
5878 1: x^6 2: x^6 1: 360 x^2
5882 ' x^6 @key{RET} 4 Z < a d x @key{RET} Z >
5887 Here we have computed the fourth derivative of @expr{x^6} by
5888 enclosing a derivative command in a ``repeat loop'' structure.
5889 This structure pops a repeat count from the stack, then
5890 executes the body of the loop that many times.
5892 If you make a mistake while entering the body of the loop,
5893 type @w{@kbd{Z C-g}} to cancel the loop command.
5895 @cindex Fibonacci numbers
5896 Here's another example:
5905 1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z >
5910 The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
5911 numbers, respectively. (To see what's going on, try a few repetitions
5912 of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
5913 key if you have one, makes a copy of the number in level 2.)
5915 @cindex Golden ratio
5916 @cindex Phi, golden ratio
5917 A fascinating property of the Fibonacci numbers is that the @expr{n}th
5918 Fibonacci number can be found directly by computing
5919 @texline @math{\phi^n / \sqrt{5}}
5920 @infoline @expr{phi^n / sqrt(5)}
5921 and then rounding to the nearest integer, where
5922 @texline @math{\phi} (``phi''),
5923 @infoline @expr{phi},
5924 the ``golden ratio,'' is
5925 @texline @math{(1 + \sqrt{5}) / 2}.
5926 @infoline @expr{(1 + sqrt(5)) / 2}.
5927 (For convenience, this constant is available from the @code{phi}
5928 variable, or the @kbd{I H P} command.)
5932 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946
5939 @cindex Continued fractions
5940 (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction}
5942 @texline @math{\phi}
5943 @infoline @expr{phi}
5945 @texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}.
5946 @infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
5947 We can compute an approximate value by carrying this however far
5948 and then replacing the innermost
5949 @texline @math{1/( \ldots )}
5950 @infoline @expr{1/( ...@: )}
5952 @texline @math{\phi}
5953 @infoline @expr{phi}
5954 using a twenty-term continued fraction.
5955 @xref{Programming Answer 5, 5}. (@bullet{})
5957 (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for
5958 Fibonacci numbers can be expressed in terms of matrices. Given a
5959 vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this
5960 vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and
5961 @expr{c} are three successive Fibonacci numbers. Now write a program
5962 that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number
5963 using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{})
5965 @cindex Harmonic numbers
5966 A more sophisticated kind of loop is the @dfn{for} loop. Suppose
5967 we wish to compute the 20th ``harmonic'' number, which is equal to
5968 the sum of the reciprocals of the integers from 1 to 20.
5977 0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z )
5982 The ``for'' loop pops two numbers, the lower and upper limits, then
5983 repeats the body of the loop as an internal counter increases from
5984 the lower limit to the upper one. Just before executing the loop
5985 body, it pushes the current loop counter. When the loop body
5986 finishes, it pops the ``step,'' i.e., the amount by which to
5987 increment the loop counter. As you can see, our loop always
5990 This harmonic number function uses the stack to hold the running
5991 total as well as for the various loop housekeeping functions. If
5992 you find this disorienting, you can sum in a variable instead:
5996 1: 0 2: 1 . 1: 3.597739
6000 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7
6005 The @kbd{s +} command adds the top-of-stack into the value in a
6006 variable (and removes that value from the stack).
6008 It's worth noting that many jobs that call for a ``for'' loop can
6009 also be done more easily by Calc's high-level operations. Two
6010 other ways to compute harmonic numbers are to use vector mapping
6011 and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
6012 or to use the summation command @kbd{a +}. Both of these are
6013 probably easier than using loops. However, there are some
6014 situations where loops really are the way to go:
6016 (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first
6017 harmonic number which is greater than 4.0.
6018 @xref{Programming Answer 7, 7}. (@bullet{})
6020 Of course, if we're going to be using variables in our programs,
6021 we have to worry about the programs clobbering values that the
6022 caller was keeping in those same variables. This is easy to
6027 . 1: 0.6667 1: 0.6667 3: 0.6667
6032 Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET}
6037 When we type @kbd{Z `} (that's a back-quote character), Calc saves
6038 its mode settings and the contents of the ten ``quick variables''
6039 for later reference. When we type @kbd{Z '} (that's an apostrophe
6040 now), Calc restores those saved values. Thus the @kbd{p 4} and
6041 @kbd{s 7} commands have no effect outside this sequence. Wrapping
6042 this around the body of a keyboard macro ensures that it doesn't
6043 interfere with what the user of the macro was doing. Notice that
6044 the contents of the stack, and the values of named variables,
6045 survive past the @kbd{Z '} command.
6047 @cindex Bernoulli numbers, approximate
6048 The @dfn{Bernoulli numbers} are a sequence with the interesting
6049 property that all of the odd Bernoulli numbers are zero, and the
6050 even ones, while difficult to compute, can be roughly approximated
6052 @texline @math{\displaystyle{2 n! \over (2 \pi)^n}}.
6053 @infoline @expr{2 n!@: / (2 pi)^n}.
6054 Let's write a keyboard macro to compute (approximate) Bernoulli numbers.
6055 (Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but
6056 this command is very slow for large @expr{n} since the higher Bernoulli
6057 numbers are very large fractions.)
6064 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
6069 You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
6070 @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if''
6071 command. For the purposes of @w{@kbd{Z [}}, the condition is ``true''
6072 if the value it pops from the stack is a nonzero number, or ``false''
6073 if it pops zero or something that is not a number (like a formula).
6074 Here we take our integer argument modulo 2; this will be nonzero
6075 if we're asking for an odd Bernoulli number.
6077 The actual tenth Bernoulli number is @expr{5/66}.
6081 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659
6086 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
6090 Just to exercise loops a bit more, let's compute a table of even
6095 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...]
6100 [ ] 2 @key{RET} 30 Z ( X | 2 Z )
6105 The vertical-bar @kbd{|} is the vector-concatenation command. When
6106 we execute it, the list we are building will be in stack level 2
6107 (initially this is an empty list), and the next Bernoulli number
6108 will be in level 1. The effect is to append the Bernoulli number
6109 onto the end of the list. (To create a table of exact fractional
6110 Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
6111 sequence of keystrokes.)
6113 With loops and conditionals, you can program essentially anything
6114 in Calc. One other command that makes looping easier is @kbd{Z /},
6115 which takes a condition from the stack and breaks out of the enclosing
6116 loop if the condition is true (non-zero). You can use this to make
6117 ``while'' and ``until'' style loops.
6119 If you make a mistake when entering a keyboard macro, you can edit
6120 it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}.
6121 One technique is to enter a throwaway dummy definition for the macro,
6122 then enter the real one in the edit command.
6126 1: 3 1: 3 Calc Macro Edit Mode.
6127 . . Original keys: 1 <return> 2 +
6134 C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h
6139 A keyboard macro is stored as a pure keystroke sequence. The
6140 @file{edmacro} package (invoked by @kbd{Z E}) scans along the
6141 macro and tries to decode it back into human-readable steps.
6142 Descriptions of the keystrokes are given as comments, which begin with
6143 @samp{;;}, and which are ignored when the edited macro is saved.
6144 Spaces and line breaks are also ignored when the edited macro is saved.
6145 To enter a space into the macro, type @code{SPC}. All the special
6146 characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL},
6147 and @code{NUL} must be written in all uppercase, as must the prefixes
6148 @code{C-} and @code{M-}.
6150 Let's edit in a new definition, for computing harmonic numbers.
6151 First, erase the four lines of the old definition. Then, type
6152 in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
6153 to copy it from this page of the Info file; you can of course skip
6154 typing the comments, which begin with @samp{;;}).
6157 Z` ;; calc-kbd-push (Save local values)
6158 0 ;; calc digits (Push a zero onto the stack)
6159 st ;; calc-store-into (Store it in the following variable)
6160 1 ;; calc quick variable (Quick variable q1)
6161 1 ;; calc digits (Initial value for the loop)
6162 TAB ;; calc-roll-down (Swap initial and final)
6163 Z( ;; calc-kbd-for (Begin the "for" loop)
6164 & ;; calc-inv (Take the reciprocal)
6165 s+ ;; calc-store-plus (Add to the following variable)
6166 1 ;; calc quick variable (Quick variable q1)
6167 1 ;; calc digits (The loop step is 1)
6168 Z) ;; calc-kbd-end-for (End the "for" loop)
6169 sr ;; calc-recall (Recall the final accumulated value)
6170 1 ;; calc quick variable (Quick variable q1)
6171 Z' ;; calc-kbd-pop (Restore values)
6175 Press @kbd{C-c C-c} to finish editing and return to the Calculator.
6186 The @file{edmacro} package defines a handy @code{read-kbd-macro} command
6187 which reads the current region of the current buffer as a sequence of
6188 keystroke names, and defines that sequence on the @kbd{X}
6189 (and @kbd{C-x e}) key. Because this is so useful, Calc puts this
6190 command on the @kbd{C-x * m} key. Try reading in this macro in the
6191 following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
6192 one end of the text below, then type @kbd{C-x * m} at the other.
6204 (@bullet{}) @strong{Exercise 8.} A general algorithm for solving
6205 equations numerically is @dfn{Newton's Method}. Given the equation
6206 @expr{f(x) = 0} for any function @expr{f}, and an initial guess
6207 @expr{x_0} which is reasonably close to the desired solution, apply
6208 this formula over and over:
6212 new_x = x - f(x)/f'(x)
6217 $$ x_{\rm new} = x - {f(x) \over f'(x)} $$
6222 where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x}
6223 values will quickly converge to a solution, i.e., eventually
6224 @texline @math{x_{\rm new}}
6225 @infoline @expr{new_x}
6226 and @expr{x} will be equal to within the limits
6227 of the current precision. Write a program which takes a formula
6228 involving the variable @expr{x}, and an initial guess @expr{x_0},
6229 on the stack, and produces a value of @expr{x} for which the formula
6230 is zero. Use it to find a solution of
6231 @texline @math{\sin(\cos x) = 0.5}
6232 @infoline @expr{sin(cos(x)) = 0.5}
6233 near @expr{x = 4.5}. (Use angles measured in radians.) Note that
6234 the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
6235 method when it is able. @xref{Programming Answer 8, 8}. (@bullet{})
6237 @cindex Digamma function
6238 @cindex Gamma constant, Euler's
6239 @cindex Euler's gamma constant
6240 (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function
6241 @texline @math{\psi(z) (``psi'')}
6242 @infoline @expr{psi(z)}
6243 is defined as the derivative of
6244 @texline @math{\ln \Gamma(z)}.
6245 @infoline @expr{ln(gamma(z))}.
6246 For large values of @expr{z}, it can be approximated by the infinite sum
6250 psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
6255 $$ \psi(z) \approx \ln z - {1\over2z} -
6256 \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
6263 @texline @math{\sum}
6264 @infoline @expr{sum}
6265 represents the sum over @expr{n} from 1 to infinity
6266 (or to some limit high enough to give the desired accuracy), and
6267 the @code{bern} function produces (exact) Bernoulli numbers.
6268 While this sum is not guaranteed to converge, in practice it is safe.
6269 An interesting mathematical constant is Euler's gamma, which is equal
6270 to about 0.5772. One way to compute it is by the formula,
6271 @texline @math{\gamma = -\psi(1)}.
6272 @infoline @expr{gamma = -psi(1)}.
6273 Unfortunately, 1 isn't a large enough argument
6274 for the above formula to work (5 is a much safer value for @expr{z}).
6275 Fortunately, we can compute
6276 @texline @math{\psi(1)}
6277 @infoline @expr{psi(1)}
6279 @texline @math{\psi(5)}
6280 @infoline @expr{psi(5)}
6281 using the recurrence
6282 @texline @math{\psi(z+1) = \psi(z) + {1 \over z}}.
6283 @infoline @expr{psi(z+1) = psi(z) + 1/z}.
6284 Your task: Develop a program to compute
6285 @texline @math{\psi(z)};
6286 @infoline @expr{psi(z)};
6287 it should ``pump up'' @expr{z}
6288 if necessary to be greater than 5, then use the above summation
6289 formula. Use looping commands to compute the sum. Use your function
6291 @texline @math{\gamma}
6292 @infoline @expr{gamma}
6293 to twelve decimal places. (Calc has a built-in command
6294 for Euler's constant, @kbd{I P}, which you can use to check your answer.)
6295 @xref{Programming Answer 9, 9}. (@bullet{})
6297 @cindex Polynomial, list of coefficients
6298 (@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and
6299 a number @expr{m} on the stack, where the polynomial is of degree
6300 @expr{m} or less (i.e., does not have any terms higher than @expr{x^m}),
6301 write a program to convert the polynomial into a list-of-coefficients
6302 notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6}
6303 should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop
6304 a way to convert from this form back to the standard algebraic form.
6305 @xref{Programming Answer 10, 10}. (@bullet{})
6308 (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the
6309 first kind} are defined by the recurrences,
6313 s(n,n) = 1 for n >= 0,
6314 s(n,0) = 0 for n > 0,
6315 s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1.
6321 $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr
6322 s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr
6323 s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
6324 \hbox{for } n \ge m \ge 1.}
6328 (These numbers are also sometimes written $\displaystyle{n \brack m}$.)
6331 This can be implemented using a @dfn{recursive} program in Calc; the
6332 program must invoke itself in order to calculate the two righthand
6333 terms in the general formula. Since it always invokes itself with
6334 ``simpler'' arguments, it's easy to see that it must eventually finish
6335 the computation. Recursion is a little difficult with Emacs keyboard
6336 macros since the macro is executed before its definition is complete.
6337 So here's the recommended strategy: Create a ``dummy macro'' and assign
6338 it to a key with, e.g., @kbd{Z K s}. Now enter the true definition,
6339 using the @kbd{z s} command to call itself recursively, then assign it
6340 to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run
6341 the complete recursive program. (Another way is to use @w{@kbd{Z E}}
6342 or @kbd{C-x * m} (@code{read-kbd-macro}) to read the whole macro at once,
6343 thus avoiding the ``training'' phase.) The task: Write a program
6344 that computes Stirling numbers of the first kind, given @expr{n} and
6345 @expr{m} on the stack. Test it with @emph{small} inputs like
6346 @expr{s(4,2)}. (There is a built-in command for Stirling numbers,
6347 @kbd{k s}, which you can use to check your answers.)
6348 @xref{Programming Answer 11, 11}. (@bullet{})
6350 The programming commands we've seen in this part of the tutorial
6351 are low-level, general-purpose operations. Often you will find
6352 that a higher-level function, such as vector mapping or rewrite
6353 rules, will do the job much more easily than a detailed, step-by-step
6356 (@bullet{}) @strong{Exercise 12.} Write another program for
6357 computing Stirling numbers of the first kind, this time using
6358 rewrite rules. Once again, @expr{n} and @expr{m} should be taken
6359 from the stack. @xref{Programming Answer 12, 12}. (@bullet{})
6364 This ends the tutorial section of the Calc manual. Now you know enough
6365 about Calc to use it effectively for many kinds of calculations. But
6366 Calc has many features that were not even touched upon in this tutorial.
6368 The rest of this manual tells the whole story.
6370 @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
6373 @node Answers to Exercises, , Programming Tutorial, Tutorial
6374 @section Answers to Exercises
6377 This section includes answers to all the exercises in the Calc tutorial.
6380 * RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
6381 * RPN Answer 2:: 2*4 + 7*9.5 + 5/4
6382 * RPN Answer 3:: Operating on levels 2 and 3
6383 * RPN Answer 4:: Joe's complex problems
6384 * Algebraic Answer 1:: Simulating Q command
6385 * Algebraic Answer 2:: Joe's algebraic woes
6386 * Algebraic Answer 3:: 1 / 0
6387 * Modes Answer 1:: 3#0.1 = 3#0.0222222?
6388 * Modes Answer 2:: 16#f.e8fe15
6389 * Modes Answer 3:: Joe's rounding bug
6390 * Modes Answer 4:: Why floating point?
6391 * Arithmetic Answer 1:: Why the \ command?
6392 * Arithmetic Answer 2:: Tripping up the B command
6393 * Vector Answer 1:: Normalizing a vector
6394 * Vector Answer 2:: Average position
6395 * Matrix Answer 1:: Row and column sums
6396 * Matrix Answer 2:: Symbolic system of equations
6397 * Matrix Answer 3:: Over-determined system
6398 * List Answer 1:: Powers of two
6399 * List Answer 2:: Least-squares fit with matrices
6400 * List Answer 3:: Geometric mean
6401 * List Answer 4:: Divisor function
6402 * List Answer 5:: Duplicate factors
6403 * List Answer 6:: Triangular list
6404 * List Answer 7:: Another triangular list
6405 * List Answer 8:: Maximum of Bessel function
6406 * List Answer 9:: Integers the hard way
6407 * List Answer 10:: All elements equal
6408 * List Answer 11:: Estimating pi with darts
6409 * List Answer 12:: Estimating pi with matchsticks
6410 * List Answer 13:: Hash codes
6411 * List Answer 14:: Random walk
6412 * Types Answer 1:: Square root of pi times rational
6413 * Types Answer 2:: Infinities
6414 * Types Answer 3:: What can "nan" be?
6415 * Types Answer 4:: Abbey Road
6416 * Types Answer 5:: Friday the 13th
6417 * Types Answer 6:: Leap years
6418 * Types Answer 7:: Erroneous donut
6419 * Types Answer 8:: Dividing intervals
6420 * Types Answer 9:: Squaring intervals
6421 * Types Answer 10:: Fermat's primality test
6422 * Types Answer 11:: pi * 10^7 seconds
6423 * Types Answer 12:: Abbey Road on CD
6424 * Types Answer 13:: Not quite pi * 10^7 seconds
6425 * Types Answer 14:: Supercomputers and c
6426 * Types Answer 15:: Sam the Slug
6427 * Algebra Answer 1:: Squares and square roots
6428 * Algebra Answer 2:: Building polynomial from roots
6429 * Algebra Answer 3:: Integral of x sin(pi x)
6430 * Algebra Answer 4:: Simpson's rule
6431 * Rewrites Answer 1:: Multiplying by conjugate
6432 * Rewrites Answer 2:: Alternative fib rule
6433 * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x
6434 * Rewrites Answer 4:: Sequence of integers
6435 * Rewrites Answer 5:: Number of terms in sum
6436 * Rewrites Answer 6:: Truncated Taylor series
6437 * Programming Answer 1:: Fresnel's C(x)
6438 * Programming Answer 2:: Negate third stack element
6439 * Programming Answer 3:: Compute sin(x) / x, etc.
6440 * Programming Answer 4:: Average value of a list
6441 * Programming Answer 5:: Continued fraction phi
6442 * Programming Answer 6:: Matrix Fibonacci numbers
6443 * Programming Answer 7:: Harmonic number greater than 4
6444 * Programming Answer 8:: Newton's method
6445 * Programming Answer 9:: Digamma function
6446 * Programming Answer 10:: Unpacking a polynomial
6447 * Programming Answer 11:: Recursive Stirling numbers
6448 * Programming Answer 12:: Stirling numbers with rewrites
6451 @c The following kludgery prevents the individual answers from
6452 @c being entered on the table of contents.
6454 \global\let\oldwrite=\write
6455 \gdef\skipwrite#1#2{\let\write=\oldwrite}
6456 \global\let\oldchapternofonts=\chapternofonts
6457 \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
6460 @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
6461 @subsection RPN Tutorial Exercise 1
6464 @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
6467 @texline @math{1 - (2 \times (3 + 4)) = -13}.
6468 @infoline @expr{1 - (2 * (3 + 4)) = -13}.
6470 @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
6471 @subsection RPN Tutorial Exercise 2
6474 @texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75}
6475 @infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75}
6477 After computing the intermediate term
6478 @texline @math{2\times4 = 8},
6479 @infoline @expr{2*4 = 8},
6480 you can leave that result on the stack while you compute the second
6481 term. With both of these results waiting on the stack you can then
6482 compute the final term, then press @kbd{+ +} to add everything up.
6491 2 @key{RET} 4 * 7 @key{RET} 9.5 *
6498 4: 8 3: 8 2: 8 1: 75.75
6499 3: 66.5 2: 66.5 1: 67.75 .
6508 Alternatively, you could add the first two terms before going on
6509 with the third term.
6513 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75
6514 1: 66.5 . 2: 5 1: 1.25 .
6518 ... + 5 @key{RET} 4 / +
6522 On an old-style RPN calculator this second method would have the
6523 advantage of using only three stack levels. But since Calc's stack
6524 can grow arbitrarily large this isn't really an issue. Which method
6525 you choose is purely a matter of taste.
6527 @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
6528 @subsection RPN Tutorial Exercise 3
6531 The @key{TAB} key provides a way to operate on the number in level 2.
6535 3: 10 3: 10 4: 10 3: 10 3: 10
6536 2: 20 2: 30 3: 30 2: 30 2: 21
6537 1: 30 1: 20 2: 20 1: 21 1: 30
6541 @key{TAB} 1 + @key{TAB}
6545 Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
6549 3: 10 3: 21 3: 21 3: 30 3: 11
6550 2: 21 2: 30 2: 30 2: 11 2: 21
6551 1: 30 1: 10 1: 11 1: 21 1: 30
6554 M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB}
6558 @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
6559 @subsection RPN Tutorial Exercise 4
6562 Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
6563 but using both the comma and the space at once yields:
6567 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ...
6568 . 1: 2 . 1: (2, ... 1: (2, 3)
6575 Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
6576 extra incomplete object to the top of the stack and delete it.
6577 But a feature of Calc is that @key{DEL} on an incomplete object
6578 deletes just one component out of that object, so he had to press
6579 @key{DEL} twice to finish the job.
6583 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3)
6584 1: (2, 3) 1: (2, ... 1: ( ... .
6587 @key{TAB} @key{DEL} @key{DEL}
6591 (As it turns out, deleting the second-to-top stack entry happens often
6592 enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
6593 @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
6594 the ``feature'' that tripped poor Joe.)
6596 @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
6597 @subsection Algebraic Entry Tutorial Exercise 1
6600 Type @kbd{' sqrt($) @key{RET}}.
6602 If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
6603 Or, RPN style, @kbd{0.5 ^}.
6605 (Actually, @samp{$^1:2}, using the fraction one-half as the power, is
6606 a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas
6607 @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.)
6609 @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
6610 @subsection Algebraic Entry Tutorial Exercise 2
6613 In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
6614 name with @samp{1+y} as its argument. Assigning a value to a variable
6615 has no relation to a function by the same name. Joe needed to use an
6616 explicit @samp{*} symbol here: @samp{2 x*(1+y)}.
6618 @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
6619 @subsection Algebraic Entry Tutorial Exercise 3
6622 The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}.
6623 The ``function'' @samp{/} cannot be evaluated when its second argument
6624 is zero, so it is left in symbolic form. When you now type @kbd{0 *},
6625 the result will be zero because Calc uses the general rule that ``zero
6626 times anything is zero.''
6628 @c [fix-ref Infinities]
6629 The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0}
6630 results in a special symbol that represents ``infinity.'' If you
6631 multiply infinity by zero, Calc uses another special new symbol to
6632 show that the answer is ``indeterminate.'' @xref{Infinities}, for
6633 further discussion of infinite and indeterminate values.
6635 @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
6636 @subsection Modes Tutorial Exercise 1
6639 Calc always stores its numbers in decimal, so even though one-third has
6640 an exact base-3 representation (@samp{3#0.1}), it is still stored as
6641 0.3333333 (chopped off after 12 or however many decimal digits) inside
6642 the calculator's memory. When this inexact number is converted back
6643 to base 3 for display, it may still be slightly inexact. When we
6644 multiply this number by 3, we get 0.999999, also an inexact value.
6646 When Calc displays a number in base 3, it has to decide how many digits
6647 to show. If the current precision is 12 (decimal) digits, that corresponds
6648 to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an
6649 exact integer, Calc shows only 25 digits, with the result that stored
6650 numbers carry a little bit of extra information that may not show up on
6651 the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666
6652 happened to round to a pleasing value when it lost that last 0.15 of a
6653 digit, but it was still inexact in Calc's memory. When he divided by 2,
6654 he still got the dreaded inexact value 0.333333. (Actually, he divided
6655 0.666667 by 2 to get 0.333334, which is why he got something a little
6656 higher than @code{3#0.1} instead of a little lower.)
6658 If Joe didn't want to be bothered with all this, he could have typed
6659 @kbd{M-24 d n} to display with one less digit than the default. (If
6660 you give @kbd{d n} a negative argument, it uses default-minus-that,
6661 so @kbd{M-- d n} would be an easier way to get the same effect.) Those
6662 inexact results would still be lurking there, but they would now be
6663 rounded to nice, natural-looking values for display purposes. (Remember,
6664 @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
6665 off one digit will round the number up to @samp{0.1}.) Depending on the
6666 nature of your work, this hiding of the inexactness may be a benefit or
6667 a danger. With the @kbd{d n} command, Calc gives you the choice.
6669 Incidentally, another consequence of all this is that if you type
6670 @kbd{M-30 d n} to display more digits than are ``really there,''
6671 you'll see garbage digits at the end of the number. (In decimal
6672 display mode, with decimally-stored numbers, these garbage digits are
6673 always zero so they vanish and you don't notice them.) Because Calc
6674 rounds off that 0.15 digit, there is the danger that two numbers could
6675 be slightly different internally but still look the same. If you feel
6676 uneasy about this, set the @kbd{d n} precision to be a little higher
6677 than normal; you'll get ugly garbage digits, but you'll always be able
6678 to tell two distinct numbers apart.
6680 An interesting side note is that most computers store their
6681 floating-point numbers in binary, and convert to decimal for display.
6682 Thus everyday programs have the same problem: Decimal 0.1 cannot be
6683 represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
6684 comes out as an inexact approximation to 1 on some machines (though
6685 they generally arrange to hide it from you by rounding off one digit as
6686 we did above). Because Calc works in decimal instead of binary, you can
6687 be sure that numbers that look exact @emph{are} exact as long as you stay
6688 in decimal display mode.
6690 It's not hard to show that any number that can be represented exactly
6691 in binary, octal, or hexadecimal is also exact in decimal, so the kinds
6692 of problems we saw in this exercise are likely to be severe only when
6693 you use a relatively unusual radix like 3.
6695 @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
6696 @subsection Modes Tutorial Exercise 2
6698 If the radix is 15 or higher, we can't use the letter @samp{e} to mark
6699 the exponent because @samp{e} is interpreted as a digit. When Calc
6700 needs to display scientific notation in a high radix, it writes
6701 @samp{16#F.E8F*16.^15}. You can enter a number like this as an
6702 algebraic entry. Also, pressing @kbd{e} without any digits before it
6703 normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
6704 puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
6705 way to enter this number.
6707 The reason Calc puts a decimal point in the @samp{16.^} is to prevent
6708 huge integers from being generated if the exponent is large (consider
6709 @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
6710 exact integer and then throw away most of the digits when we multiply
6711 it by the floating-point @samp{16#1.23}). While this wouldn't normally
6712 matter for display purposes, it could give you a nasty surprise if you
6713 copied that number into a file and later moved it back into Calc.
6715 @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
6716 @subsection Modes Tutorial Exercise 3
6719 The answer he got was @expr{0.5000000000006399}.
6721 The problem is not that the square operation is inexact, but that the
6722 sine of 45 that was already on the stack was accurate to only 12 places.
6723 Arbitrary-precision calculations still only give answers as good as
6726 The real problem is that there is no 12-digit number which, when
6727 squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]}
6728 commands decrease or increase a number by one unit in the last
6729 place (according to the current precision). They are useful for
6730 determining facts like this.
6734 1: 0.707106781187 1: 0.500000000001
6744 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999
6751 A high-precision calculation must be carried out in high precision
6752 all the way. The only number in the original problem which was known
6753 exactly was the quantity 45 degrees, so the precision must be raised
6754 before anything is done after the number 45 has been entered in order
6755 for the higher precision to be meaningful.
6757 @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
6758 @subsection Modes Tutorial Exercise 4
6761 Many calculations involve real-world quantities, like the width and
6762 height of a piece of wood or the volume of a jar. Such quantities
6763 can't be measured exactly anyway, and if the data that is input to
6764 a calculation is inexact, doing exact arithmetic on it is a waste
6767 Fractions become unwieldy after too many calculations have been
6768 done with them. For example, the sum of the reciprocals of the
6769 integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is
6770 9304682830147:2329089562800. After a point it will take a long
6771 time to add even one more term to this sum, but a floating-point
6772 calculation of the sum will not have this problem.
6774 Also, rational numbers cannot express the results of all calculations.
6775 There is no fractional form for the square root of two, so if you type
6776 @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
6778 @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
6779 @subsection Arithmetic Tutorial Exercise 1
6782 Dividing two integers that are larger than the current precision may
6783 give a floating-point result that is inaccurate even when rounded
6784 down to an integer. Consider @expr{123456789 / 2} when the current
6785 precision is 6 digits. The true answer is @expr{61728394.5}, but
6786 with a precision of 6 this will be rounded to
6787 @texline @math{12345700.0/2.0 = 61728500.0}.
6788 @infoline @expr{12345700.@: / 2.@: = 61728500.}.
6789 The result, when converted to an integer, will be off by 106.
6791 Here are two solutions: Raise the precision enough that the
6792 floating-point round-off error is strictly to the right of the
6793 decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2}
6794 produces the exact fraction @expr{123456789:2}, which can be rounded
6795 down by the @kbd{F} command without ever switching to floating-point
6798 @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
6799 @subsection Arithmetic Tutorial Exercise 2
6802 @kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it
6803 does a floating-point calculation instead and produces @expr{1.5}.
6805 Calc will find an exact result for a logarithm if the result is an integer
6806 or (when in Fraction mode) the reciprocal of an integer. But there is
6807 no efficient way to search the space of all possible rational numbers
6808 for an exact answer, so Calc doesn't try.
6810 @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
6811 @subsection Vector Tutorial Exercise 1
6814 Duplicate the vector, compute its length, then divide the vector
6815 by its length: @kbd{@key{RET} A /}.
6819 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1.
6820 . 1: 3.74165738677 . .
6827 The final @kbd{A} command shows that the normalized vector does
6828 indeed have unit length.
6830 @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
6831 @subsection Vector Tutorial Exercise 2
6834 The average position is equal to the sum of the products of the
6835 positions times their corresponding probabilities. This is the
6836 definition of the dot product operation. So all you need to do
6837 is to put the two vectors on the stack and press @kbd{*}.
6839 @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
6840 @subsection Matrix Tutorial Exercise 1
6843 The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to
6844 get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
6846 @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
6847 @subsection Matrix Tutorial Exercise 2
6860 $$ \eqalign{ x &+ a y = 6 \cr
6866 Just enter the righthand side vector, then divide by the lefthand side
6871 1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ]
6876 ' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} /
6880 This can be made more readable using @kbd{d B} to enable Big display
6886 1: [6 - -----, -----]
6891 Type @kbd{d N} to return to Normal display mode afterwards.
6893 @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
6894 @subsection Matrix Tutorial Exercise 3
6898 @texline @math{A^T A \, X = A^T B},
6899 @infoline @expr{trn(A) * A * X = trn(A) * B},
6901 @texline @math{A' = A^T A}
6902 @infoline @expr{A2 = trn(A) * A}
6904 @texline @math{B' = A^T B};
6905 @infoline @expr{B2 = trn(A) * B};
6906 now, we have a system
6907 @texline @math{A' X = B'}
6908 @infoline @expr{A2 * X = B2}
6909 which we can solve using Calc's @samp{/} command.
6924 $$ \openup1\jot \tabskip=0pt plus1fil
6925 \halign to\displaywidth{\tabskip=0pt
6926 $\hfil#$&$\hfil{}#{}$&
6927 $\hfil#$&$\hfil{}#{}$&
6928 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
6932 2a&+&4b&+&6c&=11 \cr}
6937 The first step is to enter the coefficient matrix. We'll store it in
6938 quick variable number 7 for later reference. Next, we compute the
6945 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96]
6946 [ 4, 5, 6 ] [ 2, 5, 6, 4 ] .
6947 [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ]
6948 [ 2, 4, 6 ] ] 1: [6, 2, 3, 11]
6951 ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] *
6956 Now we compute the matrix
6963 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64]
6964 1: [ [ 70, 72, 39 ] .
6974 (The actual computed answer will be slightly inexact due to
6977 Notice that the answers are similar to those for the
6978 @texline @math{3\times3}
6980 system solved in the text. That's because the fourth equation that was
6981 added to the system is almost identical to the first one multiplied
6982 by two. (If it were identical, we would have gotten the exact same
6984 @texline @math{4\times3}
6986 system would be equivalent to the original
6987 @texline @math{3\times3}
6991 Since the first and fourth equations aren't quite equivalent, they
6992 can't both be satisfied at once. Let's plug our answers back into
6993 the original system of equations to see how well they match.
6997 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2]
7009 This is reasonably close to our original @expr{B} vector,
7010 @expr{[6, 2, 3, 11]}.
7012 @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
7013 @subsection List Tutorial Exercise 1
7016 We can use @kbd{v x} to build a vector of integers. This needs to be
7017 adjusted to get the range of integers we desire. Mapping @samp{-}
7018 across the vector will accomplish this, although it turns out the
7019 plain @samp{-} key will work just as well.
7024 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4]
7027 2 v x 9 @key{RET} 5 V M - or 5 -
7032 Now we use @kbd{V M ^} to map the exponentiation operator across the
7037 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
7044 @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
7045 @subsection List Tutorial Exercise 2
7048 Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before,
7049 the first job is to form the matrix that describes the problem.
7059 $$ m \times x + b \times 1 = y $$
7064 @texline @math{19\times2}
7066 matrix with our @expr{x} vector as one column and
7067 ones as the other column. So, first we build the column of ones, then
7068 we combine the two columns to form our @expr{A} matrix.
7072 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ]
7073 1: [1, 1, 1, ...] [ 1.41, 1 ]
7077 r 1 1 v b 19 @key{RET} M-2 v p v t s 3
7083 @texline @math{A^T y}
7084 @infoline @expr{trn(A) * y}
7086 @texline @math{A^T A}
7087 @infoline @expr{trn(A) * A}
7092 1: [33.36554, 13.613] 2: [33.36554, 13.613]
7093 . 1: [ [ 98.0003, 41.63 ]
7097 v t r 2 * r 3 v t r 3 *
7102 (Hey, those numbers look familiar!)
7106 1: [0.52141679, -0.425978]
7113 Since we were solving equations of the form
7114 @texline @math{m \times x + b \times 1 = y},
7115 @infoline @expr{m*x + b*1 = y},
7116 these numbers should be @expr{m} and @expr{b}, respectively. Sure
7117 enough, they agree exactly with the result computed using @kbd{V M} and
7120 The moral of this story: @kbd{V M} and @kbd{V R} will probably solve
7121 your problem, but there is often an easier way using the higher-level
7122 arithmetic functions!
7124 @c [fix-ref Curve Fitting]
7125 In fact, there is a built-in @kbd{a F} command that does least-squares
7126 fits. @xref{Curve Fitting}.
7128 @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
7129 @subsection List Tutorial Exercise 3
7132 Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
7133 whatever) to set the mark, then move to the other end of the list
7134 and type @w{@kbd{C-x * g}}.
7138 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
7143 To make things interesting, let's assume we don't know at a glance
7144 how many numbers are in this list. Then we could type:
7148 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ]
7149 1: [2.3, 6, 22, ... ] 1: 126356422.5
7159 2: 126356422.5 2: 126356422.5 1: 7.94652913734
7160 1: [2.3, 6, 22, ... ] 1: 9 .
7168 (The @kbd{I ^} command computes the @var{n}th root of a number.
7169 You could also type @kbd{& ^} to take the reciprocal of 9 and
7170 then raise the number to that power.)
7172 @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
7173 @subsection List Tutorial Exercise 4
7176 A number @expr{j} is a divisor of @expr{n} if
7177 @texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}.
7178 @infoline @samp{n % j = 0}.
7179 The first step is to get a vector that identifies the divisors.
7183 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...]
7184 1: [1, 2, 3, 4, ...] 1: 0 .
7187 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2
7192 This vector has 1's marking divisors of 30 and 0's marking non-divisors.
7194 The zeroth divisor function is just the total number of divisors.
7195 The first divisor function is the sum of the divisors.
7200 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72
7201 1: [1, 1, 1, 0, ...] . .
7204 V R + r 1 r 2 V M * V R +
7209 Once again, the last two steps just compute a dot product for which
7210 a simple @kbd{*} would have worked equally well.
7212 @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
7213 @subsection List Tutorial Exercise 5
7216 The obvious first step is to obtain the list of factors with @kbd{k f}.
7217 This list will always be in sorted order, so if there are duplicates
7218 they will be right next to each other. A suitable method is to compare
7219 the list with a copy of itself shifted over by one.
7223 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0]
7224 . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19]
7227 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} |
7234 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0
7242 Note that we have to arrange for both vectors to have the same length
7243 so that the mapping operation works; no prime factor will ever be
7244 zero, so adding zeros on the left and right is safe. From then on
7245 the job is pretty straightforward.
7247 Incidentally, Calc provides the
7248 @texline @dfn{M@"obius} @math{\mu}
7249 @infoline @dfn{Moebius mu}
7250 function which is zero if and only if its argument is square-free. It
7251 would be a much more convenient way to do the above test in practice.
7253 @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
7254 @subsection List Tutorial Exercise 6
7257 First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
7258 to get a list of lists of integers!
7260 @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
7261 @subsection List Tutorial Exercise 7
7264 Here's one solution. First, compute the triangular list from the previous
7265 exercise and type @kbd{1 -} to subtract one from all the elements.
7278 The numbers down the lefthand edge of the list we desire are called
7279 the ``triangular numbers'' (now you know why!). The @expr{n}th
7280 triangular number is the sum of the integers from 1 to @expr{n}, and
7281 can be computed directly by the formula
7282 @texline @math{n (n+1) \over 2}.
7283 @infoline @expr{n * (n+1) / 2}.
7287 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7288 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15]
7291 v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET}
7296 Adding this list to the above list of lists produces the desired
7305 [10, 11, 12, 13, 14],
7306 [15, 16, 17, 18, 19, 20] ]
7313 If we did not know the formula for triangular numbers, we could have
7314 computed them using a @kbd{V U +} command. We could also have
7315 gotten them the hard way by mapping a reduction across the original
7320 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7321 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15]
7329 (This means ``map a @kbd{V R +} command across the vector,'' and
7330 since each element of the main vector is itself a small vector,
7331 @kbd{V R +} computes the sum of its elements.)
7333 @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
7334 @subsection List Tutorial Exercise 8
7337 The first step is to build a list of values of @expr{x}.
7341 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5]
7344 v x 21 @key{RET} 1 - 4 / s 1
7348 Next, we compute the Bessel function values.
7352 1: [0., 0.124, 0.242, ..., -0.328]
7355 V M ' besJ(1,$) @key{RET}
7360 (Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
7362 A way to isolate the maximum value is to compute the maximum using
7363 @kbd{V R X}, then compare all the Bessel values with that maximum.
7367 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ]
7371 @key{RET} V R X V M a = @key{RET} V R + @key{DEL}
7376 It's a good idea to verify, as in the last step above, that only
7377 one value is equal to the maximum. (After all, a plot of
7378 @texline @math{\sin x}
7379 @infoline @expr{sin(x)}
7380 might have many points all equal to the maximum value, 1.)
7382 The vector we have now has a single 1 in the position that indicates
7383 the maximum value of @expr{x}. Now it is a simple matter to convert
7384 this back into the corresponding value itself.
7388 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75
7389 1: [0, 0.25, 0.5, ... ] . .
7396 If @kbd{a =} had produced more than one @expr{1} value, this method
7397 would have given the sum of all maximum @expr{x} values; not very
7398 useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector})
7399 instead. This command deletes all elements of a ``data'' vector that
7400 correspond to zeros in a ``mask'' vector, leaving us with, in this
7401 example, a vector of maximum @expr{x} values.
7403 The built-in @kbd{a X} command maximizes a function using more
7404 efficient methods. Just for illustration, let's use @kbd{a X}
7405 to maximize @samp{besJ(1,x)} over this same interval.
7409 2: besJ(1, x) 1: [1.84115, 0.581865]
7413 ' besJ(1,x), [0..5] @key{RET} a X x @key{RET}
7418 The output from @kbd{a X} is a vector containing the value of @expr{x}
7419 that maximizes the function, and the function's value at that maximum.
7420 As you can see, our simple search got quite close to the right answer.
7422 @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
7423 @subsection List Tutorial Exercise 9
7426 Step one is to convert our integer into vector notation.
7430 1: 25129925999 3: 25129925999
7432 1: [11, 10, 9, ..., 1, 0]
7435 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
7442 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ]
7443 2: [100000000000, ... ] .
7451 (Recall, the @kbd{\} command computes an integer quotient.)
7455 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
7462 Next we must increment this number. This involves adding one to
7463 the last digit, plus handling carries. There is a carry to the
7464 left out of a digit if that digit is a nine and all the digits to
7465 the right of it are nines.
7469 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ]
7479 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
7487 Accumulating @kbd{*} across a vector of ones and zeros will preserve
7488 only the initial run of ones. These are the carries into all digits
7489 except the rightmost digit. Concatenating a one on the right takes
7490 care of aligning the carries properly, and also adding one to the
7495 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
7496 1: [0, 0, 2, 5, ... ] .
7499 0 r 2 | V M + 10 V M %
7504 Here we have concatenated 0 to the @emph{left} of the original number;
7505 this takes care of shifting the carries by one with respect to the
7506 digits that generated them.
7508 Finally, we must convert this list back into an integer.
7512 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ]
7513 2: 1000000000000 1: [1000000000000, 100000000000, ... ]
7514 1: [100000000000, ... ] .
7517 10 @key{RET} 12 ^ r 1 |
7524 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000
7532 Another way to do this final step would be to reduce the formula
7533 @w{@samp{10 $$ + $}} across the vector of digits.
7537 1: [0, 0, 2, 5, ... ] 1: 25129926000
7540 V R ' 10 $$ + $ @key{RET}
7544 @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
7545 @subsection List Tutorial Exercise 10
7548 For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d},
7549 which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is
7550 then compared with @expr{c} to produce another 1 or 0, which is then
7551 compared with @expr{d}. This is not at all what Joe wanted.
7553 Here's a more correct method:
7557 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7]
7561 ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET}
7568 1: [1, 1, 1, 0, 1] 1: 0
7575 @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
7576 @subsection List Tutorial Exercise 11
7579 The circle of unit radius consists of those points @expr{(x,y)} for which
7580 @expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2}
7581 and a vector of @expr{y^2}.
7583 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7588 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.]
7589 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81]
7592 v . t . 2. v b 100 @key{RET} @key{RET} V M k r
7599 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036]
7600 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094]
7603 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^
7607 Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to
7608 get a vector of 1/0 truth values, then sum the truth values.
7612 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84
7620 The ratio @expr{84/100} should approximate the ratio @cpiover{4}.
7624 1: 0.84 1: 3.36 2: 3.36 1: 1.0695
7632 Our estimate, 3.36, is off by about 7%. We could get a better estimate
7633 by taking more points (say, 1000), but it's clear that this method is
7636 (Naturally, since this example uses random numbers your own answer
7637 will be slightly different from the one shown here!)
7639 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7640 return to full-sized display of vectors.
7642 @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
7643 @subsection List Tutorial Exercise 12
7646 This problem can be made a lot easier by taking advantage of some
7647 symmetries. First of all, after some thought it's clear that the
7648 @expr{y} axis can be ignored altogether. Just pick a random @expr{x}
7649 component for one end of the match, pick a random direction
7650 @texline @math{\theta},
7651 @infoline @expr{theta},
7652 and see if @expr{x} and
7653 @texline @math{x + \cos \theta}
7654 @infoline @expr{x + cos(theta)}
7655 (which is the @expr{x} coordinate of the other endpoint) cross a line.
7656 The lines are at integer coordinates, so this happens when the two
7657 numbers surround an integer.
7659 Since the two endpoints are equivalent, we may as well choose the leftmost
7660 of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing
7661 to the right, in the range -90 to 90 degrees. (We could use radians, but
7662 it would feel like cheating to refer to @cpiover{2} radians while trying
7663 to estimate @cpi{}!)
7665 In fact, since the field of lines is infinite we can choose the
7666 coordinates 0 and 1 for the lines on either side of the leftmost
7667 endpoint. The rightmost endpoint will be between 0 and 1 if the
7668 match does not cross a line, or between 1 and 2 if it does. So:
7669 Pick random @expr{x} and
7670 @texline @math{\theta},
7671 @infoline @expr{theta},
7673 @texline @math{x + \cos \theta},
7674 @infoline @expr{x + cos(theta)},
7675 and count how many of the results are greater than one. Simple!
7677 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7682 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72]
7683 . 1: [78.4, 64.5, ..., -42.9]
7686 v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 -
7691 (The next step may be slow, depending on the speed of your computer.)
7695 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45]
7696 1: [0.20, 0.43, ..., 0.73] .
7706 1: [0, 1, ..., 1] 1: 0.64 1: 3.125
7709 1 V M a > V R + 100 / 2 @key{TAB} /
7713 Let's try the third method, too. We'll use random integers up to
7714 one million. The @kbd{k r} command with an integer argument picks
7719 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975]
7720 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450]
7723 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r
7730 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56
7733 V M k g 1 V M a = V R + 100 /
7747 For a proof of this property of the GCD function, see section 4.5.2,
7748 exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
7750 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7751 return to full-sized display of vectors.
7753 @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
7754 @subsection List Tutorial Exercise 13
7757 First, we put the string on the stack as a vector of ASCII codes.
7761 1: [84, 101, 115, ..., 51]
7764 "Testing, 1, 2, 3 @key{RET}
7769 Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
7770 there was no need to type an apostrophe. Also, Calc didn't mind that
7771 we omitted the closing @kbd{"}. (The same goes for all closing delimiters
7772 like @kbd{)} and @kbd{]} at the end of a formula.
7774 We'll show two different approaches here. In the first, we note that
7775 if the input vector is @expr{[a, b, c, d]}, then the hash code is
7776 @expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words,
7777 it's a sum of descending powers of three times the ASCII codes.
7781 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51]
7782 1: 16 1: [15, 14, 13, ..., 0]
7785 @key{RET} v l v x 16 @key{RET} -
7792 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121
7793 1: [14348907, ..., 1] . .
7796 3 @key{TAB} V M ^ * 511 %
7801 Once again, @kbd{*} elegantly summarizes most of the computation.
7802 But there's an even more elegant approach: Reduce the formula
7803 @kbd{3 $$ + $} across the vector. Recall that this represents a
7804 function of two arguments that computes its first argument times three
7805 plus its second argument.
7809 1: [84, 101, 115, ..., 51] 1: 1960915098
7812 "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET}
7817 If you did the decimal arithmetic exercise, this will be familiar.
7818 Basically, we're turning a base-3 vector of digits into an integer,
7819 except that our ``digits'' are much larger than real digits.
7821 Instead of typing @kbd{511 %} again to reduce the result, we can be
7822 cleverer still and notice that rather than computing a huge integer
7823 and taking the modulo at the end, we can take the modulo at each step
7824 without affecting the result. While this means there are more
7825 arithmetic operations, the numbers we operate on remain small so
7826 the operations are faster.
7830 1: [84, 101, 115, ..., 51] 1: 121
7833 "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET}
7837 Why does this work? Think about a two-step computation:
7838 @w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means
7839 subtracting off enough 511's to put the result in the desired range.
7840 So the result when we take the modulo after every step is,
7844 3 (3 a + b - 511 m) + c - 511 n
7850 $$ 3 (3 a + b - 511 m) + c - 511 n $$
7855 for some suitable integers @expr{m} and @expr{n}. Expanding out by
7856 the distributive law yields
7860 9 a + 3 b + c - 511*3 m - 511 n
7866 $$ 9 a + 3 b + c - 511\times3 m - 511 n $$
7871 The @expr{m} term in the latter formula is redundant because any
7872 contribution it makes could just as easily be made by the @expr{n}
7873 term. So we can take it out to get an equivalent formula with
7878 9 a + 3 b + c - 511 n'
7884 $$ 9 a + 3 b + c - 511 n' $$
7889 which is just the formula for taking the modulo only at the end of
7890 the calculation. Therefore the two methods are essentially the same.
7892 Later in the tutorial we will encounter @dfn{modulo forms}, which
7893 basically automate the idea of reducing every intermediate result
7894 modulo some value @var{m}.
7896 @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
7897 @subsection List Tutorial Exercise 14
7899 We want to use @kbd{H V U} to nest a function which adds a random
7900 step to an @expr{(x,y)} coordinate. The function is a bit long, but
7901 otherwise the problem is quite straightforward.
7905 2: [0, 0] 1: [ [ 0, 0 ]
7906 1: 50 [ 0.4288, -0.1695 ]
7907 . [ -0.4787, -0.9027 ]
7910 [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
7914 Just as the text recommended, we used @samp{< >} nameless function
7915 notation to keep the two @code{random} calls from being evaluated
7916 before nesting even begins.
7918 We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's
7919 rules acts like a matrix. We can transpose this matrix and unpack
7920 to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing.
7924 2: [ 0, 0.4288, -0.4787, ... ]
7925 1: [ 0, -0.1696, -0.9027, ... ]
7932 Incidentally, because the @expr{x} and @expr{y} are completely
7933 independent in this case, we could have done two separate commands
7934 to create our @expr{x} and @expr{y} vectors of numbers directly.
7936 To make a random walk of unit steps, we note that @code{sincos} of
7937 a random direction exactly gives us an @expr{[x, y]} step of unit
7938 length; in fact, the new nesting function is even briefer, though
7939 we might want to lower the precision a bit for it.
7943 2: [0, 0] 1: [ [ 0, 0 ]
7944 1: 50 [ 0.1318, 0.9912 ]
7945 . [ -0.5965, 0.3061 ]
7948 [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET}
7952 Another @kbd{v t v u g f} sequence will graph this new random walk.
7954 An interesting twist on these random walk functions would be to use
7955 complex numbers instead of 2-vectors to represent points on the plane.
7956 In the first example, we'd use something like @samp{random + random*(0,1)},
7957 and in the second we could use polar complex numbers with random phase
7958 angles. (This exercise was first suggested in this form by Randal
7961 @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
7962 @subsection Types Tutorial Exercise 1
7965 If the number is the square root of @cpi{} times a rational number,
7966 then its square, divided by @cpi{}, should be a rational number.
7970 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627
7978 Technically speaking this is a rational number, but not one that is
7979 likely to have arisen in the original problem. More likely, it just
7980 happens to be the fraction which most closely represents some
7981 irrational number to within 12 digits.
7983 But perhaps our result was not quite exact. Let's reduce the
7984 precision slightly and try again:
7988 1: 0.509433962268 1: 27:53
7991 U p 10 @key{RET} c F
7996 Aha! It's unlikely that an irrational number would equal a fraction
7997 this simple to within ten digits, so our original number was probably
7998 @texline @math{\sqrt{27 \pi / 53}}.
7999 @infoline @expr{sqrt(27 pi / 53)}.
8001 Notice that we didn't need to re-round the number when we reduced the
8002 precision. Remember, arithmetic operations always round their inputs
8003 to the current precision before they begin.
8005 @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
8006 @subsection Types Tutorial Exercise 2
8009 @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer.
8010 But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
8012 @samp{exp(inf) = inf}. It's tempting to say that the exponential
8013 of infinity must be ``bigger'' than ``regular'' infinity, but as
8014 far as Calc is concerned all infinities are as just as big.
8015 In other words, as @expr{x} goes to infinity, @expr{e^x} also goes
8016 to infinity, but the fact the @expr{e^x} grows much faster than
8017 @expr{x} is not relevant here.
8019 @samp{exp(-inf) = 0}. Here we have a finite answer even though
8020 the input is infinite.
8022 @samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)}
8023 represents the imaginary number @expr{i}. Here's a derivation:
8024 @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
8025 The first part is, by definition, @expr{i}; the second is @code{inf}
8026 because, once again, all infinities are the same size.
8028 @samp{sqrt(uinf) = uinf}. In fact, we do know something about the
8029 direction because @code{sqrt} is defined to return a value in the
8030 right half of the complex plane. But Calc has no notation for this,
8031 so it settles for the conservative answer @code{uinf}.
8033 @samp{abs(uinf) = inf}. No matter which direction @expr{x} points,
8034 @samp{abs(x)} always points along the positive real axis.
8036 @samp{ln(0) = -inf}. Here we have an infinite answer to a finite
8037 input. As in the @expr{1 / 0} case, Calc will only use infinities
8038 here if you have turned on Infinite mode. Otherwise, it will
8039 treat @samp{ln(0)} as an error.
8041 @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
8042 @subsection Types Tutorial Exercise 3
8045 We can make @samp{inf - inf} be any real number we like, say,
8046 @expr{a}, just by claiming that we added @expr{a} to the first
8047 infinity but not to the second. This is just as true for complex
8048 values of @expr{a}, so @code{nan} can stand for a complex number.
8049 (And, similarly, @code{uinf} can stand for an infinity that points
8050 in any direction in the complex plane, such as @samp{(0, 1) inf}).
8052 In fact, we can multiply the first @code{inf} by two. Surely
8053 @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
8054 So @code{nan} can even stand for infinity. Obviously it's just
8055 as easy to make it stand for minus infinity as for plus infinity.
8057 The moral of this story is that ``infinity'' is a slippery fish
8058 indeed, and Calc tries to handle it by having a very simple model
8059 for infinities (only the direction counts, not the ``size''); but
8060 Calc is careful to write @code{nan} any time this simple model is
8061 unable to tell what the true answer is.
8063 @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
8064 @subsection Types Tutorial Exercise 4
8068 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765"
8072 0@@ 47' 26" @key{RET} 17 /
8077 The average song length is two minutes and 47.4 seconds.
8081 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005"
8090 The album would be 53 minutes and 6 seconds long.
8092 @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
8093 @subsection Types Tutorial Exercise 5
8096 Let's suppose it's January 14, 1991. The easiest thing to do is
8097 to keep trying 13ths of months until Calc reports a Friday.
8098 We can do this by manually entering dates, or by using @kbd{t I}:
8102 1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991>
8105 ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I
8110 (Calc assumes the current year if you don't say otherwise.)
8112 This is getting tedious---we can keep advancing the date by typing
8113 @kbd{t I} over and over again, but let's automate the job by using
8114 vector mapping. The @kbd{t I} command actually takes a second
8115 ``how-many-months'' argument, which defaults to one. This
8116 argument is exactly what we want to map over:
8120 2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
8121 1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
8122 . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
8125 v x 6 @key{RET} V M t I
8130 Et voil@`a, September 13, 1991 is a Friday.
8137 ' <sep 13> - <jan 14> @key{RET}
8142 And the answer to our original question: 242 days to go.
8144 @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
8145 @subsection Types Tutorial Exercise 6
8148 The full rule for leap years is that they occur in every year divisible
8149 by four, except that they don't occur in years divisible by 100, except
8150 that they @emph{do} in years divisible by 400. We could work out the
8151 answer by carefully counting the years divisible by four and the
8152 exceptions, but there is a much simpler way that works even if we
8153 don't know the leap year rule.
8155 Let's assume the present year is 1991. Years have 365 days, except
8156 that leap years (whenever they occur) have 366 days. So let's count
8157 the number of days between now and then, and compare that to the
8158 number of years times 365. The number of extra days we find must be
8159 equal to the number of leap years there were.
8163 1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593
8164 . 1: <Tue Jan 1, 1991> .
8167 ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} -
8174 3: 2925593 2: 2925593 2: 2925593 1: 1943
8175 2: 10001 1: 8010 1: 2923650 .
8179 10001 @key{RET} 1991 - 365 * -
8183 @c [fix-ref Date Forms]
8185 There will be 1943 leap years before the year 10001. (Assuming,
8186 of course, that the algorithm for computing leap years remains
8187 unchanged for that long. @xref{Date Forms}, for some interesting
8188 background information in that regard.)
8190 @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
8191 @subsection Types Tutorial Exercise 7
8194 The relative errors must be converted to absolute errors so that
8195 @samp{+/-} notation may be used.
8203 20 @key{RET} .05 * 4 @key{RET} .05 *
8207 Now we simply chug through the formula.
8211 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21
8214 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ *
8218 It turns out the @kbd{v u} command will unpack an error form as
8219 well as a vector. This saves us some retyping of numbers.
8223 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21
8228 @key{RET} v u @key{TAB} /
8233 Thus the volume is 6316 cubic centimeters, within about 11 percent.
8235 @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
8236 @subsection Types Tutorial Exercise 8
8239 The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}.
8240 Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
8241 close to zero, its reciprocal can get arbitrarily large, so the answer
8242 is an interval that effectively means, ``any number greater than 0.1''
8243 but with no upper bound.
8245 The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
8247 Calc normally treats division by zero as an error, so that the formula
8248 @w{@samp{1 / 0}} is left unsimplified. Our third problem,
8249 @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
8250 is now a member of the interval. So Calc leaves this one unevaluated, too.
8252 If you turn on Infinite mode by pressing @kbd{m i}, you will
8253 instead get the answer @samp{[0.1 .. inf]}, which includes infinity
8254 as a possible value.
8256 The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
8257 Zero is buried inside the interval, but it's still a possible value.
8258 It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
8259 will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus
8260 the interval goes from minus infinity to plus infinity, with a ``hole''
8261 in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to
8262 represent this, so it just reports @samp{[-inf .. inf]} as the answer.
8263 It may be disappointing to hear ``the answer lies somewhere between
8264 minus infinity and plus infinity, inclusive,'' but that's the best
8265 that interval arithmetic can do in this case.
8267 @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
8268 @subsection Types Tutorial Exercise 9
8272 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9]
8273 . 1: [0 .. 9] 1: [-9 .. 9]
8276 [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} *
8281 In the first case the result says, ``if a number is between @mathit{-3} and
8282 3, its square is between 0 and 9.'' The second case says, ``the product
8283 of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.''
8285 An interval form is not a number; it is a symbol that can stand for
8286 many different numbers. Two identical-looking interval forms can stand
8287 for different numbers.
8289 The same issue arises when you try to square an error form.
8291 @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
8292 @subsection Types Tutorial Exercise 10
8295 Testing the first number, we might arbitrarily choose 17 for @expr{x}.
8299 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613
8303 17 M 811749613 @key{RET} 811749612 ^
8308 Since 533694123 is (considerably) different from 1, the number 811749613
8311 It's awkward to type the number in twice as we did above. There are
8312 various ways to avoid this, and algebraic entry is one. In fact, using
8313 a vector mapping operation we can perform several tests at once. Let's
8314 use this method to test the second number.
8318 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ]
8322 [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET}
8327 The result is three ones (modulo @expr{n}), so it's very probable that
8328 15485863 is prime. (In fact, this number is the millionth prime.)
8330 Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
8331 would have been hopelessly inefficient, since they would have calculated
8332 the power using full integer arithmetic.
8334 Calc has a @kbd{k p} command that does primality testing. For small
8335 numbers it does an exact test; for large numbers it uses a variant
8336 of the Fermat test we used here. You can use @kbd{k p} repeatedly
8337 to prove that a large integer is prime with any desired probability.
8339 @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
8340 @subsection Types Tutorial Exercise 11
8343 There are several ways to insert a calculated number into an HMS form.
8344 One way to convert a number of seconds to an HMS form is simply to
8345 multiply the number by an HMS form representing one second:
8349 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359"
8360 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0"
8361 1: 15@@ 27' 16" mod 24@@ 0' 0" .
8369 It will be just after six in the morning.
8371 The algebraic @code{hms} function can also be used to build an
8376 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359"
8379 ' hms(0, 0, 1e7 pi) @key{RET} =
8384 The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
8385 the actual number 3.14159...
8387 @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
8388 @subsection Types Tutorial Exercise 12
8391 As we recall, there are 17 songs of about 2 minutes and 47 seconds
8396 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"]
8397 1: [0@@ 0' 20" .. 0@@ 1' 0"] .
8400 [ 0@@ 20" .. 0@@ 1' ] +
8407 1: [0@@ 52' 59." .. 1@@ 4' 19."]
8415 No matter how long it is, the album will fit nicely on one CD.
8417 @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
8418 @subsection Types Tutorial Exercise 13
8421 Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds.
8423 @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
8424 @subsection Types Tutorial Exercise 14
8427 How long will it take for a signal to get from one end of the computer
8432 1: m / c 1: 3.3356 ns
8435 ' 1 m / c @key{RET} u c ns @key{RET}
8440 (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
8444 1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356
8448 ' 4.1 ns @key{RET} / u s
8453 Thus a signal could take up to 81 percent of a clock cycle just to
8454 go from one place to another inside the computer, assuming the signal
8455 could actually attain the full speed of light. Pretty tight!
8457 @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
8458 @subsection Types Tutorial Exercise 15
8461 The speed limit is 55 miles per hour on most highways. We want to
8462 find the ratio of Sam's speed to the US speed limit.
8466 1: 55 mph 2: 55 mph 3: 11 hr mph / yd
8470 ' 55 mph @key{RET} ' 5 yd/hr @key{RET} /
8474 The @kbd{u s} command cancels out these units to get a plain
8475 number. Now we take the logarithm base two to find the final
8476 answer, assuming that each successive pill doubles his speed.
8480 1: 19360. 2: 19360. 1: 14.24
8489 Thus Sam can take up to 14 pills without a worry.
8491 @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
8492 @subsection Algebra Tutorial Exercise 1
8495 @c [fix-ref Declarations]
8496 The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the
8497 Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens
8498 if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be
8499 simplified to @samp{abs(x)}, but for general complex arguments even
8500 that is not safe. (@xref{Declarations}, for a way to tell Calc
8501 that @expr{x} is known to be real.)
8503 @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
8504 @subsection Algebra Tutorial Exercise 2
8507 Suppose our roots are @expr{[a, b, c]}. We want a polynomial which
8508 is zero when @expr{x} is any of these values. The trivial polynomial
8509 @expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)}
8510 will do the job. We can use @kbd{a c x} to write this in a more
8515 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0]
8525 1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x
8528 V M ' x-$ @key{RET} V R *
8535 1: x^3 - 1.41666 x 1: 34 x - 24 x^3
8538 a c x @key{RET} 24 n * a x
8543 Sure enough, our answer (multiplied by a suitable constant) is the
8544 same as the original polynomial.
8546 @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
8547 @subsection Algebra Tutorial Exercise 3
8551 1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2
8554 ' x sin(pi x) @key{RET} m r a i x @key{RET}
8562 2: (sin(pi x) - pi x cos(pi x)) / pi^2
8565 ' [y,1] @key{RET} @key{TAB}
8572 1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
8582 1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
8592 1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
8602 1: [0., -0.95493, 0.63662, -1.5915, 1.2732]
8605 v x 5 @key{RET} @key{TAB} V M $ @key{RET}
8609 @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
8610 @subsection Algebra Tutorial Exercise 4
8613 The hard part is that @kbd{V R +} is no longer sufficient to add up all
8614 the contributions from the slices, since the slices have varying
8615 coefficients. So first we must come up with a vector of these
8616 coefficients. Here's one way:
8620 2: -1 2: 3 1: [4, 2, ..., 4]
8621 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] .
8624 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} -
8631 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1]
8639 Now we compute the function values. Note that for this method we need
8640 eleven values, including both endpoints of the desired interval.
8644 2: [1, 4, 2, ..., 4, 1]
8645 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.]
8648 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
8655 2: [1, 4, 2, ..., 4, 1]
8656 1: [0., 0.084941, 0.16993, ... ]
8659 ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET}
8664 Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
8669 1: 11.22 1: 1.122 1: 0.374
8677 Wow! That's even better than the result from the Taylor series method.
8679 @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
8680 @subsection Rewrites Tutorial Exercise 1
8683 We'll use Big mode to make the formulas more readable.
8689 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: --------
8695 ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B
8700 Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}.
8705 1: (2 + V 2 ) (V 2 - 1)
8708 a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
8716 1: 2 + V 2 - 2 1: V 2
8719 a r a*(b+c) := a*b + a*c a s
8724 (We could have used @kbd{a x} instead of a rewrite rule for the
8727 The multiply-by-conjugate rule turns out to be useful in many
8728 different circumstances, such as when the denominator involves
8729 sines and cosines or the imaginary constant @code{i}.
8731 @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
8732 @subsection Rewrites Tutorial Exercise 2
8735 Here is the rule set:
8739 [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
8741 fib(n, x, y) := fib(n-1, y, x+y) ]
8746 The first rule turns a one-argument @code{fib} that people like to write
8747 into a three-argument @code{fib} that makes computation easier. The
8748 second rule converts back from three-argument form once the computation
8749 is done. The third rule does the computation itself. It basically
8750 says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers,
8751 then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci
8754 Notice that because the number @expr{n} was ``validated'' by the
8755 conditions on the first rule, there is no need to put conditions on
8756 the other rules because the rule set would never get that far unless
8757 the input were valid. That further speeds computation, since no
8758 extra conditions need to be checked at every step.
8760 Actually, a user with a nasty sense of humor could enter a bad
8761 three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
8762 which would get the rules into an infinite loop. One thing that would
8763 help keep this from happening by accident would be to use something like
8764 @samp{ZzFib} instead of @code{fib} as the name of the three-argument
8767 @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
8768 @subsection Rewrites Tutorial Exercise 3
8771 He got an infinite loop. First, Calc did as expected and rewrote
8772 @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to
8773 apply the rule again, and found that @samp{f(2, 3, x)} looks like
8774 @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
8775 @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)}
8776 around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r}
8777 to make sure the rule applied only once.
8779 (Actually, even the first step didn't work as he expected. What Calc
8780 really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
8781 treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
8782 to it. While this may seem odd, it's just as valid a solution as the
8783 ``obvious'' one. One way to fix this would be to add the condition
8784 @samp{:: variable(x)} to the rule, to make sure the thing that matches
8785 @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
8786 on the lefthand side, so that the rule matches the actual variable
8787 @samp{x} rather than letting @samp{x} stand for something else.)
8789 @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
8790 @subsection Rewrites Tutorial Exercise 4
8797 Here is a suitable set of rules to solve the first part of the problem:
8801 [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0,
8802 seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
8806 Given the initial formula @samp{seq(6, 0)}, application of these
8807 rules produces the following sequence of formulas:
8821 whereupon neither of the rules match, and rewriting stops.
8823 We can pretty this up a bit with a couple more rules:
8827 [ seq(n) := seq(n, 0),
8834 Now, given @samp{seq(6)} as the starting configuration, we get 8
8837 The change to return a vector is quite simple:
8841 [ seq(n) := seq(n, []) :: integer(n) :: n > 0,
8843 seq(n, v) := seq(n/2, v | n) :: n%2 = 0,
8844 seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
8849 Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
8851 Notice that the @expr{n > 1} guard is no longer necessary on the last
8852 rule since the @expr{n = 1} case is now detected by another rule.
8853 But a guard has been added to the initial rule to make sure the
8854 initial value is suitable before the computation begins.
8856 While still a good idea, this guard is not as vitally important as it
8857 was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
8858 will not get into an infinite loop. Calc will not be able to prove
8859 the symbol @samp{x} is either even or odd, so none of the rules will
8860 apply and the rewrites will stop right away.
8862 @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
8863 @subsection Rewrites Tutorial Exercise 5
8870 If @expr{x} is the sum @expr{a + b}, then `@tfn{nterms(}@var{x}@tfn{)}' must
8871 be `@tfn{nterms(}@var{a}@tfn{)}' plus `@tfn{nterms(}@var{b}@tfn{)}'. If @expr{x}
8872 is not a sum, then `@tfn{nterms(}@var{x}@tfn{)}' = 1.
8876 [ nterms(a + b) := nterms(a) + nterms(b),
8882 Here we have taken advantage of the fact that earlier rules always
8883 match before later rules; @samp{nterms(x)} will only be tried if we
8884 already know that @samp{x} is not a sum.
8886 @node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises
8887 @subsection Rewrites Tutorial Exercise 6
8890 Here is a rule set that will do the job:
8894 [ a*(b + c) := a*b + a*c,
8895 opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
8896 :: constant(a) :: constant(b),
8897 opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
8898 :: constant(a) :: constant(b),
8899 a O(x^n) := O(x^n) :: constant(a),
8900 x^opt(m) O(x^n) := O(x^(n+m)),
8901 O(x^n) O(x^m) := O(x^(n+m)) ]
8905 If we really want the @kbd{+} and @kbd{*} keys to operate naturally
8906 on power series, we should put these rules in @code{EvalRules}. For
8907 testing purposes, it is better to put them in a different variable,
8908 say, @code{O}, first.
8910 The first rule just expands products of sums so that the rest of the
8911 rules can assume they have an expanded-out polynomial to work with.
8912 Note that this rule does not mention @samp{O} at all, so it will
8913 apply to any product-of-sum it encounters---this rule may surprise
8914 you if you put it into @code{EvalRules}!
8916 In the second rule, the sum of two O's is changed to the smaller O.
8917 The optional constant coefficients are there mostly so that
8918 @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
8919 as well as @samp{O(x^2) + O(x^3)}.
8921 The third rule absorbs higher powers of @samp{x} into O's.
8923 The fourth rule says that a constant times a negligible quantity
8924 is still negligible. (This rule will also match @samp{O(x^3) / 4},
8925 with @samp{a = 1/4}.)
8927 The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
8928 (It is easy to see that if one of these forms is negligible, the other
8929 is, too.) Notice the @samp{x^opt(m)} to pick up terms like
8930 @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1}
8931 but not 1 as @samp{x^0}. This turns out to be exactly what we want here.
8933 The sixth rule is the corresponding rule for products of two O's.
8935 Another way to solve this problem would be to create a new ``data type''
8936 that represents truncated power series. We might represent these as
8937 function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
8938 a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so
8939 on. Rules would exist for sums and products of such @code{series}
8940 objects, and as an optional convenience could also know how to combine a
8941 @code{series} object with a normal polynomial. (With this, and with a
8942 rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
8943 you could still enter power series in exactly the same notation as
8944 before.) Operations on such objects would probably be more efficient,
8945 although the objects would be a bit harder to read.
8947 @c [fix-ref Compositions]
8948 Some other symbolic math programs provide a power series data type
8949 similar to this. Mathematica, for example, has an object that looks
8950 like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
8951 @var{nmax}, @var{den}]}, where @var{x0} is the point about which the
8952 power series is taken (we've been assuming this was always zero),
8953 and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
8954 with fractional or negative powers. Also, the @code{PowerSeries}
8955 objects have a special display format that makes them look like
8956 @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions},
8957 for a way to do this in Calc, although for something as involved as
8958 this it would probably be better to write the formatting routine
8961 @node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises
8962 @subsection Programming Tutorial Exercise 1
8965 Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
8966 @kbd{Z F}, and answer the questions. Since this formula contains two
8967 variables, the default argument list will be @samp{(t x)}. We want to
8968 change this to @samp{(x)} since @expr{t} is really a dummy variable
8969 to be used within @code{ninteg}.
8971 The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
8972 (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
8974 @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
8975 @subsection Programming Tutorial Exercise 2
8978 One way is to move the number to the top of the stack, operate on
8979 it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
8981 Another way is to negate the top three stack entries, then negate
8982 again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}.
8984 Finally, it turns out that a negative prefix argument causes a
8985 command like @kbd{n} to operate on the specified stack entry only,
8986 which is just what we want: @kbd{C-x ( M-- 3 n C-x )}.
8988 Just for kicks, let's also do it algebraically:
8989 @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
8991 @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
8992 @subsection Programming Tutorial Exercise 3
8995 Each of these functions can be computed using the stack, or using
8996 algebraic entry, whichever way you prefer:
9000 @texline @math{\displaystyle{\sin x \over x}}:
9001 @infoline @expr{sin(x) / x}:
9003 Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}.
9005 Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}.
9008 Computing the logarithm:
9010 Using the stack: @kbd{C-x ( @key{TAB} B C-x )}
9012 Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}.
9015 Computing the vector of integers:
9017 Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that
9018 @kbd{C-u v x} takes the vector size, starting value, and increment
9021 Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a
9022 number from the stack and uses it as the prefix argument for the
9025 Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}.
9027 @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
9028 @subsection Programming Tutorial Exercise 4
9031 Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
9033 @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
9034 @subsection Programming Tutorial Exercise 5
9038 2: 1 1: 1.61803398502 2: 1.61803398502
9039 1: 20 . 1: 1.61803398875
9042 1 @key{RET} 20 Z < & 1 + Z > I H P
9047 This answer is quite accurate.
9049 @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
9050 @subsection Programming Tutorial Exercise 6
9056 [ [ 0, 1 ] * [a, b] = [b, a + b]
9061 Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1}
9062 and @expr{n+2}. Here's one program that does the job:
9065 C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
9069 This program is quite efficient because Calc knows how to raise a
9070 matrix (or other value) to the power @expr{n} in only
9071 @texline @math{\log_2 n}
9072 @infoline @expr{log(n,2)}
9073 steps. For example, this program can compute the 1000th Fibonacci
9074 number (a 209-digit integer!) in about 10 steps; even though the
9075 @kbd{Z < ... Z >} solution had much simpler steps, it would have
9076 required so many steps that it would not have been practical.
9078 @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
9079 @subsection Programming Tutorial Exercise 7
9082 The trick here is to compute the harmonic numbers differently, so that
9083 the loop counter itself accumulates the sum of reciprocals. We use
9084 a separate variable to hold the integer counter.
9092 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z )
9097 The body of the loop goes as follows: First save the harmonic sum
9098 so far in variable 2. Then delete it from the stack; the for loop
9099 itself will take care of remembering it for us. Next, recall the
9100 count from variable 1, add one to it, and feed its reciprocal to
9101 the for loop to use as the step value. The for loop will increase
9102 the ``loop counter'' by that amount and keep going until the
9103 loop counter exceeds 4.
9108 1: 3.99498713092 2: 3.99498713092
9112 r 1 r 2 @key{RET} 31 & +
9116 Thus we find that the 30th harmonic number is 3.99, and the 31st
9117 harmonic number is 4.02.
9119 @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
9120 @subsection Programming Tutorial Exercise 8
9123 The first step is to compute the derivative @expr{f'(x)} and thus
9125 @texline @math{\displaystyle{x - {f(x) \over f'(x)}}}.
9126 @infoline @expr{x - f(x)/f'(x)}.
9128 (Because this definition is long, it will be repeated in concise form
9129 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9130 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9131 keystrokes without executing them. In the following diagrams we'll
9132 pretend Calc actually executed the keystrokes as you typed them,
9133 just for purposes of illustration.)
9137 2: sin(cos(x)) - 0.5 3: 4.5
9138 1: 4.5 2: sin(cos(x)) - 0.5
9139 . 1: -(sin(x) cos(cos(x)))
9142 ' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET}
9150 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
9153 / ' x @key{RET} @key{TAB} - t 1
9157 Now, we enter the loop. We'll use a repeat loop with a 20-repetition
9158 limit just in case the method fails to converge for some reason.
9159 (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
9160 repetitions are done.)
9164 1: 4.5 3: 4.5 2: 4.5
9165 . 2: x + (sin(cos(x)) ... 1: 5.24196456928
9169 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9173 This is the new guess for @expr{x}. Now we compare it with the
9174 old one to see if we've converged.
9178 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348
9183 @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x )
9187 The loop converges in just a few steps to this value. To check
9188 the result, we can simply substitute it back into the equation.
9196 @key{RET} ' sin(cos($)) @key{RET}
9200 Let's test the new definition again:
9208 ' x^2-9 @key{RET} 1 X
9212 Once again, here's the full Newton's Method definition:
9216 C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1
9217 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9218 @key{RET} M-@key{TAB} a = Z /
9225 @c [fix-ref Nesting and Fixed Points]
9226 It turns out that Calc has a built-in command for applying a formula
9227 repeatedly until it converges to a number. @xref{Nesting and Fixed Points},
9228 to see how to use it.
9230 @c [fix-ref Root Finding]
9231 Also, of course, @kbd{a R} is a built-in command that uses Newton's
9232 method (among others) to look for numerical solutions to any equation.
9233 @xref{Root Finding}.
9235 @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
9236 @subsection Programming Tutorial Exercise 9
9239 The first step is to adjust @expr{z} to be greater than 5. A simple
9240 ``for'' loop will do the job here. If @expr{z} is less than 5, we
9241 reduce the problem using
9242 @texline @math{\psi(z) = \psi(z+1) - 1/z}.
9243 @infoline @expr{psi(z) = psi(z+1) - 1/z}. We go
9245 @texline @math{\psi(z+1)},
9246 @infoline @expr{psi(z+1)},
9247 and remember to add back a factor of @expr{-1/z} when we're done. This
9248 step is repeated until @expr{z > 5}.
9250 (Because this definition is long, it will be repeated in concise form
9251 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9252 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9253 keystrokes without executing them. In the following diagrams we'll
9254 pretend Calc actually executed the keystrokes as you typed them,
9255 just for purposes of illustration.)
9262 1.0 @key{RET} C-x ( Z ` s 1 0 t 2
9266 Here, variable 1 holds @expr{z} and variable 2 holds the adjustment
9267 factor. If @expr{z < 5}, we use a loop to increase it.
9269 (By the way, we started with @samp{1.0} instead of the integer 1 because
9270 otherwise the calculation below will try to do exact fractional arithmetic,
9271 and will never converge because fractions compare equal only if they
9272 are exactly equal, not just equal to within the current precision.)
9281 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9285 Now we compute the initial part of the sum:
9286 @texline @math{\ln z - {1 \over 2z}}
9287 @infoline @expr{ln(z) - 1/2z}
9288 minus the adjustment factor.
9292 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743
9293 1: 0.0833333333333 1: 2.28333333333 .
9300 Now we evaluate the series. We'll use another ``for'' loop counting
9301 up the value of @expr{2 n}. (Calc does have a summation command,
9302 @kbd{a +}, but we'll use loops just to get more practice with them.)
9306 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749
9307 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3
9312 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9319 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892
9320 2: -0.5749 2: -0.5772 1: 0 .
9321 1: 2.3148e-3 1: -0.5749 .
9324 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x )
9328 This is the value of
9329 @texline @math{-\gamma},
9330 @infoline @expr{- gamma},
9331 with a slight bit of roundoff error. To get a full 12 digits, let's use
9336 2: -0.577215664892 2: -0.577215664892
9337 1: 1. 1: -0.577215664901532
9339 1. @key{RET} p 16 @key{RET} X
9343 Here's the complete sequence of keystrokes:
9348 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9350 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9351 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
9358 @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
9359 @subsection Programming Tutorial Exercise 10
9362 Taking the derivative of a term of the form @expr{x^n} will produce
9364 @texline @math{n x^{n-1}}.
9365 @infoline @expr{n x^(n-1)}.
9366 Taking the derivative of a constant
9367 produces zero. From this it is easy to see that the @expr{n}th
9368 derivative of a polynomial, evaluated at @expr{x = 0}, will equal the
9369 coefficient on the @expr{x^n} term times @expr{n!}.
9371 (Because this definition is long, it will be repeated in concise form
9372 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9373 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9374 keystrokes without executing them. In the following diagrams we'll
9375 pretend Calc actually executed the keystrokes as you typed them,
9376 just for purposes of illustration.)
9380 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2
9385 ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB}
9390 Variable 1 will accumulate the vector of coefficients.
9394 2: 0 3: 0 2: 5 x^4 + ...
9395 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1
9399 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9404 Note that @kbd{s | 1} appends the top-of-stack value to the vector
9405 in a variable; it is completely analogous to @kbd{s + 1}. We could
9406 have written instead, @kbd{r 1 @key{TAB} | t 1}.
9410 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0]
9413 a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x )
9417 To convert back, a simple method is just to map the coefficients
9418 against a table of powers of @expr{x}.
9422 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0]
9423 1: 6 1: [0, 1, 2, 3, 4, 5, 6]
9426 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x
9433 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4
9434 1: [1, x, x^2, x^3, ... ] .
9437 ' x @key{RET} @key{TAB} V M ^ *
9441 Once again, here are the whole polynomial to/from vector programs:
9445 C-x ( Z ` [ ] t 1 0 @key{TAB}
9446 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9452 C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x )
9456 @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
9457 @subsection Programming Tutorial Exercise 11
9460 First we define a dummy program to go on the @kbd{z s} key. The true
9461 @w{@kbd{z s}} key is supposed to take two numbers from the stack and
9462 return one number, so @key{DEL} as a dummy definition will make
9463 sure the stack comes out right.
9471 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2
9475 The last step replaces the 2 that was eaten during the creation
9476 of the dummy @kbd{z s} command. Now we move on to the real
9477 definition. The recurrence needs to be rewritten slightly,
9478 to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
9480 (Because this definition is long, it will be repeated in concise form
9481 below. You can use @kbd{C-x * m} to load it from there.)
9491 C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z :
9498 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3
9499 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2
9500 2: 2 . . 2: 3 2: 3 1: 3
9504 @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9509 (Note that the value 3 that our dummy @kbd{z s} produces is not correct;
9510 it is merely a placeholder that will do just as well for now.)
9514 3: 3 4: 3 3: 3 2: 3 1: -6
9515 2: 3 3: 3 2: 3 1: 9 .
9520 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9527 1: -6 2: 4 1: 11 2: 11
9531 Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s
9535 Even though the result that we got during the definition was highly
9536 bogus, once the definition is complete the @kbd{z s} command gets
9539 Here's the full program once again:
9543 C-x ( M-2 @key{RET} a =
9544 Z [ @key{DEL} @key{DEL} 1
9546 Z [ @key{DEL} @key{DEL} 0
9547 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9548 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9555 You can read this definition using @kbd{C-x * m} (@code{read-kbd-macro})
9556 followed by @kbd{Z K s}, without having to make a dummy definition
9557 first, because @code{read-kbd-macro} doesn't need to execute the
9558 definition as it reads it in. For this reason, @code{C-x * m} is often
9559 the easiest way to create recursive programs in Calc.
9561 @node Programming Answer 12, , Programming Answer 11, Answers to Exercises
9562 @subsection Programming Tutorial Exercise 12
9565 This turns out to be a much easier way to solve the problem. Let's
9566 denote Stirling numbers as calls of the function @samp{s}.
9568 First, we store the rewrite rules corresponding to the definition of
9569 Stirling numbers in a convenient variable:
9572 s e StirlingRules @key{RET}
9573 [ s(n,n) := 1 :: n >= 0,
9574 s(n,0) := 0 :: n > 0,
9575 s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
9579 Now, it's just a matter of applying the rules:
9583 2: 4 1: s(4, 2) 1: 11
9587 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x )
9591 As in the case of the @code{fib} rules, it would be useful to put these
9592 rules in @code{EvalRules} and to add a @samp{:: remember} condition to
9595 @c This ends the table-of-contents kludge from above:
9597 \global\let\chapternofonts=\oldchapternofonts
9602 @node Introduction, Data Types, Tutorial, Top
9603 @chapter Introduction
9606 This chapter is the beginning of the Calc reference manual.
9607 It covers basic concepts such as the stack, algebraic and
9608 numeric entry, undo, numeric prefix arguments, etc.
9611 @c (Chapter 2, the Tutorial, has been printed in a separate volume.)
9619 * Quick Calculator::
9620 * Prefix Arguments::
9623 * Multiple Calculators::
9624 * Troubleshooting Commands::
9627 @node Basic Commands, Help Commands, Introduction, Introduction
9628 @section Basic Commands
9633 @cindex Starting the Calculator
9634 @cindex Running the Calculator
9635 To start the Calculator in its standard interface, type @kbd{M-x calc}.
9636 By default this creates a pair of small windows, @samp{*Calculator*}
9637 and @samp{*Calc Trail*}. The former displays the contents of the
9638 Calculator stack and is manipulated exclusively through Calc commands.
9639 It is possible (though not usually necessary) to create several Calc
9640 mode buffers each of which has an independent stack, undo list, and
9641 mode settings. There is exactly one Calc Trail buffer; it records a
9642 list of the results of all calculations that have been done. The
9643 Calc Trail buffer uses a variant of Calc mode, so Calculator commands
9644 still work when the trail buffer's window is selected. It is possible
9645 to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
9646 still exists and is updated silently. @xref{Trail Commands}.
9653 In most installations, the @kbd{C-x * c} key sequence is a more
9654 convenient way to start the Calculator. Also, @kbd{C-x * *}
9655 is a synonym for @kbd{C-x * c} unless you last used Calc
9660 @pindex calc-execute-extended-command
9661 Most Calc commands use one or two keystrokes. Lower- and upper-case
9662 letters are distinct. Commands may also be entered in full @kbd{M-x} form;
9663 for some commands this is the only form. As a convenience, the @kbd{x}
9664 key (@code{calc-execute-extended-command})
9665 is like @kbd{M-x} except that it enters the initial string @samp{calc-}
9666 for you. For example, the following key sequences are equivalent:
9667 @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.
9669 @cindex Extensions module
9670 @cindex @file{calc-ext} module
9671 The Calculator exists in many parts. When you type @kbd{C-x * c}, the
9672 Emacs ``auto-load'' mechanism will bring in only the first part, which
9673 contains the basic arithmetic functions. The other parts will be
9674 auto-loaded the first time you use the more advanced commands like trig
9675 functions or matrix operations. This is done to improve the response time
9676 of the Calculator in the common case when all you need to do is a
9677 little arithmetic. If for some reason the Calculator fails to load an
9678 extension module automatically, you can force it to load all the
9679 extensions by using the @kbd{C-x * L} (@code{calc-load-everything})
9680 command. @xref{Mode Settings}.
9682 If you type @kbd{M-x calc} or @kbd{C-x * c} with any numeric prefix argument,
9683 the Calculator is loaded if necessary, but it is not actually started.
9684 If the argument is positive, the @file{calc-ext} extensions are also
9685 loaded if necessary. User-written Lisp code that wishes to make use
9686 of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
9687 to auto-load the Calculator.
9691 If you type @kbd{C-x * b}, then next time you use @kbd{C-x * c} you
9692 will get a Calculator that uses the full height of the Emacs screen.
9693 When full-screen mode is on, @kbd{C-x * c} runs the @code{full-calc}
9694 command instead of @code{calc}. From the Unix shell you can type
9695 @samp{emacs -f full-calc} to start a new Emacs specifically for use
9696 as a calculator. When Calc is started from the Emacs command line
9697 like this, Calc's normal ``quit'' commands actually quit Emacs itself.
9700 @pindex calc-other-window
9701 The @kbd{C-x * o} command is like @kbd{C-x * c} except that the Calc
9702 window is not actually selected. If you are already in the Calc
9703 window, @kbd{C-x * o} switches you out of it. (The regular Emacs
9704 @kbd{C-x o} command would also work for this, but it has a
9705 tendency to drop you into the Calc Trail window instead, which
9706 @kbd{C-x * o} takes care not to do.)
9711 For one quick calculation, you can type @kbd{C-x * q} (@code{quick-calc})
9712 which prompts you for a formula (like @samp{2+3/4}). The result is
9713 displayed at the bottom of the Emacs screen without ever creating
9714 any special Calculator windows. @xref{Quick Calculator}.
9719 Finally, if you are using the X window system you may want to try
9720 @kbd{C-x * k} (@code{calc-keypad}) which runs Calc with a
9721 ``calculator keypad'' picture as well as a stack display. Click on
9722 the keys with the mouse to operate the calculator. @xref{Keypad Mode}.
9726 @cindex Quitting the Calculator
9727 @cindex Exiting the Calculator
9728 The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the
9729 Calculator's window(s). It does not delete the Calculator buffers.
9730 If you type @kbd{M-x calc} again, the Calculator will reappear with the
9731 contents of the stack intact. Typing @kbd{C-x * c} or @kbd{C-x * *}
9732 again from inside the Calculator buffer is equivalent to executing
9733 @code{calc-quit}; you can think of @kbd{C-x * *} as toggling the
9734 Calculator on and off.
9737 The @kbd{C-x * x} command also turns the Calculator off, no matter which
9738 user interface (standard, Keypad, or Embedded) is currently active.
9739 It also cancels @code{calc-edit} mode if used from there.
9742 @pindex calc-refresh
9743 @cindex Refreshing a garbled display
9744 @cindex Garbled displays, refreshing
9745 The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
9746 of the Calculator buffer from memory. Use this if the contents of the
9747 buffer have been damaged somehow.
9752 The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
9753 ``home'' position at the bottom of the Calculator buffer.
9757 @pindex calc-scroll-left
9758 @pindex calc-scroll-right
9759 @cindex Horizontal scrolling
9761 @cindex Wide text, scrolling
9762 The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
9763 @code{calc-scroll-right}. These are just like the normal horizontal
9764 scrolling commands except that they scroll one half-screen at a time by
9765 default. (Calc formats its output to fit within the bounds of the
9766 window whenever it can.)
9770 @pindex calc-scroll-down
9771 @pindex calc-scroll-up
9772 @cindex Vertical scrolling
9773 The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
9774 and @code{calc-scroll-up}. They scroll up or down by one-half the
9775 height of the Calc window.
9779 The @kbd{C-x * 0} command (@code{calc-reset}; that's @kbd{C-x *} followed
9780 by a zero) resets the Calculator to its initial state. This clears
9781 the stack, resets all the modes to their initial values (the values
9782 that were saved with @kbd{m m} (@code{calc-save-modes})), clears the
9783 caches (@pxref{Caches}), and so on. (It does @emph{not} erase the
9784 values of any variables.) With an argument of 0, Calc will be reset to
9785 its default state; namely, the modes will be given their default values.
9786 With a positive prefix argument, @kbd{C-x * 0} preserves the contents of
9787 the stack but resets everything else to its initial state; with a
9788 negative prefix argument, @kbd{C-x * 0} preserves the contents of the
9789 stack but resets everything else to its default state.
9791 @pindex calc-version
9792 The @kbd{M-x calc-version} command displays the current version number
9793 of Calc and the name of the person who installed it on your system.
9794 (This information is also present in the @samp{*Calc Trail*} buffer,
9795 and in the output of the @kbd{h h} command.)
9797 @node Help Commands, Stack Basics, Basic Commands, Introduction
9798 @section Help Commands
9801 @cindex Help commands
9804 The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
9805 Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
9806 @key{ESC} and @kbd{C-x} prefixes. You can type
9807 @kbd{?} after a prefix to see a list of commands beginning with that
9808 prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again
9809 to see additional commands for that prefix.)
9812 @pindex calc-full-help
9813 The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
9814 responses at once. When printed, this makes a nice, compact (three pages)
9815 summary of Calc keystrokes.
9817 In general, the @kbd{h} key prefix introduces various commands that
9818 provide help within Calc. Many of the @kbd{h} key functions are
9819 Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
9825 The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
9826 to read this manual on-line. This is basically the same as typing
9827 @kbd{C-h i} (the regular way to run the Info system), then, if Info
9828 is not already in the Calc manual, selecting the beginning of the
9829 manual. The @kbd{C-x * i} command is another way to read the Calc
9830 manual; it is different from @kbd{h i} in that it works any time,
9831 not just inside Calc. The plain @kbd{i} key is also equivalent to
9832 @kbd{h i}, though this key is obsolete and may be replaced with a
9833 different command in a future version of Calc.
9837 @pindex calc-tutorial
9838 The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
9839 the Tutorial section of the Calc manual. It is like @kbd{h i},
9840 except that it selects the starting node of the tutorial rather
9841 than the beginning of the whole manual. (It actually selects the
9842 node ``Interactive Tutorial'' which tells a few things about
9843 using the Info system before going on to the actual tutorial.)
9844 The @kbd{C-x * t} key is equivalent to @kbd{h t} (but it works at
9849 @pindex calc-info-summary
9850 The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
9851 on the Summary node of the Calc manual. @xref{Summary}. The @kbd{C-x * s}
9852 key is equivalent to @kbd{h s}.
9855 @pindex calc-describe-key
9856 The @kbd{h k} (@code{calc-describe-key}) command looks up a key
9857 sequence in the Calc manual. For example, @kbd{h k H a S} looks
9858 up the documentation on the @kbd{H a S} (@code{calc-solve-for})
9859 command. This works by looking up the textual description of
9860 the key(s) in the Key Index of the manual, then jumping to the
9861 node indicated by the index.
9863 Most Calc commands do not have traditional Emacs documentation
9864 strings, since the @kbd{h k} command is both more convenient and
9865 more instructive. This means the regular Emacs @kbd{C-h k}
9866 (@code{describe-key}) command will not be useful for Calc keystrokes.
9869 @pindex calc-describe-key-briefly
9870 The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
9871 key sequence and displays a brief one-line description of it at
9872 the bottom of the screen. It looks for the key sequence in the
9873 Summary node of the Calc manual; if it doesn't find the sequence
9874 there, it acts just like its regular Emacs counterpart @kbd{C-h c}
9875 (@code{describe-key-briefly}). For example, @kbd{h c H a S}
9876 gives the description:
9879 H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes)
9883 which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
9884 takes a value @expr{a} from the stack, prompts for a value @expr{v},
9885 then applies the algebraic function @code{fsolve} to these values.
9886 The @samp{?=notes} message means you can now type @kbd{?} to see
9887 additional notes from the summary that apply to this command.
9890 @pindex calc-describe-function
9891 The @kbd{h f} (@code{calc-describe-function}) command looks up an
9892 algebraic function or a command name in the Calc manual. Enter an
9893 algebraic function name to look up that function in the Function
9894 Index or enter a command name beginning with @samp{calc-} to look it
9895 up in the Command Index. This command will also look up operator
9896 symbols that can appear in algebraic formulas, like @samp{%} and
9900 @pindex calc-describe-variable
9901 The @kbd{h v} (@code{calc-describe-variable}) command looks up a
9902 variable in the Calc manual. Enter a variable name like @code{pi} or
9906 @pindex describe-bindings
9907 The @kbd{h b} (@code{calc-describe-bindings}) command is just like
9908 @kbd{C-h b}, except that only local (Calc-related) key bindings are
9912 The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
9913 the ``news'' or change history of Calc. This is kept in the file
9914 @file{README}, which Calc looks for in the same directory as the Calc
9920 The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
9921 distribution, and warranty information about Calc. These work by
9922 pulling up the appropriate parts of the ``Copying'' or ``Reporting
9923 Bugs'' sections of the manual.
9925 @node Stack Basics, Numeric Entry, Help Commands, Introduction
9926 @section Stack Basics
9929 @cindex Stack basics
9930 @c [fix-tut RPN Calculations and the Stack]
9931 Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN
9934 To add the numbers 1 and 2 in Calc you would type the keys:
9935 @kbd{1 @key{RET} 2 +}.
9936 (@key{RET} corresponds to the @key{ENTER} key on most calculators.)
9937 The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The
9938 @kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
9939 and pushes the result (3) back onto the stack. This number is ready for
9940 further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the
9941 3 and 5, subtracts them, and pushes the result (@mathit{-2}).
9943 Note that the ``top'' of the stack actually appears at the @emph{bottom}
9944 of the buffer. A line containing a single @samp{.} character signifies
9945 the end of the buffer; Calculator commands operate on the number(s)
9946 directly above this line. The @kbd{d t} (@code{calc-truncate-stack})
9947 command allows you to move the @samp{.} marker up and down in the stack;
9948 @pxref{Truncating the Stack}.
9951 @pindex calc-line-numbering
9952 Stack elements are numbered consecutively, with number 1 being the top of
9953 the stack. These line numbers are ordinarily displayed on the lefthand side
9954 of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls
9955 whether these numbers appear. (Line numbers may be turned off since they
9956 slow the Calculator down a bit and also clutter the display.)
9959 @pindex calc-realign
9960 The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
9961 the cursor to its top-of-stack ``home'' position. It also undoes any
9962 horizontal scrolling in the window. If you give it a numeric prefix
9963 argument, it instead moves the cursor to the specified stack element.
9965 The @key{RET} (or equivalent @key{SPC}) key is only required to separate
9966 two consecutive numbers.
9967 (After all, if you typed @kbd{1 2} by themselves the Calculator
9968 would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not}
9969 right after typing a number, the key duplicates the number on the top of
9970 the stack. @kbd{@key{RET} *} is thus a handy way to square a number.
9972 The @key{DEL} key pops and throws away the top number on the stack.
9973 The @key{TAB} key swaps the top two objects on the stack.
9974 @xref{Stack and Trail}, for descriptions of these and other stack-related
9977 @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
9978 @section Numeric Entry
9984 @cindex Numeric entry
9985 @cindex Entering numbers
9986 Pressing a digit or other numeric key begins numeric entry using the
9987 minibuffer. The number is pushed on the stack when you press the @key{RET}
9988 or @key{SPC} keys. If you press any other non-numeric key, the number is
9989 pushed onto the stack and the appropriate operation is performed. If
9990 you press a numeric key which is not valid, the key is ignored.
9993 @cindex Negative numbers, entering
9995 There are three different concepts corresponding to the word ``minus,''
9996 typified by @expr{a-b} (subtraction), @expr{-x}
9997 (change-sign), and @expr{-5} (negative number). Calc uses three
9998 different keys for these operations, respectively:
9999 @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts
10000 the two numbers on the top of the stack. The @kbd{n} key changes the sign
10001 of the number on the top of the stack or the number currently being entered.
10002 The @kbd{_} key begins entry of a negative number or changes the sign of
10003 the number currently being entered. The following sequences all enter the
10004 number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
10005 @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.
10007 Some other keys are active during numeric entry, such as @kbd{#} for
10008 non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
10009 These notations are described later in this manual with the corresponding
10010 data types. @xref{Data Types}.
10012 During numeric entry, the only editing key available is @key{DEL}.
10014 @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
10015 @section Algebraic Entry
10019 @pindex calc-algebraic-entry
10020 @cindex Algebraic notation
10021 @cindex Formulas, entering
10022 Calculations can also be entered in algebraic form. This is accomplished
10023 by typing the apostrophe key, ', followed by the expression in
10032 @texline @math{2+(3\times4) = 14}
10033 @infoline @expr{2+(3*4) = 14}
10034 and push it on the stack. If you wish you can
10035 ignore the RPN aspect of Calc altogether and simply enter algebraic
10036 expressions in this way. You may want to use @key{DEL} every so often to
10037 clear previous results off the stack.
10039 You can press the apostrophe key during normal numeric entry to switch
10040 the half-entered number into Algebraic entry mode. One reason to do this
10041 would be to use the full Emacs cursor motion and editing keys, which are
10042 available during algebraic entry but not during numeric entry.
10044 In the same vein, during either numeric or algebraic entry you can
10045 press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
10046 you complete your half-finished entry in a separate buffer.
10047 @xref{Editing Stack Entries}.
10050 @pindex calc-algebraic-mode
10051 @cindex Algebraic Mode
10052 If you prefer algebraic entry, you can use the command @kbd{m a}
10053 (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode,
10054 digits and other keys that would normally start numeric entry instead
10055 start full algebraic entry; as long as your formula begins with a digit
10056 you can omit the apostrophe. Open parentheses and square brackets also
10057 begin algebraic entry. You can still do RPN calculations in this mode,
10058 but you will have to press @key{RET} to terminate every number:
10059 @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
10060 thing as @kbd{2*3+4 @key{RET}}.
10062 @cindex Incomplete Algebraic Mode
10063 If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
10064 command, it enables Incomplete Algebraic mode; this is like regular
10065 Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
10066 only. Numeric keys still begin a numeric entry in this mode.
10069 @pindex calc-total-algebraic-mode
10070 @cindex Total Algebraic Mode
10071 The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
10072 stronger algebraic-entry mode, in which @emph{all} regular letter and
10073 punctuation keys begin algebraic entry. Use this if you prefer typing
10074 @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
10075 @kbd{a f}, and so on. To type regular Calc commands when you are in
10076 Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q}
10077 is the command to quit Calc, @kbd{M-p} sets the precision, and
10078 @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic
10079 mode back off again. Meta keys also terminate algebraic entry, so
10080 that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol
10081 @samp{Alg*} will appear in the mode line whenever you are in this mode.
10083 Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
10084 algebraic formula. You can then use the normal Emacs editing keys to
10085 modify this formula to your liking before pressing @key{RET}.
10088 @cindex Formulas, referring to stack
10089 Within a formula entered from the keyboard, the symbol @kbd{$}
10090 represents the number on the top of the stack. If an entered formula
10091 contains any @kbd{$} characters, the Calculator replaces the top of
10092 stack with that formula rather than simply pushing the formula onto the
10093 stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
10094 @key{RET}} replaces it with 6. Note that the @kbd{$} key always
10095 initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
10096 first character in the new formula.
10098 Higher stack elements can be accessed from an entered formula with the
10099 symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements
10100 removed (to be replaced by the entered values) equals the number of dollar
10101 signs in the longest such symbol in the formula. For example, @samp{$$+$$$}
10102 adds the second and third stack elements, replacing the top three elements
10103 with the answer. (All information about the top stack element is thus lost
10104 since no single @samp{$} appears in this formula.)
10106 A slightly different way to refer to stack elements is with a dollar
10107 sign followed by a number: @samp{$1}, @samp{$2}, and so on are much
10108 like @samp{$}, @samp{$$}, etc., except that stack entries referred
10109 to numerically are not replaced by the algebraic entry. That is, while
10110 @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
10111 on the stack and pushes an additional 6.
10113 If a sequence of formulas are entered separated by commas, each formula
10114 is pushed onto the stack in turn. For example, @samp{1,2,3} pushes
10115 those three numbers onto the stack (leaving the 3 at the top), and
10116 @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also,
10117 @samp{$,$$} exchanges the top two elements of the stack, just like the
10120 You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
10121 of @key{RET}. This uses @kbd{=} to evaluate the variables in each
10122 formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes
10123 the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
10125 If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
10126 instead of @key{RET}, Calc disables the default simplifications
10127 (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
10128 is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3
10129 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2};
10130 you might then press @kbd{=} when it is time to evaluate this formula.
10132 @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
10133 @section ``Quick Calculator'' Mode
10138 @cindex Quick Calculator
10139 There is another way to invoke the Calculator if all you need to do
10140 is make one or two quick calculations. Type @kbd{C-x * q} (or
10141 @kbd{M-x quick-calc}), then type any formula as an algebraic entry.
10142 The Calculator will compute the result and display it in the echo
10143 area, without ever actually putting up a Calc window.
10145 You can use the @kbd{$} character in a Quick Calculator formula to
10146 refer to the previous Quick Calculator result. Older results are
10147 not retained; the Quick Calculator has no effect on the full
10148 Calculator's stack or trail. If you compute a result and then
10149 forget what it was, just run @code{C-x * q} again and enter
10150 @samp{$} as the formula.
10152 If this is the first time you have used the Calculator in this Emacs
10153 session, the @kbd{C-x * q} command will create the @code{*Calculator*}
10154 buffer and perform all the usual initializations; it simply will
10155 refrain from putting that buffer up in a new window. The Quick
10156 Calculator refers to the @code{*Calculator*} buffer for all mode
10157 settings. Thus, for example, to set the precision that the Quick
10158 Calculator uses, simply run the full Calculator momentarily and use
10159 the regular @kbd{p} command.
10161 If you use @code{C-x * q} from inside the Calculator buffer, the
10162 effect is the same as pressing the apostrophe key (algebraic entry).
10164 The result of a Quick calculation is placed in the Emacs ``kill ring''
10165 as well as being displayed. A subsequent @kbd{C-y} command will
10166 yank the result into the editing buffer. You can also use this
10167 to yank the result into the next @kbd{C-x * q} input line as a more
10168 explicit alternative to @kbd{$} notation, or to yank the result
10169 into the Calculator stack after typing @kbd{C-x * c}.
10171 If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
10172 of @key{RET}, the result is inserted immediately into the current
10173 buffer rather than going into the kill ring.
10175 Quick Calculator results are actually evaluated as if by the @kbd{=}
10176 key (which replaces variable names by their stored values, if any).
10177 If the formula you enter is an assignment to a variable using the
10178 @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
10179 then the result of the evaluation is stored in that Calc variable.
10180 @xref{Store and Recall}.
10182 If the result is an integer and the current display radix is decimal,
10183 the number will also be displayed in hex, octal and binary formats. If
10184 the integer is in the range from 1 to 126, it will also be displayed as
10185 an ASCII character.
10187 For example, the quoted character @samp{"x"} produces the vector
10188 result @samp{[120]} (because 120 is the ASCII code of the lower-case
10189 `x'; @pxref{Strings}). Since this is a vector, not an integer, it
10190 is displayed only according to the current mode settings. But
10191 running Quick Calc again and entering @samp{120} will produce the
10192 result @samp{120 (16#78, 8#170, x)} which shows the number in its
10193 decimal, hexadecimal, octal, and ASCII forms.
10195 Please note that the Quick Calculator is not any faster at loading
10196 or computing the answer than the full Calculator; the name ``quick''
10197 merely refers to the fact that it's much less hassle to use for
10198 small calculations.
10200 @node Prefix Arguments, Undo, Quick Calculator, Introduction
10201 @section Numeric Prefix Arguments
10204 Many Calculator commands use numeric prefix arguments. Some, such as
10205 @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
10206 the prefix argument or use a default if you don't use a prefix.
10207 Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
10208 and prompt for a number if you don't give one as a prefix.
10210 As a rule, stack-manipulation commands accept a numeric prefix argument
10211 which is interpreted as an index into the stack. A positive argument
10212 operates on the top @var{n} stack entries; a negative argument operates
10213 on the @var{n}th stack entry in isolation; and a zero argument operates
10214 on the entire stack.
10216 Most commands that perform computations (such as the arithmetic and
10217 scientific functions) accept a numeric prefix argument that allows the
10218 operation to be applied across many stack elements. For unary operations
10219 (that is, functions of one argument like absolute value or complex
10220 conjugate), a positive prefix argument applies that function to the top
10221 @var{n} stack entries simultaneously, and a negative argument applies it
10222 to the @var{n}th stack entry only. For binary operations (functions of
10223 two arguments like addition, GCD, and vector concatenation), a positive
10224 prefix argument ``reduces'' the function across the top @var{n}
10225 stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
10226 @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
10227 @var{n} stack elements with the top stack element as a second argument
10228 (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
10229 This feature is not available for operations which use the numeric prefix
10230 argument for some other purpose.
10232 Numeric prefixes are specified the same way as always in Emacs: Press
10233 a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
10234 or press @kbd{C-u} followed by digits. Some commands treat plain
10235 @kbd{C-u} (without any actual digits) specially.
10238 @pindex calc-num-prefix
10239 You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
10240 top of the stack and enter it as the numeric prefix for the next command.
10241 For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
10242 (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
10243 to the fourth power and set the precision to that value.
10245 Conversely, if you have typed a numeric prefix argument the @kbd{~} key
10246 pushes it onto the stack in the form of an integer.
10248 @node Undo, Error Messages, Prefix Arguments, Introduction
10249 @section Undoing Mistakes
10255 @cindex Mistakes, undoing
10256 @cindex Undoing mistakes
10257 @cindex Errors, undoing
10258 The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
10259 If that operation added or dropped objects from the stack, those objects
10260 are removed or restored. If it was a ``store'' operation, you are
10261 queried whether or not to restore the variable to its original value.
10262 The @kbd{U} key may be pressed any number of times to undo successively
10263 farther back in time; with a numeric prefix argument it undoes a
10264 specified number of operations. The undo history is cleared only by the
10265 @kbd{q} (@code{calc-quit}) command. (Recall that @kbd{C-x * c} is
10266 synonymous with @code{calc-quit} while inside the Calculator; this
10267 also clears the undo history.)
10269 Currently the mode-setting commands (like @code{calc-precision}) are not
10270 undoable. You can undo past a point where you changed a mode, but you
10271 will need to reset the mode yourself.
10275 @cindex Redoing after an Undo
10276 The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
10277 mistakenly undone. Pressing @kbd{U} with a negative prefix argument is
10278 equivalent to executing @code{calc-redo}. You can redo any number of
10279 times, up to the number of recent consecutive undo commands. Redo
10280 information is cleared whenever you give any command that adds new undo
10281 information, i.e., if you undo, then enter a number on the stack or make
10282 any other change, then it will be too late to redo.
10284 @kindex M-@key{RET}
10285 @pindex calc-last-args
10286 @cindex Last-arguments feature
10287 @cindex Arguments, restoring
10288 The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
10289 it restores the arguments of the most recent command onto the stack;
10290 however, it does not remove the result of that command. Given a numeric
10291 prefix argument, this command applies to the @expr{n}th most recent
10292 command which removed items from the stack; it pushes those items back
10295 The @kbd{K} (@code{calc-keep-args}) command provides a related function
10296 to @kbd{M-@key{RET}}. @xref{Stack and Trail}.
10298 It is also possible to recall previous results or inputs using the trail.
10299 @xref{Trail Commands}.
10301 The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
10303 @node Error Messages, Multiple Calculators, Undo, Introduction
10304 @section Error Messages
10309 @cindex Errors, messages
10310 @cindex Why did an error occur?
10311 Many situations that would produce an error message in other calculators
10312 simply create unsimplified formulas in the Emacs Calculator. For example,
10313 @kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes
10314 the formula @samp{ln(0)}. Floating-point overflow and underflow are also
10315 reasons for this to happen.
10317 When a function call must be left in symbolic form, Calc usually
10318 produces a message explaining why. Messages that are probably
10319 surprising or indicative of user errors are displayed automatically.
10320 Other messages are simply kept in Calc's memory and are displayed only
10321 if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if
10322 the same computation results in several messages. (The first message
10323 will end with @samp{[w=more]} in this case.)
10326 @pindex calc-auto-why
10327 The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
10328 are displayed automatically. (Calc effectively presses @kbd{w} for you
10329 after your computation finishes.) By default, this occurs only for
10330 ``important'' messages. The other possible modes are to report
10331 @emph{all} messages automatically, or to report none automatically (so
10332 that you must always press @kbd{w} yourself to see the messages).
10334 @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
10335 @section Multiple Calculators
10338 @pindex another-calc
10339 It is possible to have any number of Calc mode buffers at once.
10340 Usually this is done by executing @kbd{M-x another-calc}, which
10341 is similar to @kbd{C-x * c} except that if a @samp{*Calculator*}
10342 buffer already exists, a new, independent one with a name of the
10343 form @samp{*Calculator*<@var{n}>} is created. You can also use the
10344 command @code{calc-mode} to put any buffer into Calculator mode, but
10345 this would ordinarily never be done.
10347 The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
10348 it only closes its window. Use @kbd{M-x kill-buffer} to destroy a
10351 Each Calculator buffer keeps its own stack, undo list, and mode settings
10352 such as precision, angular mode, and display formats. In Emacs terms,
10353 variables such as @code{calc-stack} are buffer-local variables. The
10354 global default values of these variables are used only when a new
10355 Calculator buffer is created. The @code{calc-quit} command saves
10356 the stack and mode settings of the buffer being quit as the new defaults.
10358 There is only one trail buffer, @samp{*Calc Trail*}, used by all
10359 Calculator buffers.
10361 @node Troubleshooting Commands, , Multiple Calculators, Introduction
10362 @section Troubleshooting Commands
10365 This section describes commands you can use in case a computation
10366 incorrectly fails or gives the wrong answer.
10368 @xref{Reporting Bugs}, if you find a problem that appears to be due
10369 to a bug or deficiency in Calc.
10372 * Autoloading Problems::
10373 * Recursion Depth::
10378 @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
10379 @subsection Autoloading Problems
10382 The Calc program is split into many component files; components are
10383 loaded automatically as you use various commands that require them.
10384 Occasionally Calc may lose track of when a certain component is
10385 necessary; typically this means you will type a command and it won't
10386 work because some function you've never heard of was undefined.
10389 @pindex calc-load-everything
10390 If this happens, the easiest workaround is to type @kbd{C-x * L}
10391 (@code{calc-load-everything}) to force all the parts of Calc to be
10392 loaded right away. This will cause Emacs to take up a lot more
10393 memory than it would otherwise, but it's guaranteed to fix the problem.
10395 @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
10396 @subsection Recursion Depth
10401 @pindex calc-more-recursion-depth
10402 @pindex calc-less-recursion-depth
10403 @cindex Recursion depth
10404 @cindex ``Computation got stuck'' message
10405 @cindex @code{max-lisp-eval-depth}
10406 @cindex @code{max-specpdl-size}
10407 Calc uses recursion in many of its calculations. Emacs Lisp keeps a
10408 variable @code{max-lisp-eval-depth} which limits the amount of recursion
10409 possible in an attempt to recover from program bugs. If a calculation
10410 ever halts incorrectly with the message ``Computation got stuck or
10411 ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
10412 to increase this limit. (Of course, this will not help if the
10413 calculation really did get stuck due to some problem inside Calc.)
10415 The limit is always increased (multiplied) by a factor of two. There
10416 is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
10417 decreases this limit by a factor of two, down to a minimum value of 200.
10418 The default value is 1000.
10420 These commands also double or halve @code{max-specpdl-size}, another
10421 internal Lisp recursion limit. The minimum value for this limit is 600.
10423 @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
10428 @cindex Flushing caches
10429 Calc saves certain values after they have been computed once. For
10430 example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
10431 constant @cpi{} to about 20 decimal places; if the current precision
10432 is greater than this, it will recompute @cpi{} using a series
10433 approximation. This value will not need to be recomputed ever again
10434 unless you raise the precision still further. Many operations such as
10435 logarithms and sines make use of similarly cached values such as
10437 @texline @math{\ln 2}.
10438 @infoline @expr{ln(2)}.
10439 The visible effect of caching is that
10440 high-precision computations may seem to do extra work the first time.
10441 Other things cached include powers of two (for the binary arithmetic
10442 functions), matrix inverses and determinants, symbolic integrals, and
10443 data points computed by the graphing commands.
10445 @pindex calc-flush-caches
10446 If you suspect a Calculator cache has become corrupt, you can use the
10447 @code{calc-flush-caches} command to reset all caches to the empty state.
10448 (This should only be necessary in the event of bugs in the Calculator.)
10449 The @kbd{C-x * 0} (with the zero key) command also resets caches along
10450 with all other aspects of the Calculator's state.
10452 @node Debugging Calc, , Caches, Troubleshooting Commands
10453 @subsection Debugging Calc
10456 A few commands exist to help in the debugging of Calc commands.
10457 @xref{Programming}, to see the various ways that you can write
10458 your own Calc commands.
10461 @pindex calc-timing
10462 The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
10463 in which the timing of slow commands is reported in the Trail.
10464 Any Calc command that takes two seconds or longer writes a line
10465 to the Trail showing how many seconds it took. This value is
10466 accurate only to within one second.
10468 All steps of executing a command are included; in particular, time
10469 taken to format the result for display in the stack and trail is
10470 counted. Some prompts also count time taken waiting for them to
10471 be answered, while others do not; this depends on the exact
10472 implementation of the command. For best results, if you are timing
10473 a sequence that includes prompts or multiple commands, define a
10474 keyboard macro to run the whole sequence at once. Calc's @kbd{X}
10475 command (@pxref{Keyboard Macros}) will then report the time taken
10476 to execute the whole macro.
10478 Another advantage of the @kbd{X} command is that while it is
10479 executing, the stack and trail are not updated from step to step.
10480 So if you expect the output of your test sequence to leave a result
10481 that may take a long time to format and you don't wish to count
10482 this formatting time, end your sequence with a @key{DEL} keystroke
10483 to clear the result from the stack. When you run the sequence with
10484 @kbd{X}, Calc will never bother to format the large result.
10486 Another thing @kbd{Z T} does is to increase the Emacs variable
10487 @code{gc-cons-threshold} to a much higher value (two million; the
10488 usual default in Calc is 250,000) for the duration of each command.
10489 This generally prevents garbage collection during the timing of
10490 the command, though it may cause your Emacs process to grow
10491 abnormally large. (Garbage collection time is a major unpredictable
10492 factor in the timing of Emacs operations.)
10494 Another command that is useful when debugging your own Lisp
10495 extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
10496 the error handler that changes the ``@code{max-lisp-eval-depth}
10497 exceeded'' message to the much more friendly ``Computation got
10498 stuck or ran too long.'' This handler interferes with the Emacs
10499 Lisp debugger's @code{debug-on-error} mode. Errors are reported
10500 in the handler itself rather than at the true location of the
10501 error. After you have executed @code{calc-pass-errors}, Lisp
10502 errors will be reported correctly but the user-friendly message
10505 @node Data Types, Stack and Trail, Introduction, Top
10506 @chapter Data Types
10509 This chapter discusses the various types of objects that can be placed
10510 on the Calculator stack, how they are displayed, and how they are
10511 entered. (@xref{Data Type Formats}, for information on how these data
10512 types are represented as underlying Lisp objects.)
10514 Integers, fractions, and floats are various ways of describing real
10515 numbers. HMS forms also for many purposes act as real numbers. These
10516 types can be combined to form complex numbers, modulo forms, error forms,
10517 or interval forms. (But these last four types cannot be combined
10518 arbitrarily:@: error forms may not contain modulo forms, for example.)
10519 Finally, all these types of numbers may be combined into vectors,
10520 matrices, or algebraic formulas.
10523 * Integers:: The most basic data type.
10524 * Fractions:: This and above are called @dfn{rationals}.
10525 * Floats:: This and above are called @dfn{reals}.
10526 * Complex Numbers:: This and above are called @dfn{numbers}.
10528 * Vectors and Matrices::
10535 * Incomplete Objects::
10540 @node Integers, Fractions, Data Types, Data Types
10545 The Calculator stores integers to arbitrary precision. Addition,
10546 subtraction, and multiplication of integers always yields an exact
10547 integer result. (If the result of a division or exponentiation of
10548 integers is not an integer, it is expressed in fractional or
10549 floating-point form according to the current Fraction mode.
10550 @xref{Fraction Mode}.)
10552 A decimal integer is represented as an optional sign followed by a
10553 sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to
10554 insert a comma at every third digit for display purposes, but you
10555 must not type commas during the entry of numbers.
10558 A non-decimal integer is represented as an optional sign, a radix
10559 between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11
10560 and above, the letters A through Z (upper- or lower-case) count as
10561 digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how
10562 to set the default radix for display of integers. Numbers of any radix
10563 may be entered at any time. If you press @kbd{#} at the beginning of a
10564 number, the current display radix is used.
10566 @node Fractions, Floats, Integers, Data Types
10571 A @dfn{fraction} is a ratio of two integers. Fractions are traditionally
10572 written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key
10573 performs RPN division; the following two sequences push the number
10574 @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
10575 assuming Fraction mode has been enabled.)
10576 When the Calculator produces a fractional result it always reduces it to
10577 simplest form, which may in fact be an integer.
10579 Fractions may also be entered in a three-part form, where @samp{2:3:4}
10580 represents two-and-three-quarters. @xref{Fraction Formats}, for fraction
10583 Non-decimal fractions are entered and displayed as
10584 @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
10585 form). The numerator and denominator always use the same radix.
10587 @node Floats, Complex Numbers, Fractions, Data Types
10591 @cindex Floating-point numbers
10592 A floating-point number or @dfn{float} is a number stored in scientific
10593 notation. The number of significant digits in the fractional part is
10594 governed by the current floating precision (@pxref{Precision}). The
10595 range of acceptable values is from
10596 @texline @math{10^{-3999999}}
10597 @infoline @expr{10^-3999999}
10599 @texline @math{10^{4000000}}
10600 @infoline @expr{10^4000000}
10601 (exclusive), plus the corresponding negative values and zero.
10603 Calculations that would exceed the allowable range of values (such
10604 as @samp{exp(exp(20))}) are left in symbolic form by Calc. The
10605 messages ``floating-point overflow'' or ``floating-point underflow''
10606 indicate that during the calculation a number would have been produced
10607 that was too large or too close to zero, respectively, to be represented
10608 by Calc. This does not necessarily mean the final result would have
10609 overflowed, just that an overflow occurred while computing the result.
10610 (In fact, it could report an underflow even though the final result
10611 would have overflowed!)
10613 If a rational number and a float are mixed in a calculation, the result
10614 will in general be expressed as a float. Commands that require an integer
10615 value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
10616 floats, i.e., floating-point numbers with nothing after the decimal point.
10618 Floats are identified by the presence of a decimal point and/or an
10619 exponent. In general a float consists of an optional sign, digits
10620 including an optional decimal point, and an optional exponent consisting
10621 of an @samp{e}, an optional sign, and up to seven exponent digits.
10622 For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
10625 Floating-point numbers are normally displayed in decimal notation with
10626 all significant figures shown. Exceedingly large or small numbers are
10627 displayed in scientific notation. Various other display options are
10628 available. @xref{Float Formats}.
10630 @cindex Accuracy of calculations
10631 Floating-point numbers are stored in decimal, not binary. The result
10632 of each operation is rounded to the nearest value representable in the
10633 number of significant digits specified by the current precision,
10634 rounding away from zero in the case of a tie. Thus (in the default
10635 display mode) what you see is exactly what you get. Some operations such
10636 as square roots and transcendental functions are performed with several
10637 digits of extra precision and then rounded down, in an effort to make the
10638 final result accurate to the full requested precision. However,
10639 accuracy is not rigorously guaranteed. If you suspect the validity of a
10640 result, try doing the same calculation in a higher precision. The
10641 Calculator's arithmetic is not intended to be IEEE-conformant in any
10644 While floats are always @emph{stored} in decimal, they can be entered
10645 and displayed in any radix just like integers and fractions. Since a
10646 float that is entered in a radix other that 10 will be converted to
10647 decimal, the number that Calc stores may not be exactly the number that
10648 was entered, it will be the closest decimal approximation given the
10649 current precison. The notation @samp{@var{radix}#@var{ddd}.@var{ddd}}
10650 is a floating-point number whose digits are in the specified radix.
10651 Note that the @samp{.} is more aptly referred to as a ``radix point''
10652 than as a decimal point in this case. The number @samp{8#123.4567} is
10653 defined as @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can
10654 use @samp{e} notation to write a non-decimal number in scientific
10655 notation. The exponent is written in decimal, and is considered to be a
10656 power of the radix: @samp{8#1234567e-4}. If the radix is 15 or above,
10657 the letter @samp{e} is a digit, so scientific notation must be written
10658 out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the
10659 Modes Tutorial explore some of the properties of non-decimal floats.
10661 @node Complex Numbers, Infinities, Floats, Data Types
10662 @section Complex Numbers
10665 @cindex Complex numbers
10666 There are two supported formats for complex numbers: rectangular and
10667 polar. The default format is rectangular, displayed in the form
10668 @samp{(@var{real},@var{imag})} where @var{real} is the real part and
10669 @var{imag} is the imaginary part, each of which may be any real number.
10670 Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
10671 notation; @pxref{Complex Formats}.
10673 Polar complex numbers are displayed in the form
10674 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'
10675 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'
10676 where @var{r} is the nonnegative magnitude and
10677 @texline @math{\theta}
10678 @infoline @var{theta}
10679 is the argument or phase angle. The range of
10680 @texline @math{\theta}
10681 @infoline @var{theta}
10682 depends on the current angular mode (@pxref{Angular Modes}); it is
10683 generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range
10686 Complex numbers are entered in stages using incomplete objects.
10687 @xref{Incomplete Objects}.
10689 Operations on rectangular complex numbers yield rectangular complex
10690 results, and similarly for polar complex numbers. Where the two types
10691 are mixed, or where new complex numbers arise (as for the square root of
10692 a negative real), the current @dfn{Polar mode} is used to determine the
10693 type. @xref{Polar Mode}.
10695 A complex result in which the imaginary part is zero (or the phase angle
10696 is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real
10699 @node Infinities, Vectors and Matrices, Complex Numbers, Data Types
10700 @section Infinities
10704 @cindex @code{inf} variable
10705 @cindex @code{uinf} variable
10706 @cindex @code{nan} variable
10710 The word @code{inf} represents the mathematical concept of @dfn{infinity}.
10711 Calc actually has three slightly different infinity-like values:
10712 @code{inf}, @code{uinf}, and @code{nan}. These are just regular
10713 variable names (@pxref{Variables}); you should avoid using these
10714 names for your own variables because Calc gives them special
10715 treatment. Infinities, like all variable names, are normally
10716 entered using algebraic entry.
10718 Mathematically speaking, it is not rigorously correct to treat
10719 ``infinity'' as if it were a number, but mathematicians often do
10720 so informally. When they say that @samp{1 / inf = 0}, what they
10721 really mean is that @expr{1 / x}, as @expr{x} becomes larger and
10722 larger, becomes arbitrarily close to zero. So you can imagine
10723 that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x}
10724 would go all the way to zero. Similarly, when they say that
10725 @samp{exp(inf) = inf}, they mean that
10726 @texline @math{e^x}
10727 @infoline @expr{exp(x)}
10728 grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise
10729 stands for an infinitely negative real value; for example, we say that
10730 @samp{exp(-inf) = 0}. You can have an infinity pointing in any
10731 direction on the complex plane: @samp{sqrt(-inf) = i inf}.
10733 The same concept of limits can be used to define @expr{1 / 0}. We
10734 really want the value that @expr{1 / x} approaches as @expr{x}
10735 approaches zero. But if all we have is @expr{1 / 0}, we can't
10736 tell which direction @expr{x} was coming from. If @expr{x} was
10737 positive and decreasing toward zero, then we should say that
10738 @samp{1 / 0 = inf}. But if @expr{x} was negative and increasing
10739 toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x}
10740 could be an imaginary number, giving the answer @samp{i inf} or
10741 @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean
10742 @dfn{undirected infinity}, i.e., a value which is infinitely
10743 large but with an unknown sign (or direction on the complex plane).
10745 Calc actually has three modes that say how infinities are handled.
10746 Normally, infinities never arise from calculations that didn't
10747 already have them. Thus, @expr{1 / 0} is treated simply as an
10748 error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode})
10749 command (@pxref{Infinite Mode}) enables a mode in which
10750 @expr{1 / 0} evaluates to @code{uinf} instead. There is also
10751 an alternative type of infinite mode which says to treat zeros
10752 as if they were positive, so that @samp{1 / 0 = inf}. While this
10753 is less mathematically correct, it may be the answer you want in
10756 Since all infinities are ``as large'' as all others, Calc simplifies,
10757 e.g., @samp{5 inf} to @samp{inf}. Another example is
10758 @samp{5 - inf = -inf}, where the @samp{-inf} is so large that
10759 adding a finite number like five to it does not affect it.
10760 Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
10761 that variables like @code{a} always stand for finite quantities.
10762 Just to show that infinities really are all the same size,
10763 note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
10766 It's not so easy to define certain formulas like @samp{0 * inf} and
10767 @samp{inf / inf}. Depending on where these zeros and infinities
10768 came from, the answer could be literally anything. The latter
10769 formula could be the limit of @expr{x / x} (giving a result of one),
10770 or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}),
10771 or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan}
10772 to represent such an @dfn{indeterminate} value. (The name ``nan''
10773 comes from analogy with the ``NAN'' concept of IEEE standard
10774 arithmetic; it stands for ``Not A Number.'' This is somewhat of a
10775 misnomer, since @code{nan} @emph{does} stand for some number or
10776 infinity, it's just that @emph{which} number it stands for
10777 cannot be determined.) In Calc's notation, @samp{0 * inf = nan}
10778 and @samp{inf / inf = nan}. A few other common indeterminate
10779 expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also,
10780 @samp{0 / 0 = nan} if you have turned on Infinite mode
10781 (as described above).
10783 Infinities are especially useful as parts of @dfn{intervals}.
10784 @xref{Interval Forms}.
10786 @node Vectors and Matrices, Strings, Infinities, Data Types
10787 @section Vectors and Matrices
10791 @cindex Plain vectors
10793 The @dfn{vector} data type is flexible and general. A vector is simply a
10794 list of zero or more data objects. When these objects are numbers, the
10795 whole is a vector in the mathematical sense. When these objects are
10796 themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
10797 A vector which is not a matrix is referred to here as a @dfn{plain vector}.
10799 A vector is displayed as a list of values separated by commas and enclosed
10800 in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by
10801 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex
10802 numbers, are entered as incomplete objects. @xref{Incomplete Objects}.
10803 During algebraic entry, vectors are entered all at once in the usual
10804 brackets-and-commas form. Matrices may be entered algebraically as nested
10805 vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
10806 with rows separated by semicolons. The commas may usually be omitted
10807 when entering vectors: @samp{[1 2 3]}. Curly braces may be used in
10808 place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
10811 Traditional vector and matrix arithmetic is also supported;
10812 @pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
10813 Many other operations are applied to vectors element-wise. For example,
10814 the complex conjugate of a vector is a vector of the complex conjugates
10821 Algebraic functions for building vectors include @samp{vec(a, b, c)}
10822 to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an
10823 @texline @math{n\times m}
10824 @infoline @var{n}x@var{m}
10825 matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
10826 from 1 to @samp{n}.
10828 @node Strings, HMS Forms, Vectors and Matrices, Data Types
10834 @cindex Character strings
10835 Character strings are not a special data type in the Calculator.
10836 Rather, a string is represented simply as a vector all of whose
10837 elements are integers in the range 0 to 255 (ASCII codes). You can
10838 enter a string at any time by pressing the @kbd{"} key. Quotation
10839 marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
10840 inside strings. Other notations introduced by backslashes are:
10856 Finally, a backslash followed by three octal digits produces any
10857 character from its ASCII code.
10860 @pindex calc-display-strings
10861 Strings are normally displayed in vector-of-integers form. The
10862 @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
10863 which any vectors of small integers are displayed as quoted strings
10866 The backslash notations shown above are also used for displaying
10867 strings. Characters 128 and above are not translated by Calc; unless
10868 you have an Emacs modified for 8-bit fonts, these will show up in
10869 backslash-octal-digits notation. For characters below 32, and
10870 for character 127, Calc uses the backslash-letter combination if
10871 there is one, or otherwise uses a @samp{\^} sequence.
10873 The only Calc feature that uses strings is @dfn{compositions};
10874 @pxref{Compositions}. Strings also provide a convenient
10875 way to do conversions between ASCII characters and integers.
10881 There is a @code{string} function which provides a different display
10882 format for strings. Basically, @samp{string(@var{s})}, where @var{s}
10883 is a vector of integers in the proper range, is displayed as the
10884 corresponding string of characters with no surrounding quotation
10885 marks or other modifications. Thus @samp{string("ABC")} (or
10886 @samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
10887 This happens regardless of whether @w{@kbd{d "}} has been used. The
10888 only way to turn it off is to use @kbd{d U} (unformatted language
10889 mode) which will display @samp{string("ABC")} instead.
10891 Control characters are displayed somewhat differently by @code{string}.
10892 Characters below 32, and character 127, are shown using @samp{^} notation
10893 (same as shown above, but without the backslash). The quote and
10894 backslash characters are left alone, as are characters 128 and above.
10900 The @code{bstring} function is just like @code{string} except that
10901 the resulting string is breakable across multiple lines if it doesn't
10902 fit all on one line. Potential break points occur at every space
10903 character in the string.
10905 @node HMS Forms, Date Forms, Strings, Data Types
10909 @cindex Hours-minutes-seconds forms
10910 @cindex Degrees-minutes-seconds forms
10911 @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
10912 argument, the interpretation is Degrees-Minutes-Seconds. All functions
10913 that operate on angles accept HMS forms. These are interpreted as
10914 degrees regardless of the current angular mode. It is also possible to
10915 use HMS as the angular mode so that calculated angles are expressed in
10916 degrees, minutes, and seconds.
10922 @kindex ' (HMS forms)
10926 @kindex " (HMS forms)
10930 @kindex h (HMS forms)
10934 @kindex o (HMS forms)
10938 @kindex m (HMS forms)
10942 @kindex s (HMS forms)
10943 The default format for HMS values is
10944 @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters
10945 @samp{h} (for ``hours'') or
10946 @samp{o} (approximating the ``degrees'' symbol) are accepted as well as
10947 @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
10948 accepted in place of @samp{"}.
10949 The @var{hours} value is an integer (or integer-valued float).
10950 The @var{mins} value is an integer or integer-valued float between 0 and 59.
10951 The @var{secs} value is a real number between 0 (inclusive) and 60
10952 (exclusive). A positive HMS form is interpreted as @var{hours} +
10953 @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted
10954 as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600.
10955 Display format for HMS forms is quite flexible. @xref{HMS Formats}.
10957 HMS forms can be added and subtracted. When they are added to numbers,
10958 the numbers are interpreted according to the current angular mode. HMS
10959 forms can also be multiplied and divided by real numbers. Dividing
10960 two HMS forms produces a real-valued ratio of the two angles.
10963 @cindex Time of day
10964 Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
10965 the stack as an HMS form.
10967 @node Date Forms, Modulo Forms, HMS Forms, Data Types
10968 @section Date Forms
10972 A @dfn{date form} represents a date and possibly an associated time.
10973 Simple date arithmetic is supported: Adding a number to a date
10974 produces a new date shifted by that many days; adding an HMS form to
10975 a date shifts it by that many hours. Subtracting two date forms
10976 computes the number of days between them (represented as a simple
10977 number). Many other operations, such as multiplying two date forms,
10978 are nonsensical and are not allowed by Calc.
10980 Date forms are entered and displayed enclosed in @samp{< >} brackets.
10981 The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
10982 or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
10983 Input is flexible; date forms can be entered in any of the usual
10984 notations for dates and times. @xref{Date Formats}.
10986 Date forms are stored internally as numbers, specifically the number
10987 of days since midnight on the morning of January 1 of the year 1 AD.
10988 If the internal number is an integer, the form represents a date only;
10989 if the internal number is a fraction or float, the form represents
10990 a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>}
10991 is represented by the number 726842.25. The standard precision of
10992 12 decimal digits is enough to ensure that a (reasonable) date and
10993 time can be stored without roundoff error.
10995 If the current precision is greater than 12, date forms will keep
10996 additional digits in the seconds position. For example, if the
10997 precision is 15, the seconds will keep three digits after the
10998 decimal point. Decreasing the precision below 12 may cause the
10999 time part of a date form to become inaccurate. This can also happen
11000 if astronomically high years are used, though this will not be an
11001 issue in everyday (or even everymillennium) use. Note that date
11002 forms without times are stored as exact integers, so roundoff is
11003 never an issue for them.
11005 You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
11006 (@code{calc-unpack}) commands to get at the numerical representation
11007 of a date form. @xref{Packing and Unpacking}.
11009 Date forms can go arbitrarily far into the future or past. Negative
11010 year numbers represent years BC. Calc uses a combination of the
11011 Gregorian and Julian calendars, following the history of Great
11012 Britain and the British colonies. This is the same calendar that
11013 is used by the @code{cal} program in most Unix implementations.
11015 @cindex Julian calendar
11016 @cindex Gregorian calendar
11017 Some historical background: The Julian calendar was created by
11018 Julius Caesar in the year 46 BC as an attempt to fix the gradual
11019 drift caused by the lack of leap years in the calendar used
11020 until that time. The Julian calendar introduced an extra day in
11021 all years divisible by four. After some initial confusion, the
11022 calendar was adopted around the year we call 8 AD. Some centuries
11023 later it became apparent that the Julian year of 365.25 days was
11024 itself not quite right. In 1582 Pope Gregory XIII introduced the
11025 Gregorian calendar, which added the new rule that years divisible
11026 by 100, but not by 400, were not to be considered leap years
11027 despite being divisible by four. Many countries delayed adoption
11028 of the Gregorian calendar because of religious differences;
11029 in Britain it was put off until the year 1752, by which time
11030 the Julian calendar had fallen eleven days behind the true
11031 seasons. So the switch to the Gregorian calendar in early
11032 September 1752 introduced a discontinuity: The day after
11033 Sep 2, 1752 is Sep 14, 1752. Calc follows this convention.
11034 To take another example, Russia waited until 1918 before
11035 adopting the new calendar, and thus needed to remove thirteen
11036 days (between Feb 1, 1918 and Feb 14, 1918). This means that
11037 Calc's reckoning will be inconsistent with Russian history between
11038 1752 and 1918, and similarly for various other countries.
11040 Today's timekeepers introduce an occasional ``leap second'' as
11041 well, but Calc does not take these minor effects into account.
11042 (If it did, it would have to report a non-integer number of days
11043 between, say, @samp{<12:00am Mon Jan 1, 1900>} and
11044 @samp{<12:00am Sat Jan 1, 2000>}.)
11046 Calc uses the Julian calendar for all dates before the year 1752,
11047 including dates BC when the Julian calendar technically had not
11048 yet been invented. Thus the claim that day number @mathit{-10000} is
11049 called ``August 16, 28 BC'' should be taken with a grain of salt.
11051 Please note that there is no ``year 0''; the day before
11052 @samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}. These are
11053 days 0 and @mathit{-1} respectively in Calc's internal numbering scheme.
11055 @cindex Julian day counting
11056 Another day counting system in common use is, confusingly, also
11057 called ``Julian.'' It was invented in 1583 by Joseph Justus
11058 Scaliger, who named it in honor of his father Julius Caesar
11059 Scaliger. For obscure reasons he chose to start his day
11060 numbering on Jan 1, 4713 BC at noon, which in Calc's scheme
11061 is @mathit{-1721423.5} (recall that Calc starts at midnight instead
11062 of noon). Thus to convert a Calc date code obtained by
11063 unpacking a date form into a Julian day number, simply add
11064 1721423.5. The Julian code for @samp{6:00am Jan 9, 1991}
11065 is 2448265.75. The built-in @kbd{t J} command performs
11066 this conversion for you.
11068 @cindex Unix time format
11069 The Unix operating system measures time as an integer number of
11070 seconds since midnight, Jan 1, 1970. To convert a Calc date
11071 value into a Unix time stamp, first subtract 719164 (the code
11072 for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
11073 seconds in a day) and press @kbd{R} to round to the nearest
11074 integer. If you have a date form, you can simply subtract the
11075 day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
11076 719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
11077 to convert from Unix time to a Calc date form. (Note that
11078 Unix normally maintains the time in the GMT time zone; you may
11079 need to subtract five hours to get New York time, or eight hours
11080 for California time. The same is usually true of Julian day
11081 counts.) The built-in @kbd{t U} command performs these
11084 @node Modulo Forms, Error Forms, Date Forms, Data Types
11085 @section Modulo Forms
11088 @cindex Modulo forms
11089 A @dfn{modulo form} is a real number which is taken modulo (i.e., within
11090 an integer multiple of) some value @var{M}. Arithmetic modulo @var{M}
11091 often arises in number theory. Modulo forms are written
11092 `@var{a} @tfn{mod} @var{M}',
11093 where @var{a} and @var{M} are real numbers or HMS forms, and
11094 @texline @math{0 \le a < M}.
11095 @infoline @expr{0 <= a < @var{M}}.
11096 In many applications @expr{a} and @expr{M} will be
11097 integers but this is not required.
11102 @kindex M (modulo forms)
11106 @tindex mod (operator)
11107 To create a modulo form during numeric entry, press the shift-@kbd{M}
11108 key to enter the word @samp{mod}. As a special convenience, pressing
11109 shift-@kbd{M} a second time automatically enters the value of @expr{M}
11110 that was most recently used before. During algebraic entry, either
11111 type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
11112 Once again, pressing this a second time enters the current modulo.
11114 Modulo forms are not to be confused with the modulo operator @samp{%}.
11115 The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
11116 the result 7. Further computations treat this 7 as just a regular integer.
11117 The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
11118 further computations with this value are again reduced modulo 10 so that
11119 the result always lies in the desired range.
11121 When two modulo forms with identical @expr{M}'s are added or multiplied,
11122 the Calculator simply adds or multiplies the values, then reduces modulo
11123 @expr{M}. If one argument is a modulo form and the other a plain number,
11124 the plain number is treated like a compatible modulo form. It is also
11125 possible to raise modulo forms to powers; the result is the value raised
11126 to the power, then reduced modulo @expr{M}. (When all values involved
11127 are integers, this calculation is done much more efficiently than
11128 actually computing the power and then reducing.)
11130 @cindex Modulo division
11131 Two modulo forms `@var{a} @tfn{mod} @var{M}' and `@var{b} @tfn{mod} @var{M}'
11132 can be divided if @expr{a}, @expr{b}, and @expr{M} are all
11133 integers. The result is the modulo form which, when multiplied by
11134 `@var{b} @tfn{mod} @var{M}', produces `@var{a} @tfn{mod} @var{M}'. If
11135 there is no solution to this equation (which can happen only when
11136 @expr{M} is non-prime), or if any of the arguments are non-integers, the
11137 division is left in symbolic form. Other operations, such as square
11138 roots, are not yet supported for modulo forms. (Note that, although
11139 @w{`@tfn{(}@var{a} @tfn{mod} @var{M}@tfn{)^.5}'} will compute a ``modulo square root''
11140 in the sense of reducing
11141 @texline @math{\sqrt a}
11142 @infoline @expr{sqrt(a)}
11143 modulo @expr{M}, this is not a useful definition from the
11144 number-theoretical point of view.)
11146 It is possible to mix HMS forms and modulo forms. For example, an
11147 HMS form modulo 24 could be used to manipulate clock times; an HMS
11148 form modulo 360 would be suitable for angles. Making the modulo @expr{M}
11149 also be an HMS form eliminates troubles that would arise if the angular
11150 mode were inadvertently set to Radians, in which case
11151 @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
11154 Modulo forms cannot have variables or formulas for components. If you
11155 enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
11156 to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}.
11158 You can use @kbd{v p} and @kbd{%} to modify modulo forms.
11159 @xref{Packing and Unpacking}. @xref{Basic Arithmetic}.
11165 The algebraic function @samp{makemod(a, m)} builds the modulo form
11166 @w{@samp{a mod m}}.
11168 @node Error Forms, Interval Forms, Modulo Forms, Data Types
11169 @section Error Forms
11172 @cindex Error forms
11173 @cindex Standard deviations
11174 An @dfn{error form} is a number with an associated standard
11175 deviation, as in @samp{2.3 +/- 0.12}. The notation
11176 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11177 @infoline `@var{x} @tfn{+/-} sigma'
11178 stands for an uncertain value which follows
11179 a normal or Gaussian distribution of mean @expr{x} and standard
11180 deviation or ``error''
11181 @texline @math{\sigma}.
11182 @infoline @expr{sigma}.
11183 Both the mean and the error can be either numbers or
11184 formulas. Generally these are real numbers but the mean may also be
11185 complex. If the error is negative or complex, it is changed to its
11186 absolute value. An error form with zero error is converted to a
11187 regular number by the Calculator.
11189 All arithmetic and transcendental functions accept error forms as input.
11190 Operations on the mean-value part work just like operations on regular
11191 numbers. The error part for any function @expr{f(x)} (such as
11192 @texline @math{\sin x}
11193 @infoline @expr{sin(x)})
11194 is defined by the error of @expr{x} times the derivative of @expr{f}
11195 evaluated at the mean value of @expr{x}. For a two-argument function
11196 @expr{f(x,y)} (such as addition) the error is the square root of the sum
11197 of the squares of the errors due to @expr{x} and @expr{y}.
11200 f(x \hbox{\code{ +/- }} \sigma)
11201 &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
11202 f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
11203 &= f(x,y) \hbox{\code{ +/- }}
11204 \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
11206 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
11207 \right| \right)^2 } \cr
11211 definition assumes the errors in @expr{x} and @expr{y} are uncorrelated.
11212 A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
11213 is not the same as @samp{(2 +/- 1)^2}; the former represents the product
11214 of two independent values which happen to have the same probability
11215 distributions, and the latter is the product of one random value with itself.
11216 The former will produce an answer with less error, since on the average
11217 the two independent errors can be expected to cancel out.
11219 Consult a good text on error analysis for a discussion of the proper use
11220 of standard deviations. Actual errors often are neither Gaussian-distributed
11221 nor uncorrelated, and the above formulas are valid only when errors
11222 are small. As an example, the error arising from
11223 @texline `@tfn{sin(}@var{x} @tfn{+/-} @math{\sigma}@tfn{)}'
11224 @infoline `@tfn{sin(}@var{x} @tfn{+/-} @var{sigma}@tfn{)}'
11226 @texline `@math{\sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11227 @infoline `@var{sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11228 When @expr{x} is close to zero,
11229 @texline @math{\cos x}
11230 @infoline @expr{cos(x)}
11231 is close to one so the error in the sine is close to
11232 @texline @math{\sigma};
11233 @infoline @expr{sigma};
11234 this makes sense, since
11235 @texline @math{\sin x}
11236 @infoline @expr{sin(x)}
11237 is approximately @expr{x} near zero, so a given error in @expr{x} will
11238 produce about the same error in the sine. Likewise, near 90 degrees
11239 @texline @math{\cos x}
11240 @infoline @expr{cos(x)}
11241 is nearly zero and so the computed error is
11242 small: The sine curve is nearly flat in that region, so an error in @expr{x}
11243 has relatively little effect on the value of
11244 @texline @math{\sin x}.
11245 @infoline @expr{sin(x)}.
11246 However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so
11247 Calc will report zero error! We get an obviously wrong result because
11248 we have violated the small-error approximation underlying the error
11249 analysis. If the error in @expr{x} had been small, the error in
11250 @texline @math{\sin x}
11251 @infoline @expr{sin(x)}
11252 would indeed have been negligible.
11257 @kindex p (error forms)
11259 To enter an error form during regular numeric entry, use the @kbd{p}
11260 (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually
11261 typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
11262 @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-+} to
11263 type the @samp{+/-} symbol, or type it out by hand.
11265 Error forms and complex numbers can be mixed; the formulas shown above
11266 are used for complex numbers, too; note that if the error part evaluates
11267 to a complex number its absolute value (or the square root of the sum of
11268 the squares of the absolute values of the two error contributions) is
11269 used. Mathematically, this corresponds to a radially symmetric Gaussian
11270 distribution of numbers on the complex plane. However, note that Calc
11271 considers an error form with real components to represent a real number,
11272 not a complex distribution around a real mean.
11274 Error forms may also be composed of HMS forms. For best results, both
11275 the mean and the error should be HMS forms if either one is.
11281 The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
11283 @node Interval Forms, Incomplete Objects, Error Forms, Data Types
11284 @section Interval Forms
11287 @cindex Interval forms
11288 An @dfn{interval} is a subset of consecutive real numbers. For example,
11289 the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
11290 inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you
11291 obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if
11292 you multiply some number in the range @samp{[2 ..@: 4]} by some other
11293 number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
11294 from 1 to 8. Interval arithmetic is used to get a worst-case estimate
11295 of the possible range of values a computation will produce, given the
11296 set of possible values of the input.
11299 Calc supports several varieties of intervals, including @dfn{closed}
11300 intervals of the type shown above, @dfn{open} intervals such as
11301 @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
11302 @emph{exclusive}, and @dfn{semi-open} intervals in which one end
11303 uses a round parenthesis and the other a square bracket. In mathematical
11305 @samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas
11306 @samp{[2 ..@: 4)} represents @expr{2 <= x < 4},
11307 @samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and
11308 @samp{(2 ..@: 4)} represents @expr{2 < x < 4}.
11311 Calc supports several varieties of intervals, including \dfn{closed}
11312 intervals of the type shown above, \dfn{open} intervals such as
11313 \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
11314 \emph{exclusive}, and \dfn{semi-open} intervals in which one end
11315 uses a round parenthesis and the other a square bracket. In mathematical
11318 [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr
11319 [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr
11320 (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr
11321 (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr
11325 The lower and upper limits of an interval must be either real numbers
11326 (or HMS or date forms), or symbolic expressions which are assumed to be
11327 real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit
11328 must be less than the upper limit. A closed interval containing only
11329 one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
11330 automatically. An interval containing no values at all (such as
11331 @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
11332 guaranteed to behave well when used in arithmetic. Note that the
11333 interval @samp{[3 .. inf)} represents all real numbers greater than
11334 or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
11335 In fact, @samp{[-inf .. inf]} represents all real numbers including
11336 the real infinities.
11338 Intervals are entered in the notation shown here, either as algebraic
11339 formulas, or using incomplete forms. (@xref{Incomplete Objects}.)
11340 In algebraic formulas, multiple periods in a row are collected from
11341 left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
11342 rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to
11343 get the other interpretation. If you omit the lower or upper limit,
11344 a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
11346 Infinite mode also affects operations on intervals
11347 (@pxref{Infinities}). Calc will always introduce an open infinity,
11348 as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities,
11349 @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode;
11350 otherwise they are left unevaluated. Note that the ``direction'' of
11351 a zero is not an issue in this case since the zero is always assumed
11352 to be continuous with the rest of the interval. For intervals that
11353 contain zero inside them Calc is forced to give the result,
11354 @samp{1 / (-2 .. 2) = [-inf .. inf]}.
11356 While it may seem that intervals and error forms are similar, they are
11357 based on entirely different concepts of inexact quantities. An error
11359 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11360 @infoline `@var{x} @tfn{+/-} @var{sigma}'
11361 means a variable is random, and its value could
11362 be anything but is ``probably'' within one
11363 @texline @math{\sigma}
11364 @infoline @var{sigma}
11365 of the mean value @expr{x}. An interval
11366 `@tfn{[}@var{a} @tfn{..@:} @var{b}@tfn{]}' means a
11367 variable's value is unknown, but guaranteed to lie in the specified
11368 range. Error forms are statistical or ``average case'' approximations;
11369 interval arithmetic tends to produce ``worst case'' bounds on an
11372 Intervals may not contain complex numbers, but they may contain
11373 HMS forms or date forms.
11375 @xref{Set Operations}, for commands that interpret interval forms
11376 as subsets of the set of real numbers.
11382 The algebraic function @samp{intv(n, a, b)} builds an interval form
11383 from @samp{a} to @samp{b}; @samp{n} is an integer code which must
11384 be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
11387 Please note that in fully rigorous interval arithmetic, care would be
11388 taken to make sure that the computation of the lower bound rounds toward
11389 minus infinity, while upper bound computations round toward plus
11390 infinity. Calc's arithmetic always uses a round-to-nearest mode,
11391 which means that roundoff errors could creep into an interval
11392 calculation to produce intervals slightly smaller than they ought to
11393 be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
11394 should yield the interval @samp{[1..2]} again, but in fact it yields the
11395 (slightly too small) interval @samp{[1..1.9999999]} due to roundoff
11398 @node Incomplete Objects, Variables, Interval Forms, Data Types
11399 @section Incomplete Objects
11419 @cindex Incomplete vectors
11420 @cindex Incomplete complex numbers
11421 @cindex Incomplete interval forms
11422 When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
11423 vector, respectively, the effect is to push an @dfn{incomplete} complex
11424 number or vector onto the stack. The @kbd{,} key adds the value(s) at
11425 the top of the stack onto the current incomplete object. The @kbd{)}
11426 and @kbd{]} keys ``close'' the incomplete object after adding any values
11427 on the top of the stack in front of the incomplete object.
11429 As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
11430 pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )}
11431 pushes the complex number @samp{(1, 1.414)} (approximately).
11433 If several values lie on the stack in front of the incomplete object,
11434 all are collected and appended to the object. Thus the @kbd{,} key
11435 is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people
11436 prefer the equivalent @key{SPC} key to @key{RET}.
11438 As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
11439 @kbd{,} adds a zero or duplicates the preceding value in the list being
11440 formed. Typing @key{DEL} during incomplete entry removes the last item
11444 The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
11445 numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for
11446 creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
11447 equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
11451 Incomplete entry is also used to enter intervals. For example,
11452 @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type
11453 the first period, it will be interpreted as a decimal point, but when
11454 you type a second period immediately afterward, it is re-interpreted as
11455 part of the interval symbol. Typing @kbd{..} corresponds to executing
11456 the @code{calc-dots} command.
11458 If you find incomplete entry distracting, you may wish to enter vectors
11459 and complex numbers as algebraic formulas by pressing the apostrophe key.
11461 @node Variables, Formulas, Incomplete Objects, Data Types
11465 @cindex Variables, in formulas
11466 A @dfn{variable} is somewhere between a storage register on a conventional
11467 calculator, and a variable in a programming language. (In fact, a Calc
11468 variable is really just an Emacs Lisp variable that contains a Calc number
11469 or formula.) A variable's name is normally composed of letters and digits.
11470 Calc also allows apostrophes and @code{#} signs in variable names.
11471 (The Calc variable @code{foo} corresponds to the Emacs Lisp variable
11472 @code{var-foo}, but unless you access the variable from within Emacs
11473 Lisp, you don't need to worry about it. Variable names in algebraic
11474 formulas implicitly have @samp{var-} prefixed to their names. The
11475 @samp{#} character in variable names used in algebraic formulas
11476 corresponds to a dash @samp{-} in the Lisp variable name. If the name
11477 contains any dashes, the prefix @samp{var-} is @emph{not} automatically
11478 added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both
11479 refer to the same variable.)
11481 In a command that takes a variable name, you can either type the full
11482 name of a variable, or type a single digit to use one of the special
11483 convenience variables @code{q0} through @code{q9}. For example,
11484 @kbd{3 s s 2} stores the number 3 in variable @code{q2}, and
11485 @w{@kbd{3 s s foo @key{RET}}} stores that number in variable
11488 To push a variable itself (as opposed to the variable's value) on the
11489 stack, enter its name as an algebraic expression using the apostrophe
11493 @pindex calc-evaluate
11494 @cindex Evaluation of variables in a formula
11495 @cindex Variables, evaluation
11496 @cindex Formulas, evaluation
11497 The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
11498 replacing all variables in the formula which have been given values by a
11499 @code{calc-store} or @code{calc-let} command by their stored values.
11500 Other variables are left alone. Thus a variable that has not been
11501 stored acts like an abstract variable in algebra; a variable that has
11502 been stored acts more like a register in a traditional calculator.
11503 With a positive numeric prefix argument, @kbd{=} evaluates the top
11504 @var{n} stack entries; with a negative argument, @kbd{=} evaluates
11505 the @var{n}th stack entry.
11507 @cindex @code{e} variable
11508 @cindex @code{pi} variable
11509 @cindex @code{i} variable
11510 @cindex @code{phi} variable
11511 @cindex @code{gamma} variable
11517 A few variables are called @dfn{special constants}. Their names are
11518 @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
11519 (@xref{Scientific Functions}.) When they are evaluated with @kbd{=},
11520 their values are calculated if necessary according to the current precision
11521 or complex polar mode. If you wish to use these symbols for other purposes,
11522 simply undefine or redefine them using @code{calc-store}.
11524 The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
11525 infinite or indeterminate values. It's best not to use them as
11526 regular variables, since Calc uses special algebraic rules when
11527 it manipulates them. Calc displays a warning message if you store
11528 a value into any of these special variables.
11530 @xref{Store and Recall}, for a discussion of commands dealing with variables.
11532 @node Formulas, , Variables, Data Types
11537 @cindex Expressions
11538 @cindex Operators in formulas
11539 @cindex Precedence of operators
11540 When you press the apostrophe key you may enter any expression or formula
11541 in algebraic form. (Calc uses the terms ``expression'' and ``formula''
11542 interchangeably.) An expression is built up of numbers, variable names,
11543 and function calls, combined with various arithmetic operators.
11545 be used to indicate grouping. Spaces are ignored within formulas, except
11546 that spaces are not permitted within variable names or numbers.
11547 Arithmetic operators, in order from highest to lowest precedence, and
11548 with their equivalent function names, are:
11550 @samp{_} [@code{subscr}] (subscripts);
11552 postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
11554 prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x})
11555 and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
11557 @samp{+/-} [@code{sdev}] (the standard deviation symbol) and
11558 @samp{mod} [@code{makemod}] (the symbol for modulo forms);
11560 postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
11561 and postfix @samp{!!} [@code{dfact}] (double factorial);
11563 @samp{^} [@code{pow}] (raised-to-the-power-of);
11565 @samp{*} [@code{mul}];
11567 @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
11568 @samp{\} [@code{idiv}] (integer division);
11570 infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
11572 @samp{|} [@code{vconcat}] (vector concatenation);
11574 relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
11575 @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
11577 @samp{&&} [@code{land}] (logical ``and'');
11579 @samp{||} [@code{lor}] (logical ``or'');
11581 the C-style ``if'' operator @samp{a?b:c} [@code{if}];
11583 @samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
11585 @samp{&&&} [@code{pand}] (rewrite pattern ``and'');
11587 @samp{|||} [@code{por}] (rewrite pattern ``or'');
11589 @samp{:=} [@code{assign}] (for assignments and rewrite rules);
11591 @samp{::} [@code{condition}] (rewrite pattern condition);
11593 @samp{=>} [@code{evalto}].
11595 Note that, unlike in usual computer notation, multiplication binds more
11596 strongly than division: @samp{a*b/c*d} is equivalent to
11597 @texline @math{a b \over c d}.
11598 @infoline @expr{(a*b)/(c*d)}.
11600 @cindex Multiplication, implicit
11601 @cindex Implicit multiplication
11602 The multiplication sign @samp{*} may be omitted in many cases. In particular,
11603 if the righthand side is a number, variable name, or parenthesized
11604 expression, the @samp{*} may be omitted. Implicit multiplication has the
11605 same precedence as the explicit @samp{*} operator. The one exception to
11606 the rule is that a variable name followed by a parenthesized expression,
11608 is interpreted as a function call, not an implicit @samp{*}. In many
11609 cases you must use a space if you omit the @samp{*}: @samp{2a} is the
11610 same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
11611 is a variable called @code{ab}, @emph{not} the product of @samp{a} and
11612 @samp{b}! Also note that @samp{f (x)} is still a function call.
11614 @cindex Implicit comma in vectors
11615 The rules are slightly different for vectors written with square brackets.
11616 In vectors, the space character is interpreted (like the comma) as a
11617 separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is
11618 equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
11619 to @samp{2*a*b + c*d}.
11620 Note that spaces around the brackets, and around explicit commas, are
11621 ignored. To force spaces to be interpreted as multiplication you can
11622 enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
11623 interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted
11624 between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.
11626 Vectors that contain commas (not embedded within nested parentheses or
11627 brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector
11628 of two elements. Also, if it would be an error to treat spaces as
11629 separators, but not otherwise, then Calc will ignore spaces:
11630 @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
11631 a vector of two elements. Finally, vectors entered with curly braces
11632 instead of square brackets do not give spaces any special treatment.
11633 When Calc displays a vector that does not contain any commas, it will
11634 insert parentheses if necessary to make the meaning clear:
11635 @w{@samp{[(a b)]}}.
11637 The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
11638 or five modulo minus-two? Calc always interprets the leftmost symbol as
11639 an infix operator preferentially (modulo, in this case), so you would
11640 need to write @samp{(5%)-2} to get the former interpretation.
11642 @cindex Function call notation
11643 A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function
11644 @code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo},
11645 but unless you access the function from within Emacs Lisp, you don't
11646 need to worry about it.) Most mathematical Calculator commands like
11647 @code{calc-sin} have function equivalents like @code{sin}.
11648 If no Lisp function is defined for a function called by a formula, the
11649 call is left as it is during algebraic manipulation: @samp{f(x+y)} is
11650 left alone. Beware that many innocent-looking short names like @code{in}
11651 and @code{re} have predefined meanings which could surprise you; however,
11652 single letters or single letters followed by digits are always safe to
11653 use for your own function names. @xref{Function Index}.
11655 In the documentation for particular commands, the notation @kbd{H S}
11656 (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
11657 command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
11658 represent the same operation.
11660 Commands that interpret (``parse'') text as algebraic formulas include
11661 algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
11662 the contents of the editing buffer when you finish, the @kbd{C-x * g}
11663 and @w{@kbd{C-x * r}} commands, the @kbd{C-y} command, the X window system
11664 ``paste'' mouse operation, and Embedded mode. All of these operations
11665 use the same rules for parsing formulas; in particular, language modes
11666 (@pxref{Language Modes}) affect them all in the same way.
11668 When you read a large amount of text into the Calculator (say a vector
11669 which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
11670 you may wish to include comments in the text. Calc's formula parser
11671 ignores the symbol @samp{%%} and anything following it on a line:
11674 [ a + b, %% the sum of "a" and "b"
11676 %% last line is coming up:
11681 This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
11683 @xref{Syntax Tables}, for a way to create your own operators and other
11684 input notations. @xref{Compositions}, for a way to create new display
11687 @xref{Algebra}, for commands for manipulating formulas symbolically.
11689 @node Stack and Trail, Mode Settings, Data Types, Top
11690 @chapter Stack and Trail Commands
11693 This chapter describes the Calc commands for manipulating objects on the
11694 stack and in the trail buffer. (These commands operate on objects of any
11695 type, such as numbers, vectors, formulas, and incomplete objects.)
11698 * Stack Manipulation::
11699 * Editing Stack Entries::
11704 @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
11705 @section Stack Manipulation Commands
11711 @cindex Duplicating stack entries
11712 To duplicate the top object on the stack, press @key{RET} or @key{SPC}
11713 (two equivalent keys for the @code{calc-enter} command).
11714 Given a positive numeric prefix argument, these commands duplicate
11715 several elements at the top of the stack.
11716 Given a negative argument,
11717 these commands duplicate the specified element of the stack.
11718 Given an argument of zero, they duplicate the entire stack.
11719 For example, with @samp{10 20 30} on the stack,
11720 @key{RET} creates @samp{10 20 30 30},
11721 @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
11722 @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
11723 @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.
11727 The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
11728 have it, else on @kbd{C-j}) is like @code{calc-enter}
11729 except that the sign of the numeric prefix argument is interpreted
11730 oppositely. Also, with no prefix argument the default argument is 2.
11731 Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
11732 are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
11733 @samp{10 20 30 20}.
11738 @cindex Removing stack entries
11739 @cindex Deleting stack entries
11740 To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
11741 The @kbd{C-d} key is a synonym for @key{DEL}.
11742 (If the top element is an incomplete object with at least one element, the
11743 last element is removed from it.) Given a positive numeric prefix argument,
11744 several elements are removed. Given a negative argument, the specified
11745 element of the stack is deleted. Given an argument of zero, the entire
11747 For example, with @samp{10 20 30} on the stack,
11748 @key{DEL} leaves @samp{10 20},
11749 @kbd{C-u 2 @key{DEL}} leaves @samp{10},
11750 @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
11751 @kbd{C-u 0 @key{DEL}} leaves an empty stack.
11753 @kindex M-@key{DEL}
11754 @pindex calc-pop-above
11755 The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
11756 @key{LFD} is to @key{RET}: It interprets the sign of the numeric
11757 prefix argument in the opposite way, and the default argument is 2.
11758 Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
11759 leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
11760 the third stack element.
11763 @pindex calc-roll-down
11764 To exchange the top two elements of the stack, press @key{TAB}
11765 (@code{calc-roll-down}). Given a positive numeric prefix argument, the
11766 specified number of elements at the top of the stack are rotated downward.
11767 Given a negative argument, the entire stack is rotated downward the specified
11768 number of times. Given an argument of zero, the entire stack is reversed
11770 For example, with @samp{10 20 30 40 50} on the stack,
11771 @key{TAB} creates @samp{10 20 30 50 40},
11772 @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
11773 @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
11774 @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.
11776 @kindex M-@key{TAB}
11777 @pindex calc-roll-up
11778 The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
11779 except that it rotates upward instead of downward. Also, the default
11780 with no prefix argument is to rotate the top 3 elements.
11781 For example, with @samp{10 20 30 40 50} on the stack,
11782 @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
11783 @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
11784 @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
11785 @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.
11787 A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
11788 terms of moving a particular element to a new position in the stack.
11789 With a positive argument @var{n}, @key{TAB} moves the top stack
11790 element down to level @var{n}, making room for it by pulling all the
11791 intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the
11792 element at level @var{n} up to the top. (Compare with @key{LFD},
11793 which copies instead of moving the element in level @var{n}.)
11795 With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack
11796 to move the object in level @var{n} to the deepest place in the
11797 stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}}
11798 rotates the deepest stack element to be in level @mathit{n}, also
11799 putting the top stack element in level @mathit{@var{n}+1}.
11801 @xref{Selecting Subformulas}, for a way to apply these commands to
11802 any portion of a vector or formula on the stack.
11804 @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
11805 @section Editing Stack Entries
11810 @pindex calc-edit-finish
11811 @cindex Editing the stack with Emacs
11812 The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary
11813 buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using
11814 regular Emacs commands. With a numeric prefix argument, it edits the
11815 specified number of stack entries at once. (An argument of zero edits
11816 the entire stack; a negative argument edits one specific stack entry.)
11818 When you are done editing, press @kbd{C-c C-c} to finish and return
11819 to Calc. The @key{RET} and @key{LFD} keys also work to finish most
11820 sorts of editing, though in some cases Calc leaves @key{RET} with its
11821 usual meaning (``insert a newline'') if it's a situation where you
11822 might want to insert new lines into the editing buffer.
11824 When you finish editing, the Calculator parses the lines of text in
11825 the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
11826 original stack elements in the original buffer with these new values,
11827 then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer
11828 continues to exist during editing, but for best results you should be
11829 careful not to change it until you have finished the edit. You can
11830 also cancel the edit by killing the buffer with @kbd{C-x k}.
11832 The formula is normally reevaluated as it is put onto the stack.
11833 For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
11834 @kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to
11835 finish, Calc will put the result on the stack without evaluating it.
11837 If you give a prefix argument to @kbd{C-c C-c},
11838 Calc will not kill the @samp{*Calc Edit*} buffer. You can switch
11839 back to that buffer and continue editing if you wish. However, you
11840 should understand that if you initiated the edit with @kbd{`}, the
11841 @kbd{C-c C-c} operation will be programmed to replace the top of the
11842 stack with the new edited value, and it will do this even if you have
11843 rearranged the stack in the meanwhile. This is not so much of a problem
11844 with other editing commands, though, such as @kbd{s e}
11845 (@code{calc-edit-variable}; @pxref{Operations on Variables}).
11847 If the @code{calc-edit} command involves more than one stack entry,
11848 each line of the @samp{*Calc Edit*} buffer is interpreted as a
11849 separate formula. Otherwise, the entire buffer is interpreted as
11850 one formula, with line breaks ignored. (You can use @kbd{C-o} or
11851 @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
11853 The @kbd{`} key also works during numeric or algebraic entry. The
11854 text entered so far is moved to the @code{*Calc Edit*} buffer for
11855 more extensive editing than is convenient in the minibuffer.
11857 @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
11858 @section Trail Commands
11861 @cindex Trail buffer
11862 The commands for manipulating the Calc Trail buffer are two-key sequences
11863 beginning with the @kbd{t} prefix.
11866 @pindex calc-trail-display
11867 The @kbd{t d} (@code{calc-trail-display}) command turns display of the
11868 trail on and off. Normally the trail display is toggled on if it was off,
11869 off if it was on. With a numeric prefix of zero, this command always
11870 turns the trail off; with a prefix of one, it always turns the trail on.
11871 The other trail-manipulation commands described here automatically turn
11872 the trail on. Note that when the trail is off values are still recorded
11873 there; they are simply not displayed. To set Emacs to turn the trail
11874 off by default, type @kbd{t d} and then save the mode settings with
11875 @kbd{m m} (@code{calc-save-modes}).
11878 @pindex calc-trail-in
11880 @pindex calc-trail-out
11881 The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
11882 (@code{calc-trail-out}) commands switch the cursor into and out of the
11883 Calc Trail window. In practice they are rarely used, since the commands
11884 shown below are a more convenient way to move around in the
11885 trail, and they work ``by remote control'' when the cursor is still
11886 in the Calculator window.
11888 @cindex Trail pointer
11889 There is a @dfn{trail pointer} which selects some entry of the trail at
11890 any given time. The trail pointer looks like a @samp{>} symbol right
11891 before the selected number. The following commands operate on the
11892 trail pointer in various ways.
11895 @pindex calc-trail-yank
11896 @cindex Retrieving previous results
11897 The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
11898 the trail and pushes it onto the Calculator stack. It allows you to
11899 re-use any previously computed value without retyping. With a numeric
11900 prefix argument @var{n}, it yanks the value @var{n} lines above the current
11904 @pindex calc-trail-scroll-left
11906 @pindex calc-trail-scroll-right
11907 The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
11908 (@code{calc-trail-scroll-right}) commands horizontally scroll the trail
11909 window left or right by one half of its width.
11912 @pindex calc-trail-next
11914 @pindex calc-trail-previous
11916 @pindex calc-trail-forward
11918 @pindex calc-trail-backward
11919 The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
11920 (@code{calc-trail-previous)} commands move the trail pointer down or up
11921 one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
11922 (@code{calc-trail-backward}) commands move the trail pointer down or up
11923 one screenful at a time. All of these commands accept numeric prefix
11924 arguments to move several lines or screenfuls at a time.
11927 @pindex calc-trail-first
11929 @pindex calc-trail-last
11931 @pindex calc-trail-here
11932 The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
11933 (@code{calc-trail-last}) commands move the trail pointer to the first or
11934 last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command
11935 moves the trail pointer to the cursor position; unlike the other trail
11936 commands, @kbd{t h} works only when Calc Trail is the selected window.
11939 @pindex calc-trail-isearch-forward
11941 @pindex calc-trail-isearch-backward
11943 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
11944 (@code{calc-trail-isearch-backward}) commands perform an incremental
11945 search forward or backward through the trail. You can press @key{RET}
11946 to terminate the search; the trail pointer moves to the current line.
11947 If you cancel the search with @kbd{C-g}, the trail pointer stays where
11948 it was when the search began.
11951 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
11952 (@code{calc-trail-isearch-backward}) com\-mands perform an incremental
11953 search forward or backward through the trail. You can press @key{RET}
11954 to terminate the search; the trail pointer moves to the current line.
11955 If you cancel the search with @kbd{C-g}, the trail pointer stays where
11956 it was when the search began.
11960 @pindex calc-trail-marker
11961 The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
11962 line of text of your own choosing into the trail. The text is inserted
11963 after the line containing the trail pointer; this usually means it is
11964 added to the end of the trail. Trail markers are useful mainly as the
11965 targets for later incremental searches in the trail.
11968 @pindex calc-trail-kill
11969 The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
11970 from the trail. The line is saved in the Emacs kill ring suitable for
11971 yanking into another buffer, but it is not easy to yank the text back
11972 into the trail buffer. With a numeric prefix argument, this command
11973 kills the @var{n} lines below or above the selected one.
11975 The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
11976 elsewhere; @pxref{Vector and Matrix Formats}.
11978 @node Keep Arguments, , Trail Commands, Stack and Trail
11979 @section Keep Arguments
11983 @pindex calc-keep-args
11984 The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
11985 the following command. It prevents that command from removing its
11986 arguments from the stack. For example, after @kbd{2 @key{RET} 3 +},
11987 the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
11988 the stack contains the arguments and the result: @samp{2 3 5}.
11990 With the exception of keyboard macros, this works for all commands that
11991 take arguments off the stack. (To avoid potentially unpleasant behavior,
11992 a @kbd{K} prefix before a keyboard macro will be ignored. A @kbd{K}
11993 prefix called @emph{within} the keyboard macro will still take effect.)
11994 As another example, @kbd{K a s} simplifies a formula, pushing the
11995 simplified version of the formula onto the stack after the original
11996 formula (rather than replacing the original formula). Note that you
11997 could get the same effect by typing @kbd{@key{RET} a s}, copying the
11998 formula and then simplifying the copy. One difference is that for a very
11999 large formula the time taken to format the intermediate copy in
12000 @kbd{@key{RET} a s} could be noticeable; @kbd{K a s} would avoid this
12003 Even stack manipulation commands are affected. @key{TAB} works by
12004 popping two values and pushing them back in the opposite order,
12005 so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
12007 A few Calc commands provide other ways of doing the same thing.
12008 For example, @kbd{' sin($)} replaces the number on the stack with
12009 its sine using algebraic entry; to push the sine and keep the
12010 original argument you could use either @kbd{' sin($1)} or
12011 @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s}
12012 command is effectively the same as @kbd{K s t}. @xref{Storing Variables}.
12014 If you execute a command and then decide you really wanted to keep
12015 the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
12016 This command pushes the last arguments that were popped by any command
12017 onto the stack. Note that the order of things on the stack will be
12018 different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
12019 @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}.
12021 @node Mode Settings, Arithmetic, Stack and Trail, Top
12022 @chapter Mode Settings
12025 This chapter describes commands that set modes in the Calculator.
12026 They do not affect the contents of the stack, although they may change
12027 the @emph{appearance} or @emph{interpretation} of the stack's contents.
12030 * General Mode Commands::
12032 * Inverse and Hyperbolic::
12033 * Calculation Modes::
12034 * Simplification Modes::
12042 @node General Mode Commands, Precision, Mode Settings, Mode Settings
12043 @section General Mode Commands
12047 @pindex calc-save-modes
12048 @cindex Continuous memory
12049 @cindex Saving mode settings
12050 @cindex Permanent mode settings
12051 @cindex Calc init file, mode settings
12052 You can save all of the current mode settings in your Calc init file
12053 (the file given by the variable @code{calc-settings-file}, typically
12054 @file{~/.calc.el}) with the @kbd{m m} (@code{calc-save-modes}) command.
12055 This will cause Emacs to reestablish these modes each time it starts up.
12056 The modes saved in the file include everything controlled by the @kbd{m}
12057 and @kbd{d} prefix keys, the current precision and binary word size,
12058 whether or not the trail is displayed, the current height of the Calc
12059 window, and more. The current interface (used when you type @kbd{C-x * *})
12060 is also saved. If there were already saved mode settings in the
12061 file, they are replaced. Otherwise, the new mode information is
12062 appended to the end of the file.
12065 @pindex calc-mode-record-mode
12066 The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
12067 record all the mode settings (as if by pressing @kbd{m m}) every
12068 time a mode setting changes. If the modes are saved this way, then this
12069 ``automatic mode recording'' mode is also saved.
12070 Type @kbd{m R} again to disable this method of recording the mode
12071 settings. To turn it off permanently, the @kbd{m m} command will also be
12072 necessary. (If Embedded mode is enabled, other options for recording
12073 the modes are available; @pxref{Mode Settings in Embedded Mode}.)
12076 @pindex calc-settings-file-name
12077 The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
12078 choose a different file than the current value of @code{calc-settings-file}
12079 for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information.
12080 You are prompted for a file name. All Calc modes are then reset to
12081 their default values, then settings from the file you named are loaded
12082 if this file exists, and this file becomes the one that Calc will
12083 use in the future for commands like @kbd{m m}. The default settings
12084 file name is @file{~/.calc.el}. You can see the current file name by
12085 giving a blank response to the @kbd{m F} prompt. See also the
12086 discussion of the @code{calc-settings-file} variable; @pxref{Customizing Calc}.
12088 If the file name you give is your user init file (typically
12089 @file{~/.emacs}), @kbd{m F} will not automatically load the new file. This
12090 is because your user init file may contain other things you don't want
12091 to reread. You can give
12092 a numeric prefix argument of 1 to @kbd{m F} to force it to read the
12093 file no matter what. Conversely, an argument of @mathit{-1} tells
12094 @kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2}
12095 tells @kbd{m F} not to reset the modes to their defaults beforehand,
12096 which is useful if you intend your new file to have a variant of the
12097 modes present in the file you were using before.
12100 @pindex calc-always-load-extensions
12101 The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
12102 in which the first use of Calc loads the entire program, including all
12103 extensions modules. Otherwise, the extensions modules will not be loaded
12104 until the various advanced Calc features are used. Since this mode only
12105 has effect when Calc is first loaded, @kbd{m x} is usually followed by
12106 @kbd{m m} to make the mode-setting permanent. To load all of Calc just
12107 once, rather than always in the future, you can press @kbd{C-x * L}.
12110 @pindex calc-shift-prefix
12111 The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
12112 all of Calc's letter prefix keys may be typed shifted as well as unshifted.
12113 If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
12114 you might find it easier to turn this mode on so that you can type
12115 @kbd{A S} instead. When this mode is enabled, the commands that used to
12116 be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
12117 now be invoked by pressing the shifted letter twice: @kbd{A A}. Note
12118 that the @kbd{v} prefix key always works both shifted and unshifted, and
12119 the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h}
12120 prefix is not affected by this mode. Press @kbd{m S} again to disable
12121 shifted-prefix mode.
12123 @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
12128 @pindex calc-precision
12129 @cindex Precision of calculations
12130 The @kbd{p} (@code{calc-precision}) command controls the precision to
12131 which floating-point calculations are carried. The precision must be
12132 at least 3 digits and may be arbitrarily high, within the limits of
12133 memory and time. This affects only floats: Integer and rational
12134 calculations are always carried out with as many digits as necessary.
12136 The @kbd{p} key prompts for the current precision. If you wish you
12137 can instead give the precision as a numeric prefix argument.
12139 Many internal calculations are carried to one or two digits higher
12140 precision than normal. Results are rounded down afterward to the
12141 current precision. Unless a special display mode has been selected,
12142 floats are always displayed with their full stored precision, i.e.,
12143 what you see is what you get. Reducing the current precision does not
12144 round values already on the stack, but those values will be rounded
12145 down before being used in any calculation. The @kbd{c 0} through
12146 @kbd{c 9} commands (@pxref{Conversions}) can be used to round an
12147 existing value to a new precision.
12149 @cindex Accuracy of calculations
12150 It is important to distinguish the concepts of @dfn{precision} and
12151 @dfn{accuracy}. In the normal usage of these words, the number
12152 123.4567 has a precision of 7 digits but an accuracy of 4 digits.
12153 The precision is the total number of digits not counting leading
12154 or trailing zeros (regardless of the position of the decimal point).
12155 The accuracy is simply the number of digits after the decimal point
12156 (again not counting trailing zeros). In Calc you control the precision,
12157 not the accuracy of computations. If you were to set the accuracy
12158 instead, then calculations like @samp{exp(100)} would generate many
12159 more digits than you would typically need, while @samp{exp(-100)} would
12160 probably round to zero! In Calc, both these computations give you
12161 exactly 12 (or the requested number of) significant digits.
12163 The only Calc features that deal with accuracy instead of precision
12164 are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
12165 and the rounding functions like @code{floor} and @code{round}
12166 (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9}
12167 deal with both precision and accuracy depending on the magnitudes
12168 of the numbers involved.
12170 If you need to work with a particular fixed accuracy (say, dollars and
12171 cents with two digits after the decimal point), one solution is to work
12172 with integers and an ``implied'' decimal point. For example, $8.99
12173 divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
12174 (actually $1.49833 with our implied decimal point); pressing @kbd{R}
12175 would round this to 150 cents, i.e., $1.50.
12177 @xref{Floats}, for still more on floating-point precision and related
12180 @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
12181 @section Inverse and Hyperbolic Flags
12185 @pindex calc-inverse
12186 There is no single-key equivalent to the @code{calc-arcsin} function.
12187 Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
12188 the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
12189 The @kbd{I} key actually toggles the Inverse Flag. When this flag
12190 is set, the word @samp{Inv} appears in the mode line.
12193 @pindex calc-hyperbolic
12194 Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
12195 Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
12196 If both of these flags are set at once, the effect will be
12197 @code{calc-arcsinh}. (The Hyperbolic flag is also used by some
12198 non-trigonometric commands; for example @kbd{H L} computes a base-10,
12199 instead of base-@mathit{e}, logarithm.)
12201 Command names like @code{calc-arcsin} are provided for completeness, and
12202 may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to
12203 toggle the Inverse and/or Hyperbolic flags and then execute the
12204 corresponding base command (@code{calc-sin} in this case).
12206 The Inverse and Hyperbolic flags apply only to the next Calculator
12207 command, after which they are automatically cleared. (They are also
12208 cleared if the next keystroke is not a Calc command.) Digits you
12209 type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix
12210 arguments for the next command, not as numeric entries. The same
12211 is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to
12212 subtract and keep arguments).
12214 The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed
12215 elsewhere. @xref{Keep Arguments}.
12217 @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
12218 @section Calculation Modes
12221 The commands in this section are two-key sequences beginning with
12222 the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.)
12223 The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
12224 (@pxref{Algebraic Entry}).
12233 * Automatic Recomputation::
12234 * Working Message::
12237 @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
12238 @subsection Angular Modes
12241 @cindex Angular mode
12242 The Calculator supports three notations for angles: radians, degrees,
12243 and degrees-minutes-seconds. When a number is presented to a function
12244 like @code{sin} that requires an angle, the current angular mode is
12245 used to interpret the number as either radians or degrees. If an HMS
12246 form is presented to @code{sin}, it is always interpreted as
12247 degrees-minutes-seconds.
12249 Functions that compute angles produce a number in radians, a number in
12250 degrees, or an HMS form depending on the current angular mode. If the
12251 result is a complex number and the current mode is HMS, the number is
12252 instead expressed in degrees. (Complex-number calculations would
12253 normally be done in Radians mode, though. Complex numbers are converted
12254 to degrees by calculating the complex result in radians and then
12255 multiplying by 180 over @cpi{}.)
12258 @pindex calc-radians-mode
12260 @pindex calc-degrees-mode
12262 @pindex calc-hms-mode
12263 The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
12264 and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
12265 The current angular mode is displayed on the Emacs mode line.
12266 The default angular mode is Degrees.
12268 @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
12269 @subsection Polar Mode
12273 The Calculator normally ``prefers'' rectangular complex numbers in the
12274 sense that rectangular form is used when the proper form can not be
12275 decided from the input. This might happen by multiplying a rectangular
12276 number by a polar one, by taking the square root of a negative real
12277 number, or by entering @kbd{( 2 @key{SPC} 3 )}.
12280 @pindex calc-polar-mode
12281 The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
12282 preference between rectangular and polar forms. In Polar mode, all
12283 of the above example situations would produce polar complex numbers.
12285 @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
12286 @subsection Fraction Mode
12289 @cindex Fraction mode
12290 @cindex Division of integers
12291 Division of two integers normally yields a floating-point number if the
12292 result cannot be expressed as an integer. In some cases you would
12293 rather get an exact fractional answer. One way to accomplish this is
12294 to use the @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command, which
12295 divides the two integers on the top of the stack to produce a fraction:
12296 @kbd{6 @key{RET} 4 :} produces @expr{3:2} even though
12297 @kbd{6 @key{RET} 4 /} produces @expr{1.5}.
12300 @pindex calc-frac-mode
12301 To set the Calculator to produce fractional results for normal integer
12302 divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
12303 For example, @expr{8/4} produces @expr{2} in either mode,
12304 but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in
12307 At any time you can use @kbd{c f} (@code{calc-float}) to convert a
12308 fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
12309 float to a fraction. @xref{Conversions}.
12311 @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
12312 @subsection Infinite Mode
12315 @cindex Infinite mode
12316 The Calculator normally treats results like @expr{1 / 0} as errors;
12317 formulas like this are left in unsimplified form. But Calc can be
12318 put into a mode where such calculations instead produce ``infinite''
12322 @pindex calc-infinite-mode
12323 The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
12324 on and off. When the mode is off, infinities do not arise except
12325 in calculations that already had infinities as inputs. (One exception
12326 is that infinite open intervals like @samp{[0 .. inf)} can be
12327 generated; however, intervals closed at infinity (@samp{[0 .. inf]})
12328 will not be generated when Infinite mode is off.)
12330 With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
12331 an undirected infinity. @xref{Infinities}, for a discussion of the
12332 difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0}
12333 evaluates to @code{nan}, the ``indeterminate'' symbol. Various other
12334 functions can also return infinities in this mode; for example,
12335 @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again,
12336 note that @samp{exp(inf) = inf} regardless of Infinite mode because
12337 this calculation has infinity as an input.
12339 @cindex Positive Infinite mode
12340 The @kbd{m i} command with a numeric prefix argument of zero,
12341 i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in
12342 which zero is treated as positive instead of being directionless.
12343 Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
12344 Note that zero never actually has a sign in Calc; there are no
12345 separate representations for @mathit{+0} and @mathit{-0}. Positive
12346 Infinite mode merely changes the interpretation given to the
12347 single symbol, @samp{0}. One consequence of this is that, while
12348 you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
12349 is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
12351 @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
12352 @subsection Symbolic Mode
12355 @cindex Symbolic mode
12356 @cindex Inexact results
12357 Calculations are normally performed numerically wherever possible.
12358 For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
12359 algebraic expression, produces a numeric answer if the argument is a
12360 number or a symbolic expression if the argument is an expression:
12361 @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
12364 @pindex calc-symbolic-mode
12365 In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
12366 command, functions which would produce inexact, irrational results are
12367 left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
12371 @pindex calc-eval-num
12372 The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
12373 the expression at the top of the stack, by temporarily disabling
12374 @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
12375 Given a numeric prefix argument, it also
12376 sets the floating-point precision to the specified value for the duration
12379 To evaluate a formula numerically without expanding the variables it
12380 contains, you can use the key sequence @kbd{m s a v m s} (this uses
12381 @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
12384 @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
12385 @subsection Matrix and Scalar Modes
12388 @cindex Matrix mode
12389 @cindex Scalar mode
12390 Calc sometimes makes assumptions during algebraic manipulation that
12391 are awkward or incorrect when vectors and matrices are involved.
12392 Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which
12393 modify its behavior around vectors in useful ways.
12396 @pindex calc-matrix-mode
12397 Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode.
12398 In this mode, all objects are assumed to be matrices unless provably
12399 otherwise. One major effect is that Calc will no longer consider
12400 multiplication to be commutative. (Recall that in matrix arithmetic,
12401 @samp{A*B} is not the same as @samp{B*A}.) This assumption affects
12402 rewrite rules and algebraic simplification. Another effect of this
12403 mode is that calculations that would normally produce constants like
12404 0 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now
12405 produce function calls that represent ``generic'' zero or identity
12406 matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function
12407 @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
12408 identity matrix; if @var{n} is omitted, it doesn't know what
12409 dimension to use and so the @code{idn} call remains in symbolic
12410 form. However, if this generic identity matrix is later combined
12411 with a matrix whose size is known, it will be converted into
12412 a true identity matrix of the appropriate size. On the other hand,
12413 if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
12414 will assume it really was a scalar after all and produce, e.g., 3.
12416 Press @kbd{m v} a second time to get Scalar mode. Here, objects are
12417 assumed @emph{not} to be vectors or matrices unless provably so.
12418 For example, normally adding a variable to a vector, as in
12419 @samp{[x, y, z] + a}, will leave the sum in symbolic form because
12420 as far as Calc knows, @samp{a} could represent either a number or
12421 another 3-vector. In Scalar mode, @samp{a} is assumed to be a
12422 non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
12424 Press @kbd{m v} a third time to return to the normal mode of operation.
12426 If you press @kbd{m v} with a numeric prefix argument @var{n}, you
12427 get a special ``dimensioned'' Matrix mode in which matrices of
12428 unknown size are assumed to be @var{n}x@var{n} square matrices.
12429 Then, the function call @samp{idn(1)} will expand into an actual
12430 matrix rather than representing a ``generic'' matrix. Simply typing
12431 @kbd{C-u m v} will get you a square Matrix mode, in which matrices of
12432 unknown size are assumed to be square matrices of unspecified size.
12434 @cindex Declaring scalar variables
12435 Of course these modes are approximations to the true state of
12436 affairs, which is probably that some quantities will be matrices
12437 and others will be scalars. One solution is to ``declare''
12438 certain variables or functions to be scalar-valued.
12439 @xref{Declarations}, to see how to make declarations in Calc.
12441 There is nothing stopping you from declaring a variable to be
12442 scalar and then storing a matrix in it; however, if you do, the
12443 results you get from Calc may not be valid. Suppose you let Calc
12444 get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
12445 @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as
12446 for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
12447 your earlier promise to Calc that @samp{a} would be scalar.
12449 Another way to mix scalars and matrices is to use selections
12450 (@pxref{Selecting Subformulas}). Use Matrix mode when operating on
12451 your formula normally; then, to apply Scalar mode to a certain part
12452 of the formula without affecting the rest just select that part,
12453 change into Scalar mode and press @kbd{=} to resimplify the part
12454 under this mode, then change back to Matrix mode before deselecting.
12456 @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
12457 @subsection Automatic Recomputation
12460 The @dfn{evaluates-to} operator, @samp{=>}, has the special
12461 property that any @samp{=>} formulas on the stack are recomputed
12462 whenever variable values or mode settings that might affect them
12463 are changed. @xref{Evaluates-To Operator}.
12466 @pindex calc-auto-recompute
12467 The @kbd{m C} (@code{calc-auto-recompute}) command turns this
12468 automatic recomputation on and off. If you turn it off, Calc will
12469 not update @samp{=>} operators on the stack (nor those in the
12470 attached Embedded mode buffer, if there is one). They will not
12471 be updated unless you explicitly do so by pressing @kbd{=} or until
12472 you press @kbd{m C} to turn recomputation back on. (While automatic
12473 recomputation is off, you can think of @kbd{m C m C} as a command
12474 to update all @samp{=>} operators while leaving recomputation off.)
12476 To update @samp{=>} operators in an Embedded buffer while
12477 automatic recomputation is off, use @w{@kbd{C-x * u}}.
12478 @xref{Embedded Mode}.
12480 @node Working Message, , Automatic Recomputation, Calculation Modes
12481 @subsection Working Messages
12484 @cindex Performance
12485 @cindex Working messages
12486 Since the Calculator is written entirely in Emacs Lisp, which is not
12487 designed for heavy numerical work, many operations are quite slow.
12488 The Calculator normally displays the message @samp{Working...} in the
12489 echo area during any command that may be slow. In addition, iterative
12490 operations such as square roots and trigonometric functions display the
12491 intermediate result at each step. Both of these types of messages can
12492 be disabled if you find them distracting.
12495 @pindex calc-working
12496 Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
12497 disable all ``working'' messages. Use a numeric prefix of 1 to enable
12498 only the plain @samp{Working...} message. Use a numeric prefix of 2 to
12499 see intermediate results as well. With no numeric prefix this displays
12502 While it may seem that the ``working'' messages will slow Calc down
12503 considerably, experiments have shown that their impact is actually
12504 quite small. But if your terminal is slow you may find that it helps
12505 to turn the messages off.
12507 @node Simplification Modes, Declarations, Calculation Modes, Mode Settings
12508 @section Simplification Modes
12511 The current @dfn{simplification mode} controls how numbers and formulas
12512 are ``normalized'' when being taken from or pushed onto the stack.
12513 Some normalizations are unavoidable, such as rounding floating-point
12514 results to the current precision, and reducing fractions to simplest
12515 form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}),
12516 are done by default but can be turned off when necessary.
12518 When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the
12519 stack, Calc pops these numbers, normalizes them, creates the formula
12520 @expr{2+3}, normalizes it, and pushes the result. Of course the standard
12521 rules for normalizing @expr{2+3} will produce the result @expr{5}.
12523 Simplification mode commands consist of the lower-case @kbd{m} prefix key
12524 followed by a shifted letter.
12527 @pindex calc-no-simplify-mode
12528 The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
12529 simplifications. These would leave a formula like @expr{2+3} alone. In
12530 fact, nothing except simple numbers are ever affected by normalization
12534 @pindex calc-num-simplify-mode
12535 The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
12536 of any formulas except those for which all arguments are constants. For
12537 example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is
12538 simplified to @expr{a+0} but no further, since one argument of the sum
12539 is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified
12540 because the top-level @samp{-} operator's arguments are not both
12541 constant numbers (one of them is the formula @expr{a+2}).
12542 A constant is a number or other numeric object (such as a constant
12543 error form or modulo form), or a vector all of whose
12544 elements are constant.
12547 @pindex calc-default-simplify-mode
12548 The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
12549 default simplifications for all formulas. This includes many easy and
12550 fast algebraic simplifications such as @expr{a+0} to @expr{a}, and
12551 @expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like
12552 @expr{@tfn{deriv}(x^2, x)} to @expr{2 x}.
12555 @pindex calc-bin-simplify-mode
12556 The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
12557 simplifications to a result and then, if the result is an integer,
12558 uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
12559 to the current binary word size. @xref{Binary Functions}. Real numbers
12560 are rounded to the nearest integer and then clipped; other kinds of
12561 results (after the default simplifications) are left alone.
12564 @pindex calc-alg-simplify-mode
12565 The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
12566 simplification; it applies all the default simplifications, and also
12567 the more powerful (and slower) simplifications made by @kbd{a s}
12568 (@code{calc-simplify}). @xref{Algebraic Simplifications}.
12571 @pindex calc-ext-simplify-mode
12572 The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
12573 algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
12574 command. @xref{Unsafe Simplifications}.
12577 @pindex calc-units-simplify-mode
12578 The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
12579 simplification; it applies the command @kbd{u s}
12580 (@code{calc-simplify-units}), which in turn
12581 is a superset of @kbd{a s}. In this mode, variable names which
12582 are identifiable as unit names (like @samp{mm} for ``millimeters'')
12583 are simplified with their unit definitions in mind.
12585 A common technique is to set the simplification mode down to the lowest
12586 amount of simplification you will allow to be applied automatically, then
12587 use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
12588 perform higher types of simplifications on demand. @xref{Algebraic
12589 Definitions}, for another sample use of No-Simplification mode.
12591 @node Declarations, Display Modes, Simplification Modes, Mode Settings
12592 @section Declarations
12595 A @dfn{declaration} is a statement you make that promises you will
12596 use a certain variable or function in a restricted way. This may
12597 give Calc the freedom to do things that it couldn't do if it had to
12598 take the fully general situation into account.
12601 * Declaration Basics::
12602 * Kinds of Declarations::
12603 * Functions for Declarations::
12606 @node Declaration Basics, Kinds of Declarations, Declarations, Declarations
12607 @subsection Declaration Basics
12611 @pindex calc-declare-variable
12612 The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
12613 way to make a declaration for a variable. This command prompts for
12614 the variable name, then prompts for the declaration. The default
12615 at the declaration prompt is the previous declaration, if any.
12616 You can edit this declaration, or press @kbd{C-k} to erase it and
12617 type a new declaration. (Or, erase it and press @key{RET} to clear
12618 the declaration, effectively ``undeclaring'' the variable.)
12620 A declaration is in general a vector of @dfn{type symbols} and
12621 @dfn{range} values. If there is only one type symbol or range value,
12622 you can write it directly rather than enclosing it in a vector.
12623 For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
12624 be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
12625 declares @code{bar} to be a constant integer between 1 and 6.
12626 (Actually, you can omit the outermost brackets and Calc will
12627 provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
12629 @cindex @code{Decls} variable
12631 Declarations in Calc are kept in a special variable called @code{Decls}.
12632 This variable encodes the set of all outstanding declarations in
12633 the form of a matrix. Each row has two elements: A variable or
12634 vector of variables declared by that row, and the declaration
12635 specifier as described above. You can use the @kbd{s D} command to
12636 edit this variable if you wish to see all the declarations at once.
12637 @xref{Operations on Variables}, for a description of this command
12638 and the @kbd{s p} command that allows you to save your declarations
12639 permanently if you wish.
12641 Items being declared can also be function calls. The arguments in
12642 the call are ignored; the effect is to say that this function returns
12643 values of the declared type for any valid arguments. The @kbd{s d}
12644 command declares only variables, so if you wish to make a function
12645 declaration you will have to edit the @code{Decls} matrix yourself.
12647 For example, the declaration matrix
12653 [ f(1,2,3), [0 .. inf) ] ]
12658 declares that @code{foo} represents a real number, @code{j}, @code{k}
12659 and @code{n} represent integers, and the function @code{f} always
12660 returns a real number in the interval shown.
12663 If there is a declaration for the variable @code{All}, then that
12664 declaration applies to all variables that are not otherwise declared.
12665 It does not apply to function names. For example, using the row
12666 @samp{[All, real]} says that all your variables are real unless they
12667 are explicitly declared without @code{real} in some other row.
12668 The @kbd{s d} command declares @code{All} if you give a blank
12669 response to the variable-name prompt.
12671 @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
12672 @subsection Kinds of Declarations
12675 The type-specifier part of a declaration (that is, the second prompt
12676 in the @kbd{s d} command) can be a type symbol, an interval, or a
12677 vector consisting of zero or more type symbols followed by zero or
12678 more intervals or numbers that represent the set of possible values
12683 [ [ a, [1, 2, 3, 4, 5] ]
12685 [ c, [int, 1 .. 5] ] ]
12689 Here @code{a} is declared to contain one of the five integers shown;
12690 @code{b} is any number in the interval from 1 to 5 (any real number
12691 since we haven't specified), and @code{c} is any integer in that
12692 interval. Thus the declarations for @code{a} and @code{c} are
12693 nearly equivalent (see below).
12695 The type-specifier can be the empty vector @samp{[]} to say that
12696 nothing is known about a given variable's value. This is the same
12697 as not declaring the variable at all except that it overrides any
12698 @code{All} declaration which would otherwise apply.
12700 The initial value of @code{Decls} is the empty vector @samp{[]}.
12701 If @code{Decls} has no stored value or if the value stored in it
12702 is not valid, it is ignored and there are no declarations as far
12703 as Calc is concerned. (The @kbd{s d} command will replace such a
12704 malformed value with a fresh empty matrix, @samp{[]}, before recording
12705 the new declaration.) Unrecognized type symbols are ignored.
12707 The following type symbols describe what sorts of numbers will be
12708 stored in a variable:
12714 Numerical integers. (Integers or integer-valued floats.)
12716 Fractions. (Rational numbers which are not integers.)
12718 Rational numbers. (Either integers or fractions.)
12720 Floating-point numbers.
12722 Real numbers. (Integers, fractions, or floats. Actually,
12723 intervals and error forms with real components also count as
12726 Positive real numbers. (Strictly greater than zero.)
12728 Nonnegative real numbers. (Greater than or equal to zero.)
12730 Numbers. (Real or complex.)
12733 Calc uses this information to determine when certain simplifications
12734 of formulas are safe. For example, @samp{(x^y)^z} cannot be
12735 simplified to @samp{x^(y z)} in general; for example,
12736 @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}.
12737 However, this simplification @emph{is} safe if @code{z} is known
12738 to be an integer, or if @code{x} is known to be a nonnegative
12739 real number. If you have given declarations that allow Calc to
12740 deduce either of these facts, Calc will perform this simplification
12743 Calc can apply a certain amount of logic when using declarations.
12744 For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
12745 has been declared @code{int}; Calc knows that an integer times an
12746 integer, plus an integer, must always be an integer. (In fact,
12747 Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
12748 it is able to determine that @samp{2n+1} must be an odd integer.)
12750 Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
12751 because Calc knows that the @code{abs} function always returns a
12752 nonnegative real. If you had a @code{myabs} function that also had
12753 this property, you could get Calc to recognize it by adding the row
12754 @samp{[myabs(), nonneg]} to the @code{Decls} matrix.
12756 One instance of this simplification is @samp{sqrt(x^2)} (since the
12757 @code{sqrt} function is effectively a one-half power). Normally
12758 Calc leaves this formula alone. After the command
12759 @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
12760 @samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
12761 simplify this formula all the way to @samp{x}.
12763 If there are any intervals or real numbers in the type specifier,
12764 they comprise the set of possible values that the variable or
12765 function being declared can have. In particular, the type symbol
12766 @code{real} is effectively the same as the range @samp{[-inf .. inf]}
12767 (note that infinity is included in the range of possible values);
12768 @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
12769 the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is
12770 redundant because the fact that the variable is real can be
12771 deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
12772 @samp{[rat, [-5 .. 5]]} are useful combinations.
12774 Note that the vector of intervals or numbers is in the same format
12775 used by Calc's set-manipulation commands. @xref{Set Operations}.
12777 The type specifier @samp{[1, 2, 3]} is equivalent to
12778 @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
12779 In other words, the range of possible values means only that
12780 the variable's value must be numerically equal to a number in
12781 that range, but not that it must be equal in type as well.
12782 Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
12783 and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
12785 If you use a conflicting combination of type specifiers, the
12786 results are unpredictable. An example is @samp{[pos, [0 .. 5]]},
12787 where the interval does not lie in the range described by the
12790 ``Real'' declarations mostly affect simplifications involving powers
12791 like the one described above. Another case where they are used
12792 is in the @kbd{a P} command which returns a list of all roots of a
12793 polynomial; if the variable has been declared real, only the real
12794 roots (if any) will be included in the list.
12796 ``Integer'' declarations are used for simplifications which are valid
12797 only when certain values are integers (such as @samp{(x^y)^z}
12800 Another command that makes use of declarations is @kbd{a s}, when
12801 simplifying equations and inequalities. It will cancel @code{x}
12802 from both sides of @samp{a x = b x} only if it is sure @code{x}
12803 is non-zero, say, because it has a @code{pos} declaration.
12804 To declare specifically that @code{x} is real and non-zero,
12805 use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
12806 current notation to say that @code{x} is nonzero but not necessarily
12807 real.) The @kbd{a e} command does ``unsafe'' simplifications,
12808 including cancelling @samp{x} from the equation when @samp{x} is
12809 not known to be nonzero.
12811 Another set of type symbols distinguish between scalars and vectors.
12815 The value is not a vector.
12817 The value is a vector.
12819 The value is a matrix (a rectangular vector of vectors).
12821 The value is a square matrix.
12824 These type symbols can be combined with the other type symbols
12825 described above; @samp{[int, matrix]} describes an object which
12826 is a matrix of integers.
12828 Scalar/vector declarations are used to determine whether certain
12829 algebraic operations are safe. For example, @samp{[a, b, c] + x}
12830 is normally not simplified to @samp{[a + x, b + x, c + x]}, but
12831 it will be if @code{x} has been declared @code{scalar}. On the
12832 other hand, multiplication is usually assumed to be commutative,
12833 but the terms in @samp{x y} will never be exchanged if both @code{x}
12834 and @code{y} are known to be vectors or matrices. (Calc currently
12835 never distinguishes between @code{vector} and @code{matrix}
12838 @xref{Matrix Mode}, for a discussion of Matrix mode and
12839 Scalar mode, which are similar to declaring @samp{[All, matrix]}
12840 or @samp{[All, scalar]} but much more convenient.
12842 One more type symbol that is recognized is used with the @kbd{H a d}
12843 command for taking total derivatives of a formula. @xref{Calculus}.
12847 The value is a constant with respect to other variables.
12850 Calc does not check the declarations for a variable when you store
12851 a value in it. However, storing @mathit{-3.5} in a variable that has
12852 been declared @code{pos}, @code{int}, or @code{matrix} may have
12853 unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5}
12854 if it substitutes the value first, or to @expr{-3.5} if @code{x}
12855 was declared @code{pos} and the formula @samp{sqrt(x^2)} is
12856 simplified to @samp{x} before the value is substituted. Before
12857 using a variable for a new purpose, it is best to use @kbd{s d}
12858 or @kbd{s D} to check to make sure you don't still have an old
12859 declaration for the variable that will conflict with its new meaning.
12861 @node Functions for Declarations, , Kinds of Declarations, Declarations
12862 @subsection Functions for Declarations
12865 Calc has a set of functions for accessing the current declarations
12866 in a convenient manner. These functions return 1 if the argument
12867 can be shown to have the specified property, or 0 if the argument
12868 can be shown @emph{not} to have that property; otherwise they are
12869 left unevaluated. These functions are suitable for use with rewrite
12870 rules (@pxref{Conditional Rewrite Rules}) or programming constructs
12871 (@pxref{Conditionals in Macros}). They can be entered only using
12872 algebraic notation. @xref{Logical Operations}, for functions
12873 that perform other tests not related to declarations.
12875 For example, @samp{dint(17)} returns 1 because 17 is an integer, as
12876 do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
12877 @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
12878 Calc consults knowledge of its own built-in functions as well as your
12879 own declarations: @samp{dint(floor(x))} returns 1.
12893 The @code{dint} function checks if its argument is an integer.
12894 The @code{dnatnum} function checks if its argument is a natural
12895 number, i.e., a nonnegative integer. The @code{dnumint} function
12896 checks if its argument is numerically an integer, i.e., either an
12897 integer or an integer-valued float. Note that these and the other
12898 data type functions also accept vectors or matrices composed of
12899 suitable elements, and that real infinities @samp{inf} and @samp{-inf}
12900 are considered to be integers for the purposes of these functions.
12906 The @code{drat} function checks if its argument is rational, i.e.,
12907 an integer or fraction. Infinities count as rational, but intervals
12908 and error forms do not.
12914 The @code{dreal} function checks if its argument is real. This
12915 includes integers, fractions, floats, real error forms, and intervals.
12921 The @code{dimag} function checks if its argument is imaginary,
12922 i.e., is mathematically equal to a real number times @expr{i}.
12936 The @code{dpos} function checks for positive (but nonzero) reals.
12937 The @code{dneg} function checks for negative reals. The @code{dnonneg}
12938 function checks for nonnegative reals, i.e., reals greater than or
12939 equal to zero. Note that the @kbd{a s} command can simplify an
12940 expression like @expr{x > 0} to 1 or 0 using @code{dpos}, and that
12941 @kbd{a s} is effectively applied to all conditions in rewrite rules,
12942 so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
12943 are rarely necessary.
12949 The @code{dnonzero} function checks that its argument is nonzero.
12950 This includes all nonzero real or complex numbers, all intervals that
12951 do not include zero, all nonzero modulo forms, vectors all of whose
12952 elements are nonzero, and variables or formulas whose values can be
12953 deduced to be nonzero. It does not include error forms, since they
12954 represent values which could be anything including zero. (This is
12955 also the set of objects considered ``true'' in conditional contexts.)
12965 The @code{deven} function returns 1 if its argument is known to be
12966 an even integer (or integer-valued float); it returns 0 if its argument
12967 is known not to be even (because it is known to be odd or a non-integer).
12968 The @kbd{a s} command uses this to simplify a test of the form
12969 @samp{x % 2 = 0}. There is also an analogous @code{dodd} function.
12975 The @code{drange} function returns a set (an interval or a vector
12976 of intervals and/or numbers; @pxref{Set Operations}) that describes
12977 the set of possible values of its argument. If the argument is
12978 a variable or a function with a declaration, the range is copied
12979 from the declaration. Otherwise, the possible signs of the
12980 expression are determined using a method similar to @code{dpos},
12981 etc., and a suitable set like @samp{[0 .. inf]} is returned. If
12982 the expression is not provably real, the @code{drange} function
12983 remains unevaluated.
12989 The @code{dscalar} function returns 1 if its argument is provably
12990 scalar, or 0 if its argument is provably non-scalar. It is left
12991 unevaluated if this cannot be determined. (If Matrix mode or Scalar
12992 mode is in effect, this function returns 1 or 0, respectively,
12993 if it has no other information.) When Calc interprets a condition
12994 (say, in a rewrite rule) it considers an unevaluated formula to be
12995 ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
12996 provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
12997 is provably non-scalar; both are ``false'' if there is insufficient
12998 information to tell.
13000 @node Display Modes, Language Modes, Declarations, Mode Settings
13001 @section Display Modes
13004 The commands in this section are two-key sequences beginning with the
13005 @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
13006 (@code{calc-line-breaking}) commands are described elsewhere;
13007 @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
13008 Display formats for vectors and matrices are also covered elsewhere;
13009 @pxref{Vector and Matrix Formats}.
13011 One thing all display modes have in common is their treatment of the
13012 @kbd{H} prefix. This prefix causes any mode command that would normally
13013 refresh the stack to leave the stack display alone. The word ``Dirty''
13014 will appear in the mode line when Calc thinks the stack display may not
13015 reflect the latest mode settings.
13017 @kindex d @key{RET}
13018 @pindex calc-refresh-top
13019 The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
13020 top stack entry according to all the current modes. Positive prefix
13021 arguments reformat the top @var{n} entries; negative prefix arguments
13022 reformat the specified entry, and a prefix of zero is equivalent to
13023 @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
13024 For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
13025 but reformats only the top two stack entries in the new mode.
13027 The @kbd{I} prefix has another effect on the display modes. The mode
13028 is set only temporarily; the top stack entry is reformatted according
13029 to that mode, then the original mode setting is restored. In other
13030 words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
13034 * Grouping Digits::
13036 * Complex Formats::
13037 * Fraction Formats::
13040 * Truncating the Stack::
13045 @node Radix Modes, Grouping Digits, Display Modes, Display Modes
13046 @subsection Radix Modes
13049 @cindex Radix display
13050 @cindex Non-decimal numbers
13051 @cindex Decimal and non-decimal numbers
13052 Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
13053 notation. Calc can actually display in any radix from two (binary) to 36.
13054 When the radix is above 10, the letters @code{A} to @code{Z} are used as
13055 digits. When entering such a number, letter keys are interpreted as
13056 potential digits rather than terminating numeric entry mode.
13062 @cindex Hexadecimal integers
13063 @cindex Octal integers
13064 The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
13065 binary, octal, hexadecimal, and decimal as the current display radix,
13066 respectively. Numbers can always be entered in any radix, though the
13067 current radix is used as a default if you press @kbd{#} without any initial
13068 digits. A number entered without a @kbd{#} is @emph{always} interpreted
13073 To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
13074 an integer from 2 to 36. You can specify the radix as a numeric prefix
13075 argument; otherwise you will be prompted for it.
13078 @pindex calc-leading-zeros
13079 @cindex Leading zeros
13080 Integers normally are displayed with however many digits are necessary to
13081 represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros})
13082 command causes integers to be padded out with leading zeros according to the
13083 current binary word size. (@xref{Binary Functions}, for a discussion of
13084 word size.) If the absolute value of the word size is @expr{w}, all integers
13085 are displayed with at least enough digits to represent
13086 @texline @math{2^w-1}
13087 @infoline @expr{(2^w)-1}
13088 in the current radix. (Larger integers will still be displayed in their
13091 @node Grouping Digits, Float Formats, Radix Modes, Display Modes
13092 @subsection Grouping Digits
13096 @pindex calc-group-digits
13097 @cindex Grouping digits
13098 @cindex Digit grouping
13099 Long numbers can be hard to read if they have too many digits. For
13100 example, the factorial of 30 is 33 digits long! Press @kbd{d g}
13101 (@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits
13102 are displayed in clumps of 3 or 4 (depending on the current radix)
13103 separated by commas.
13105 The @kbd{d g} command toggles grouping on and off.
13106 With a numeric prefix of 0, this command displays the current state of
13107 the grouping flag; with an argument of minus one it disables grouping;
13108 with a positive argument @expr{N} it enables grouping on every @expr{N}
13109 digits. For floating-point numbers, grouping normally occurs only
13110 before the decimal point. A negative prefix argument @expr{-N} enables
13111 grouping every @expr{N} digits both before and after the decimal point.
13114 @pindex calc-group-char
13115 The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
13116 character as the grouping separator. The default is the comma character.
13117 If you find it difficult to read vectors of large integers grouped with
13118 commas, you may wish to use spaces or some other character instead.
13119 This command takes the next character you type, whatever it is, and
13120 uses it as the digit separator. As a special case, @kbd{d , \} selects
13121 @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
13123 Please note that grouped numbers will not generally be parsed correctly
13124 if re-read in textual form, say by the use of @kbd{C-x * y} and @kbd{C-x * g}.
13125 (@xref{Kill and Yank}, for details on these commands.) One exception is
13126 the @samp{\,} separator, which doesn't interfere with parsing because it
13127 is ignored by @TeX{} language mode.
13129 @node Float Formats, Complex Formats, Grouping Digits, Display Modes
13130 @subsection Float Formats
13133 Floating-point quantities are normally displayed in standard decimal
13134 form, with scientific notation used if the exponent is especially high
13135 or low. All significant digits are normally displayed. The commands
13136 in this section allow you to choose among several alternative display
13137 formats for floats.
13140 @pindex calc-normal-notation
13141 The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
13142 display format. All significant figures in a number are displayed.
13143 With a positive numeric prefix, numbers are rounded if necessary to
13144 that number of significant digits. With a negative numerix prefix,
13145 the specified number of significant digits less than the current
13146 precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the
13147 current precision is 12.)
13150 @pindex calc-fix-notation
13151 The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
13152 notation. The numeric argument is the number of digits after the
13153 decimal point, zero or more. This format will relax into scientific
13154 notation if a nonzero number would otherwise have been rounded all the
13155 way to zero. Specifying a negative number of digits is the same as
13156 for a positive number, except that small nonzero numbers will be rounded
13157 to zero rather than switching to scientific notation.
13160 @pindex calc-sci-notation
13161 @cindex Scientific notation, display of
13162 The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
13163 notation. A positive argument sets the number of significant figures
13164 displayed, of which one will be before and the rest after the decimal
13165 point. A negative argument works the same as for @kbd{d n} format.
13166 The default is to display all significant digits.
13169 @pindex calc-eng-notation
13170 @cindex Engineering notation, display of
13171 The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
13172 notation. This is similar to scientific notation except that the
13173 exponent is rounded down to a multiple of three, with from one to three
13174 digits before the decimal point. An optional numeric prefix sets the
13175 number of significant digits to display, as for @kbd{d s}.
13177 It is important to distinguish between the current @emph{precision} and
13178 the current @emph{display format}. After the commands @kbd{C-u 10 p}
13179 and @kbd{C-u 6 d n} the Calculator computes all results to ten
13180 significant figures but displays only six. (In fact, intermediate
13181 calculations are often carried to one or two more significant figures,
13182 but values placed on the stack will be rounded down to ten figures.)
13183 Numbers are never actually rounded to the display precision for storage,
13184 except by commands like @kbd{C-k} and @kbd{C-x * y} which operate on the
13185 actual displayed text in the Calculator buffer.
13188 @pindex calc-point-char
13189 The @kbd{d .} (@code{calc-point-char}) command selects the character used
13190 as a decimal point. Normally this is a period; users in some countries
13191 may wish to change this to a comma. Note that this is only a display
13192 style; on entry, periods must always be used to denote floating-point
13193 numbers, and commas to separate elements in a list.
13195 @node Complex Formats, Fraction Formats, Float Formats, Display Modes
13196 @subsection Complex Formats
13200 @pindex calc-complex-notation
13201 There are three supported notations for complex numbers in rectangular
13202 form. The default is as a pair of real numbers enclosed in parentheses
13203 and separated by a comma: @samp{(a,b)}. The @kbd{d c}
13204 (@code{calc-complex-notation}) command selects this style.
13207 @pindex calc-i-notation
13209 @pindex calc-j-notation
13210 The other notations are @kbd{d i} (@code{calc-i-notation}), in which
13211 numbers are displayed in @samp{a+bi} form, and @kbd{d j}
13212 (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
13213 in some disciplines.
13215 @cindex @code{i} variable
13217 Complex numbers are normally entered in @samp{(a,b)} format.
13218 If you enter @samp{2+3i} as an algebraic formula, it will be stored as
13219 the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate
13220 this formula and you have not changed the variable @samp{i}, the @samp{i}
13221 will be interpreted as @samp{(0,1)} and the formula will be simplified
13222 to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not}
13223 interpret the formula @samp{2 + 3 * i} as a complex number.
13224 @xref{Variables}, under ``special constants.''
13226 @node Fraction Formats, HMS Formats, Complex Formats, Display Modes
13227 @subsection Fraction Formats
13231 @pindex calc-over-notation
13232 Display of fractional numbers is controlled by the @kbd{d o}
13233 (@code{calc-over-notation}) command. By default, a number like
13234 eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command
13235 prompts for a one- or two-character format. If you give one character,
13236 that character is used as the fraction separator. Common separators are
13237 @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be
13238 used regardless of the display format; in particular, the @kbd{/} is used
13239 for RPN-style division, @emph{not} for entering fractions.)
13241 If you give two characters, fractions use ``integer-plus-fractional-part''
13242 notation. For example, the format @samp{+/} would display eight thirds
13243 as @samp{2+2/3}. If two colons are present in a number being entered,
13244 the number is interpreted in this form (so that the entries @kbd{2:2:3}
13245 and @kbd{8:3} are equivalent).
13247 It is also possible to follow the one- or two-character format with
13248 a number. For example: @samp{:10} or @samp{+/3}. In this case,
13249 Calc adjusts all fractions that are displayed to have the specified
13250 denominator, if possible. Otherwise it adjusts the denominator to
13251 be a multiple of the specified value. For example, in @samp{:6} mode
13252 the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be
13253 displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6},
13254 and @expr{1:8} will be displayed as @expr{3:24}. Integers are also
13255 affected by this mode: 3 is displayed as @expr{18:6}. Note that the
13256 format @samp{:1} writes fractions the same as @samp{:}, but it writes
13257 integers as @expr{n:1}.
13259 The fraction format does not affect the way fractions or integers are
13260 stored, only the way they appear on the screen. The fraction format
13261 never affects floats.
13263 @node HMS Formats, Date Formats, Fraction Formats, Display Modes
13264 @subsection HMS Formats
13268 @pindex calc-hms-notation
13269 The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
13270 HMS (hours-minutes-seconds) forms. It prompts for a string which
13271 consists basically of an ``hours'' marker, optional punctuation, a
13272 ``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
13273 Punctuation is zero or more spaces, commas, or semicolons. The hours
13274 marker is one or more non-punctuation characters. The minutes and
13275 seconds markers must be single non-punctuation characters.
13277 The default HMS format is @samp{@@ ' "}, producing HMS values of the form
13278 @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same
13279 value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o}
13280 keys are recognized as synonyms for @kbd{@@} regardless of display format.
13281 The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
13282 @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
13283 already been typed; otherwise, they have their usual meanings
13284 (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
13285 @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
13286 The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
13287 @kbd{o}) has already been pressed; otherwise it means to switch to algebraic
13290 @node Date Formats, Truncating the Stack, HMS Formats, Display Modes
13291 @subsection Date Formats
13295 @pindex calc-date-notation
13296 The @kbd{d d} (@code{calc-date-notation}) command controls the display
13297 of date forms (@pxref{Date Forms}). It prompts for a string which
13298 contains letters that represent the various parts of a date and time.
13299 To show which parts should be omitted when the form represents a pure
13300 date with no time, parts of the string can be enclosed in @samp{< >}
13301 marks. If you don't include @samp{< >} markers in the format, Calc
13302 guesses at which parts, if any, should be omitted when formatting
13305 The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
13306 An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
13307 If you enter a blank format string, this default format is
13310 Calc uses @samp{< >} notation for nameless functions as well as for
13311 dates. @xref{Specifying Operators}. To avoid confusion with nameless
13312 functions, your date formats should avoid using the @samp{#} character.
13315 * Date Formatting Codes::
13316 * Free-Form Dates::
13317 * Standard Date Formats::
13320 @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
13321 @subsubsection Date Formatting Codes
13324 When displaying a date, the current date format is used. All
13325 characters except for letters and @samp{<} and @samp{>} are
13326 copied literally when dates are formatted. The portion between
13327 @samp{< >} markers is omitted for pure dates, or included for
13328 date/time forms. Letters are interpreted according to the table
13331 When dates are read in during algebraic entry, Calc first tries to
13332 match the input string to the current format either with or without
13333 the time part. The punctuation characters (including spaces) must
13334 match exactly; letter fields must correspond to suitable text in
13335 the input. If this doesn't work, Calc checks if the input is a
13336 simple number; if so, the number is interpreted as a number of days
13337 since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and
13338 flexible algorithm which is described in the next section.
13340 Weekday names are ignored during reading.
13342 Two-digit year numbers are interpreted as lying in the range
13343 from 1941 to 2039. Years outside that range are always
13344 entered and displayed in full. Year numbers with a leading
13345 @samp{+} sign are always interpreted exactly, allowing the
13346 entry and display of the years 1 through 99 AD.
13348 Here is a complete list of the formatting codes for dates:
13352 Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
13354 Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
13356 Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
13358 Year: ``1991'' for 1991, ``23'' for 23 AD.
13360 Year: ``1991'' for 1991, ``+23'' for 23 AD.
13362 Year: ``ad'' or blank.
13364 Year: ``AD'' or blank.
13366 Year: ``ad '' or blank. (Note trailing space.)
13368 Year: ``AD '' or blank.
13370 Year: ``a.d.'' or blank.
13372 Year: ``A.D.'' or blank.
13374 Year: ``bc'' or blank.
13376 Year: ``BC'' or blank.
13378 Year: `` bc'' or blank. (Note leading space.)
13380 Year: `` BC'' or blank.
13382 Year: ``b.c.'' or blank.
13384 Year: ``B.C.'' or blank.
13386 Month: ``8'' for August.
13388 Month: ``08'' for August.
13390 Month: `` 8'' for August.
13392 Month: ``AUG'' for August.
13394 Month: ``Aug'' for August.
13396 Month: ``aug'' for August.
13398 Month: ``AUGUST'' for August.
13400 Month: ``August'' for August.
13402 Day: ``7'' for 7th day of month.
13404 Day: ``07'' for 7th day of month.
13406 Day: `` 7'' for 7th day of month.
13408 Weekday: ``0'' for Sunday, ``6'' for Saturday.
13410 Weekday: ``SUN'' for Sunday.
13412 Weekday: ``Sun'' for Sunday.
13414 Weekday: ``sun'' for Sunday.
13416 Weekday: ``SUNDAY'' for Sunday.
13418 Weekday: ``Sunday'' for Sunday.
13420 Day of year: ``34'' for Feb. 3.
13422 Day of year: ``034'' for Feb. 3.
13424 Day of year: `` 34'' for Feb. 3.
13426 Hour: ``5'' for 5 AM; ``17'' for 5 PM.
13428 Hour: ``05'' for 5 AM; ``17'' for 5 PM.
13430 Hour: `` 5'' for 5 AM; ``17'' for 5 PM.
13432 Hour: ``5'' for 5 AM and 5 PM.
13434 Hour: ``05'' for 5 AM and 5 PM.
13436 Hour: `` 5'' for 5 AM and 5 PM.
13438 AM/PM: ``a'' or ``p''.
13440 AM/PM: ``A'' or ``P''.
13442 AM/PM: ``am'' or ``pm''.
13444 AM/PM: ``AM'' or ``PM''.
13446 AM/PM: ``a.m.'' or ``p.m.''.
13448 AM/PM: ``A.M.'' or ``P.M.''.
13450 Minutes: ``7'' for 7.
13452 Minutes: ``07'' for 7.
13454 Minutes: `` 7'' for 7.
13456 Seconds: ``7'' for 7; ``7.23'' for 7.23.
13458 Seconds: ``07'' for 7; ``07.23'' for 7.23.
13460 Seconds: `` 7'' for 7; `` 7.23'' for 7.23.
13462 Optional seconds: ``07'' for 7; blank for 0.
13464 Optional seconds: `` 7'' for 7; blank for 0.
13466 Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991.
13468 Numeric date: ``726842'' for any time on Wed Jan 9, 1991.
13470 Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991.
13472 Julian date: ``2448266'' for any time on Wed Jan 9, 1991.
13474 Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991.
13476 Brackets suppression. An ``X'' at the front of the format
13477 causes the surrounding @w{@samp{< >}} delimiters to be omitted
13478 when formatting dates. Note that the brackets are still
13479 required for algebraic entry.
13482 If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
13483 colon is also omitted if the seconds part is zero.
13485 If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
13486 appear in the format, then negative year numbers are displayed
13487 without a minus sign. Note that ``aa'' and ``bb'' are mutually
13488 exclusive. Some typical usages would be @samp{YYYY AABB};
13489 @samp{AAAYYYYBBB}; @samp{YYYYBBB}.
13491 The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
13492 ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
13493 reading unless several of these codes are strung together with no
13494 punctuation in between, in which case the input must have exactly as
13495 many digits as there are letters in the format.
13497 The ``j,'' ``J,'' and ``U'' formats do not make any time zone
13498 adjustment. They effectively use @samp{julian(x,0)} and
13499 @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
13501 @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
13502 @subsubsection Free-Form Dates
13505 When reading a date form during algebraic entry, Calc falls back
13506 on the algorithm described here if the input does not exactly
13507 match the current date format. This algorithm generally
13508 ``does the right thing'' and you don't have to worry about it,
13509 but it is described here in full detail for the curious.
13511 Calc does not distinguish between upper- and lower-case letters
13512 while interpreting dates.
13514 First, the time portion, if present, is located somewhere in the
13515 text and then removed. The remaining text is then interpreted as
13518 A time is of the form @samp{hh:mm:ss}, possibly with the seconds
13519 part omitted and possibly with an AM/PM indicator added to indicate
13520 12-hour time. If the AM/PM is present, the minutes may also be
13521 omitted. The AM/PM part may be any of the words @samp{am},
13522 @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
13523 abbreviated to one letter, and the alternate forms @samp{a.m.},
13524 @samp{p.m.}, and @samp{mid} are also understood. Obviously
13525 @samp{noon} and @samp{midnight} are allowed only on 12:00:00.
13526 The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
13527 recognized with no number attached.
13529 If there is no AM/PM indicator, the time is interpreted in 24-hour
13532 To read the date portion, all words and numbers are isolated
13533 from the string; other characters are ignored. All words must
13534 be either month names or day-of-week names (the latter of which
13535 are ignored). Names can be written in full or as three-letter
13538 Large numbers, or numbers with @samp{+} or @samp{-} signs,
13539 are interpreted as years. If one of the other numbers is
13540 greater than 12, then that must be the day and the remaining
13541 number in the input is therefore the month. Otherwise, Calc
13542 assumes the month, day and year are in the same order that they
13543 appear in the current date format. If the year is omitted, the
13544 current year is taken from the system clock.
13546 If there are too many or too few numbers, or any unrecognizable
13547 words, then the input is rejected.
13549 If there are any large numbers (of five digits or more) other than
13550 the year, they are ignored on the assumption that they are something
13551 like Julian dates that were included along with the traditional
13552 date components when the date was formatted.
13554 One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
13555 may optionally be used; the latter two are equivalent to a
13556 minus sign on the year value.
13558 If you always enter a four-digit year, and use a name instead
13559 of a number for the month, there is no danger of ambiguity.
13561 @node Standard Date Formats, , Free-Form Dates, Date Formats
13562 @subsubsection Standard Date Formats
13565 There are actually ten standard date formats, numbered 0 through 9.
13566 Entering a blank line at the @kbd{d d} command's prompt gives
13567 you format number 1, Calc's usual format. You can enter any digit
13568 to select the other formats.
13570 To create your own standard date formats, give a numeric prefix
13571 argument from 0 to 9 to the @w{@kbd{d d}} command. The format you
13572 enter will be recorded as the new standard format of that
13573 number, as well as becoming the new current date format.
13574 You can save your formats permanently with the @w{@kbd{m m}}
13575 command (@pxref{Mode Settings}).
13579 @samp{N} (Numerical format)
13581 @samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format)
13583 @samp{D Mmm YYYY<, h:mm:SS>} (European format)
13585 @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format)
13587 @samp{M/D/Y< H:mm:SSpp>} (American slashed format)
13589 @samp{D.M.Y< h:mm:SS>} (European dotted format)
13591 @samp{M-D-Y< H:mm:SSpp>} (American dashed format)
13593 @samp{D-M-Y< h:mm:SS>} (European dashed format)
13595 @samp{j<, h:mm:ss>} (Julian day plus time)
13597 @samp{YYddd< hh:mm:ss>} (Year-day format)
13600 @node Truncating the Stack, Justification, Date Formats, Display Modes
13601 @subsection Truncating the Stack
13605 @pindex calc-truncate-stack
13606 @cindex Truncating the stack
13607 @cindex Narrowing the stack
13608 The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
13609 line that marks the top-of-stack up or down in the Calculator buffer.
13610 The number right above that line is considered to the be at the top of
13611 the stack. Any numbers below that line are ``hidden'' from all stack
13612 operations (although still visible to the user). This is similar to the
13613 Emacs ``narrowing'' feature, except that the values below the @samp{.}
13614 are @emph{visible}, just temporarily frozen. This feature allows you to
13615 keep several independent calculations running at once in different parts
13616 of the stack, or to apply a certain command to an element buried deep in
13619 Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
13620 is on. Thus, this line and all those below it become hidden. To un-hide
13621 these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
13622 With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the
13623 bottom @expr{n} values in the buffer. With a negative argument, it hides
13624 all but the top @expr{n} values. With an argument of zero, it hides zero
13625 values, i.e., moves the @samp{.} all the way down to the bottom.
13628 @pindex calc-truncate-up
13630 @pindex calc-truncate-down
13631 The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
13632 (@code{calc-truncate-down}) commands move the @samp{.} up or down one
13633 line at a time (or several lines with a prefix argument).
13635 @node Justification, Labels, Truncating the Stack, Display Modes
13636 @subsection Justification
13640 @pindex calc-left-justify
13642 @pindex calc-center-justify
13644 @pindex calc-right-justify
13645 Values on the stack are normally left-justified in the window. You can
13646 control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
13647 @kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
13648 (@code{calc-center-justify}). For example, in Right-Justification mode,
13649 stack entries are displayed flush-right against the right edge of the
13652 If you change the width of the Calculator window you may have to type
13653 @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
13656 Right-justification is especially useful together with fixed-point
13657 notation (see @code{d f}; @code{calc-fix-notation}). With these modes
13658 together, the decimal points on numbers will always line up.
13660 With a numeric prefix argument, the justification commands give you
13661 a little extra control over the display. The argument specifies the
13662 horizontal ``origin'' of a display line. It is also possible to
13663 specify a maximum line width using the @kbd{d b} command (@pxref{Normal
13664 Language Modes}). For reference, the precise rules for formatting and
13665 breaking lines are given below. Notice that the interaction between
13666 origin and line width is slightly different in each justification
13669 In Left-Justified mode, the line is indented by a number of spaces
13670 given by the origin (default zero). If the result is longer than the
13671 maximum line width, if given, or too wide to fit in the Calc window
13672 otherwise, then it is broken into lines which will fit; each broken
13673 line is indented to the origin.
13675 In Right-Justified mode, lines are shifted right so that the rightmost
13676 character is just before the origin, or just before the current
13677 window width if no origin was specified. If the line is too long
13678 for this, then it is broken; the current line width is used, if
13679 specified, or else the origin is used as a width if that is
13680 specified, or else the line is broken to fit in the window.
13682 In Centering mode, the origin is the column number of the center of
13683 each stack entry. If a line width is specified, lines will not be
13684 allowed to go past that width; Calc will either indent less or
13685 break the lines if necessary. If no origin is specified, half the
13686 line width or Calc window width is used.
13688 Note that, in each case, if line numbering is enabled the display
13689 is indented an additional four spaces to make room for the line
13690 number. The width of the line number is taken into account when
13691 positioning according to the current Calc window width, but not
13692 when positioning by explicit origins and widths. In the latter
13693 case, the display is formatted as specified, and then uniformly
13694 shifted over four spaces to fit the line numbers.
13696 @node Labels, , Justification, Display Modes
13701 @pindex calc-left-label
13702 The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
13703 then displays that string to the left of every stack entry. If the
13704 entries are left-justified (@pxref{Justification}), then they will
13705 appear immediately after the label (unless you specified an origin
13706 greater than the length of the label). If the entries are centered
13707 or right-justified, the label appears on the far left and does not
13708 affect the horizontal position of the stack entry.
13710 Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
13713 @pindex calc-right-label
13714 The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
13715 label on the righthand side. It does not affect positioning of
13716 the stack entries unless they are right-justified. Also, if both
13717 a line width and an origin are given in Right-Justified mode, the
13718 stack entry is justified to the origin and the righthand label is
13719 justified to the line width.
13721 One application of labels would be to add equation numbers to
13722 formulas you are manipulating in Calc and then copying into a
13723 document (possibly using Embedded mode). The equations would
13724 typically be centered, and the equation numbers would be on the
13725 left or right as you prefer.
13727 @node Language Modes, Modes Variable, Display Modes, Mode Settings
13728 @section Language Modes
13731 The commands in this section change Calc to use a different notation for
13732 entry and display of formulas, corresponding to the conventions of some
13733 other common language such as Pascal or La@TeX{}. Objects displayed on the
13734 stack or yanked from the Calculator to an editing buffer will be formatted
13735 in the current language; objects entered in algebraic entry or yanked from
13736 another buffer will be interpreted according to the current language.
13738 The current language has no effect on things written to or read from the
13739 trail buffer, nor does it affect numeric entry. Only algebraic entry is
13740 affected. You can make even algebraic entry ignore the current language
13741 and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
13743 For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
13744 program; elsewhere in the program you need the derivatives of this formula
13745 with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C}
13746 to switch to C notation. Now use @code{C-u C-x * g} to grab the formula
13747 into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
13748 to the first variable, and @kbd{C-x * y} to yank the formula for the derivative
13749 back into your C program. Press @kbd{U} to undo the differentiation and
13750 repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
13752 Without being switched into C mode first, Calc would have misinterpreted
13753 the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
13754 @code{atan} was equivalent to Calc's built-in @code{arctan} function,
13755 and would have written the formula back with notations (like implicit
13756 multiplication) which would not have been valid for a C program.
13758 As another example, suppose you are maintaining a C program and a La@TeX{}
13759 document, each of which needs a copy of the same formula. You can grab the
13760 formula from the program in C mode, switch to La@TeX{} mode, and yank the
13761 formula into the document in La@TeX{} math-mode format.
13763 Language modes are selected by typing the letter @kbd{d} followed by a
13764 shifted letter key.
13767 * Normal Language Modes::
13768 * C FORTRAN Pascal::
13769 * TeX and LaTeX Language Modes::
13770 * Eqn Language Mode::
13771 * Mathematica Language Mode::
13772 * Maple Language Mode::
13777 @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
13778 @subsection Normal Language Modes
13782 @pindex calc-normal-language
13783 The @kbd{d N} (@code{calc-normal-language}) command selects the usual
13784 notation for Calc formulas, as described in the rest of this manual.
13785 Matrices are displayed in a multi-line tabular format, but all other
13786 objects are written in linear form, as they would be typed from the
13790 @pindex calc-flat-language
13791 @cindex Matrix display
13792 The @kbd{d O} (@code{calc-flat-language}) command selects a language
13793 identical with the normal one, except that matrices are written in
13794 one-line form along with everything else. In some applications this
13795 form may be more suitable for yanking data into other buffers.
13798 @pindex calc-line-breaking
13799 @cindex Line breaking
13800 @cindex Breaking up long lines
13801 Even in one-line mode, long formulas or vectors will still be split
13802 across multiple lines if they exceed the width of the Calculator window.
13803 The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
13804 feature on and off. (It works independently of the current language.)
13805 If you give a numeric prefix argument of five or greater to the @kbd{d b}
13806 command, that argument will specify the line width used when breaking
13810 @pindex calc-big-language
13811 The @kbd{d B} (@code{calc-big-language}) command selects a language
13812 which uses textual approximations to various mathematical notations,
13813 such as powers, quotients, and square roots:
13823 in place of @samp{sqrt((a+1)/b + c^2)}.
13825 Subscripts like @samp{a_i} are displayed as actual subscripts in Big
13826 mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
13827 are displayed as @samp{a} with subscripts separated by commas:
13828 @samp{i, j}. They must still be entered in the usual underscore
13831 One slight ambiguity of Big notation is that
13840 can represent either the negative rational number @expr{-3:4}, or the
13841 actual expression @samp{-(3/4)}; but the latter formula would normally
13842 never be displayed because it would immediately be evaluated to
13843 @expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in
13846 Non-decimal numbers are displayed with subscripts. Thus there is no
13847 way to tell the difference between @samp{16#C2} and @samp{C2_16},
13848 though generally you will know which interpretation is correct.
13849 Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
13852 In Big mode, stack entries often take up several lines. To aid
13853 readability, stack entries are separated by a blank line in this mode.
13854 You may find it useful to expand the Calc window's height using
13855 @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
13856 one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
13858 Long lines are currently not rearranged to fit the window width in
13859 Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
13860 to scroll across a wide formula. For really big formulas, you may
13861 even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
13864 @pindex calc-unformatted-language
13865 The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
13866 the use of operator notation in formulas. In this mode, the formula
13867 shown above would be displayed:
13870 sqrt(add(div(add(a, 1), b), pow(c, 2)))
13873 These four modes differ only in display format, not in the format
13874 expected for algebraic entry. The standard Calc operators work in
13875 all four modes, and unformatted notation works in any language mode
13876 (except that Mathematica mode expects square brackets instead of
13879 @node C FORTRAN Pascal, TeX and LaTeX Language Modes, Normal Language Modes, Language Modes
13880 @subsection C, FORTRAN, and Pascal Modes
13884 @pindex calc-c-language
13886 The @kbd{d C} (@code{calc-c-language}) command selects the conventions
13887 of the C language for display and entry of formulas. This differs from
13888 the normal language mode in a variety of (mostly minor) ways. In
13889 particular, C language operators and operator precedences are used in
13890 place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)}
13891 in C mode; a value raised to a power is written as a function call,
13894 In C mode, vectors and matrices use curly braces instead of brackets.
13895 Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
13896 rather than using the @samp{#} symbol. Array subscripting is
13897 translated into @code{subscr} calls, so that @samp{a[i]} in C
13898 mode is the same as @samp{a_i} in Normal mode. Assignments
13899 turn into the @code{assign} function, which Calc normally displays
13900 using the @samp{:=} symbol.
13902 The variables @code{pi} and @code{e} would be displayed @samp{pi}
13903 and @samp{e} in Normal mode, but in C mode they are displayed as
13904 @samp{M_PI} and @samp{M_E}, corresponding to the names of constants
13905 typically provided in the @file{<math.h>} header. Functions whose
13906 names are different in C are translated automatically for entry and
13907 display purposes. For example, entering @samp{asin(x)} will push the
13908 formula @samp{arcsin(x)} onto the stack; this formula will be displayed
13909 as @samp{asin(x)} as long as C mode is in effect.
13912 @pindex calc-pascal-language
13913 @cindex Pascal language
13914 The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
13915 conventions. Like C mode, Pascal mode interprets array brackets and uses
13916 a different table of operators. Hexadecimal numbers are entered and
13917 displayed with a preceding dollar sign. (Thus the regular meaning of
13918 @kbd{$2} during algebraic entry does not work in Pascal mode, though
13919 @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
13920 always.) No special provisions are made for other non-decimal numbers,
13921 vectors, and so on, since there is no universally accepted standard way
13922 of handling these in Pascal.
13925 @pindex calc-fortran-language
13926 @cindex FORTRAN language
13927 The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
13928 conventions. Various function names are transformed into FORTRAN
13929 equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be
13930 entered this way or using square brackets. Since FORTRAN uses round
13931 parentheses for both function calls and array subscripts, Calc displays
13932 both in the same way; @samp{a(i)} is interpreted as a function call
13933 upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
13934 Also, if the variable @code{a} has been declared to have type
13935 @code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
13936 subscript. (@xref{Declarations}.) Usually it doesn't matter, though;
13937 if you enter the subscript expression @samp{a(i)} and Calc interprets
13938 it as a function call, you'll never know the difference unless you
13939 switch to another language mode or replace @code{a} with an actual
13940 vector (or unless @code{a} happens to be the name of a built-in
13943 Underscores are allowed in variable and function names in all of these
13944 language modes. The underscore here is equivalent to the @samp{#} in
13945 Normal mode, or to hyphens in the underlying Emacs Lisp variable names.
13947 FORTRAN and Pascal modes normally do not adjust the case of letters in
13948 formulas. Most built-in Calc names use lower-case letters. If you use a
13949 positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
13950 modes will use upper-case letters exclusively for display, and will
13951 convert to lower-case on input. With a negative prefix, these modes
13952 convert to lower-case for display and input.
13954 @node TeX and LaTeX Language Modes, Eqn Language Mode, C FORTRAN Pascal, Language Modes
13955 @subsection @TeX{} and La@TeX{} Language Modes
13959 @pindex calc-tex-language
13960 @cindex TeX language
13962 @pindex calc-latex-language
13963 @cindex LaTeX language
13964 The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
13965 of ``math mode'' in Donald Knuth's @TeX{} typesetting language,
13966 and the @kbd{d L} (@code{calc-latex-language}) command selects the
13967 conventions of ``math mode'' in La@TeX{}, a typesetting language that
13968 uses @TeX{} as its formatting engine. Calc's La@TeX{} language mode can
13969 read any formula that the @TeX{} language mode can, although La@TeX{}
13970 mode may display it differently.
13972 Formulas are entered and displayed in the appropriate notation;
13973 @texline @math{\sin(a/b)}
13974 @infoline @expr{sin(a/b)}
13975 will appear as @samp{\sin\left( a \over b \right)} in @TeX{} mode and
13976 @samp{\sin\left(\frac@{a@}@{b@}\right)} in La@TeX{} mode.
13977 Math formulas are often enclosed by @samp{$ $} signs in @TeX{} and
13978 La@TeX{}; these should be omitted when interfacing with Calc. To Calc,
13979 the @samp{$} sign has the same meaning it always does in algebraic
13980 formulas (a reference to an existing entry on the stack).
13982 Complex numbers are displayed as in @samp{3 + 4i}. Fractions and
13983 quotients are written using @code{\over} in @TeX{} mode (as in
13984 @code{@{a \over b@}}) and @code{\frac} in La@TeX{} mode (as in
13985 @code{\frac@{a@}@{b@}}); binomial coefficients are written with
13986 @code{\choose} in @TeX{} mode (as in @code{@{a \choose b@}}) and
13987 @code{\binom} in La@TeX{} mode (as in @code{\binom@{a@}@{b@}}).
13988 Interval forms are written with @code{\ldots}, and error forms are
13989 written with @code{\pm}. Absolute values are written as in
13990 @samp{|x + 1|}, and the floor and ceiling functions are written with
13991 @code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and
13992 @code{\right} are ignored when reading formulas in @TeX{} and La@TeX{}
13993 modes. Both @code{inf} and @code{uinf} are written as @code{\infty};
13994 when read, @code{\infty} always translates to @code{inf}.
13996 Function calls are written the usual way, with the function name followed
13997 by the arguments in parentheses. However, functions for which @TeX{}
13998 and La@TeX{} have special names (like @code{\sin}) will use curly braces
13999 instead of parentheses for very simple arguments. During input, curly
14000 braces and parentheses work equally well for grouping, but when the
14001 document is formatted the curly braces will be invisible. Thus the
14003 @texline @math{\sin{2 x}}
14004 @infoline @expr{sin 2x}
14006 @texline @math{\sin(2 + x)}.
14007 @infoline @expr{sin(2 + x)}.
14009 Function and variable names not treated specially by @TeX{} and La@TeX{}
14010 are simply written out as-is, which will cause them to come out in
14011 italic letters in the printed document. If you invoke @kbd{d T} or
14012 @kbd{d L} with a positive numeric prefix argument, names of more than
14013 one character will instead be enclosed in a protective commands that
14014 will prevent them from being typeset in the math italics; they will be
14015 written @samp{\hbox@{@var{name}@}} in @TeX{} mode and
14016 @samp{\text@{@var{name}@}} in La@TeX{} mode. The
14017 @samp{\hbox@{ @}} and @samp{\text@{ @}} notations are ignored during
14018 reading. If you use a negative prefix argument, such function names are
14019 written @samp{\@var{name}}, and function names that begin with @code{\} during
14020 reading have the @code{\} removed. (Note that in this mode, long
14021 variable names are still written with @code{\hbox} or @code{\text}.
14022 However, you can always make an actual variable name like @code{\bar} in
14025 During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
14026 by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and
14027 @code{\bmatrix}. In La@TeX{} mode this also applies to
14028 @samp{\begin@{matrix@} ... \end@{matrix@}},
14029 @samp{\begin@{bmatrix@} ... \end@{bmatrix@}},
14030 @samp{\begin@{pmatrix@} ... \end@{pmatrix@}}, as well as
14031 @samp{\begin@{smallmatrix@} ... \end@{smallmatrix@}}.
14032 The symbol @samp{&} is interpreted as a comma,
14033 and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
14034 During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
14035 format in @TeX{} mode and in
14036 @samp{\begin@{pmatrix@} a & b \\ c & d \end@{pmatrix@}} format in
14037 La@TeX{} mode; you may need to edit this afterwards to change to your
14038 preferred matrix form. If you invoke @kbd{d T} or @kbd{d L} with an
14039 argument of 2 or -2, then matrices will be displayed in two-dimensional
14050 This may be convenient for isolated matrices, but could lead to
14051 expressions being displayed like
14054 \begin@{pmatrix@} \times x
14061 While this wouldn't bother Calc, it is incorrect La@TeX{}.
14062 (Similarly for @TeX{}.)
14064 Accents like @code{\tilde} and @code{\bar} translate into function
14065 calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline}
14066 sequence is treated as an accent. The @code{\vec} accent corresponds
14067 to the function name @code{Vec}, because @code{vec} is the name of
14068 a built-in Calc function. The following table shows the accents
14069 in Calc, @TeX{}, La@TeX{} and @dfn{eqn} (described in the next section):
14073 @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes
14074 @let@calcindexersh=@calcindexernoshow
14182 acute \acute \acute
14186 breve \breve \breve
14188 check \check \check
14194 dotdot \ddot \ddot dotdot
14197 grave \grave \grave
14202 tilde \tilde \tilde tilde
14204 under \underline \underline under
14209 The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
14210 @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an
14211 alias for @code{\rightarrow}. However, if the @samp{=>} is the
14212 top-level expression being formatted, a slightly different notation
14213 is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto}
14214 word is ignored by Calc's input routines, and is undefined in @TeX{}.
14215 You will typically want to include one of the following definitions
14216 at the top of a @TeX{} file that uses @code{\evalto}:
14220 \def\evalto#1\to@{@}
14223 The first definition formats evaluates-to operators in the usual
14224 way. The second causes only the @var{b} part to appear in the
14225 printed document; the @var{a} part and the arrow are hidden.
14226 Another definition you may wish to use is @samp{\let\to=\Rightarrow}
14227 which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
14228 @xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
14230 The complete set of @TeX{} control sequences that are ignored during
14234 \hbox \mbox \text \left \right
14235 \, \> \: \; \! \quad \qquad \hfil \hfill
14236 \displaystyle \textstyle \dsize \tsize
14237 \scriptstyle \scriptscriptstyle \ssize \ssize
14238 \rm \bf \it \sl \roman \bold \italic \slanted
14239 \cal \mit \Cal \Bbb \frak \goth
14243 Note that, because these symbols are ignored, reading a @TeX{} or
14244 La@TeX{} formula into Calc and writing it back out may lose spacing and
14247 Also, the ``discretionary multiplication sign'' @samp{\*} is read
14248 the same as @samp{*}.
14251 The @TeX{} version of this manual includes some printed examples at the
14252 end of this section.
14255 Here are some examples of how various Calc formulas are formatted in @TeX{}:
14260 \sin\left( {a^2 \over b_i} \right)
14264 $$ \sin\left( a^2 \over b_i \right) $$
14270 [(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
14271 [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
14276 $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
14282 [abs(a), abs(a / b), floor(a), ceil(a / b)]
14283 [|a|, \left| a \over b \right|,
14284 \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
14288 $$ [|a|, \left| a \over b \right|,
14289 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
14295 [sin(a), sin(2 a), sin(2 + a), sin(a / b)]
14296 [\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
14297 \sin\left( @{a \over b@} \right)]
14302 $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
14306 First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
14307 @kbd{C-u - d T} (using the example definition
14308 @samp{\def\foo#1@{\tilde F(#1)@}}:
14312 [f(a), foo(bar), sin(pi)]
14313 [f(a), foo(bar), \sin{\pi}]
14314 [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
14315 [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
14319 $$ [f(a), foo(bar), \sin{\pi}] $$
14320 $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
14321 $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
14325 First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
14330 \evalto 2 + 3 \to 5
14340 First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
14344 [2 + 3 => 5, a / 2 => (b + c) / 2]
14345 [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
14350 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
14351 {\let\to\Rightarrow
14352 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
14356 Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
14360 [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
14361 \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14362 \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14367 $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14368 $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14373 @node Eqn Language Mode, Mathematica Language Mode, TeX and LaTeX Language Modes, Language Modes
14374 @subsection Eqn Language Mode
14378 @pindex calc-eqn-language
14379 @dfn{Eqn} is another popular formatter for math formulas. It is
14380 designed for use with the TROFF text formatter, and comes standard
14381 with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language})
14382 command selects @dfn{eqn} notation.
14384 The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
14385 a significant part in the parsing of the language. For example,
14386 @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
14387 @code{sqrt} operator. @dfn{Eqn} also understands more conventional
14388 grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are
14389 required only when the argument contains spaces.
14391 In Calc's @dfn{eqn} mode, however, curly braces are required to
14392 delimit arguments of operators like @code{sqrt}. The first of the
14393 above examples would treat only the @samp{x} as the argument of
14394 @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
14395 @samp{sin * x + 1}, because @code{sin} is not a special operator
14396 in the @dfn{eqn} language. If you always surround the argument
14397 with curly braces, Calc will never misunderstand.
14399 Calc also understands parentheses as grouping characters. Another
14400 peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
14401 words with spaces from any surrounding characters that aren't curly
14402 braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
14403 (The spaces around @code{sin} are important to make @dfn{eqn}
14404 recognize that @code{sin} should be typeset in a roman font, and
14405 the spaces around @code{x} and @code{y} are a good idea just in
14406 case the @dfn{eqn} document has defined special meanings for these
14409 Powers and subscripts are written with the @code{sub} and @code{sup}
14410 operators, respectively. Note that the caret symbol @samp{^} is
14411 treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
14412 symbol (these are used to introduce spaces of various widths into
14413 the typeset output of @dfn{eqn}).
14415 As in La@TeX{} mode, Calc's formatter omits parentheses around the
14416 arguments of functions like @code{ln} and @code{sin} if they are
14417 ``simple-looking''; in this case Calc surrounds the argument with
14418 braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
14420 Font change codes (like @samp{roman @var{x}}) and positioning codes
14421 (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
14422 @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right},
14423 @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input
14424 are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
14425 @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
14426 of quotes in @dfn{eqn}, but it is good enough for most uses.
14428 Accent codes (@samp{@var{x} dot}) are handled by treating them as
14429 function calls (@samp{dot(@var{x})}) internally.
14430 @xref{TeX and LaTeX Language Modes}, for a table of these accent
14431 functions. The @code{prime} accent is treated specially if it occurs on
14432 a variable or function name: @samp{f prime prime @w{( x prime )}} is
14433 stored internally as @samp{f'@w{'}(x')}. For example, taking the
14434 derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2
14435 x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}.
14437 Assignments are written with the @samp{<-} (left-arrow) symbol,
14438 and @code{evalto} operators are written with @samp{->} or
14439 @samp{evalto ... ->} (@pxref{TeX and LaTeX Language Modes}, for a discussion
14440 of this). The regular Calc symbols @samp{:=} and @samp{=>} are also
14441 recognized for these operators during reading.
14443 Vectors in @dfn{eqn} mode use regular Calc square brackets, but
14444 matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
14445 The words @code{lcol} and @code{rcol} are recognized as synonyms
14446 for @code{ccol} during input, and are generated instead of @code{ccol}
14447 if the matrix justification mode so specifies.
14449 @node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
14450 @subsection Mathematica Language Mode
14454 @pindex calc-mathematica-language
14455 @cindex Mathematica language
14456 The @kbd{d M} (@code{calc-mathematica-language}) command selects the
14457 conventions of Mathematica. Notable differences in Mathematica mode
14458 are that the names of built-in functions are capitalized, and function
14459 calls use square brackets instead of parentheses. Thus the Calc
14460 formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
14463 Vectors and matrices use curly braces in Mathematica. Complex numbers
14464 are written @samp{3 + 4 I}. The standard special constants in Calc are
14465 written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
14466 @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
14468 Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point
14469 numbers in scientific notation are written @samp{1.23*10.^3}.
14470 Subscripts use double square brackets: @samp{a[[i]]}.
14472 @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
14473 @subsection Maple Language Mode
14477 @pindex calc-maple-language
14478 @cindex Maple language
14479 The @kbd{d W} (@code{calc-maple-language}) command selects the
14480 conventions of Maple.
14482 Maple's language is much like C. Underscores are allowed in symbol
14483 names; square brackets are used for subscripts; explicit @samp{*}s for
14484 multiplications are required. Use either @samp{^} or @samp{**} to
14487 Maple uses square brackets for lists and curly braces for sets. Calc
14488 interprets both notations as vectors, and displays vectors with square
14489 brackets. This means Maple sets will be converted to lists when they
14490 pass through Calc. As a special case, matrices are written as calls
14491 to the function @code{matrix}, given a list of lists as the argument,
14492 and can be read in this form or with all-capitals @code{MATRIX}.
14494 The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
14495 Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
14496 writes any kind of interval as @samp{2 .. 3}. This means you cannot
14497 see the difference between an open and a closed interval while in
14498 Maple display mode.
14500 Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
14501 are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
14502 @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
14503 Floating-point numbers are written @samp{1.23*10.^3}.
14505 Among things not currently handled by Calc's Maple mode are the
14506 various quote symbols, procedures and functional operators, and
14507 inert (@samp{&}) operators.
14509 @node Compositions, Syntax Tables, Maple Language Mode, Language Modes
14510 @subsection Compositions
14513 @cindex Compositions
14514 There are several @dfn{composition functions} which allow you to get
14515 displays in a variety of formats similar to those in Big language
14516 mode. Most of these functions do not evaluate to anything; they are
14517 placeholders which are left in symbolic form by Calc's evaluator but
14518 are recognized by Calc's display formatting routines.
14520 Two of these, @code{string} and @code{bstring}, are described elsewhere.
14521 @xref{Strings}. For example, @samp{string("ABC")} is displayed as
14522 @samp{ABC}. When viewed on the stack it will be indistinguishable from
14523 the variable @code{ABC}, but internally it will be stored as
14524 @samp{string([65, 66, 67])} and can still be manipulated this way; for
14525 example, the selection and vector commands @kbd{j 1 v v j u} would
14526 select the vector portion of this object and reverse the elements, then
14527 deselect to reveal a string whose characters had been reversed.
14529 The composition functions do the same thing in all language modes
14530 (although their components will of course be formatted in the current
14531 language mode). The one exception is Unformatted mode (@kbd{d U}),
14532 which does not give the composition functions any special treatment.
14533 The functions are discussed here because of their relationship to
14534 the language modes.
14537 * Composition Basics::
14538 * Horizontal Compositions::
14539 * Vertical Compositions::
14540 * Other Compositions::
14541 * Information about Compositions::
14542 * User-Defined Compositions::
14545 @node Composition Basics, Horizontal Compositions, Compositions, Compositions
14546 @subsubsection Composition Basics
14549 Compositions are generally formed by stacking formulas together
14550 horizontally or vertically in various ways. Those formulas are
14551 themselves compositions. @TeX{} users will find this analogous
14552 to @TeX{}'s ``boxes.'' Each multi-line composition has a
14553 @dfn{baseline}; horizontal compositions use the baselines to
14554 decide how formulas should be positioned relative to one another.
14555 For example, in the Big mode formula
14567 the second term of the sum is four lines tall and has line three as
14568 its baseline. Thus when the term is combined with 17, line three
14569 is placed on the same level as the baseline of 17.
14575 Another important composition concept is @dfn{precedence}. This is
14576 an integer that represents the binding strength of various operators.
14577 For example, @samp{*} has higher precedence (195) than @samp{+} (180),
14578 which means that @samp{(a * b) + c} will be formatted without the
14579 parentheses, but @samp{a * (b + c)} will keep the parentheses.
14581 The operator table used by normal and Big language modes has the
14582 following precedences:
14585 _ 1200 @r{(subscripts)}
14586 % 1100 @r{(as in n}%@r{)}
14587 - 1000 @r{(as in }-@r{n)}
14588 ! 1000 @r{(as in }!@r{n)}
14591 !! 210 @r{(as in n}!!@r{)}
14592 ! 210 @r{(as in n}!@r{)}
14594 * 195 @r{(or implicit multiplication)}
14596 + - 180 @r{(as in a}+@r{b)}
14598 < = 160 @r{(and other relations)}
14610 The general rule is that if an operator with precedence @expr{n}
14611 occurs as an argument to an operator with precedence @expr{m}, then
14612 the argument is enclosed in parentheses if @expr{n < m}. Top-level
14613 expressions and expressions which are function arguments, vector
14614 components, etc., are formatted with precedence zero (so that they
14615 normally never get additional parentheses).
14617 For binary left-associative operators like @samp{+}, the righthand
14618 argument is actually formatted with one-higher precedence than shown
14619 in the table. This makes sure @samp{(a + b) + c} omits the parentheses,
14620 but the unnatural form @samp{a + (b + c)} keeps its parentheses.
14621 Right-associative operators like @samp{^} format the lefthand argument
14622 with one-higher precedence.
14628 The @code{cprec} function formats an expression with an arbitrary
14629 precedence. For example, @samp{cprec(abc, 185)} will combine into
14630 sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because
14631 this @code{cprec} form has higher precedence than addition, but lower
14632 precedence than multiplication).
14638 A final composition issue is @dfn{line breaking}. Calc uses two
14639 different strategies for ``flat'' and ``non-flat'' compositions.
14640 A non-flat composition is anything that appears on multiple lines
14641 (not counting line breaking). Examples would be matrices and Big
14642 mode powers and quotients. Non-flat compositions are displayed
14643 exactly as specified. If they come out wider than the current
14644 window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
14647 Flat compositions, on the other hand, will be broken across several
14648 lines if they are too wide to fit the window. Certain points in a
14649 composition are noted internally as @dfn{break points}. Calc's
14650 general strategy is to fill each line as much as possible, then to
14651 move down to the next line starting at the first break point that
14652 didn't fit. However, the line breaker understands the hierarchical
14653 structure of formulas. It will not break an ``inner'' formula if
14654 it can use an earlier break point from an ``outer'' formula instead.
14655 For example, a vector of sums might be formatted as:
14659 [ a + b + c, d + e + f,
14660 g + h + i, j + k + l, m ]
14665 If the @samp{m} can fit, then so, it seems, could the @samp{g}.
14666 But Calc prefers to break at the comma since the comma is part
14667 of a ``more outer'' formula. Calc would break at a plus sign
14668 only if it had to, say, if the very first sum in the vector had
14669 itself been too large to fit.
14671 Of the composition functions described below, only @code{choriz}
14672 generates break points. The @code{bstring} function (@pxref{Strings})
14673 also generates breakable items: A break point is added after every
14674 space (or group of spaces) except for spaces at the very beginning or
14677 Composition functions themselves count as levels in the formula
14678 hierarchy, so a @code{choriz} that is a component of a larger
14679 @code{choriz} will be less likely to be broken. As a special case,
14680 if a @code{bstring} occurs as a component of a @code{choriz} or
14681 @code{choriz}-like object (such as a vector or a list of arguments
14682 in a function call), then the break points in that @code{bstring}
14683 will be on the same level as the break points of the surrounding
14686 @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
14687 @subsubsection Horizontal Compositions
14694 The @code{choriz} function takes a vector of objects and composes
14695 them horizontally. For example, @samp{choriz([17, a b/c, d])} formats
14696 as @w{@samp{17a b / cd}} in Normal language mode, or as
14707 in Big language mode. This is actually one case of the general
14708 function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
14709 either or both of @var{sep} and @var{prec} may be omitted.
14710 @var{Prec} gives the @dfn{precedence} to use when formatting
14711 each of the components of @var{vec}. The default precedence is
14712 the precedence from the surrounding environment.
14714 @var{Sep} is a string (i.e., a vector of character codes as might
14715 be entered with @code{" "} notation) which should separate components
14716 of the composition. Also, if @var{sep} is given, the line breaker
14717 will allow lines to be broken after each occurrence of @var{sep}.
14718 If @var{sep} is omitted, the composition will not be breakable
14719 (unless any of its component compositions are breakable).
14721 For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
14722 formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz}
14723 to have precedence 180 ``outwards'' as well as ``inwards,''
14724 enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)}
14725 formats as @samp{2 (a + b c + (d = e))}.
14727 The baseline of a horizontal composition is the same as the
14728 baselines of the component compositions, which are all aligned.
14730 @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
14731 @subsubsection Vertical Compositions
14738 The @code{cvert} function makes a vertical composition. Each
14739 component of the vector is centered in a column. The baseline of
14740 the result is by default the top line of the resulting composition.
14741 For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
14742 formats in Big mode as
14757 There are several special composition functions that work only as
14758 components of a vertical composition. The @code{cbase} function
14759 controls the baseline of the vertical composition; the baseline
14760 will be the same as the baseline of whatever component is enclosed
14761 in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]),
14762 cvert([a^2 + 1, cbase(b^2)]))} displays as
14782 There are also @code{ctbase} and @code{cbbase} functions which
14783 make the baseline of the vertical composition equal to the top
14784 or bottom line (rather than the baseline) of that component.
14785 Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
14786 cvert([cbbase(a / b)])} gives
14798 There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
14799 function in a given vertical composition. These functions can also
14800 be written with no arguments: @samp{ctbase()} is a zero-height object
14801 which means the baseline is the top line of the following item, and
14802 @samp{cbbase()} means the baseline is the bottom line of the preceding
14809 The @code{crule} function builds a ``rule,'' or horizontal line,
14810 across a vertical composition. By itself @samp{crule()} uses @samp{-}
14811 characters to build the rule. You can specify any other character,
14812 e.g., @samp{crule("=")}. The argument must be a character code or
14813 vector of exactly one character code. It is repeated to match the
14814 width of the widest item in the stack. For example, a quotient
14815 with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
14834 Finally, the functions @code{clvert} and @code{crvert} act exactly
14835 like @code{cvert} except that the items are left- or right-justified
14836 in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
14847 Like @code{choriz}, the vertical compositions accept a second argument
14848 which gives the precedence to use when formatting the components.
14849 Vertical compositions do not support separator strings.
14851 @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
14852 @subsubsection Other Compositions
14859 The @code{csup} function builds a superscripted expression. For
14860 example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
14861 language mode. This is essentially a horizontal composition of
14862 @samp{a} and @samp{b}, where @samp{b} is shifted up so that its
14863 bottom line is one above the baseline.
14869 Likewise, the @code{csub} function builds a subscripted expression.
14870 This shifts @samp{b} down so that its top line is one below the
14871 bottom line of @samp{a} (note that this is not quite analogous to
14872 @code{csup}). Other arrangements can be obtained by using
14873 @code{choriz} and @code{cvert} directly.
14879 The @code{cflat} function formats its argument in ``flat'' mode,
14880 as obtained by @samp{d O}, if the current language mode is normal
14881 or Big. It has no effect in other language modes. For example,
14882 @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
14883 to improve its readability.
14889 The @code{cspace} function creates horizontal space. For example,
14890 @samp{cspace(4)} is effectively the same as @samp{string(" ")}.
14891 A second string (i.e., vector of characters) argument is repeated
14892 instead of the space character. For example, @samp{cspace(4, "ab")}
14893 looks like @samp{abababab}. If the second argument is not a string,
14894 it is formatted in the normal way and then several copies of that
14895 are composed together: @samp{cspace(4, a^2)} yields
14905 If the number argument is zero, this is a zero-width object.
14911 The @code{cvspace} function creates vertical space, or a vertical
14912 stack of copies of a certain string or formatted object. The
14913 baseline is the center line of the resulting stack. A numerical
14914 argument of zero will produce an object which contributes zero
14915 height if used in a vertical composition.
14925 There are also @code{ctspace} and @code{cbspace} functions which
14926 create vertical space with the baseline the same as the baseline
14927 of the top or bottom copy, respectively, of the second argument.
14928 Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
14945 @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
14946 @subsubsection Information about Compositions
14949 The functions in this section are actual functions; they compose their
14950 arguments according to the current language and other display modes,
14951 then return a certain measurement of the composition as an integer.
14957 The @code{cwidth} function measures the width, in characters, of a
14958 composition. For example, @samp{cwidth(a + b)} is 5, and
14959 @samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in
14960 @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve
14961 the composition functions described in this section.
14967 The @code{cheight} function measures the height of a composition.
14968 This is the total number of lines in the argument's printed form.
14978 The functions @code{cascent} and @code{cdescent} measure the amount
14979 of the height that is above (and including) the baseline, or below
14980 the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
14981 always equals @samp{cheight(@var{x})}. For a one-line formula like
14982 @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
14983 For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
14984 returns 1. The only formula for which @code{cascent} will return zero
14985 is @samp{cvspace(0)} or equivalents.
14987 @node User-Defined Compositions, , Information about Compositions, Compositions
14988 @subsubsection User-Defined Compositions
14992 @pindex calc-user-define-composition
14993 The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
14994 define the display format for any algebraic function. You provide a
14995 formula containing a certain number of argument variables on the stack.
14996 Any time Calc formats a call to the specified function in the current
14997 language mode and with that number of arguments, Calc effectively
14998 replaces the function call with that formula with the arguments
15001 Calc builds the default argument list by sorting all the variable names
15002 that appear in the formula into alphabetical order. You can edit this
15003 argument list before pressing @key{RET} if you wish. Any variables in
15004 the formula that do not appear in the argument list will be displayed
15005 literally; any arguments that do not appear in the formula will not
15006 affect the display at all.
15008 You can define formats for built-in functions, for functions you have
15009 defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
15010 which have no definitions but are being used as purely syntactic objects.
15011 You can define different formats for each language mode, and for each
15012 number of arguments, using a succession of @kbd{Z C} commands. When
15013 Calc formats a function call, it first searches for a format defined
15014 for the current language mode (and number of arguments); if there is
15015 none, it uses the format defined for the Normal language mode. If
15016 neither format exists, Calc uses its built-in standard format for that
15017 function (usually just @samp{@var{func}(@var{args})}).
15019 If you execute @kbd{Z C} with the number 0 on the stack instead of a
15020 formula, any defined formats for the function in the current language
15021 mode will be removed. The function will revert to its standard format.
15023 For example, the default format for the binomial coefficient function
15024 @samp{choose(n, m)} in the Big language mode is
15035 You might prefer the notation,
15045 To define this notation, first make sure you are in Big mode,
15046 then put the formula
15049 choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
15053 on the stack and type @kbd{Z C}. Answer the first prompt with
15054 @code{choose}. The second prompt will be the default argument list
15055 of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press
15056 @key{RET}. Now, try it out: For example, turn simplification
15057 off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
15058 as an algebraic entry.
15067 As another example, let's define the usual notation for Stirling
15068 numbers of the first kind, @samp{stir1(n, m)}. This is just like
15069 the regular format for binomial coefficients but with square brackets
15070 instead of parentheses.
15073 choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
15076 Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
15077 @samp{(n m)}, and type @key{RET}.
15079 The formula provided to @kbd{Z C} usually will involve composition
15080 functions, but it doesn't have to. Putting the formula @samp{a + b + c}
15081 onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
15082 the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
15083 This ``sum'' will act exactly like a real sum for all formatting
15084 purposes (it will be parenthesized the same, and so on). However
15085 it will be computationally unrelated to a sum. For example, the
15086 formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
15087 Operator precedences have caused the ``sum'' to be written in
15088 parentheses, but the arguments have not actually been summed.
15089 (Generally a display format like this would be undesirable, since
15090 it can easily be confused with a real sum.)
15092 The special function @code{eval} can be used inside a @kbd{Z C}
15093 composition formula to cause all or part of the formula to be
15094 evaluated at display time. For example, if the formula is
15095 @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
15096 as @samp{1 + 5}. Evaluation will use the default simplifications,
15097 regardless of the current simplification mode. There are also
15098 @code{evalsimp} and @code{evalextsimp} which simplify as if by
15099 @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions''
15100 operate only in the context of composition formulas (and also in
15101 rewrite rules, where they serve a similar purpose; @pxref{Rewrite
15102 Rules}). On the stack, a call to @code{eval} will be left in
15105 It is not a good idea to use @code{eval} except as a last resort.
15106 It can cause the display of formulas to be extremely slow. For
15107 example, while @samp{eval(a + b)} might seem quite fast and simple,
15108 there are several situations where it could be slow. For example,
15109 @samp{a} and/or @samp{b} could be polar complex numbers, in which
15110 case doing the sum requires trigonometry. Or, @samp{a} could be
15111 the factorial @samp{fact(100)} which is unevaluated because you
15112 have typed @kbd{m O}; @code{eval} will evaluate it anyway to
15113 produce a large, unwieldy integer.
15115 You can save your display formats permanently using the @kbd{Z P}
15116 command (@pxref{Creating User Keys}).
15118 @node Syntax Tables, , Compositions, Language Modes
15119 @subsection Syntax Tables
15122 @cindex Syntax tables
15123 @cindex Parsing formulas, customized
15124 Syntax tables do for input what compositions do for output: They
15125 allow you to teach custom notations to Calc's formula parser.
15126 Calc keeps a separate syntax table for each language mode.
15128 (Note that the Calc ``syntax tables'' discussed here are completely
15129 unrelated to the syntax tables described in the Emacs manual.)
15132 @pindex calc-edit-user-syntax
15133 The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
15134 syntax table for the current language mode. If you want your
15135 syntax to work in any language, define it in the Normal language
15136 mode. Type @kbd{C-c C-c} to finish editing the syntax table, or
15137 @kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all
15138 the syntax tables along with the other mode settings;
15139 @pxref{General Mode Commands}.
15142 * Syntax Table Basics::
15143 * Precedence in Syntax Tables::
15144 * Advanced Syntax Patterns::
15145 * Conditional Syntax Rules::
15148 @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
15149 @subsubsection Syntax Table Basics
15152 @dfn{Parsing} is the process of converting a raw string of characters,
15153 such as you would type in during algebraic entry, into a Calc formula.
15154 Calc's parser works in two stages. First, the input is broken down
15155 into @dfn{tokens}, such as words, numbers, and punctuation symbols
15156 like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is
15157 ignored (except when it serves to separate adjacent words). Next,
15158 the parser matches this string of tokens against various built-in
15159 syntactic patterns, such as ``an expression followed by @samp{+}
15160 followed by another expression'' or ``a name followed by @samp{(},
15161 zero or more expressions separated by commas, and @samp{)}.''
15163 A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
15164 which allow you to specify new patterns to define your own
15165 favorite input notations. Calc's parser always checks the syntax
15166 table for the current language mode, then the table for the Normal
15167 language mode, before it uses its built-in rules to parse an
15168 algebraic formula you have entered. Each syntax rule should go on
15169 its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
15170 and a Calc formula with an optional @dfn{condition}. (Syntax rules
15171 resemble algebraic rewrite rules, but the notation for patterns is
15172 completely different.)
15174 A syntax pattern is a list of tokens, separated by spaces.
15175 Except for a few special symbols, tokens in syntax patterns are
15176 matched literally, from left to right. For example, the rule,
15183 would cause Calc to parse the formula @samp{4+foo()*5} as if it
15184 were @samp{4+(2+3)*5}. Notice that the parentheses were written
15185 as two separate tokens in the rule. As a result, the rule works
15186 for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written
15187 the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
15188 as a single, indivisible token, so that @w{@samp{foo( )}} would
15189 not be recognized by the rule. (It would be parsed as a regular
15190 zero-argument function call instead.) In fact, this rule would
15191 also make trouble for the rest of Calc's parser: An unrelated
15192 formula like @samp{bar()} would now be tokenized into @samp{bar ()}
15193 instead of @samp{bar ( )}, so that the standard parser for function
15194 calls would no longer recognize it!
15196 While it is possible to make a token with a mixture of letters
15197 and punctuation symbols, this is not recommended. It is better to
15198 break it into several tokens, as we did with @samp{foo()} above.
15200 The symbol @samp{#} in a syntax pattern matches any Calc expression.
15201 On the righthand side, the things that matched the @samp{#}s can
15202 be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
15203 matches the leftmost @samp{#} in the pattern). For example, these
15204 rules match a user-defined function, prefix operator, infix operator,
15205 and postfix operator, respectively:
15208 foo ( # ) := myfunc(#1)
15209 foo # := myprefix(#1)
15210 # foo # := myinfix(#1,#2)
15211 # foo := mypostfix(#1)
15214 Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
15215 will parse as @samp{mypostfix(2+3)}.
15217 It is important to write the first two rules in the order shown,
15218 because Calc tries rules in order from first to last. If the
15219 pattern @samp{foo #} came first, it would match anything that could
15220 match the @samp{foo ( # )} rule, since an expression in parentheses
15221 is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would
15222 never get to match anything. Likewise, the last two rules must be
15223 written in the order shown or else @samp{3 foo 4} will be parsed as
15224 @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these
15225 ambiguities is not to use the same symbol in more than one way at
15226 the same time! In case you're not convinced, try the following
15227 exercise: How will the above rules parse the input @samp{foo(3,4)},
15228 if at all? Work it out for yourself, then try it in Calc and see.)
15230 Calc is quite flexible about what sorts of patterns are allowed.
15231 The only rule is that every pattern must begin with a literal
15232 token (like @samp{foo} in the first two patterns above), or with
15233 a @samp{#} followed by a literal token (as in the last two
15234 patterns). After that, any mixture is allowed, although putting
15235 two @samp{#}s in a row will not be very useful since two
15236 expressions with nothing between them will be parsed as one
15237 expression that uses implicit multiplication.
15239 As a more practical example, Maple uses the notation
15240 @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
15241 recognize at present. To handle this syntax, we simply add the
15245 sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
15249 to the Maple mode syntax table. As another example, C mode can't
15250 read assignment operators like @samp{++} and @samp{*=}. We can
15251 define these operators quite easily:
15254 # *= # := muleq(#1,#2)
15255 # ++ := postinc(#1)
15260 To complete the job, we would use corresponding composition functions
15261 and @kbd{Z C} to cause these functions to display in their respective
15262 Maple and C notations. (Note that the C example ignores issues of
15263 operator precedence, which are discussed in the next section.)
15265 You can enclose any token in quotes to prevent its usual
15266 interpretation in syntax patterns:
15269 # ":=" # := becomes(#1,#2)
15272 Quotes also allow you to include spaces in a token, although once
15273 again it is generally better to use two tokens than one token with
15274 an embedded space. To include an actual quotation mark in a quoted
15275 token, precede it with a backslash. (This also works to include
15276 backslashes in tokens.)
15279 # "bad token" # "/\"\\" # := silly(#1,#2,#3)
15283 This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
15285 The token @kbd{#} has a predefined meaning in Calc's formula parser;
15286 it is not valid to use @samp{"#"} in a syntax rule. However, longer
15287 tokens that include the @samp{#} character are allowed. Also, while
15288 @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
15289 the syntax table will prevent those characters from working in their
15290 usual ways (referring to stack entries and quoting strings,
15293 Finally, the notation @samp{%%} anywhere in a syntax table causes
15294 the rest of the line to be ignored as a comment.
15296 @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
15297 @subsubsection Precedence
15300 Different operators are generally assigned different @dfn{precedences}.
15301 By default, an operator defined by a rule like
15304 # foo # := foo(#1,#2)
15308 will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
15309 will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the
15310 precedence of an operator, use the notation @samp{#/@var{p}} in
15311 place of @samp{#}, where @var{p} is an integer precedence level.
15312 For example, 185 lies between the precedences for @samp{+} and
15313 @samp{*}, so if we change this rule to
15316 #/185 foo #/186 := foo(#1,#2)
15320 then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
15321 Also, because we've given the righthand expression slightly higher
15322 precedence, our new operator will be left-associative:
15323 @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
15324 By raising the precedence of the lefthand expression instead, we
15325 can create a right-associative operator.
15327 @xref{Composition Basics}, for a table of precedences of the
15328 standard Calc operators. For the precedences of operators in other
15329 language modes, look in the Calc source file @file{calc-lang.el}.
15331 @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
15332 @subsubsection Advanced Syntax Patterns
15335 To match a function with a variable number of arguments, you could
15339 foo ( # ) := myfunc(#1)
15340 foo ( # , # ) := myfunc(#1,#2)
15341 foo ( # , # , # ) := myfunc(#1,#2,#3)
15345 but this isn't very elegant. To match variable numbers of items,
15346 Calc uses some notations inspired regular expressions and the
15347 ``extended BNF'' style used by some language designers.
15350 foo ( @{ # @}*, ) := apply(myfunc,#1)
15353 The token @samp{@{} introduces a repeated or optional portion.
15354 One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
15355 ends the portion. These will match zero or more, one or more,
15356 or zero or one copies of the enclosed pattern, respectively.
15357 In addition, @samp{@}*} and @samp{@}+} can be followed by a
15358 separator token (with no space in between, as shown above).
15359 Thus @samp{@{ # @}*,} matches nothing, or one expression, or
15360 several expressions separated by commas.
15362 A complete @samp{@{ ... @}} item matches as a vector of the
15363 items that matched inside it. For example, the above rule will
15364 match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
15365 The Calc @code{apply} function takes a function name and a vector
15366 of arguments and builds a call to the function with those
15367 arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
15369 If the body of a @samp{@{ ... @}} contains several @samp{#}s
15370 (or nested @samp{@{ ... @}} constructs), then the items will be
15371 strung together into the resulting vector. If the body
15372 does not contain anything but literal tokens, the result will
15373 always be an empty vector.
15376 foo ( @{ # , # @}+, ) := bar(#1)
15377 foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
15381 will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
15382 @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after
15383 some thought it's easy to see how this pair of rules will parse
15384 @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
15385 rule will only match an even number of arguments. The rule
15388 foo ( # @{ , # , # @}? ) := bar(#1,#2)
15392 will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
15393 @samp{foo(2)} as @samp{bar(2,[])}.
15395 The notation @samp{@{ ... @}?.} (note the trailing period) works
15396 just the same as regular @samp{@{ ... @}?}, except that it does not
15397 count as an argument; the following two rules are equivalent:
15400 foo ( # , @{ also @}? # ) := bar(#1,#3)
15401 foo ( # , @{ also @}?. # ) := bar(#1,#2)
15405 Note that in the first case the optional text counts as @samp{#2},
15406 which will always be an empty vector, but in the second case no
15407 empty vector is produced.
15409 Another variant is @samp{@{ ... @}?$}, which means the body is
15410 optional only at the end of the input formula. All built-in syntax
15411 rules in Calc use this for closing delimiters, so that during
15412 algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
15413 the closing parenthesis and bracket. Calc does this automatically
15414 for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
15415 rules, but you can use @samp{@{ ... @}?$} explicitly to get
15416 this effect with any token (such as @samp{"@}"} or @samp{end}).
15417 Like @samp{@{ ... @}?.}, this notation does not count as an
15418 argument. Conversely, you can use quotes, as in @samp{")"}, to
15419 prevent a closing-delimiter token from being automatically treated
15422 Calc's parser does not have full backtracking, which means some
15423 patterns will not work as you might expect:
15426 foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
15430 Here we are trying to make the first argument optional, so that
15431 @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc
15432 first tries to match @samp{2,} against the optional part of the
15433 pattern, finds a match, and so goes ahead to match the rest of the
15434 pattern. Later on it will fail to match the second comma, but it
15435 doesn't know how to go back and try the other alternative at that
15436 point. One way to get around this would be to use two rules:
15439 foo ( # , # , # ) := bar([#1],#2,#3)
15440 foo ( # , # ) := bar([],#1,#2)
15443 More precisely, when Calc wants to match an optional or repeated
15444 part of a pattern, it scans forward attempting to match that part.
15445 If it reaches the end of the optional part without failing, it
15446 ``finalizes'' its choice and proceeds. If it fails, though, it
15447 backs up and tries the other alternative. Thus Calc has ``partial''
15448 backtracking. A fully backtracking parser would go on to make sure
15449 the rest of the pattern matched before finalizing the choice.
15451 @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
15452 @subsubsection Conditional Syntax Rules
15455 It is possible to attach a @dfn{condition} to a syntax rule. For
15459 foo ( # ) := ifoo(#1) :: integer(#1)
15460 foo ( # ) := gfoo(#1)
15464 will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
15465 @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any
15466 number of conditions may be attached; all must be true for the
15467 rule to succeed. A condition is ``true'' if it evaluates to a
15468 nonzero number. @xref{Logical Operations}, for a list of Calc
15469 functions like @code{integer} that perform logical tests.
15471 The exact sequence of events is as follows: When Calc tries a
15472 rule, it first matches the pattern as usual. It then substitutes
15473 @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the
15474 conditions are simplified and evaluated in order from left to right,
15475 as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}).
15476 Each result is true if it is a nonzero number, or an expression
15477 that can be proven to be nonzero (@pxref{Declarations}). If the
15478 results of all conditions are true, the expression (such as
15479 @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
15480 result of the parse. If the result of any condition is false, Calc
15481 goes on to try the next rule in the syntax table.
15483 Syntax rules also support @code{let} conditions, which operate in
15484 exactly the same way as they do in algebraic rewrite rules.
15485 @xref{Other Features of Rewrite Rules}, for details. A @code{let}
15486 condition is always true, but as a side effect it defines a
15487 variable which can be used in later conditions, and also in the
15488 expression after the @samp{:=} sign:
15491 foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
15495 The @code{dnumint} function tests if a value is numerically an
15496 integer, i.e., either a true integer or an integer-valued float.
15497 This rule will parse @code{foo} with a half-integer argument,
15498 like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
15500 The lefthand side of a syntax rule @code{let} must be a simple
15501 variable, not the arbitrary pattern that is allowed in rewrite
15504 The @code{matches} function is also treated specially in syntax
15505 rule conditions (again, in the same way as in rewrite rules).
15506 @xref{Matching Commands}. If the matching pattern contains
15507 meta-variables, then those meta-variables may be used in later
15508 conditions and in the result expression. The arguments to
15509 @code{matches} are not evaluated in this situation.
15512 sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
15516 This is another way to implement the Maple mode @code{sum} notation.
15517 In this approach, we allow @samp{#2} to equal the whole expression
15518 @samp{i=1..10}. Then, we use @code{matches} to break it apart into
15519 its components. If the expression turns out not to match the pattern,
15520 the syntax rule will fail. Note that @kbd{Z S} always uses Calc's
15521 Normal language mode for editing expressions in syntax rules, so we
15522 must use regular Calc notation for the interval @samp{[b..c]} that
15523 will correspond to the Maple mode interval @samp{1..10}.
15525 @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
15526 @section The @code{Modes} Variable
15530 @pindex calc-get-modes
15531 The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
15532 a vector of numbers that describes the various mode settings that
15533 are in effect. With a numeric prefix argument, it pushes only the
15534 @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard
15535 macros can use the @kbd{m g} command to modify their behavior based
15536 on the current mode settings.
15538 @cindex @code{Modes} variable
15540 The modes vector is also available in the special variable
15541 @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
15542 It will not work to store into this variable; in fact, if you do,
15543 @code{Modes} will cease to track the current modes. (The @kbd{m g}
15544 command will continue to work, however.)
15546 In general, each number in this vector is suitable as a numeric
15547 prefix argument to the associated mode-setting command. (Recall
15548 that the @kbd{~} key takes a number from the stack and gives it as
15549 a numeric prefix to the next command.)
15551 The elements of the modes vector are as follows:
15555 Current precision. Default is 12; associated command is @kbd{p}.
15558 Binary word size. Default is 32; associated command is @kbd{b w}.
15561 Stack size (not counting the value about to be pushed by @kbd{m g}).
15562 This is zero if @kbd{m g} is executed with an empty stack.
15565 Number radix. Default is 10; command is @kbd{d r}.
15568 Floating-point format. This is the number of digits, plus the
15569 constant 0 for normal notation, 10000 for scientific notation,
15570 20000 for engineering notation, or 30000 for fixed-point notation.
15571 These codes are acceptable as prefix arguments to the @kbd{d n}
15572 command, but note that this may lose information: For example,
15573 @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
15574 identical) effects if the current precision is 12, but they both
15575 produce a code of 10012, which will be treated by @kbd{d n} as
15576 @kbd{C-u 12 d s}. If the precision then changes, the float format
15577 will still be frozen at 12 significant figures.
15580 Angular mode. Default is 1 (degrees). Other values are 2 (radians)
15581 and 3 (HMS). The @kbd{m d} command accepts these prefixes.
15584 Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}.
15587 Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}.
15590 Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0.
15591 Command is @kbd{m p}.
15594 Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar
15595 mode, @mathit{-2} for Matrix mode, @mathit{-3} for square Matrix mode,
15597 @texline @math{N\times N}
15598 @infoline @var{N}x@var{N}
15599 Matrix mode. Command is @kbd{m v}.
15602 Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}),
15603 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
15604 or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes.
15607 Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on,
15608 or 0 if the mode is on with positive zeros. Command is @kbd{m i}.
15611 For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
15612 precision by two, leaving a copy of the old precision on the stack.
15613 Later, @kbd{~ p} will restore the original precision using that
15614 stack value. (This sequence might be especially useful inside a
15617 As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
15618 oldest (bottommost) stack entry.
15620 Yet another example: The HP-48 ``round'' command rounds a number
15621 to the current displayed precision. You could roughly emulate this
15622 in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This
15623 would not work for fixed-point mode, but it wouldn't be hard to
15624 do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
15625 programming commands. @xref{Conditionals in Macros}.)
15627 @node Calc Mode Line, , Modes Variable, Mode Settings
15628 @section The Calc Mode Line
15631 @cindex Mode line indicators
15632 This section is a summary of all symbols that can appear on the
15633 Calc mode line, the highlighted bar that appears under the Calc
15634 stack window (or under an editing window in Embedded mode).
15636 The basic mode line format is:
15639 --%%-Calc: 12 Deg @var{other modes} (Calculator)
15642 The @samp{%%} is the Emacs symbol for ``read-only''; it shows that
15643 regular Emacs commands are not allowed to edit the stack buffer
15644 as if it were text.
15646 The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode
15647 is enabled. The words after this describe the various Calc modes
15648 that are in effect.
15650 The first mode is always the current precision, an integer.
15651 The second mode is always the angular mode, either @code{Deg},
15652 @code{Rad}, or @code{Hms}.
15654 Here is a complete list of the remaining symbols that can appear
15659 Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
15662 Incomplete algebraic mode (@kbd{C-u m a}).
15665 Total algebraic mode (@kbd{m t}).
15668 Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
15671 Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
15673 @item Matrix@var{n}
15674 Dimensioned Matrix mode (@kbd{C-u @var{n} m v}; @pxref{Matrix Mode}).
15677 Square Matrix mode (@kbd{C-u m v}; @pxref{Matrix Mode}).
15680 Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
15683 Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
15686 Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
15689 Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
15692 Positive Infinite mode (@kbd{C-u 0 m i}).
15695 Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
15698 Default simplifications for numeric arguments only (@kbd{m N}).
15700 @item BinSimp@var{w}
15701 Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
15704 Algebraic simplification mode (@kbd{m A}).
15707 Extended algebraic simplification mode (@kbd{m E}).
15710 Units simplification mode (@kbd{m U}).
15713 Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
15716 Current radix is 8 (@kbd{d 8}).
15719 Current radix is 16 (@kbd{d 6}).
15722 Current radix is @var{n} (@kbd{d r}).
15725 Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
15728 Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
15731 One-line normal language mode (@kbd{d O}).
15734 Unformatted language mode (@kbd{d U}).
15737 C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
15740 Pascal language mode (@kbd{d P}).
15743 FORTRAN language mode (@kbd{d F}).
15746 @TeX{} language mode (@kbd{d T}; @pxref{TeX and LaTeX Language Modes}).
15749 La@TeX{} language mode (@kbd{d L}; @pxref{TeX and LaTeX Language Modes}).
15752 @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
15755 Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
15758 Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
15761 Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
15764 Fixed point mode with @var{n} digits after the point (@kbd{d f}).
15767 Scientific notation mode (@kbd{d s}).
15770 Scientific notation with @var{n} digits (@kbd{d s}).
15773 Engineering notation mode (@kbd{d e}).
15776 Engineering notation with @var{n} digits (@kbd{d e}).
15779 Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
15782 Right-justified display (@kbd{d >}).
15785 Right-justified display with width @var{n} (@kbd{d >}).
15788 Centered display (@kbd{d =}).
15790 @item Center@var{n}
15791 Centered display with center column @var{n} (@kbd{d =}).
15794 Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
15797 No line breaking (@kbd{d b}).
15800 Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
15803 Record modes in @file{~/.calc.el} (@kbd{m R}; @pxref{General Mode Commands}).
15806 Record modes in Embedded buffer (@kbd{m R}).
15809 Record modes as editing-only in Embedded buffer (@kbd{m R}).
15812 Record modes as permanent-only in Embedded buffer (@kbd{m R}).
15815 Record modes as global in Embedded buffer (@kbd{m R}).
15818 Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
15822 GNUPLOT process is alive in background (@pxref{Graphics}).
15825 Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
15828 The stack display may not be up-to-date (@pxref{Display Modes}).
15831 ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
15834 ``Hyperbolic'' prefix was pressed (@kbd{H}).
15837 ``Keep-arguments'' prefix was pressed (@kbd{K}).
15840 Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
15843 In addition, the symbols @code{Active} and @code{~Active} can appear
15844 as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}.
15846 @node Arithmetic, Scientific Functions, Mode Settings, Top
15847 @chapter Arithmetic Functions
15850 This chapter describes the Calc commands for doing simple calculations
15851 on numbers, such as addition, absolute value, and square roots. These
15852 commands work by removing the top one or two values from the stack,
15853 performing the desired operation, and pushing the result back onto the
15854 stack. If the operation cannot be performed, the result pushed is a
15855 formula instead of a number, such as @samp{2/0} (because division by zero
15856 is invalid) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
15858 Most of the commands described here can be invoked by a single keystroke.
15859 Some of the more obscure ones are two-letter sequences beginning with
15860 the @kbd{f} (``functions'') prefix key.
15862 @xref{Prefix Arguments}, for a discussion of the effect of numeric
15863 prefix arguments on commands in this chapter which do not otherwise
15864 interpret a prefix argument.
15867 * Basic Arithmetic::
15868 * Integer Truncation::
15869 * Complex Number Functions::
15871 * Date Arithmetic::
15872 * Financial Functions::
15873 * Binary Functions::
15876 @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
15877 @section Basic Arithmetic
15886 The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may
15887 be any of the standard Calc data types. The resulting sum is pushed back
15890 If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
15891 the result is a vector or matrix sum. If one argument is a vector and the
15892 other a scalar (i.e., a non-vector), the scalar is added to each of the
15893 elements of the vector to form a new vector. If the scalar is not a
15894 number, the operation is left in symbolic form: Suppose you added @samp{x}
15895 to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or
15896 you may plan to substitute a 2-vector for @samp{x} in the future. Since
15897 the Calculator can't tell which interpretation you want, it makes the
15898 safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x}
15899 to every element of a vector.
15901 If either argument of @kbd{+} is a complex number, the result will in general
15902 be complex. If one argument is in rectangular form and the other polar,
15903 the current Polar mode determines the form of the result. If Symbolic
15904 mode is enabled, the sum may be left as a formula if the necessary
15905 conversions for polar addition are non-trivial.
15907 If both arguments of @kbd{+} are HMS forms, the forms are added according to
15908 the usual conventions of hours-minutes-seconds notation. If one argument
15909 is an HMS form and the other is a number, that number is converted from
15910 degrees or radians (depending on the current Angular mode) to HMS format
15911 and then the two HMS forms are added.
15913 If one argument of @kbd{+} is a date form, the other can be either a
15914 real number, which advances the date by a certain number of days, or
15915 an HMS form, which advances the date by a certain amount of time.
15916 Subtracting two date forms yields the number of days between them.
15917 Adding two date forms is meaningless, but Calc interprets it as the
15918 subtraction of one date form and the negative of the other. (The
15919 negative of a date form can be understood by remembering that dates
15920 are stored as the number of days before or after Jan 1, 1 AD.)
15922 If both arguments of @kbd{+} are error forms, the result is an error form
15923 with an appropriately computed standard deviation. If one argument is an
15924 error form and the other is a number, the number is taken to have zero error.
15925 Error forms may have symbolic formulas as their mean and/or error parts;
15926 adding these will produce a symbolic error form result. However, adding an
15927 error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
15928 work, for the same reasons just mentioned for vectors. Instead you must
15929 write @samp{(a +/- b) + (c +/- 0)}.
15931 If both arguments of @kbd{+} are modulo forms with equal values of @expr{M},
15932 or if one argument is a modulo form and the other a plain number, the
15933 result is a modulo form which represents the sum, modulo @expr{M}, of
15936 If both arguments of @kbd{+} are intervals, the result is an interval
15937 which describes all possible sums of the possible input values. If
15938 one argument is a plain number, it is treated as the interval
15939 @w{@samp{[x ..@: x]}}.
15941 If one argument of @kbd{+} is an infinity and the other is not, the
15942 result is that same infinity. If both arguments are infinite and in
15943 the same direction, the result is the same infinity, but if they are
15944 infinite in different directions the result is @code{nan}.
15952 The @kbd{-} (@code{calc-minus}) command subtracts two values. The top
15953 number on the stack is subtracted from the one behind it, so that the
15954 computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options
15955 available for @kbd{+} are available for @kbd{-} as well.
15963 The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one
15964 argument is a vector and the other a scalar, the scalar is multiplied by
15965 the elements of the vector to produce a new vector. If both arguments
15966 are vectors, the interpretation depends on the dimensions of the
15967 vectors: If both arguments are matrices, a matrix multiplication is
15968 done. If one argument is a matrix and the other a plain vector, the
15969 vector is interpreted as a row vector or column vector, whichever is
15970 dimensionally correct. If both arguments are plain vectors, the result
15971 is a single scalar number which is the dot product of the two vectors.
15973 If one argument of @kbd{*} is an HMS form and the other a number, the
15974 HMS form is multiplied by that amount. It is an error to multiply two
15975 HMS forms together, or to attempt any multiplication involving date
15976 forms. Error forms, modulo forms, and intervals can be multiplied;
15977 see the comments for addition of those forms. When two error forms
15978 or intervals are multiplied they are considered to be statistically
15979 independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
15980 whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
15983 @pindex calc-divide
15988 The @kbd{/} (@code{calc-divide}) command divides two numbers.
15990 When combining multiplication and division in an algebraic formula, it
15991 is good style to use parentheses to distinguish between possible
15992 interpretations; the expression @samp{a/b*c} should be written
15993 @samp{(a/b)*c} or @samp{a/(b*c)}, as appropriate. Without the
15994 parentheses, Calc will interpret @samp{a/b*c} as @samp{a/(b*c)}, since
15995 in algebraic entry Calc gives division a lower precedence than
15996 multiplication. (This is not standard across all computer languages, and
15997 Calc may change the precedence depending on the language mode being used.
15998 @xref{Language Modes}.) This default ordering can be changed by setting
15999 the customizable variable @code{calc-multiplication-has-precedence} to
16000 @code{nil} (@pxref{Customizing Calc}); this will give multiplication and
16001 division equal precedences. Note that Calc's default choice of
16002 precedence allows @samp{a b / c d} to be used as a shortcut for
16011 When dividing a scalar @expr{B} by a square matrix @expr{A}, the
16012 computation performed is @expr{B} times the inverse of @expr{A}. This
16013 also occurs if @expr{B} is itself a vector or matrix, in which case the
16014 effect is to solve the set of linear equations represented by @expr{B}.
16015 If @expr{B} is a matrix with the same number of rows as @expr{A}, or a
16016 plain vector (which is interpreted here as a column vector), then the
16017 equation @expr{A X = B} is solved for the vector or matrix @expr{X}.
16018 Otherwise, if @expr{B} is a non-square matrix with the same number of
16019 @emph{columns} as @expr{A}, the equation @expr{X A = B} is solved. If
16020 you wish a vector @expr{B} to be interpreted as a row vector to be
16021 solved as @expr{X A = B}, make it into a one-row matrix with @kbd{C-u 1
16022 v p} first. To force a left-handed solution with a square matrix
16023 @expr{B}, transpose @expr{A} and @expr{B} before dividing, then
16024 transpose the result.
16026 HMS forms can be divided by real numbers or by other HMS forms. Error
16027 forms can be divided in any combination of ways. Modulo forms where both
16028 values and the modulo are integers can be divided to get an integer modulo
16029 form result. Intervals can be divided; dividing by an interval that
16030 encompasses zero or has zero as a limit will result in an infinite
16039 The @kbd{^} (@code{calc-power}) command raises a number to a power. If
16040 the power is an integer, an exact result is computed using repeated
16041 multiplications. For non-integer powers, Calc uses Newton's method or
16042 logarithms and exponentials. Square matrices can be raised to integer
16043 powers. If either argument is an error (or interval or modulo) form,
16044 the result is also an error (or interval or modulo) form.
16048 If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
16049 computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5.
16050 (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
16059 The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
16060 to produce an integer result. It is equivalent to dividing with
16061 @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
16062 more convenient and efficient. Also, since it is an all-integer
16063 operation when the arguments are integers, it avoids problems that
16064 @kbd{/ F} would have with floating-point roundoff.
16072 The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
16073 operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
16074 for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For
16075 positive @expr{b}, the result will always be between 0 (inclusive) and
16076 @expr{b} (exclusive). Modulo does not work for HMS forms and error forms.
16077 If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which
16078 must be positive real number.
16083 The @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command
16084 divides the two integers on the top of the stack to produce a fractional
16085 result. This is a convenient shorthand for enabling Fraction mode (with
16086 @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry
16087 the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
16088 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in
16089 this case, it would be much easier simply to enter the fraction directly
16090 as @kbd{8:6 @key{RET}}!)
16093 @pindex calc-change-sign
16094 The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
16095 of the stack. It works on numbers, vectors and matrices, HMS forms, date
16096 forms, error forms, intervals, and modulo forms.
16101 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
16102 value of a number. The result of @code{abs} is always a nonnegative
16103 real number: With a complex argument, it computes the complex magnitude.
16104 With a vector or matrix argument, it computes the Frobenius norm, i.e.,
16105 the square root of the sum of the squares of the absolute values of the
16106 elements. The absolute value of an error form is defined by replacing
16107 the mean part with its absolute value and leaving the error part the same.
16108 The absolute value of a modulo form is undefined. The absolute value of
16109 an interval is defined in the obvious way.
16112 @pindex calc-abssqr
16114 The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
16115 absolute value squared of a number, vector or matrix, or error form.
16120 The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
16121 argument is positive, @mathit{-1} if its argument is negative, or 0 if its
16122 argument is zero. In algebraic form, you can also write @samp{sign(a,x)}
16123 which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
16124 zero depending on the sign of @samp{a}.
16130 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
16131 reciprocal of a number, i.e., @expr{1 / x}. Operating on a square
16132 matrix, it computes the inverse of that matrix.
16137 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
16138 root of a number. For a negative real argument, the result will be a
16139 complex number whose form is determined by the current Polar mode.
16144 The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
16145 root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)}
16146 is the length of the hypotenuse of a right triangle with sides @expr{a}
16147 and @expr{b}. If the arguments are complex numbers, their squared
16148 magnitudes are used.
16153 The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
16154 integer square root of an integer. This is the true square root of the
16155 number, rounded down to an integer. For example, @samp{isqrt(10)}
16156 produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact
16157 integer arithmetic throughout to avoid roundoff problems. If the input
16158 is a floating-point number or other non-integer value, this is exactly
16159 the same as @samp{floor(sqrt(x))}.
16167 The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
16168 [@code{max}] commands take the minimum or maximum of two real numbers,
16169 respectively. These commands also work on HMS forms, date forms,
16170 intervals, and infinities. (In algebraic expressions, these functions
16171 take any number of arguments and return the maximum or minimum among
16172 all the arguments.)
16176 @pindex calc-mant-part
16178 @pindex calc-xpon-part
16180 The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
16181 the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X}
16182 (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
16183 @expr{e}. The original number is equal to
16184 @texline @math{m \times 10^e},
16185 @infoline @expr{m * 10^e},
16186 where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
16187 @expr{m=e=0} if the original number is zero. For integers
16188 and fractions, @code{mant} returns the number unchanged and @code{xpon}
16189 returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be
16190 used to ``unpack'' a floating-point number; this produces an integer
16191 mantissa and exponent, with the constraint that the mantissa is not
16192 a multiple of ten (again except for the @expr{m=e=0} case).
16195 @pindex calc-scale-float
16197 The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
16198 by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any
16199 real @samp{x}. The second argument must be an integer, but the first
16200 may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05}
16201 or @samp{1:20} depending on the current Fraction mode.
16205 @pindex calc-decrement
16206 @pindex calc-increment
16209 The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
16210 (@code{calc-increment}) [@code{incr}] functions decrease or increase
16211 a number by one unit. For integers, the effect is obvious. For
16212 floating-point numbers, the change is by one unit in the last place.
16213 For example, incrementing @samp{12.3456} when the current precision
16214 is 6 digits yields @samp{12.3457}. If the current precision had been
16215 8 digits, the result would have been @samp{12.345601}. Incrementing
16216 @samp{0.0} produces
16217 @texline @math{10^{-p}},
16218 @infoline @expr{10^-p},
16219 where @expr{p} is the current
16220 precision. These operations are defined only on integers and floats.
16221 With numeric prefix arguments, they change the number by @expr{n} units.
16223 Note that incrementing followed by decrementing, or vice-versa, will
16224 almost but not quite always cancel out. Suppose the precision is
16225 6 digits and the number @samp{9.99999} is on the stack. Incrementing
16226 will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
16227 One digit has been dropped. This is an unavoidable consequence of the
16228 way floating-point numbers work.
16230 Incrementing a date/time form adjusts it by a certain number of seconds.
16231 Incrementing a pure date form adjusts it by a certain number of days.
16233 @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
16234 @section Integer Truncation
16237 There are four commands for truncating a real number to an integer,
16238 differing mainly in their treatment of negative numbers. All of these
16239 commands have the property that if the argument is an integer, the result
16240 is the same integer. An integer-valued floating-point argument is converted
16243 If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
16244 expressed as an integer-valued floating-point number.
16246 @cindex Integer part of a number
16255 The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
16256 truncates a real number to the next lower integer, i.e., toward minus
16257 infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
16261 @pindex calc-ceiling
16268 The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
16269 command truncates toward positive infinity. Thus @kbd{3.6 I F} produces
16270 4, and @kbd{_3.6 I F} produces @mathit{-3}.
16280 The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
16281 rounds to the nearest integer. When the fractional part is .5 exactly,
16282 this command rounds away from zero. (All other rounding in the
16283 Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4
16284 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}.
16294 The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
16295 command truncates toward zero. In other words, it ``chops off''
16296 everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and
16297 @kbd{_3.6 I R} produces @mathit{-3}.
16299 These functions may not be applied meaningfully to error forms, but they
16300 do work for intervals. As a convenience, applying @code{floor} to a
16301 modulo form floors the value part of the form. Applied to a vector,
16302 these functions operate on all elements of the vector one by one.
16303 Applied to a date form, they operate on the internal numerical
16304 representation of dates, converting a date/time form into a pure date.
16322 There are two more rounding functions which can only be entered in
16323 algebraic notation. The @code{roundu} function is like @code{round}
16324 except that it rounds up, toward plus infinity, when the fractional
16325 part is .5. This distinction matters only for negative arguments.
16326 Also, @code{rounde} rounds to an even number in the case of a tie,
16327 rounding up or down as necessary. For example, @samp{rounde(3.5)} and
16328 @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
16329 The advantage of round-to-even is that the net error due to rounding
16330 after a long calculation tends to cancel out to zero. An important
16331 subtle point here is that the number being fed to @code{rounde} will
16332 already have been rounded to the current precision before @code{rounde}
16333 begins. For example, @samp{rounde(2.500001)} with a current precision
16334 of 6 will incorrectly, or at least surprisingly, yield 2 because the
16335 argument will first have been rounded down to @expr{2.5} (which
16336 @code{rounde} sees as an exact tie between 2 and 3).
16338 Each of these functions, when written in algebraic formulas, allows
16339 a second argument which specifies the number of digits after the
16340 decimal point to keep. For example, @samp{round(123.4567, 2)} will
16341 produce the answer 123.46, and @samp{round(123.4567, -1)} will
16342 produce 120 (i.e., the cutoff is one digit to the @emph{left} of
16343 the decimal point). A second argument of zero is equivalent to
16344 no second argument at all.
16346 @cindex Fractional part of a number
16347 To compute the fractional part of a number (i.e., the amount which, when
16348 added to `@tfn{floor(}@var{n}@tfn{)}', will produce @var{n}) just take @var{n}
16349 modulo 1 using the @code{%} command.
16351 Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
16352 and @kbd{f Q} (integer square root) commands, which are analogous to
16353 @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
16354 arguments and return the result rounded down to an integer.
16356 @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
16357 @section Complex Number Functions
16363 The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
16364 complex conjugate of a number. For complex number @expr{a+bi}, the
16365 complex conjugate is @expr{a-bi}. If the argument is a real number,
16366 this command leaves it the same. If the argument is a vector or matrix,
16367 this command replaces each element by its complex conjugate.
16370 @pindex calc-argument
16372 The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
16373 ``argument'' or polar angle of a complex number. For a number in polar
16374 notation, this is simply the second component of the pair
16375 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'.
16376 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'.
16377 The result is expressed according to the current angular mode and will
16378 be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees
16379 (inclusive), or the equivalent range in radians.
16381 @pindex calc-imaginary
16382 The @code{calc-imaginary} command multiplies the number on the
16383 top of the stack by the imaginary number @expr{i = (0,1)}. This
16384 command is not normally bound to a key in Calc, but it is available
16385 on the @key{IMAG} button in Keypad mode.
16390 The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
16391 by its real part. This command has no effect on real numbers. (As an
16392 added convenience, @code{re} applied to a modulo form extracts
16398 The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
16399 by its imaginary part; real numbers are converted to zero. With a vector
16400 or matrix argument, these functions operate element-wise.
16405 @kindex v p (complex)
16407 The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
16408 the stack into a composite object such as a complex number. With
16409 a prefix argument of @mathit{-1}, it produces a rectangular complex number;
16410 with an argument of @mathit{-2}, it produces a polar complex number.
16411 (Also, @pxref{Building Vectors}.)
16416 @kindex v u (complex)
16417 @pindex calc-unpack
16418 The @kbd{v u} (@code{calc-unpack}) command takes the complex number
16419 (or other composite object) on the top of the stack and unpacks it
16420 into its separate components.
16422 @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
16423 @section Conversions
16426 The commands described in this section convert numbers from one form
16427 to another; they are two-key sequences beginning with the letter @kbd{c}.
16432 The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
16433 number on the top of the stack to floating-point form. For example,
16434 @expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to
16435 @expr{1.5}, and @expr{2.3} is left the same. If the value is a composite
16436 object such as a complex number or vector, each of the components is
16437 converted to floating-point. If the value is a formula, all numbers
16438 in the formula are converted to floating-point. Note that depending
16439 on the current floating-point precision, conversion to floating-point
16440 format may lose information.
16442 As a special exception, integers which appear as powers or subscripts
16443 are not floated by @kbd{c f}. If you really want to float a power,
16444 you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
16445 Because @kbd{c f} cannot examine the formula outside of the selection,
16446 it does not notice that the thing being floated is a power.
16447 @xref{Selecting Subformulas}.
16449 The normal @kbd{c f} command is ``pervasive'' in the sense that it
16450 applies to all numbers throughout the formula. The @code{pfloat}
16451 algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
16452 changes to @samp{a + 1.0} as soon as it is evaluated.
16456 With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
16457 only on the number or vector of numbers at the top level of its
16458 argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
16459 is left unevaluated because its argument is not a number.
16461 You should use @kbd{H c f} if you wish to guarantee that the final
16462 value, once all the variables have been assigned, is a float; you
16463 would use @kbd{c f} if you wish to do the conversion on the numbers
16464 that appear right now.
16467 @pindex calc-fraction
16469 The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
16470 floating-point number into a fractional approximation. By default, it
16471 produces a fraction whose decimal representation is the same as the
16472 input number, to within the current precision. You can also give a
16473 numeric prefix argument to specify a tolerance, either directly, or,
16474 if the prefix argument is zero, by using the number on top of the stack
16475 as the tolerance. If the tolerance is a positive integer, the fraction
16476 is correct to within that many significant figures. If the tolerance is
16477 a non-positive integer, it specifies how many digits fewer than the current
16478 precision to use. If the tolerance is a floating-point number, the
16479 fraction is correct to within that absolute amount.
16483 The @code{pfrac} function is pervasive, like @code{pfloat}.
16484 There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
16485 which is analogous to @kbd{H c f} discussed above.
16488 @pindex calc-to-degrees
16490 The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
16491 number into degrees form. The value on the top of the stack may be an
16492 HMS form (interpreted as degrees-minutes-seconds), or a real number which
16493 will be interpreted in radians regardless of the current angular mode.
16496 @pindex calc-to-radians
16498 The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
16499 HMS form or angle in degrees into an angle in radians.
16502 @pindex calc-to-hms
16504 The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
16505 number, interpreted according to the current angular mode, to an HMS
16506 form describing the same angle. In algebraic notation, the @code{hms}
16507 function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
16508 (The three-argument version is independent of the current angular mode.)
16510 @pindex calc-from-hms
16511 The @code{calc-from-hms} command converts the HMS form on the top of the
16512 stack into a real number according to the current angular mode.
16519 The @kbd{c p} (@code{calc-polar}) command converts the complex number on
16520 the top of the stack from polar to rectangular form, or from rectangular
16521 to polar form, whichever is appropriate. Real numbers are left the same.
16522 This command is equivalent to the @code{rect} or @code{polar}
16523 functions in algebraic formulas, depending on the direction of
16524 conversion. (It uses @code{polar}, except that if the argument is
16525 already a polar complex number, it uses @code{rect} instead. The
16526 @kbd{I c p} command always uses @code{rect}.)
16531 The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
16532 number on the top of the stack. Floating point numbers are re-rounded
16533 according to the current precision. Polar numbers whose angular
16534 components have strayed from the @mathit{-180} to @mathit{+180} degree range
16535 are normalized. (Note that results will be undesirable if the current
16536 angular mode is different from the one under which the number was
16537 produced!) Integers and fractions are generally unaffected by this
16538 operation. Vectors and formulas are cleaned by cleaning each component
16539 number (i.e., pervasively).
16541 If the simplification mode is set below the default level, it is raised
16542 to the default level for the purposes of this command. Thus, @kbd{c c}
16543 applies the default simplifications even if their automatic application
16544 is disabled. @xref{Simplification Modes}.
16546 @cindex Roundoff errors, correcting
16547 A numeric prefix argument to @kbd{c c} sets the floating-point precision
16548 to that value for the duration of the command. A positive prefix (of at
16549 least 3) sets the precision to the specified value; a negative or zero
16550 prefix decreases the precision by the specified amount.
16553 @pindex calc-clean-num
16554 The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
16555 to @kbd{c c} with the corresponding negative prefix argument. If roundoff
16556 errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
16557 decimal place often conveniently does the trick.
16559 The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
16560 through @kbd{c 9} commands, also ``clip'' very small floating-point
16561 numbers to zero. If the exponent is less than or equal to the negative
16562 of the specified precision, the number is changed to 0.0. For example,
16563 if the current precision is 12, then @kbd{c 2} changes the vector
16564 @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
16565 Numbers this small generally arise from roundoff noise.
16567 If the numbers you are using really are legitimately this small,
16568 you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
16569 (The plain @kbd{c c} command rounds to the current precision but
16570 does not clip small numbers.)
16572 One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
16573 a prefix argument, is that integer-valued floats are converted to
16574 plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
16575 produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge
16576 numbers (@samp{1e100} is technically an integer-valued float, but
16577 you wouldn't want it automatically converted to a 100-digit integer).
16582 With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
16583 operate non-pervasively [@code{clean}].
16585 @node Date Arithmetic, Financial Functions, Conversions, Arithmetic
16586 @section Date Arithmetic
16589 @cindex Date arithmetic, additional functions
16590 The commands described in this section perform various conversions
16591 and calculations involving date forms (@pxref{Date Forms}). They
16592 use the @kbd{t} (for time/date) prefix key followed by shifted
16595 The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
16596 commands. In particular, adding a number to a date form advances the
16597 date form by a certain number of days; adding an HMS form to a date
16598 form advances the date by a certain amount of time; and subtracting two
16599 date forms produces a difference measured in days. The commands
16600 described here provide additional, more specialized operations on dates.
16602 Many of these commands accept a numeric prefix argument; if you give
16603 plain @kbd{C-u} as the prefix, these commands will instead take the
16604 additional argument from the top of the stack.
16607 * Date Conversions::
16613 @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
16614 @subsection Date Conversions
16620 The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
16621 date form into a number, measured in days since Jan 1, 1 AD. The
16622 result will be an integer if @var{date} is a pure date form, or a
16623 fraction or float if @var{date} is a date/time form. Or, if its
16624 argument is a number, it converts this number into a date form.
16626 With a numeric prefix argument, @kbd{t D} takes that many objects
16627 (up to six) from the top of the stack and interprets them in one
16628 of the following ways:
16630 The @samp{date(@var{year}, @var{month}, @var{day})} function
16631 builds a pure date form out of the specified year, month, and
16632 day, which must all be integers. @var{Year} is a year number,
16633 such as 1991 (@emph{not} the same as 91!). @var{Month} must be
16634 an integer in the range 1 to 12; @var{day} must be in the range
16635 1 to 31. If the specified month has fewer than 31 days and
16636 @var{day} is too large, the equivalent day in the following
16637 month will be used.
16639 The @samp{date(@var{month}, @var{day})} function builds a
16640 pure date form using the current year, as determined by the
16643 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
16644 function builds a date/time form using an @var{hms} form.
16646 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
16647 @var{minute}, @var{second})} function builds a date/time form.
16648 @var{hour} should be an integer in the range 0 to 23;
16649 @var{minute} should be an integer in the range 0 to 59;
16650 @var{second} should be any real number in the range @samp{[0 .. 60)}.
16651 The last two arguments default to zero if omitted.
16654 @pindex calc-julian
16656 @cindex Julian day counts, conversions
16657 The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
16658 a date form into a Julian day count, which is the number of days
16659 since noon on Jan 1, 4713 BC. A pure date is converted to an integer
16660 Julian count representing noon of that day. A date/time form is
16661 converted to an exact floating-point Julian count, adjusted to
16662 interpret the date form in the current time zone but the Julian
16663 day count in Greenwich Mean Time. A numeric prefix argument allows
16664 you to specify the time zone; @pxref{Time Zones}. Use a prefix of
16665 zero to suppress the time zone adjustment. Note that pure date forms
16666 are never time-zone adjusted.
16668 This command can also do the opposite conversion, from a Julian day
16669 count (either an integer day, or a floating-point day and time in
16670 the GMT zone), into a pure date form or a date/time form in the
16671 current or specified time zone.
16674 @pindex calc-unix-time
16676 @cindex Unix time format, conversions
16677 The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
16678 converts a date form into a Unix time value, which is the number of
16679 seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result
16680 will be an integer if the current precision is 12 or less; for higher
16681 precisions, the result may be a float with (@var{precision}@minus{}12)
16682 digits after the decimal. Just as for @kbd{t J}, the numeric time
16683 is interpreted in the GMT time zone and the date form is interpreted
16684 in the current or specified zone. Some systems use Unix-like
16685 numbering but with the local time zone; give a prefix of zero to
16686 suppress the adjustment if so.
16689 @pindex calc-convert-time-zones
16691 @cindex Time Zones, converting between
16692 The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
16693 command converts a date form from one time zone to another. You
16694 are prompted for each time zone name in turn; you can answer with
16695 any suitable Calc time zone expression (@pxref{Time Zones}).
16696 If you answer either prompt with a blank line, the local time
16697 zone is used for that prompt. You can also answer the first
16698 prompt with @kbd{$} to take the two time zone names from the
16699 stack (and the date to be converted from the third stack level).
16701 @node Date Functions, Business Days, Date Conversions, Date Arithmetic
16702 @subsection Date Functions
16708 The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
16709 current date and time on the stack as a date form. The time is
16710 reported in terms of the specified time zone; with no numeric prefix
16711 argument, @kbd{t N} reports for the current time zone.
16714 @pindex calc-date-part
16715 The @kbd{t P} (@code{calc-date-part}) command extracts one part
16716 of a date form. The prefix argument specifies the part; with no
16717 argument, this command prompts for a part code from 1 to 9.
16718 The various part codes are described in the following paragraphs.
16721 The @kbd{M-1 t P} [@code{year}] function extracts the year number
16722 from a date form as an integer, e.g., 1991. This and the
16723 following functions will also accept a real number for an
16724 argument, which is interpreted as a standard Calc day number.
16725 Note that this function will never return zero, since the year
16726 1 BC immediately precedes the year 1 AD.
16729 The @kbd{M-2 t P} [@code{month}] function extracts the month number
16730 from a date form as an integer in the range 1 to 12.
16733 The @kbd{M-3 t P} [@code{day}] function extracts the day number
16734 from a date form as an integer in the range 1 to 31.
16737 The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
16738 a date form as an integer in the range 0 (midnight) to 23. Note
16739 that 24-hour time is always used. This returns zero for a pure
16740 date form. This function (and the following two) also accept
16741 HMS forms as input.
16744 The @kbd{M-5 t P} [@code{minute}] function extracts the minute
16745 from a date form as an integer in the range 0 to 59.
16748 The @kbd{M-6 t P} [@code{second}] function extracts the second
16749 from a date form. If the current precision is 12 or less,
16750 the result is an integer in the range 0 to 59. For higher
16751 precisions, the result may instead be a floating-point number.
16754 The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
16755 number from a date form as an integer in the range 0 (Sunday)
16759 The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
16760 number from a date form as an integer in the range 1 (January 1)
16761 to 366 (December 31 of a leap year).
16764 The @kbd{M-9 t P} [@code{time}] function extracts the time portion
16765 of a date form as an HMS form. This returns @samp{0@@ 0' 0"}
16766 for a pure date form.
16769 @pindex calc-new-month
16771 The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
16772 computes a new date form that represents the first day of the month
16773 specified by the input date. The result is always a pure date
16774 form; only the year and month numbers of the input are retained.
16775 With a numeric prefix argument @var{n} in the range from 1 to 31,
16776 @kbd{t M} computes the @var{n}th day of the month. (If @var{n}
16777 is greater than the actual number of days in the month, or if
16778 @var{n} is zero, the last day of the month is used.)
16781 @pindex calc-new-year
16783 The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
16784 computes a new pure date form that represents the first day of
16785 the year specified by the input. The month, day, and time
16786 of the input date form are lost. With a numeric prefix argument
16787 @var{n} in the range from 1 to 366, @kbd{t Y} computes the
16788 @var{n}th day of the year (366 is treated as 365 in non-leap
16789 years). A prefix argument of 0 computes the last day of the
16790 year (December 31). A negative prefix argument from @mathit{-1} to
16791 @mathit{-12} computes the first day of the @var{n}th month of the year.
16794 @pindex calc-new-week
16796 The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
16797 computes a new pure date form that represents the Sunday on or before
16798 the input date. With a numeric prefix argument, it can be made to
16799 use any day of the week as the starting day; the argument must be in
16800 the range from 0 (Sunday) to 6 (Saturday). This function always
16801 subtracts between 0 and 6 days from the input date.
16803 Here's an example use of @code{newweek}: Find the date of the next
16804 Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
16805 will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
16806 will give you the following Wednesday. A further look at the definition
16807 of @code{newweek} shows that if the input date is itself a Wednesday,
16808 this formula will return the Wednesday one week in the future. An
16809 exercise for the reader is to modify this formula to yield the same day
16810 if the input is already a Wednesday. Another interesting exercise is
16811 to preserve the time-of-day portion of the input (@code{newweek} resets
16812 the time to midnight; hint:@: how can @code{newweek} be defined in terms
16813 of the @code{weekday} function?).
16819 The @samp{pwday(@var{date})} function (not on any key) computes the
16820 day-of-month number of the Sunday on or before @var{date}. With
16821 two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
16822 number of the Sunday on or before day number @var{day} of the month
16823 specified by @var{date}. The @var{day} must be in the range from
16824 7 to 31; if the day number is greater than the actual number of days
16825 in the month, the true number of days is used instead. Thus
16826 @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
16827 @samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
16828 With a third @var{weekday} argument, @code{pwday} can be made to look
16829 for any day of the week instead of Sunday.
16832 @pindex calc-inc-month
16834 The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
16835 increases a date form by one month, or by an arbitrary number of
16836 months specified by a numeric prefix argument. The time portion,
16837 if any, of the date form stays the same. The day also stays the
16838 same, except that if the new month has fewer days the day
16839 number may be reduced to lie in the valid range. For example,
16840 @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
16841 Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
16842 the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
16849 The @samp{incyear(@var{date}, @var{step})} function increases
16850 a date form by the specified number of years, which may be
16851 any positive or negative integer. Note that @samp{incyear(d, n)}
16852 is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
16853 simple equivalents in terms of day arithmetic because
16854 months and years have varying lengths. If the @var{step}
16855 argument is omitted, 1 year is assumed. There is no keyboard
16856 command for this function; use @kbd{C-u 12 t I} instead.
16858 There is no @code{newday} function at all because @kbd{F} [@code{floor}]
16859 serves this purpose. Similarly, instead of @code{incday} and
16860 @code{incweek} simply use @expr{d + n} or @expr{d + 7 n}.
16862 @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
16863 which can adjust a date/time form by a certain number of seconds.
16865 @node Business Days, Time Zones, Date Functions, Date Arithmetic
16866 @subsection Business Days
16869 Often time is measured in ``business days'' or ``working days,''
16870 where weekends and holidays are skipped. Calc's normal date
16871 arithmetic functions use calendar days, so that subtracting two
16872 consecutive Mondays will yield a difference of 7 days. By contrast,
16873 subtracting two consecutive Mondays would yield 5 business days
16874 (assuming two-day weekends and the absence of holidays).
16880 @pindex calc-business-days-plus
16881 @pindex calc-business-days-minus
16882 The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
16883 and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
16884 commands perform arithmetic using business days. For @kbd{t +},
16885 one argument must be a date form and the other must be a real
16886 number (positive or negative). If the number is not an integer,
16887 then a certain amount of time is added as well as a number of
16888 days; for example, adding 0.5 business days to a time in Friday
16889 evening will produce a time in Monday morning. It is also
16890 possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
16891 half a business day. For @kbd{t -}, the arguments are either a
16892 date form and a number or HMS form, or two date forms, in which
16893 case the result is the number of business days between the two
16896 @cindex @code{Holidays} variable
16898 By default, Calc considers any day that is not a Saturday or
16899 Sunday to be a business day. You can define any number of
16900 additional holidays by editing the variable @code{Holidays}.
16901 (There is an @w{@kbd{s H}} convenience command for editing this
16902 variable.) Initially, @code{Holidays} contains the vector
16903 @samp{[sat, sun]}. Entries in the @code{Holidays} vector may
16904 be any of the following kinds of objects:
16908 Date forms (pure dates, not date/time forms). These specify
16909 particular days which are to be treated as holidays.
16912 Intervals of date forms. These specify a range of days, all of
16913 which are holidays (e.g., Christmas week). @xref{Interval Forms}.
16916 Nested vectors of date forms. Each date form in the vector is
16917 considered to be a holiday.
16920 Any Calc formula which evaluates to one of the above three things.
16921 If the formula involves the variable @expr{y}, it stands for a
16922 yearly repeating holiday; @expr{y} will take on various year
16923 numbers like 1992. For example, @samp{date(y, 12, 25)} specifies
16924 Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
16925 Thanksgiving (which is held on the fourth Thursday of November).
16926 If the formula involves the variable @expr{m}, that variable
16927 takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is
16928 a holiday that takes place on the 15th of every month.
16931 A weekday name, such as @code{sat} or @code{sun}. This is really
16932 a variable whose name is a three-letter, lower-case day name.
16935 An interval of year numbers (integers). This specifies the span of
16936 years over which this holiday list is to be considered valid. Any
16937 business-day arithmetic that goes outside this range will result
16938 in an error message. Use this if you are including an explicit
16939 list of holidays, rather than a formula to generate them, and you
16940 want to make sure you don't accidentally go beyond the last point
16941 where the holidays you entered are complete. If there is no
16942 limiting interval in the @code{Holidays} vector, the default
16943 @samp{[1 .. 2737]} is used. (This is the absolute range of years
16944 for which Calc's business-day algorithms will operate.)
16947 An interval of HMS forms. This specifies the span of hours that
16948 are to be considered one business day. For example, if this
16949 range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
16950 the business day is only eight hours long, so that @kbd{1.5 t +}
16951 on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
16952 four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
16953 Likewise, @kbd{t -} will now express differences in time as
16954 fractions of an eight-hour day. Times before 9am will be treated
16955 as 9am by business date arithmetic, and times at or after 5pm will
16956 be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays},
16957 the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
16958 (Regardless of the type of bounds you specify, the interval is
16959 treated as inclusive on the low end and exclusive on the high end,
16960 so that the work day goes from 9am up to, but not including, 5pm.)
16963 If the @code{Holidays} vector is empty, then @kbd{t +} and
16964 @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
16965 then be no difference between business days and calendar days.
16967 Calc expands the intervals and formulas you give into a complete
16968 list of holidays for internal use. This is done mainly to make
16969 sure it can detect multiple holidays. (For example,
16970 @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
16971 Calc's algorithms take care to count it only once when figuring
16972 the number of holidays between two dates.)
16974 Since the complete list of holidays for all the years from 1 to
16975 2737 would be huge, Calc actually computes only the part of the
16976 list between the smallest and largest years that have been involved
16977 in business-day calculations so far. Normally, you won't have to
16978 worry about this. Keep in mind, however, that if you do one
16979 calculation for 1992, and another for 1792, even if both involve
16980 only a small range of years, Calc will still work out all the
16981 holidays that fall in that 200-year span.
16983 If you add a (positive) number of days to a date form that falls on a
16984 weekend or holiday, the date form is treated as if it were the most
16985 recent business day. (Thus adding one business day to a Friday,
16986 Saturday, or Sunday will all yield the following Monday.) If you
16987 subtract a number of days from a weekend or holiday, the date is
16988 effectively on the following business day. (So subtracting one business
16989 day from Saturday, Sunday, or Monday yields the preceding Friday.) The
16990 difference between two dates one or both of which fall on holidays
16991 equals the number of actual business days between them. These
16992 conventions are consistent in the sense that, if you add @var{n}
16993 business days to any date, the difference between the result and the
16994 original date will come out to @var{n} business days. (It can't be
16995 completely consistent though; a subtraction followed by an addition
16996 might come out a bit differently, since @kbd{t +} is incapable of
16997 producing a date that falls on a weekend or holiday.)
17003 There is a @code{holiday} function, not on any keys, that takes
17004 any date form and returns 1 if that date falls on a weekend or
17005 holiday, as defined in @code{Holidays}, or 0 if the date is a
17008 @node Time Zones, , Business Days, Date Arithmetic
17009 @subsection Time Zones
17013 @cindex Daylight saving time
17014 Time zones and daylight saving time are a complicated business.
17015 The conversions to and from Julian and Unix-style dates automatically
17016 compute the correct time zone and daylight saving adjustment to use,
17017 provided they can figure out this information. This section describes
17018 Calc's time zone adjustment algorithm in detail, in case you want to
17019 do conversions in different time zones or in case Calc's algorithms
17020 can't determine the right correction to use.
17022 Adjustments for time zones and daylight saving time are done by
17023 @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
17024 commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
17025 to exactly 30 days even though there is a daylight-saving
17026 transition in between. This is also true for Julian pure dates:
17027 @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian
17028 and Unix date/times will adjust for daylight saving time: using Calc's
17029 default daylight saving time rule (see the explanation below),
17030 @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
17031 evaluates to @samp{29.95833} (that's 29 days and 23 hours)
17032 because one hour was lost when daylight saving commenced on
17035 In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
17036 computes the actual number of 24-hour periods between two dates, whereas
17037 @samp{@var{date1} - @var{date2}} computes the number of calendar
17038 days between two dates without taking daylight saving into account.
17040 @pindex calc-time-zone
17045 The @code{calc-time-zone} [@code{tzone}] command converts the time
17046 zone specified by its numeric prefix argument into a number of
17047 seconds difference from Greenwich mean time (GMT). If the argument
17048 is a number, the result is simply that value multiplied by 3600.
17049 Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If
17050 Daylight Saving time is in effect, one hour should be subtracted from
17051 the normal difference.
17053 If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
17054 date arithmetic commands that include a time zone argument) takes the
17055 zone argument from the top of the stack. (In the case of @kbd{t J}
17056 and @kbd{t U}, the normal argument is then taken from the second-to-top
17057 stack position.) This allows you to give a non-integer time zone
17058 adjustment. The time-zone argument can also be an HMS form, or
17059 it can be a variable which is a time zone name in upper- or lower-case.
17060 For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
17061 (for Pacific standard and daylight saving times, respectively).
17063 North American and European time zone names are defined as follows;
17064 note that for each time zone there is one name for standard time,
17065 another for daylight saving time, and a third for ``generalized'' time
17066 in which the daylight saving adjustment is computed from context.
17070 YST PST MST CST EST AST NST GMT WET MET MEZ
17071 9 8 7 6 5 4 3.5 0 -1 -2 -2
17073 YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ
17074 8 7 6 5 4 3 2.5 -1 -2 -3 -3
17076 YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ
17077 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3
17081 @vindex math-tzone-names
17082 To define time zone names that do not appear in the above table,
17083 you must modify the Lisp variable @code{math-tzone-names}. This
17084 is a list of lists describing the different time zone names; its
17085 structure is best explained by an example. The three entries for
17086 Pacific Time look like this:
17090 ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard
17091 ( "PDT" 8 -1 ) ; adjustment, then daylight saving adjustment.
17092 ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone.
17096 @cindex @code{TimeZone} variable
17098 With no arguments, @code{calc-time-zone} or @samp{tzone()} will by
17099 default get the time zone and daylight saving information from the
17100 calendar (@pxref{Daylight Saving,Calendar/Diary,The Calendar and the Diary,
17101 emacs,The GNU Emacs Manual}). To use a different time zone, or if the
17102 calendar does not give the desired result, you can set the Calc variable
17103 @code{TimeZone} (which is by default @code{nil}) to an appropriate
17104 time zone name. (The easiest way to do this is to edit the
17105 @code{TimeZone} variable using Calc's @kbd{s T} command, then use the
17106 @kbd{s p} (@code{calc-permanent-variable}) command to save the value of
17107 @code{TimeZone} permanently.)
17108 If the time zone given by @code{TimeZone} is a generalized time zone,
17109 e.g., @code{EGT}, Calc examines the date being converted to tell whether
17110 to use standard or daylight saving time. But if the current time zone
17111 is explicit, e.g., @code{EST} or @code{EDT}, then that adjustment is
17112 used exactly and Calc's daylight saving algorithm is not consulted.
17113 The special time zone name @code{local}
17114 is equivalent to no argument; i.e., it uses the information obtained
17117 The @kbd{t J} and @code{t U} commands with no numeric prefix
17118 arguments do the same thing as @samp{tzone()}; namely, use the
17119 information from the calendar if @code{TimeZone} is @code{nil},
17120 otherwise use the time zone given by @code{TimeZone}.
17122 @vindex math-daylight-savings-hook
17123 @findex math-std-daylight-savings
17124 When Calc computes the daylight saving information itself (i.e., when
17125 the @code{TimeZone} variable is set), it will by default consider
17126 daylight saving time to begin at 2 a.m.@: on the second Sunday of March
17127 (for years from 2007 on) or on the last Sunday in April (for years
17128 before 2007), and to end at 2 a.m.@: on the first Sunday of
17129 November. (for years from 2007 on) or the last Sunday in October (for
17130 years before 2007). These are the rules that have been in effect in
17131 much of North America since 1966 and take into account the rule change
17132 that began in 2007. If you are in a country that uses different rules
17133 for computing daylight saving time, you have two choices: Write your own
17134 daylight saving hook, or control time zones explicitly by setting the
17135 @code{TimeZone} variable and/or always giving a time-zone argument for
17136 the conversion functions.
17138 The Lisp variable @code{math-daylight-savings-hook} holds the
17139 name of a function that is used to compute the daylight saving
17140 adjustment for a given date. The default is
17141 @code{math-std-daylight-savings}, which computes an adjustment
17142 (either 0 or @mathit{-1}) using the North American rules given above.
17144 The daylight saving hook function is called with four arguments:
17145 The date, as a floating-point number in standard Calc format;
17146 a six-element list of the date decomposed into year, month, day,
17147 hour, minute, and second, respectively; a string which contains
17148 the generalized time zone name in upper-case, e.g., @code{"WEGT"};
17149 and a special adjustment to be applied to the hour value when
17150 converting into a generalized time zone (see below).
17152 @findex math-prev-weekday-in-month
17153 The Lisp function @code{math-prev-weekday-in-month} is useful for
17154 daylight saving computations. This is an internal version of
17155 the user-level @code{pwday} function described in the previous
17156 section. It takes four arguments: The floating-point date value,
17157 the corresponding six-element date list, the day-of-month number,
17158 and the weekday number (0-6).
17160 The default daylight saving hook ignores the time zone name, but a
17161 more sophisticated hook could use different algorithms for different
17162 time zones. It would also be possible to use different algorithms
17163 depending on the year number, but the default hook always uses the
17164 algorithm for 1987 and later. Here is a listing of the default
17165 daylight saving hook:
17168 (defun math-std-daylight-savings (date dt zone bump)
17169 (cond ((< (nth 1 dt) 4) 0)
17171 (let ((sunday (math-prev-weekday-in-month date dt 7 0)))
17172 (cond ((< (nth 2 dt) sunday) 0)
17173 ((= (nth 2 dt) sunday)
17174 (if (>= (nth 3 dt) (+ 3 bump)) -1 0))
17176 ((< (nth 1 dt) 10) -1)
17178 (let ((sunday (math-prev-weekday-in-month date dt 31 0)))
17179 (cond ((< (nth 2 dt) sunday) -1)
17180 ((= (nth 2 dt) sunday)
17181 (if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
17188 The @code{bump} parameter is equal to zero when Calc is converting
17189 from a date form in a generalized time zone into a GMT date value.
17190 It is @mathit{-1} when Calc is converting in the other direction. The
17191 adjustments shown above ensure that the conversion behaves correctly
17192 and reasonably around the 2 a.m.@: transition in each direction.
17194 There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
17195 beginning of daylight saving time; converting a date/time form that
17196 falls in this hour results in a time value for the following hour,
17197 from 3 a.m.@: to 4 a.m. At the end of daylight saving time, the
17198 hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
17199 form that falls in this hour results in a time value for the first
17200 manifestation of that time (@emph{not} the one that occurs one hour
17203 If @code{math-daylight-savings-hook} is @code{nil}, then the
17204 daylight saving adjustment is always taken to be zero.
17206 In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
17207 computes the time zone adjustment for a given zone name at a
17208 given date. The @var{date} is ignored unless @var{zone} is a
17209 generalized time zone. If @var{date} is a date form, the
17210 daylight saving computation is applied to it as it appears.
17211 If @var{date} is a numeric date value, it is adjusted for the
17212 daylight-saving version of @var{zone} before being given to
17213 the daylight saving hook. This odd-sounding rule ensures
17214 that the daylight-saving computation is always done in
17215 local time, not in the GMT time that a numeric @var{date}
17216 is typically represented in.
17222 The @samp{dsadj(@var{date}, @var{zone})} function computes the
17223 daylight saving adjustment that is appropriate for @var{date} in
17224 time zone @var{zone}. If @var{zone} is explicitly in or not in
17225 daylight saving time (e.g., @code{PDT} or @code{PST}) the
17226 @var{date} is ignored. If @var{zone} is a generalized time zone,
17227 the algorithms described above are used. If @var{zone} is omitted,
17228 the computation is done for the current time zone.
17230 @xref{Reporting Bugs}, for the address of Calc's author, if you
17231 should wish to contribute your improved versions of
17232 @code{math-tzone-names} and @code{math-daylight-savings-hook}
17233 to the Calc distribution.
17235 @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
17236 @section Financial Functions
17239 Calc's financial or business functions use the @kbd{b} prefix
17240 key followed by a shifted letter. (The @kbd{b} prefix followed by
17241 a lower-case letter is used for operations on binary numbers.)
17243 Note that the rate and the number of intervals given to these
17244 functions must be on the same time scale, e.g., both months or
17245 both years. Mixing an annual interest rate with a time expressed
17246 in months will give you very wrong answers!
17248 It is wise to compute these functions to a higher precision than
17249 you really need, just to make sure your answer is correct to the
17250 last penny; also, you may wish to check the definitions at the end
17251 of this section to make sure the functions have the meaning you expect.
17257 * Related Financial Functions::
17258 * Depreciation Functions::
17259 * Definitions of Financial Functions::
17262 @node Percentages, Future Value, Financial Functions, Financial Functions
17263 @subsection Percentages
17266 @pindex calc-percent
17269 The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
17270 say 5.4, and converts it to an equivalent actual number. For example,
17271 @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or
17272 @key{ESC} key combined with @kbd{%}.)
17274 Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
17275 You can enter @samp{5.4%} yourself during algebraic entry. The
17276 @samp{%} operator simply means, ``the preceding value divided by
17277 100.'' The @samp{%} operator has very high precedence, so that
17278 @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
17279 (The @samp{%} operator is just a postfix notation for the
17280 @code{percent} function, just like @samp{20!} is the notation for
17281 @samp{fact(20)}, or twenty-factorial.)
17283 The formula @samp{5.4%} would normally evaluate immediately to
17284 0.054, but the @kbd{M-%} command suppresses evaluation as it puts
17285 the formula onto the stack. However, the next Calc command that
17286 uses the formula @samp{5.4%} will evaluate it as its first step.
17287 The net effect is that you get to look at @samp{5.4%} on the stack,
17288 but Calc commands see it as @samp{0.054}, which is what they expect.
17290 In particular, @samp{5.4%} and @samp{0.054} are suitable values
17291 for the @var{rate} arguments of the various financial functions,
17292 but the number @samp{5.4} is probably @emph{not} suitable---it
17293 represents a rate of 540 percent!
17295 The key sequence @kbd{M-% *} effectively means ``percent-of.''
17296 For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
17297 68 (and also 68% of 25, which comes out to the same thing).
17300 @pindex calc-convert-percent
17301 The @kbd{c %} (@code{calc-convert-percent}) command converts the
17302 value on the top of the stack from numeric to percentage form.
17303 For example, if 0.08 is on the stack, @kbd{c %} converts it to
17304 @samp{8%}. The quantity is the same, it's just represented
17305 differently. (Contrast this with @kbd{M-%}, which would convert
17306 this number to @samp{0.08%}.) The @kbd{=} key is a convenient way
17307 to convert a formula like @samp{8%} back to numeric form, 0.08.
17309 To compute what percentage one quantity is of another quantity,
17310 use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
17314 @pindex calc-percent-change
17316 The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
17317 calculates the percentage change from one number to another.
17318 For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
17319 since 50 is 25% larger than 40. A negative result represents a
17320 decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
17321 20% smaller than 50. (The answers are different in magnitude
17322 because, in the first case, we're increasing by 25% of 40, but
17323 in the second case, we're decreasing by 20% of 50.) The effect
17324 of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting
17325 the answer to percentage form as if by @kbd{c %}.
17327 @node Future Value, Present Value, Percentages, Financial Functions
17328 @subsection Future Value
17332 @pindex calc-fin-fv
17334 The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
17335 the future value of an investment. It takes three arguments
17336 from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}.
17337 If you give payments of @var{payment} every year for @var{n}
17338 years, and the money you have paid earns interest at @var{rate} per
17339 year, then this function tells you what your investment would be
17340 worth at the end of the period. (The actual interval doesn't
17341 have to be years, as long as @var{n} and @var{rate} are expressed
17342 in terms of the same intervals.) This function assumes payments
17343 occur at the @emph{end} of each interval.
17347 The @kbd{I b F} [@code{fvb}] command does the same computation,
17348 but assuming your payments are at the beginning of each interval.
17349 Suppose you plan to deposit $1000 per year in a savings account
17350 earning 5.4% interest, starting right now. How much will be
17351 in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}.
17352 Thus you will have earned $870 worth of interest over the years.
17353 Using the stack, this calculation would have been
17354 @kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed
17355 as a number between 0 and 1, @emph{not} as a percentage.
17359 The @kbd{H b F} [@code{fvl}] command computes the future value
17360 of an initial lump sum investment. Suppose you could deposit
17361 those five thousand dollars in the bank right now; how much would
17362 they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}.
17364 The algebraic functions @code{fv} and @code{fvb} accept an optional
17365 fourth argument, which is used as an initial lump sum in the sense
17366 of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n},
17367 @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
17368 + fvl(@var{rate}, @var{n}, @var{initial})}.
17370 To illustrate the relationships between these functions, we could
17371 do the @code{fvb} calculation ``by hand'' using @code{fvl}. The
17372 final balance will be the sum of the contributions of our five
17373 deposits at various times. The first deposit earns interest for
17374 five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second
17375 deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) =
17376 1234.13}. And so on down to the last deposit, which earns one
17377 year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of
17378 these five values is, sure enough, $5870.73, just as was computed
17379 by @code{fvb} directly.
17381 What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments
17382 are now at the ends of the periods. The end of one year is the same
17383 as the beginning of the next, so what this really means is that we've
17384 lost the payment at year zero (which contributed $1300.78), but we're
17385 now counting the payment at year five (which, since it didn't have
17386 a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 =
17387 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
17389 @node Present Value, Related Financial Functions, Future Value, Financial Functions
17390 @subsection Present Value
17394 @pindex calc-fin-pv
17396 The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
17397 the present value of an investment. Like @code{fv}, it takes
17398 three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}.
17399 It computes the present value of a series of regular payments.
17400 Suppose you have the chance to make an investment that will
17401 pay $2000 per year over the next four years; as you receive
17402 these payments you can put them in the bank at 9% interest.
17403 You want to know whether it is better to make the investment, or
17404 to keep the money in the bank where it earns 9% interest right
17405 from the start. The calculation @code{pv(9%, 4, 2000)} gives the
17406 result 6479.44. If your initial investment must be less than this,
17407 say, $6000, then the investment is worthwhile. But if you had to
17408 put up $7000, then it would be better just to leave it in the bank.
17410 Here is the interpretation of the result of @code{pv}: You are
17411 trying to compare the return from the investment you are
17412 considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
17413 the return from leaving the money in the bank, which is
17414 @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
17415 you would have to put up in advance. The @code{pv} function
17416 finds the break-even point, @expr{x = 6479.44}, at which
17417 @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is
17418 the largest amount you should be willing to invest.
17422 The @kbd{I b P} [@code{pvb}] command solves the same problem,
17423 but with payments occurring at the beginning of each interval.
17424 It has the same relationship to @code{fvb} as @code{pv} has
17425 to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59},
17426 a larger number than @code{pv} produced because we get to start
17427 earning interest on the return from our investment sooner.
17431 The @kbd{H b P} [@code{pvl}] command computes the present value of
17432 an investment that will pay off in one lump sum at the end of the
17433 period. For example, if we get our $8000 all at the end of the
17434 four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much
17435 less than @code{pv} reported, because we don't earn any interest
17436 on the return from this investment. Note that @code{pvl} and
17437 @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}.
17439 You can give an optional fourth lump-sum argument to @code{pv}
17440 and @code{pvb}; this is handled in exactly the same way as the
17441 fourth argument for @code{fv} and @code{fvb}.
17444 @pindex calc-fin-npv
17446 The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
17447 the net present value of a series of irregular investments.
17448 The first argument is the interest rate. The second argument is
17449 a vector which represents the expected return from the investment
17450 at the end of each interval. For example, if the rate represents
17451 a yearly interest rate, then the vector elements are the return
17452 from the first year, second year, and so on.
17454 Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
17455 Obviously this function is more interesting when the payments are
17458 The @code{npv} function can actually have two or more arguments.
17459 Multiple arguments are interpreted in the same way as for the
17460 vector statistical functions like @code{vsum}.
17461 @xref{Single-Variable Statistics}. Basically, if there are several
17462 payment arguments, each either a vector or a plain number, all these
17463 values are collected left-to-right into the complete list of payments.
17464 A numeric prefix argument on the @kbd{b N} command says how many
17465 payment values or vectors to take from the stack.
17469 The @kbd{I b N} [@code{npvb}] command computes the net present
17470 value where payments occur at the beginning of each interval
17471 rather than at the end.
17473 @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
17474 @subsection Related Financial Functions
17477 The functions in this section are basically inverses of the
17478 present value functions with respect to the various arguments.
17481 @pindex calc-fin-pmt
17483 The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
17484 the amount of periodic payment necessary to amortize a loan.
17485 Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
17486 value of @var{payment} such that @code{pv(@var{rate}, @var{n},
17487 @var{payment}) = @var{amount}}.
17491 The @kbd{I b M} [@code{pmtb}] command does the same computation
17492 but using @code{pvb} instead of @code{pv}. Like @code{pv} and
17493 @code{pvb}, these functions can also take a fourth argument which
17494 represents an initial lump-sum investment.
17497 The @kbd{H b M} key just invokes the @code{fvl} function, which is
17498 the inverse of @code{pvl}. There is no explicit @code{pmtl} function.
17501 @pindex calc-fin-nper
17503 The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
17504 the number of regular payments necessary to amortize a loan.
17505 Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
17506 the value of @var{n} such that @code{pv(@var{rate}, @var{n},
17507 @var{payment}) = @var{amount}}. If @var{payment} is too small
17508 ever to amortize a loan for @var{amount} at interest rate @var{rate},
17509 the @code{nper} function is left in symbolic form.
17513 The @kbd{I b #} [@code{nperb}] command does the same computation
17514 but using @code{pvb} instead of @code{pv}. You can give a fourth
17515 lump-sum argument to these functions, but the computation will be
17516 rather slow in the four-argument case.
17520 The @kbd{H b #} [@code{nperl}] command does the same computation
17521 using @code{pvl}. By exchanging @var{payment} and @var{amount} you
17522 can also get the solution for @code{fvl}. For example,
17523 @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
17524 bank account earning 8%, it will take nine years to grow to $2000.
17527 @pindex calc-fin-rate
17529 The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
17530 the rate of return on an investment. This is also an inverse of @code{pv}:
17531 @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
17532 @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
17533 @var{amount}}. The result is expressed as a formula like @samp{6.3%}.
17539 The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
17540 commands solve the analogous equations with @code{pvb} or @code{pvl}
17541 in place of @code{pv}. Also, @code{rate} and @code{rateb} can
17542 accept an optional fourth argument just like @code{pv} and @code{pvb}.
17543 To redo the above example from a different perspective,
17544 @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
17545 interest rate of 8% in order to double your account in nine years.
17548 @pindex calc-fin-irr
17550 The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
17551 analogous function to @code{rate} but for net present value.
17552 Its argument is a vector of payments. Thus @code{irr(@var{payments})}
17553 computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
17554 this rate is known as the @dfn{internal rate of return}.
17558 The @kbd{I b I} [@code{irrb}] command computes the internal rate of
17559 return assuming payments occur at the beginning of each period.
17561 @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
17562 @subsection Depreciation Functions
17565 The functions in this section calculate @dfn{depreciation}, which is
17566 the amount of value that a possession loses over time. These functions
17567 are characterized by three parameters: @var{cost}, the original cost
17568 of the asset; @var{salvage}, the value the asset will have at the end
17569 of its expected ``useful life''; and @var{life}, the number of years
17570 (or other periods) of the expected useful life.
17572 There are several methods for calculating depreciation that differ in
17573 the way they spread the depreciation over the lifetime of the asset.
17576 @pindex calc-fin-sln
17578 The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
17579 ``straight-line'' depreciation. In this method, the asset depreciates
17580 by the same amount every year (or period). For example,
17581 @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000
17582 initially and will be worth $2000 after five years; it loses $2000
17586 @pindex calc-fin-syd
17588 The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
17589 accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation
17590 is higher during the early years of the asset's life. Since the
17591 depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
17592 parameter which specifies which year is requested, from 1 to @var{life}.
17593 If @var{period} is outside this range, the @code{syd} function will
17597 @pindex calc-fin-ddb
17599 The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
17600 accelerated depreciation using the double-declining balance method.
17601 It also takes a fourth @var{period} parameter.
17603 For symmetry, the @code{sln} function will accept a @var{period}
17604 parameter as well, although it will ignore its value except that the
17605 return value will as usual be zero if @var{period} is out of range.
17607 For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
17608 and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
17609 ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
17610 the three depreciation methods:
17614 [ [ 2000, 3333, 4800 ]
17615 [ 2000, 2667, 2880 ]
17616 [ 2000, 2000, 1728 ]
17617 [ 2000, 1333, 592 ]
17623 (Values have been rounded to nearest integers in this figure.)
17624 We see that @code{sln} depreciates by the same amount each year,
17625 @kbd{syd} depreciates more at the beginning and less at the end,
17626 and @kbd{ddb} weights the depreciation even more toward the beginning.
17628 Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]};
17629 the total depreciation in any method is (by definition) the
17630 difference between the cost and the salvage value.
17632 @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
17633 @subsection Definitions
17636 For your reference, here are the actual formulas used to compute
17637 Calc's financial functions.
17639 Calc will not evaluate a financial function unless the @var{rate} or
17640 @var{n} argument is known. However, @var{payment} or @var{amount} can
17641 be a variable. Calc expands these functions according to the
17642 formulas below for symbolic arguments only when you use the @kbd{a "}
17643 (@code{calc-expand-formula}) command, or when taking derivatives or
17644 integrals or solving equations involving the functions.
17647 These formulas are shown using the conventions of Big display
17648 mode (@kbd{d B}); for example, the formula for @code{fv} written
17649 linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
17654 fv(rate, n, pmt) = pmt * ---------------
17658 ((1 + rate) - 1) (1 + rate)
17659 fvb(rate, n, pmt) = pmt * ----------------------------
17663 fvl(rate, n, pmt) = pmt * (1 + rate)
17667 pv(rate, n, pmt) = pmt * ----------------
17671 (1 - (1 + rate) ) (1 + rate)
17672 pvb(rate, n, pmt) = pmt * -----------------------------
17676 pvl(rate, n, pmt) = pmt * (1 + rate)
17679 npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate)
17682 npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate)
17685 (amt - x * (1 + rate) ) * rate
17686 pmt(rate, n, amt, x) = -------------------------------
17691 (amt - x * (1 + rate) ) * rate
17692 pmtb(rate, n, amt, x) = -------------------------------
17694 (1 - (1 + rate) ) (1 + rate)
17697 nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate)
17701 nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
17705 nperl(rate, pmt, amt) = - log(---, 1 + rate)
17710 ratel(n, pmt, amt) = ------ - 1
17715 sln(cost, salv, life) = -----------
17718 (cost - salv) * (life - per + 1)
17719 syd(cost, salv, life, per) = --------------------------------
17720 life * (life + 1) / 2
17723 ddb(cost, salv, life, per) = --------, book = cost - depreciation so far
17729 $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
17730 $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
17731 $$ \code{fvl}(r, n, p) = p (1 + r)^n $$
17732 $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
17733 $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
17734 $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
17735 $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
17736 $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
17737 $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
17738 $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
17739 (1 - (1 + r)^{-n}) (1 + r) } $$
17740 $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
17741 $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
17742 $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
17743 $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
17744 $$ \code{sln}(c, s, l) = { c - s \over l } $$
17745 $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
17746 $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
17750 In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted.
17752 These functions accept any numeric objects, including error forms,
17753 intervals, and even (though not very usefully) complex numbers. The
17754 above formulas specify exactly the behavior of these functions with
17755 all sorts of inputs.
17757 Note that if the first argument to the @code{log} in @code{nper} is
17758 negative, @code{nper} leaves itself in symbolic form rather than
17759 returning a (financially meaningless) complex number.
17761 @samp{rate(num, pmt, amt)} solves the equation
17762 @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
17763 (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
17764 for an initial guess. The @code{rateb} function is the same except
17765 that it uses @code{pvb}. Note that @code{ratel} can be solved
17766 directly; its formula is shown in the above list.
17768 Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
17771 If you give a fourth argument to @code{nper} or @code{nperb}, Calc
17772 will also use @kbd{H a R} to solve the equation using an initial
17773 guess interval of @samp{[0 .. 100]}.
17775 A fourth argument to @code{fv} simply sums the two components
17776 calculated from the above formulas for @code{fv} and @code{fvl}.
17777 The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
17779 The @kbd{ddb} function is computed iteratively; the ``book'' value
17780 starts out equal to @var{cost}, and decreases according to the above
17781 formula for the specified number of periods. If the book value
17782 would decrease below @var{salvage}, it only decreases to @var{salvage}
17783 and the depreciation is zero for all subsequent periods. The @code{ddb}
17784 function returns the amount the book value decreased in the specified
17787 @node Binary Functions, , Financial Functions, Arithmetic
17788 @section Binary Number Functions
17791 The commands in this chapter all use two-letter sequences beginning with
17792 the @kbd{b} prefix.
17794 @cindex Binary numbers
17795 The ``binary'' operations actually work regardless of the currently
17796 displayed radix, although their results make the most sense in a radix
17797 like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
17798 commands, respectively). You may also wish to enable display of leading
17799 zeros with @kbd{d z}. @xref{Radix Modes}.
17801 @cindex Word size for binary operations
17802 The Calculator maintains a current @dfn{word size} @expr{w}, an
17803 arbitrary positive or negative integer. For a positive word size, all
17804 of the binary operations described here operate modulo @expr{2^w}. In
17805 particular, negative arguments are converted to positive integers modulo
17806 @expr{2^w} by all binary functions.
17808 If the word size is negative, binary operations produce 2's complement
17810 @texline @math{-2^{-w-1}}
17811 @infoline @expr{-(2^(-w-1))}
17813 @texline @math{2^{-w-1}-1}
17814 @infoline @expr{2^(-w-1)-1}
17815 inclusive. Either mode accepts inputs in any range; the sign of
17816 @expr{w} affects only the results produced.
17821 The @kbd{b c} (@code{calc-clip})
17822 [@code{clip}] command can be used to clip a number by reducing it modulo
17823 @expr{2^w}. The commands described in this chapter automatically clip
17824 their results to the current word size. Note that other operations like
17825 addition do not use the current word size, since integer addition
17826 generally is not ``binary.'' (However, @pxref{Simplification Modes},
17827 @code{calc-bin-simplify-mode}.) For example, with a word size of 8
17828 bits @kbd{b c} converts a number to the range 0 to 255; with a word
17829 size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127.
17832 @pindex calc-word-size
17833 The default word size is 32 bits. All operations except the shifts and
17834 rotates allow you to specify a different word size for that one
17835 operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the
17836 top of stack to the range 0 to 255 regardless of the current word size.
17837 To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
17838 This command displays a prompt with the current word size; press @key{RET}
17839 immediately to keep this word size, or type a new word size at the prompt.
17841 When the binary operations are written in symbolic form, they take an
17842 optional second (or third) word-size parameter. When a formula like
17843 @samp{and(a,b)} is finally evaluated, the word size current at that time
17844 will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
17845 @mathit{-8} will always be used. A symbolic binary function will be left
17846 in symbolic form unless the all of its argument(s) are integers or
17847 integer-valued floats.
17849 If either or both arguments are modulo forms for which @expr{M} is a
17850 power of two, that power of two is taken as the word size unless a
17851 numeric prefix argument overrides it. The current word size is never
17852 consulted when modulo-power-of-two forms are involved.
17857 The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
17858 AND of the two numbers on the top of the stack. In other words, for each
17859 of the @expr{w} binary digits of the two numbers (pairwise), the corresponding
17860 bit of the result is 1 if and only if both input bits are 1:
17861 @samp{and(2#1100, 2#1010) = 2#1000}.
17866 The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
17867 inclusive OR of two numbers. A bit is 1 if either of the input bits, or
17868 both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}.
17873 The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
17874 exclusive OR of two numbers. A bit is 1 if exactly one of the input bits
17875 is 1: @samp{xor(2#1100, 2#1010) = 2#0110}.
17880 The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
17881 difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
17882 so that @samp{diff(2#1100, 2#1010) = 2#0100}.
17887 The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
17888 NOT of a number. A bit is 1 if the input bit is 0 and vice-versa.
17891 @pindex calc-lshift-binary
17893 The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
17894 number left by one bit, or by the number of bits specified in the numeric
17895 prefix argument. A negative prefix argument performs a logical right shift,
17896 in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)}
17897 is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
17898 Bits shifted ``off the end,'' according to the current word size, are lost.
17914 The @kbd{H b l} command also does a left shift, but it takes two arguments
17915 from the stack (the value to shift, and, at top-of-stack, the number of
17916 bits to shift). This version interprets the prefix argument just like
17917 the regular binary operations, i.e., as a word size. The Hyperbolic flag
17918 has a similar effect on the rest of the binary shift and rotate commands.
17921 @pindex calc-rshift-binary
17923 The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
17924 number right by one bit, or by the number of bits specified in the numeric
17925 prefix argument: @samp{rsh(a,n) = lsh(a,-n)}.
17928 @pindex calc-lshift-arith
17930 The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
17931 number left. It is analogous to @code{lsh}, except that if the shift
17932 is rightward (the prefix argument is negative), an arithmetic shift
17933 is performed as described below.
17936 @pindex calc-rshift-arith
17938 The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
17939 an ``arithmetic'' shift to the right, in which the leftmost bit (according
17940 to the current word size) is duplicated rather than shifting in zeros.
17941 This corresponds to dividing by a power of two where the input is interpreted
17942 as a signed, twos-complement number. (The distinction between the @samp{rsh}
17943 and @samp{rash} operations is totally independent from whether the word
17944 size is positive or negative.) With a negative prefix argument, this
17945 performs a standard left shift.
17948 @pindex calc-rotate-binary
17950 The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
17951 number one bit to the left. The leftmost bit (according to the current
17952 word size) is dropped off the left and shifted in on the right. With a
17953 numeric prefix argument, the number is rotated that many bits to the left
17956 @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
17957 pack and unpack binary integers into sets. (For example, @kbd{b u}
17958 unpacks the number @samp{2#11001} to the set of bit-numbers
17959 @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1''
17960 bits in a binary integer.
17962 Another interesting use of the set representation of binary integers
17963 is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to
17964 unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
17965 with 31 minus that bit-number; type @kbd{b p} to pack the set back
17966 into a binary integer.
17968 @node Scientific Functions, Matrix Functions, Arithmetic, Top
17969 @chapter Scientific Functions
17972 The functions described here perform trigonometric and other transcendental
17973 calculations. They generally produce floating-point answers correct to the
17974 full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
17975 flag keys must be used to get some of these functions from the keyboard.
17979 @cindex @code{pi} variable
17982 @cindex @code{e} variable
17985 @cindex @code{gamma} variable
17987 @cindex Gamma constant, Euler's
17988 @cindex Euler's gamma constant
17990 @cindex @code{phi} variable
17991 @cindex Phi, golden ratio
17992 @cindex Golden ratio
17993 One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
17994 the value of @cpi{} (at the current precision) onto the stack. With the
17995 Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms.
17996 With the Inverse flag, it pushes Euler's constant
17997 @texline @math{\gamma}
17998 @infoline @expr{gamma}
17999 (about 0.5772). With both Inverse and Hyperbolic, it
18000 pushes the ``golden ratio''
18001 @texline @math{\phi}
18002 @infoline @expr{phi}
18003 (about 1.618). (At present, Euler's constant is not available
18004 to unlimited precision; Calc knows only the first 100 digits.)
18005 In Symbolic mode, these commands push the
18006 actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
18007 respectively, instead of their values; @pxref{Symbolic Mode}.
18017 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
18018 @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command
18019 computes the square of the argument.
18021 @xref{Prefix Arguments}, for a discussion of the effect of numeric
18022 prefix arguments on commands in this chapter which do not otherwise
18023 interpret a prefix argument.
18026 * Logarithmic Functions::
18027 * Trigonometric and Hyperbolic Functions::
18028 * Advanced Math Functions::
18031 * Combinatorial Functions::
18032 * Probability Distribution Functions::
18035 @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
18036 @section Logarithmic Functions
18046 The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
18047 logarithm of the real or complex number on the top of the stack. With
18048 the Inverse flag it computes the exponential function instead, although
18049 this is redundant with the @kbd{E} command.
18058 The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
18059 exponential, i.e., @expr{e} raised to the power of the number on the stack.
18060 The meanings of the Inverse and Hyperbolic flags follow from those for
18061 the @code{calc-ln} command.
18076 The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
18077 (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}],
18078 it raises ten to a given power.) Note that the common logarithm of a
18079 complex number is computed by taking the natural logarithm and dividing
18081 @texline @math{\ln10}.
18082 @infoline @expr{ln(10)}.
18089 The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
18090 to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since
18091 @texline @math{2^{10} = 1024}.
18092 @infoline @expr{2^10 = 1024}.
18093 In certain cases like @samp{log(3,9)}, the result
18094 will be either @expr{1:2} or @expr{0.5} depending on the current Fraction
18095 mode setting. With the Inverse flag [@code{alog}], this command is
18096 similar to @kbd{^} except that the order of the arguments is reversed.
18101 The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
18102 integer logarithm of a number to any base. The number and the base must
18103 themselves be positive integers. This is the true logarithm, rounded
18104 down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the
18105 range from 1000 to 9999. If both arguments are positive integers, exact
18106 integer arithmetic is used; otherwise, this is equivalent to
18107 @samp{floor(log(x,b))}.
18112 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
18113 @texline @math{e^x - 1},
18114 @infoline @expr{exp(x)-1},
18115 but using an algorithm that produces a more accurate
18116 answer when the result is close to zero, i.e., when
18117 @texline @math{e^x}
18118 @infoline @expr{exp(x)}
18124 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
18125 @texline @math{\ln(x+1)},
18126 @infoline @expr{ln(x+1)},
18127 producing a more accurate answer when @expr{x} is close to zero.
18129 @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
18130 @section Trigonometric/Hyperbolic Functions
18136 The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
18137 of an angle or complex number. If the input is an HMS form, it is interpreted
18138 as degrees-minutes-seconds; otherwise, the input is interpreted according
18139 to the current angular mode. It is best to use Radians mode when operating
18140 on complex numbers.
18142 Calc's ``units'' mechanism includes angular units like @code{deg},
18143 @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated
18144 all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
18145 simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
18146 of the current angular mode. @xref{Basic Operations on Units}.
18148 Also, the symbolic variable @code{pi} is not ordinarily recognized in
18149 arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
18150 the @kbd{a s} (@code{calc-simplify}) command recognizes many such
18151 formulas when the current angular mode is Radians @emph{and} Symbolic
18152 mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
18153 @xref{Symbolic Mode}. Beware, this simplification occurs even if you
18154 have stored a different value in the variable @samp{pi}; this is one
18155 reason why changing built-in variables is a bad idea. Arguments of
18156 the form @expr{x} plus a multiple of @cpiover{2} are also simplified.
18157 Calc includes similar formulas for @code{cos} and @code{tan}.
18159 The @kbd{a s} command knows all angles which are integer multiples of
18160 @cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode,
18161 analogous simplifications occur for integer multiples of 15 or 18
18162 degrees, and for arguments plus multiples of 90 degrees.
18165 @pindex calc-arcsin
18167 With the Inverse flag, @code{calc-sin} computes an arcsine. This is also
18168 available as the @code{calc-arcsin} command or @code{arcsin} algebraic
18169 function. The returned argument is converted to degrees, radians, or HMS
18170 notation depending on the current angular mode.
18176 @pindex calc-arcsinh
18178 With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
18179 sine, also available as @code{calc-sinh} [@code{sinh}]. With the
18180 Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
18181 (@code{calc-arcsinh}) [@code{arcsinh}].
18190 @pindex calc-arccos
18208 @pindex calc-arccosh
18226 @pindex calc-arctan
18244 @pindex calc-arctanh
18249 The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
18250 of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
18251 computes the tangent, along with all the various inverse and hyperbolic
18252 variants of these functions.
18255 @pindex calc-arctan2
18257 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
18258 numbers from the stack and computes the arc tangent of their ratio. The
18259 result is in the full range from @mathit{-180} (exclusive) to @mathit{+180}
18260 (inclusive) degrees, or the analogous range in radians. A similar
18261 result would be obtained with @kbd{/} followed by @kbd{I T}, but the
18262 value would only be in the range from @mathit{-90} to @mathit{+90} degrees
18263 since the division loses information about the signs of the two
18264 components, and an error might result from an explicit division by zero
18265 which @code{arctan2} would avoid. By (arbitrary) definition,
18266 @samp{arctan2(0,0)=0}.
18268 @pindex calc-sincos
18280 The @code{calc-sincos} [@code{sincos}] command computes the sine and
18281 cosine of a number, returning them as a vector of the form
18282 @samp{[@var{cos}, @var{sin}]}.
18283 With the Inverse flag [@code{arcsincos}], this command takes a two-element
18284 vector as an argument and computes @code{arctan2} of the elements.
18285 (This command does not accept the Hyperbolic flag.)
18299 The remaining trigonometric functions, @code{calc-sec} [@code{sec}],
18300 @code{calc-csc} [@code{csc}] and @code{calc-sec} [@code{sec}], are also
18301 available. With the Hyperbolic flag, these compute their hyperbolic
18302 counterparts, which are also available separately as @code{calc-sech}
18303 [@code{sech}], @code{calc-csch} [@code{csch}] and @code{calc-sech}
18304 [@code{sech}]. (These commmands do not accept the Inverse flag.)
18306 @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
18307 @section Advanced Mathematical Functions
18310 Calc can compute a variety of less common functions that arise in
18311 various branches of mathematics. All of the functions described in
18312 this section allow arbitrary complex arguments and, except as noted,
18313 will work to arbitrarily large precisions. They can not at present
18314 handle error forms or intervals as arguments.
18316 NOTE: These functions are still experimental. In particular, their
18317 accuracy is not guaranteed in all domains. It is advisable to set the
18318 current precision comfortably higher than you actually need when
18319 using these functions. Also, these functions may be impractically
18320 slow for some values of the arguments.
18325 The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
18326 gamma function. For positive integer arguments, this is related to the
18327 factorial function: @samp{gamma(n+1) = fact(n)}. For general complex
18328 arguments the gamma function can be defined by the following definite
18330 @texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}.
18331 @infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
18332 (The actual implementation uses far more efficient computational methods.)
18348 @pindex calc-inc-gamma
18361 The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
18362 the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by
18364 @texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}.
18365 @infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
18366 This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the
18367 definition of the normal gamma function).
18369 Several other varieties of incomplete gamma function are defined.
18370 The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by
18371 some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
18372 You can think of this as taking the other half of the integral, from
18373 @expr{x} to infinity.
18376 The functions corresponding to the integrals that define @expr{P(a,x)}
18377 and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)}
18378 factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively
18379 (where @expr{g} and @expr{G} represent the lower- and upper-case Greek
18380 letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}]
18381 and @kbd{H I f G} [@code{gammaG}] commands.
18385 The functions corresponding to the integrals that define $P(a,x)$
18386 and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
18387 factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
18388 You can obtain these using the \kbd{H f G} [\code{gammag}] and
18389 \kbd{I H f G} [\code{gammaG}] commands.
18395 The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
18396 Euler beta function, which is defined in terms of the gamma function as
18397 @texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)},
18398 @infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)},
18400 @texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}.
18401 @infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
18405 @pindex calc-inc-beta
18408 The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
18409 the incomplete beta function @expr{I(x,a,b)}. It is defined by
18410 @texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}.
18411 @infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
18412 Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
18413 un-normalized version [@code{betaB}].
18420 The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
18422 @texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}.
18423 @infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
18424 The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
18425 is the corresponding integral from @samp{x} to infinity; the sum
18426 @texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}.
18427 @infoline @expr{erf(x) + erfc(x) = 1}.
18431 @pindex calc-bessel-J
18432 @pindex calc-bessel-Y
18435 The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
18436 (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
18437 functions of the first and second kinds, respectively.
18438 In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
18439 @expr{n} is often an integer, but is not required to be one.
18440 Calc's implementation of the Bessel functions currently limits the
18441 precision to 8 digits, and may not be exact even to that precision.
18444 @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
18445 @section Branch Cuts and Principal Values
18448 @cindex Branch cuts
18449 @cindex Principal values
18450 All of the logarithmic, trigonometric, and other scientific functions are
18451 defined for complex numbers as well as for reals.
18452 This section describes the values
18453 returned in cases where the general result is a family of possible values.
18454 Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
18455 second edition, in these matters. This section will describe each
18456 function briefly; for a more detailed discussion (including some nifty
18457 diagrams), consult Steele's book.
18459 Note that the branch cuts for @code{arctan} and @code{arctanh} were
18460 changed between the first and second editions of Steele. Versions of
18461 Calc starting with 2.00 follow the second edition.
18463 The new branch cuts exactly match those of the HP-28/48 calculators.
18464 They also match those of Mathematica 1.2, except that Mathematica's
18465 @code{arctan} cut is always in the right half of the complex plane,
18466 and its @code{arctanh} cut is always in the top half of the plane.
18467 Calc's cuts are continuous with quadrants I and III for @code{arctan},
18468 or II and IV for @code{arctanh}.
18470 Note: The current implementations of these functions with complex arguments
18471 are designed with proper behavior around the branch cuts in mind, @emph{not}
18472 efficiency or accuracy. You may need to increase the floating precision
18473 and wait a while to get suitable answers from them.
18475 For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive
18476 or zero, the result is close to the @expr{+i} axis. For @expr{b} small and
18477 negative, the result is close to the @expr{-i} axis. The result always lies
18478 in the right half of the complex plane.
18480 For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}.
18481 The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
18482 Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
18483 negative real axis.
18485 The following table describes these branch cuts in another way.
18486 If the real and imaginary parts of @expr{z} are as shown, then
18487 the real and imaginary parts of @expr{f(z)} will be as shown.
18488 Here @code{eps} stands for a small positive value; each
18489 occurrence of @code{eps} may stand for a different small value.
18493 ----------------------------------------
18496 -, +eps +eps, + +eps, +
18497 -, -eps +eps, - +eps, -
18500 For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}.
18501 One interesting consequence of this is that @samp{(-8)^1:3} does
18502 not evaluate to @mathit{-2} as you might expect, but to the complex
18503 number @expr{(1., 1.732)}. Both of these are valid cube roots
18504 of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps
18505 less-obvious root for the sake of mathematical consistency.
18507 For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
18508 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18510 For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
18511 or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on
18512 the real axis, less than @mathit{-1} and greater than 1.
18514 For @samp{arctan(z)}: This is defined by
18515 @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the
18516 imaginary axis, below @expr{-i} and above @expr{i}.
18518 For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}.
18519 The branch cuts are on the imaginary axis, below @expr{-i} and
18522 For @samp{arccosh(z)}: This is defined by
18523 @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the
18524 real axis less than 1.
18526 For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
18527 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18529 The following tables for @code{arcsin}, @code{arccos}, and
18530 @code{arctan} assume the current angular mode is Radians. The
18531 hyperbolic functions operate independently of the angular mode.
18534 z arcsin(z) arccos(z)
18535 -------------------------------------------------------
18536 (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0
18537 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps
18538 (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps
18539 <-1, 0 -pi/2, + pi, -
18540 <-1, +eps -pi/2 + eps, + pi - eps, -
18541 <-1, -eps -pi/2 + eps, - pi - eps, +
18543 >1, +eps pi/2 - eps, + +eps, -
18544 >1, -eps pi/2 - eps, - +eps, +
18548 z arccosh(z) arctanh(z)
18549 -----------------------------------------------------
18550 (-1..1), 0 0, (0..pi) any, 0
18551 (-1..1), +eps +eps, (0..pi) any, +eps
18552 (-1..1), -eps +eps, (-pi..0) any, -eps
18553 <-1, 0 +, pi -, pi/2
18554 <-1, +eps +, pi - eps -, pi/2 - eps
18555 <-1, -eps +, -pi + eps -, -pi/2 + eps
18556 >1, 0 +, 0 +, -pi/2
18557 >1, +eps +, +eps +, pi/2 - eps
18558 >1, -eps +, -eps +, -pi/2 + eps
18562 z arcsinh(z) arctan(z)
18563 -----------------------------------------------------
18564 0, (-1..1) 0, (-pi/2..pi/2) 0, any
18565 0, <-1 -, -pi/2 -pi/2, -
18566 +eps, <-1 +, -pi/2 + eps pi/2 - eps, -
18567 -eps, <-1 -, -pi/2 + eps -pi/2 + eps, -
18568 0, >1 +, pi/2 pi/2, +
18569 +eps, >1 +, pi/2 - eps pi/2 - eps, +
18570 -eps, >1 -, pi/2 - eps -pi/2 + eps, +
18573 Finally, the following identities help to illustrate the relationship
18574 between the complex trigonometric and hyperbolic functions. They
18575 are valid everywhere, including on the branch cuts.
18578 sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z)
18579 cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z)
18580 tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z)
18581 sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)
18584 The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
18585 for general complex arguments, but their branch cuts and principal values
18586 are not rigorously specified at present.
18588 @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
18589 @section Random Numbers
18593 @pindex calc-random
18595 The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
18596 random numbers of various sorts.
18598 Given a positive numeric prefix argument @expr{M}, it produces a random
18599 integer @expr{N} in the range
18600 @texline @math{0 \le N < M}.
18601 @infoline @expr{0 <= N < M}.
18602 Each of the @expr{M} values appears with equal probability.
18604 With no numeric prefix argument, the @kbd{k r} command takes its argument
18605 from the stack instead. Once again, if this is a positive integer @expr{M}
18606 the result is a random integer less than @expr{M}. However, note that
18607 while numeric prefix arguments are limited to six digits or so, an @expr{M}
18608 taken from the stack can be arbitrarily large. If @expr{M} is negative,
18609 the result is a random integer in the range
18610 @texline @math{M < N \le 0}.
18611 @infoline @expr{M < N <= 0}.
18613 If the value on the stack is a floating-point number @expr{M}, the result
18614 is a random floating-point number @expr{N} in the range
18615 @texline @math{0 \le N < M}
18616 @infoline @expr{0 <= N < M}
18618 @texline @math{M < N \le 0},
18619 @infoline @expr{M < N <= 0},
18620 according to the sign of @expr{M}.
18622 If @expr{M} is zero, the result is a Gaussian-distributed random real
18623 number; the distribution has a mean of zero and a standard deviation
18624 of one. The algorithm used generates random numbers in pairs; thus,
18625 every other call to this function will be especially fast.
18627 If @expr{M} is an error form
18628 @texline @math{m} @code{+/-} @math{\sigma}
18629 @infoline @samp{m +/- s}
18631 @texline @math{\sigma}
18633 are both real numbers, the result uses a Gaussian distribution with mean
18634 @var{m} and standard deviation
18635 @texline @math{\sigma}.
18638 If @expr{M} is an interval form, the lower and upper bounds specify the
18639 acceptable limits of the random numbers. If both bounds are integers,
18640 the result is a random integer in the specified range. If either bound
18641 is floating-point, the result is a random real number in the specified
18642 range. If the interval is open at either end, the result will be sure
18643 not to equal that end value. (This makes a big difference for integer
18644 intervals, but for floating-point intervals it's relatively minor:
18645 with a precision of 6, @samp{random([1.0..2.0))} will return any of one
18646 million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
18647 additionally return 2.00000, but the probability of this happening is
18650 If @expr{M} is a vector, the result is one element taken at random from
18651 the vector. All elements of the vector are given equal probabilities.
18654 The sequence of numbers produced by @kbd{k r} is completely random by
18655 default, i.e., the sequence is seeded each time you start Calc using
18656 the current time and other information. You can get a reproducible
18657 sequence by storing a particular ``seed value'' in the Calc variable
18658 @code{RandSeed}. Any integer will do for a seed; integers of from 1
18659 to 12 digits are good. If you later store a different integer into
18660 @code{RandSeed}, Calc will switch to a different pseudo-random
18661 sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
18662 from the current time. If you store the same integer that you used
18663 before back into @code{RandSeed}, you will get the exact same sequence
18664 of random numbers as before.
18666 @pindex calc-rrandom
18667 The @code{calc-rrandom} command (not on any key) produces a random real
18668 number between zero and one. It is equivalent to @samp{random(1.0)}.
18671 @pindex calc-random-again
18672 The @kbd{k a} (@code{calc-random-again}) command produces another random
18673 number, re-using the most recent value of @expr{M}. With a numeric
18674 prefix argument @var{n}, it produces @var{n} more random numbers using
18675 that value of @expr{M}.
18678 @pindex calc-shuffle
18680 The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
18681 random values with no duplicates. The value on the top of the stack
18682 specifies the set from which the random values are drawn, and may be any
18683 of the @expr{M} formats described above. The numeric prefix argument
18684 gives the length of the desired list. (If you do not provide a numeric
18685 prefix argument, the length of the list is taken from the top of the
18686 stack, and @expr{M} from second-to-top.)
18688 If @expr{M} is a floating-point number, zero, or an error form (so
18689 that the random values are being drawn from the set of real numbers)
18690 there is little practical difference between using @kbd{k h} and using
18691 @kbd{k r} several times. But if the set of possible values consists
18692 of just a few integers, or the elements of a vector, then there is
18693 a very real chance that multiple @kbd{k r}'s will produce the same
18694 number more than once. The @kbd{k h} command produces a vector whose
18695 elements are always distinct. (Actually, there is a slight exception:
18696 If @expr{M} is a vector, no given vector element will be drawn more
18697 than once, but if several elements of @expr{M} are equal, they may
18698 each make it into the result vector.)
18700 One use of @kbd{k h} is to rearrange a list at random. This happens
18701 if the prefix argument is equal to the number of values in the list:
18702 @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
18703 @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument
18704 @var{n} is negative it is replaced by the size of the set represented
18705 by @expr{M}. Naturally, this is allowed only when @expr{M} specifies
18706 a small discrete set of possibilities.
18708 To do the equivalent of @kbd{k h} but with duplications allowed,
18709 given @expr{M} on the stack and with @var{n} just entered as a numeric
18710 prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use
18711 @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
18712 elements of this vector. @xref{Matrix Functions}.
18715 * Random Number Generator:: (Complete description of Calc's algorithm)
18718 @node Random Number Generator, , Random Numbers, Random Numbers
18719 @subsection Random Number Generator
18721 Calc's random number generator uses several methods to ensure that
18722 the numbers it produces are highly random. Knuth's @emph{Art of
18723 Computer Programming}, Volume II, contains a thorough description
18724 of the theory of random number generators and their measurement and
18727 If @code{RandSeed} has no stored value, Calc calls Emacs' built-in
18728 @code{random} function to get a stream of random numbers, which it
18729 then treats in various ways to avoid problems inherent in the simple
18730 random number generators that many systems use to implement @code{random}.
18732 When Calc's random number generator is first invoked, it ``seeds''
18733 the low-level random sequence using the time of day, so that the
18734 random number sequence will be different every time you use Calc.
18736 Since Emacs Lisp doesn't specify the range of values that will be
18737 returned by its @code{random} function, Calc exercises the function
18738 several times to estimate the range. When Calc subsequently uses
18739 the @code{random} function, it takes only 10 bits of the result
18740 near the most-significant end. (It avoids at least the bottom
18741 four bits, preferably more, and also tries to avoid the top two
18742 bits.) This strategy works well with the linear congruential
18743 generators that are typically used to implement @code{random}.
18745 If @code{RandSeed} contains an integer, Calc uses this integer to
18746 seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
18748 @texline @math{X_{n-55} - X_{n-24}}.
18749 @infoline @expr{X_n-55 - X_n-24}).
18750 This method expands the seed
18751 value into a large table which is maintained internally; the variable
18752 @code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]}
18753 to indicate that the seed has been absorbed into this table. When
18754 @code{RandSeed} contains a vector, @kbd{k r} and related commands
18755 continue to use the same internal table as last time. There is no
18756 way to extract the complete state of the random number generator
18757 so that you can restart it from any point; you can only restart it
18758 from the same initial seed value. A simple way to restart from the
18759 same seed is to type @kbd{s r RandSeed} to get the seed vector,
18760 @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
18761 to reseed the generator with that number.
18763 Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
18764 of Knuth. It fills a table with 13 random 10-bit numbers. Then,
18765 to generate a new random number, it uses the previous number to
18766 index into the table, picks the value it finds there as the new
18767 random number, then replaces that table entry with a new value
18768 obtained from a call to the base random number generator (either
18769 the additive congruential generator or the @code{random} function
18770 supplied by the system). If there are any flaws in the base
18771 generator, shuffling will tend to even them out. But if the system
18772 provides an excellent @code{random} function, shuffling will not
18773 damage its randomness.
18775 To create a random integer of a certain number of digits, Calc
18776 builds the integer three decimal digits at a time. For each group
18777 of three digits, Calc calls its 10-bit shuffling random number generator
18778 (which returns a value from 0 to 1023); if the random value is 1000
18779 or more, Calc throws it out and tries again until it gets a suitable
18782 To create a random floating-point number with precision @var{p}, Calc
18783 simply creates a random @var{p}-digit integer and multiplies by
18784 @texline @math{10^{-p}}.
18785 @infoline @expr{10^-p}.
18786 The resulting random numbers should be very clean, but note
18787 that relatively small numbers will have few significant random digits.
18788 In other words, with a precision of 12, you will occasionally get
18789 numbers on the order of
18790 @texline @math{10^{-9}}
18791 @infoline @expr{10^-9}
18793 @texline @math{10^{-10}},
18794 @infoline @expr{10^-10},
18795 but those numbers will only have two or three random digits since they
18796 correspond to small integers times
18797 @texline @math{10^{-12}}.
18798 @infoline @expr{10^-12}.
18800 To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
18801 counts the digits in @var{m}, creates a random integer with three
18802 additional digits, then reduces modulo @var{m}. Unless @var{m} is a
18803 power of ten the resulting values will be very slightly biased toward
18804 the lower numbers, but this bias will be less than 0.1%. (For example,
18805 if @var{m} is 42, Calc will reduce a random integer less than 100000
18806 modulo 42 to get a result less than 42. It is easy to show that the
18807 numbers 40 and 41 will be only 2380/2381 as likely to result from this
18808 modulo operation as numbers 39 and below.) If @var{m} is a power of
18809 ten, however, the numbers should be completely unbiased.
18811 The Gaussian random numbers generated by @samp{random(0.0)} use the
18812 ``polar'' method described in Knuth section 3.4.1C. This method
18813 generates a pair of Gaussian random numbers at a time, so only every
18814 other call to @samp{random(0.0)} will require significant calculations.
18816 @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
18817 @section Combinatorial Functions
18820 Commands relating to combinatorics and number theory begin with the
18821 @kbd{k} key prefix.
18826 The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
18827 Greatest Common Divisor of two integers. It also accepts fractions;
18828 the GCD of two fractions is defined by taking the GCD of the
18829 numerators, and the LCM of the denominators. This definition is
18830 consistent with the idea that @samp{a / gcd(a,x)} should yield an
18831 integer for any @samp{a} and @samp{x}. For other types of arguments,
18832 the operation is left in symbolic form.
18837 The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
18838 Least Common Multiple of two integers or fractions. The product of
18839 the LCM and GCD of two numbers is equal to the product of the
18843 @pindex calc-extended-gcd
18845 The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
18846 the GCD of two integers @expr{x} and @expr{y} and returns a vector
18847 @expr{[g, a, b]} where
18848 @texline @math{g = \gcd(x,y) = a x + b y}.
18849 @infoline @expr{g = gcd(x,y) = a x + b y}.
18852 @pindex calc-factorial
18858 The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
18859 factorial of the number at the top of the stack. If the number is an
18860 integer, the result is an exact integer. If the number is an
18861 integer-valued float, the result is a floating-point approximation. If
18862 the number is a non-integral real number, the generalized factorial is used,
18863 as defined by the Euler Gamma function. Please note that computation of
18864 large factorials can be slow; using floating-point format will help
18865 since fewer digits must be maintained. The same is true of many of
18866 the commands in this section.
18869 @pindex calc-double-factorial
18875 The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
18876 computes the ``double factorial'' of an integer. For an even integer,
18877 this is the product of even integers from 2 to @expr{N}. For an odd
18878 integer, this is the product of odd integers from 3 to @expr{N}. If
18879 the argument is an integer-valued float, the result is a floating-point
18880 approximation. This function is undefined for negative even integers.
18881 The notation @expr{N!!} is also recognized for double factorials.
18884 @pindex calc-choose
18886 The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
18887 binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number
18888 on the top of the stack and @expr{N} is second-to-top. If both arguments
18889 are integers, the result is an exact integer. Otherwise, the result is a
18890 floating-point approximation. The binomial coefficient is defined for all
18892 @texline @math{N! \over M! (N-M)!\,}.
18893 @infoline @expr{N! / M! (N-M)!}.
18899 The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
18900 number-of-permutations function @expr{N! / (N-M)!}.
18903 The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
18904 number-of-perm\-utations function $N! \over (N-M)!\,$.
18909 @pindex calc-bernoulli-number
18911 The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
18912 computes a given Bernoulli number. The value at the top of the stack
18913 is a nonnegative integer @expr{n} that specifies which Bernoulli number
18914 is desired. The @kbd{H k b} command computes a Bernoulli polynomial,
18915 taking @expr{n} from the second-to-top position and @expr{x} from the
18916 top of the stack. If @expr{x} is a variable or formula the result is
18917 a polynomial in @expr{x}; if @expr{x} is a number the result is a number.
18921 @pindex calc-euler-number
18923 The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
18924 computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
18925 Bernoulli and Euler numbers occur in the Taylor expansions of several
18930 @pindex calc-stirling-number
18933 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
18934 computes a Stirling number of the first
18935 @texline kind@tie{}@math{n \brack m},
18937 given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s}
18938 [@code{stir2}] command computes a Stirling number of the second
18939 @texline kind@tie{}@math{n \brace m}.
18941 These are the number of @expr{m}-cycle permutations of @expr{n} objects,
18942 and the number of ways to partition @expr{n} objects into @expr{m}
18943 non-empty sets, respectively.
18946 @pindex calc-prime-test
18948 The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
18949 the top of the stack is prime. For integers less than eight million, the
18950 answer is always exact and reasonably fast. For larger integers, a
18951 probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
18952 The number is first checked against small prime factors (up to 13). Then,
18953 any number of iterations of the algorithm are performed. Each step either
18954 discovers that the number is non-prime, or substantially increases the
18955 certainty that the number is prime. After a few steps, the chance that
18956 a number was mistakenly described as prime will be less than one percent.
18957 (Indeed, this is a worst-case estimate of the probability; in practice
18958 even a single iteration is quite reliable.) After the @kbd{k p} command,
18959 the number will be reported as definitely prime or non-prime if possible,
18960 or otherwise ``probably'' prime with a certain probability of error.
18966 The normal @kbd{k p} command performs one iteration of the primality
18967 test. Pressing @kbd{k p} repeatedly for the same integer will perform
18968 additional iterations. Also, @kbd{k p} with a numeric prefix performs
18969 the specified number of iterations. There is also an algebraic function
18970 @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n}
18971 is (probably) prime and 0 if not.
18974 @pindex calc-prime-factors
18976 The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
18977 attempts to decompose an integer into its prime factors. For numbers up
18978 to 25 million, the answer is exact although it may take some time. The
18979 result is a vector of the prime factors in increasing order. For larger
18980 inputs, prime factors above 5000 may not be found, in which case the
18981 last number in the vector will be an unfactored integer greater than 25
18982 million (with a warning message). For negative integers, the first
18983 element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and
18984 @mathit{1}, the result is a list of the same number.
18987 @pindex calc-next-prime
18989 @mindex nextpr@idots
18992 The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
18993 the next prime above a given number. Essentially, it searches by calling
18994 @code{calc-prime-test} on successive integers until it finds one that
18995 passes the test. This is quite fast for integers less than eight million,
18996 but once the probabilistic test comes into play the search may be rather
18997 slow. Ordinarily this command stops for any prime that passes one iteration
18998 of the primality test. With a numeric prefix argument, a number must pass
18999 the specified number of iterations before the search stops. (This only
19000 matters when searching above eight million.) You can always use additional
19001 @kbd{k p} commands to increase your certainty that the number is indeed
19005 @pindex calc-prev-prime
19007 @mindex prevpr@idots
19010 The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
19011 analogously finds the next prime less than a given number.
19014 @pindex calc-totient
19016 The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
19018 @texline function@tie{}@math{\phi(n)},
19019 @infoline function,
19020 the number of integers less than @expr{n} which
19021 are relatively prime to @expr{n}.
19024 @pindex calc-moebius
19026 The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
19027 @texline M@"obius @math{\mu}
19028 @infoline Moebius ``mu''
19029 function. If the input number is a product of @expr{k}
19030 distinct factors, this is @expr{(-1)^k}. If the input number has any
19031 duplicate factors (i.e., can be divided by the same prime more than once),
19032 the result is zero.
19034 @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
19035 @section Probability Distribution Functions
19038 The functions in this section compute various probability distributions.
19039 For continuous distributions, this is the integral of the probability
19040 density function from @expr{x} to infinity. (These are the ``upper
19041 tail'' distribution functions; there are also corresponding ``lower
19042 tail'' functions which integrate from minus infinity to @expr{x}.)
19043 For discrete distributions, the upper tail function gives the sum
19044 from @expr{x} to infinity; the lower tail function gives the sum
19045 from minus infinity up to, but not including,@w{ }@expr{x}.
19047 To integrate from @expr{x} to @expr{y}, just use the distribution
19048 function twice and subtract. For example, the probability that a
19049 Gaussian random variable with mean 2 and standard deviation 1 will
19050 lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
19051 (``the probability that it is greater than 2.5, but not greater than 2.8''),
19052 or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
19059 The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
19060 binomial distribution. Push the parameters @var{n}, @var{p}, and
19061 then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
19062 probability that an event will occur @var{x} or more times out
19063 of @var{n} trials, if its probability of occurring in any given
19064 trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is
19065 the probability that the event will occur fewer than @var{x} times.
19067 The other probability distribution functions similarly take the
19068 form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
19069 and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
19070 @var{x}. The arguments to the algebraic functions are the value of
19071 the random variable first, then whatever other parameters define the
19072 distribution. Note these are among the few Calc functions where the
19073 order of the arguments in algebraic form differs from the order of
19074 arguments as found on the stack. (The random variable comes last on
19075 the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
19076 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
19077 recover the original arguments but substitute a new value for @expr{x}.)
19090 The @samp{utpc(x,v)} function uses the chi-square distribution with
19091 @texline @math{\nu}
19093 degrees of freedom. It is the probability that a model is
19094 correct if its chi-square statistic is @expr{x}.
19107 The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
19108 various statistical tests. The parameters
19109 @texline @math{\nu_1}
19110 @infoline @expr{v1}
19112 @texline @math{\nu_2}
19113 @infoline @expr{v2}
19114 are the degrees of freedom in the numerator and denominator,
19115 respectively, used in computing the statistic @expr{F}.
19128 The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
19129 with mean @expr{m} and standard deviation
19130 @texline @math{\sigma}.
19131 @infoline @expr{s}.
19132 It is the probability that such a normal-distributed random variable
19133 would exceed @expr{x}.
19146 The @samp{utpp(n,x)} function uses a Poisson distribution with
19147 mean @expr{x}. It is the probability that @expr{n} or more such
19148 Poisson random events will occur.
19161 The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
19163 @texline @math{\nu}
19165 degrees of freedom. It is the probability that a
19166 t-distributed random variable will be greater than @expr{t}.
19167 (Note: This computes the distribution function
19168 @texline @math{A(t|\nu)}
19169 @infoline @expr{A(t|v)}
19171 @texline @math{A(0|\nu) = 1}
19172 @infoline @expr{A(0|v) = 1}
19174 @texline @math{A(\infty|\nu) \to 0}.
19175 @infoline @expr{A(inf|v) -> 0}.
19176 The @code{UTPT} operation on the HP-48 uses a different definition which
19177 returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.)
19179 While Calc does not provide inverses of the probability distribution
19180 functions, the @kbd{a R} command can be used to solve for the inverse.
19181 Since the distribution functions are monotonic, @kbd{a R} is guaranteed
19182 to be able to find a solution given any initial guess.
19183 @xref{Numerical Solutions}.
19185 @node Matrix Functions, Algebra, Scientific Functions, Top
19186 @chapter Vector/Matrix Functions
19189 Many of the commands described here begin with the @kbd{v} prefix.
19190 (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
19191 The commands usually apply to both plain vectors and matrices; some
19192 apply only to matrices or only to square matrices. If the argument
19193 has the wrong dimensions the operation is left in symbolic form.
19195 Vectors are entered and displayed using @samp{[a,b,c]} notation.
19196 Matrices are vectors of which all elements are vectors of equal length.
19197 (Though none of the standard Calc commands use this concept, a
19198 three-dimensional matrix or rank-3 tensor could be defined as a
19199 vector of matrices, and so on.)
19202 * Packing and Unpacking::
19203 * Building Vectors::
19204 * Extracting Elements::
19205 * Manipulating Vectors::
19206 * Vector and Matrix Arithmetic::
19208 * Statistical Operations::
19209 * Reducing and Mapping::
19210 * Vector and Matrix Formats::
19213 @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
19214 @section Packing and Unpacking
19217 Calc's ``pack'' and ``unpack'' commands collect stack entries to build
19218 composite objects such as vectors and complex numbers. They are
19219 described in this chapter because they are most often used to build
19224 The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
19225 elements from the stack into a matrix, complex number, HMS form, error
19226 form, etc. It uses a numeric prefix argument to specify the kind of
19227 object to be built; this argument is referred to as the ``packing mode.''
19228 If the packing mode is a nonnegative integer, a vector of that
19229 length is created. For example, @kbd{C-u 5 v p} will pop the top
19230 five stack elements and push back a single vector of those five
19231 elements. (@kbd{C-u 0 v p} simply creates an empty vector.)
19233 The same effect can be had by pressing @kbd{[} to push an incomplete
19234 vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
19235 the incomplete object up past a certain number of elements, and
19236 then pressing @kbd{]} to complete the vector.
19238 Negative packing modes create other kinds of composite objects:
19242 Two values are collected to build a complex number. For example,
19243 @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
19244 @expr{(5, 7)}. The result is always a rectangular complex
19245 number. The two input values must both be real numbers,
19246 i.e., integers, fractions, or floats. If they are not, Calc
19247 will instead build a formula like @samp{a + (0, 1) b}. (The
19248 other packing modes also create a symbolic answer if the
19249 components are not suitable.)
19252 Two values are collected to build a polar complex number.
19253 The first is the magnitude; the second is the phase expressed
19254 in either degrees or radians according to the current angular
19258 Three values are collected into an HMS form. The first
19259 two values (hours and minutes) must be integers or
19260 integer-valued floats. The third value may be any real
19264 Two values are collected into an error form. The inputs
19265 may be real numbers or formulas.
19268 Two values are collected into a modulo form. The inputs
19269 must be real numbers.
19272 Two values are collected into the interval @samp{[a .. b]}.
19273 The inputs may be real numbers, HMS or date forms, or formulas.
19276 Two values are collected into the interval @samp{[a .. b)}.
19279 Two values are collected into the interval @samp{(a .. b]}.
19282 Two values are collected into the interval @samp{(a .. b)}.
19285 Two integer values are collected into a fraction.
19288 Two values are collected into a floating-point number.
19289 The first is the mantissa; the second, which must be an
19290 integer, is the exponent. The result is the mantissa
19291 times ten to the power of the exponent.
19294 This is treated the same as @mathit{-11} by the @kbd{v p} command.
19295 When unpacking, @mathit{-12} specifies that a floating-point mantissa
19299 A real number is converted into a date form.
19302 Three numbers (year, month, day) are packed into a pure date form.
19305 Six numbers are packed into a date/time form.
19308 With any of the two-input negative packing modes, either or both
19309 of the inputs may be vectors. If both are vectors of the same
19310 length, the result is another vector made by packing corresponding
19311 elements of the input vectors. If one input is a vector and the
19312 other is a plain number, the number is packed along with each vector
19313 element to produce a new vector. For example, @kbd{C-u -4 v p}
19314 could be used to convert a vector of numbers and a vector of errors
19315 into a single vector of error forms; @kbd{C-u -5 v p} could convert
19316 a vector of numbers and a single number @var{M} into a vector of
19317 numbers modulo @var{M}.
19319 If you don't give a prefix argument to @kbd{v p}, it takes
19320 the packing mode from the top of the stack. The elements to
19321 be packed then begin at stack level 2. Thus
19322 @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
19323 enter the error form @samp{1 +/- 2}.
19325 If the packing mode taken from the stack is a vector, the result is a
19326 matrix with the dimensions specified by the elements of the vector,
19327 which must each be integers. For example, if the packing mode is
19328 @samp{[2, 3]}, then six numbers will be taken from the stack and
19329 returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
19331 If any elements of the vector are negative, other kinds of
19332 packing are done at that level as described above. For
19333 example, @samp{[2, 3, -4]} takes 12 objects and creates a
19334 @texline @math{2\times3}
19336 matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
19337 Also, @samp{[-4, -10]} will convert four integers into an
19338 error form consisting of two fractions: @samp{a:b +/- c:d}.
19344 There is an equivalent algebraic function,
19345 @samp{pack(@var{mode}, @var{items})} where @var{mode} is a
19346 packing mode (an integer or a vector of integers) and @var{items}
19347 is a vector of objects to be packed (re-packed, really) according
19348 to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
19349 yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is
19350 left in symbolic form if the packing mode is invalid, or if the
19351 number of data items does not match the number of items required
19355 @pindex calc-unpack
19356 The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
19357 number, HMS form, or other composite object on the top of the stack and
19358 ``unpacks'' it, pushing each of its elements onto the stack as separate
19359 objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value
19360 at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
19361 each of the arguments of the top-level operator onto the stack.
19363 You can optionally give a numeric prefix argument to @kbd{v u}
19364 to specify an explicit (un)packing mode. If the packing mode is
19365 negative and the input is actually a vector or matrix, the result
19366 will be two or more similar vectors or matrices of the elements.
19367 For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
19368 the result of @kbd{C-u -4 v u} will be the two vectors
19369 @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
19371 Note that the prefix argument can have an effect even when the input is
19372 not a vector. For example, if the input is the number @mathit{-5}, then
19373 @kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5}
19374 when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
19375 and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5}
19376 and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational
19377 number). Plain @kbd{v u} with this input would complain that the input
19378 is not a composite object.
19380 Unpacking mode @mathit{-11} converts a float into an integer mantissa and
19381 an integer exponent, where the mantissa is not divisible by 10
19382 (except that 0.0 is represented by a mantissa and exponent of 0).
19383 Unpacking mode @mathit{-12} converts a float into a floating-point mantissa
19384 and integer exponent, where the mantissa (for non-zero numbers)
19385 is guaranteed to lie in the range [1 .. 10). In both cases,
19386 the mantissa is shifted left or right (and the exponent adjusted
19387 to compensate) in order to satisfy these constraints.
19389 Positive unpacking modes are treated differently than for @kbd{v p}.
19390 A mode of 1 is much like plain @kbd{v u} with no prefix argument,
19391 except that in addition to the components of the input object,
19392 a suitable packing mode to re-pack the object is also pushed.
19393 Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
19396 A mode of 2 unpacks two levels of the object; the resulting
19397 re-packing mode will be a vector of length 2. This might be used
19398 to unpack a matrix, say, or a vector of error forms. Higher
19399 unpacking modes unpack the input even more deeply.
19405 There are two algebraic functions analogous to @kbd{v u}.
19406 The @samp{unpack(@var{mode}, @var{item})} function unpacks the
19407 @var{item} using the given @var{mode}, returning the result as
19408 a vector of components. Here the @var{mode} must be an
19409 integer, not a vector. For example, @samp{unpack(-4, a +/- b)}
19410 returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
19416 The @code{unpackt} function is like @code{unpack} but instead
19417 of returning a simple vector of items, it returns a vector of
19418 two things: The mode, and the vector of items. For example,
19419 @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
19420 and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
19421 The identity for re-building the original object is
19422 @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The
19423 @code{apply} function builds a function call given the function
19424 name and a vector of arguments.)
19426 @cindex Numerator of a fraction, extracting
19427 Subscript notation is a useful way to extract a particular part
19428 of an object. For example, to get the numerator of a rational
19429 number, you can use @samp{unpack(-10, @var{x})_1}.
19431 @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
19432 @section Building Vectors
19435 Vectors and matrices can be added,
19436 subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.
19439 @pindex calc-concat
19444 The @kbd{|} (@code{calc-concat}) [@code{vconcat}] command ``concatenates'' two vectors
19445 into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
19446 will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments
19447 are matrices, the rows of the first matrix are concatenated with the
19448 rows of the second. (In other words, two matrices are just two vectors
19449 of row-vectors as far as @kbd{|} is concerned.)
19451 If either argument to @kbd{|} is a scalar (a non-vector), it is treated
19452 like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |}
19453 produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a
19454 matrix and the other is a plain vector, the vector is treated as a
19459 The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
19460 two vectors without any special cases. Both inputs must be vectors.
19461 Whether or not they are matrices is not taken into account. If either
19462 argument is a scalar, the @code{append} function is left in symbolic form.
19463 See also @code{cons} and @code{rcons} below.
19467 The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
19468 two stack arguments in the opposite order. Thus @kbd{I |} is equivalent
19469 to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
19474 The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
19475 square matrix. The optional numeric prefix gives the number of rows
19476 and columns in the matrix. If the value at the top of the stack is a
19477 vector, the elements of the vector are used as the diagonal elements; the
19478 prefix, if specified, must match the size of the vector. If the value on
19479 the stack is a scalar, it is used for each element on the diagonal, and
19480 the prefix argument is required.
19482 To build a constant square matrix, e.g., a
19483 @texline @math{3\times3}
19485 matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero
19486 matrix first and then add a constant value to that matrix. (Another
19487 alternative would be to use @kbd{v b} and @kbd{v a}; see below.)
19492 The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
19493 matrix of the specified size. It is a convenient form of @kbd{v d}
19494 where the diagonal element is always one. If no prefix argument is given,
19495 this command prompts for one.
19497 In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
19498 except that @expr{a} is required to be a scalar (non-vector) quantity.
19499 If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an
19500 identity matrix of unknown size. Calc can operate algebraically on
19501 such generic identity matrices, and if one is combined with a matrix
19502 whose size is known, it is converted automatically to an identity
19503 matrix of a suitable matching size. The @kbd{v i} command with an
19504 argument of zero creates a generic identity matrix, @samp{idn(1)}.
19505 Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic
19506 identity matrices are immediately expanded to the current default
19512 The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
19513 of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
19514 prefix argument. If you do not provide a prefix argument, you will be
19515 prompted to enter a suitable number. If @var{n} is negative, the result
19516 is a vector of negative integers from @var{n} to @mathit{-1}.
19518 With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
19519 three values from the stack: @var{n}, @var{start}, and @var{incr} (with
19520 @var{incr} at top-of-stack). Counting starts at @var{start} and increases
19521 by @var{incr} for successive vector elements. If @var{start} or @var{n}
19522 is in floating-point format, the resulting vector elements will also be
19523 floats. Note that @var{start} and @var{incr} may in fact be any kind
19524 of numbers or formulas.
19526 When @var{start} and @var{incr} are specified, a negative @var{n} has a
19527 different interpretation: It causes a geometric instead of arithmetic
19528 sequence to be generated. For example, @samp{index(-3, a, b)} produces
19529 @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form,
19530 @samp{index(@var{n}, @var{start})}, the default value for @var{incr}
19531 is one for positive @var{n} or two for negative @var{n}.
19534 @pindex calc-build-vector
19536 The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
19537 vector of @var{n} copies of the value on the top of the stack, where @var{n}
19538 is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)}
19539 can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
19540 (Interactively, just use @kbd{v b} twice: once to build a row, then again
19541 to build a matrix of copies of that row.)
19549 The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
19550 element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
19551 function returns the vector with its first element removed. In both
19552 cases, the argument must be a non-empty vector.
19557 The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
19558 and a vector @var{t} from the stack, and produces the vector whose head is
19559 @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except
19560 if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
19561 whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
19581 Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
19582 @code{rtail}, @code{rcons}] in which case @var{t} instead represents
19583 the @emph{last} single element of the vector, with @var{h}
19584 representing the remainder of the vector. Thus the vector
19585 @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
19586 Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
19587 @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
19589 @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
19590 @section Extracting Vector Elements
19596 The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
19597 the matrix on the top of the stack, or one element of the plain vector on
19598 the top of the stack. The row or element is specified by the numeric
19599 prefix argument; the default is to prompt for the row or element number.
19600 The matrix or vector is replaced by the specified row or element in the
19601 form of a vector or scalar, respectively.
19603 @cindex Permutations, applying
19604 With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
19605 the element or row from the top of the stack, and the vector or matrix
19606 from the second-to-top position. If the index is itself a vector of
19607 integers, the result is a vector of the corresponding elements of the
19608 input vector, or a matrix of the corresponding rows of the input matrix.
19609 This command can be used to obtain any permutation of a vector.
19611 With @kbd{C-u}, if the index is an interval form with integer components,
19612 it is interpreted as a range of indices and the corresponding subvector or
19613 submatrix is returned.
19615 @cindex Subscript notation
19617 @pindex calc-subscript
19620 Subscript notation in algebraic formulas (@samp{a_b}) stands for the
19621 Calc function @code{subscr}, which is synonymous with @code{mrow}.
19622 Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if
19623 @expr{k} is one, two, or three, respectively. A double subscript
19624 (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
19625 access the element at row @expr{i}, column @expr{j} of a matrix.
19626 The @kbd{a _} (@code{calc-subscript}) command creates a subscript
19627 formula @samp{a_b} out of two stack entries. (It is on the @kbd{a}
19628 ``algebra'' prefix because subscripted variables are often used
19629 purely as an algebraic notation.)
19632 Given a negative prefix argument, @kbd{v r} instead deletes one row or
19633 element from the matrix or vector on the top of the stack. Thus
19634 @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
19635 replaces the matrix with the same matrix with its second row removed.
19636 In algebraic form this function is called @code{mrrow}.
19639 Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
19640 of a square matrix in the form of a vector. In algebraic form this
19641 function is called @code{getdiag}.
19647 The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
19648 the analogous operation on columns of a matrix. Given a plain vector
19649 it extracts (or removes) one element, just like @kbd{v r}. If the
19650 index in @kbd{C-u v c} is an interval or vector and the argument is a
19651 matrix, the result is a submatrix with only the specified columns
19652 retained (and possibly permuted in the case of a vector index).
19654 To extract a matrix element at a given row and column, use @kbd{v r} to
19655 extract the row as a vector, then @kbd{v c} to extract the column element
19656 from that vector. In algebraic formulas, it is often more convenient to
19657 use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j}
19658 of matrix @expr{m}.
19661 @pindex calc-subvector
19663 The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
19664 a subvector of a vector. The arguments are the vector, the starting
19665 index, and the ending index, with the ending index in the top-of-stack
19666 position. The starting index indicates the first element of the vector
19667 to take. The ending index indicates the first element @emph{past} the
19668 range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
19669 the subvector @samp{[b, c]}. You could get the same result using
19670 @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
19672 If either the start or the end index is zero or negative, it is
19673 interpreted as relative to the end of the vector. Thus
19674 @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In
19675 the algebraic form, the end index can be omitted in which case it
19676 is taken as zero, i.e., elements from the starting element to the
19677 end of the vector are used. The infinity symbol, @code{inf}, also
19678 has this effect when used as the ending index.
19682 With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
19683 from a vector. The arguments are interpreted the same as for the
19684 normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
19685 produces @samp{[a, d, e]}. It is always true that @code{subvec} and
19686 @code{rsubvec} return complementary parts of the input vector.
19688 @xref{Selecting Subformulas}, for an alternative way to operate on
19689 vectors one element at a time.
19691 @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
19692 @section Manipulating Vectors
19696 @pindex calc-vlength
19698 The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
19699 length of a vector. The length of a non-vector is considered to be zero.
19700 Note that matrices are just vectors of vectors for the purposes of this
19705 With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
19706 of the dimensions of a vector, matrix, or higher-order object. For
19707 example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
19709 @texline @math{2\times3}
19714 @pindex calc-vector-find
19716 The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
19717 along a vector for the first element equal to a given target. The target
19718 is on the top of the stack; the vector is in the second-to-top position.
19719 If a match is found, the result is the index of the matching element.
19720 Otherwise, the result is zero. The numeric prefix argument, if given,
19721 allows you to select any starting index for the search.
19724 @pindex calc-arrange-vector
19726 @cindex Arranging a matrix
19727 @cindex Reshaping a matrix
19728 @cindex Flattening a matrix
19729 The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
19730 rearranges a vector to have a certain number of columns and rows. The
19731 numeric prefix argument specifies the number of columns; if you do not
19732 provide an argument, you will be prompted for the number of columns.
19733 The vector or matrix on the top of the stack is @dfn{flattened} into a
19734 plain vector. If the number of columns is nonzero, this vector is
19735 then formed into a matrix by taking successive groups of @var{n} elements.
19736 If the number of columns does not evenly divide the number of elements
19737 in the vector, the last row will be short and the result will not be
19738 suitable for use as a matrix. For example, with the matrix
19739 @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
19740 @samp{[[1, 2, 3, 4]]} (a
19741 @texline @math{1\times4}
19743 matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a
19744 @texline @math{4\times1}
19746 matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original
19747 @texline @math{2\times2}
19749 matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a
19750 matrix), and @kbd{v a 0} produces the flattened list
19751 @samp{[1, 2, @w{3, 4}]}.
19753 @cindex Sorting data
19759 The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
19760 a vector into increasing order. Real numbers, real infinities, and
19761 constant interval forms come first in this ordering; next come other
19762 kinds of numbers, then variables (in alphabetical order), then finally
19763 come formulas and other kinds of objects; these are sorted according
19764 to a kind of lexicographic ordering with the useful property that
19765 one vector is less or greater than another if the first corresponding
19766 unequal elements are less or greater, respectively. Since quoted strings
19767 are stored by Calc internally as vectors of ASCII character codes
19768 (@pxref{Strings}), this means vectors of strings are also sorted into
19769 alphabetical order by this command.
19771 The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
19773 @cindex Permutation, inverse of
19774 @cindex Inverse of permutation
19775 @cindex Index tables
19776 @cindex Rank tables
19782 The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
19783 produces an index table or permutation vector which, if applied to the
19784 input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
19785 A permutation vector is just a vector of integers from 1 to @var{n}, where
19786 each integer occurs exactly once. One application of this is to sort a
19787 matrix of data rows using one column as the sort key; extract that column,
19788 grade it with @kbd{V G}, then use the result to reorder the original matrix
19789 with @kbd{C-u v r}. Another interesting property of the @code{V G} command
19790 is that, if the input is itself a permutation vector, the result will
19791 be the inverse of the permutation. The inverse of an index table is
19792 a rank table, whose @var{k}th element says where the @var{k}th original
19793 vector element will rest when the vector is sorted. To get a rank
19794 table, just use @kbd{V G V G}.
19796 With the Inverse flag, @kbd{I V G} produces an index table that would
19797 sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G}
19798 use a ``stable'' sorting algorithm, i.e., any two elements which are equal
19799 will not be moved out of their original order. Generally there is no way
19800 to tell with @kbd{V S}, since two elements which are equal look the same,
19801 but with @kbd{V G} this can be an important issue. In the matrix-of-rows
19802 example, suppose you have names and telephone numbers as two columns and
19803 you wish to sort by phone number primarily, and by name when the numbers
19804 are equal. You can sort the data matrix by names first, and then again
19805 by phone numbers. Because the sort is stable, any two rows with equal
19806 phone numbers will remain sorted by name even after the second sort.
19810 @pindex calc-histogram
19812 @mindex histo@idots
19815 The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
19816 histogram of a vector of numbers. Vector elements are assumed to be
19817 integers or real numbers in the range [0..@var{n}) for some ``number of
19818 bins'' @var{n}, which is the numeric prefix argument given to the
19819 command. The result is a vector of @var{n} counts of how many times
19820 each value appeared in the original vector. Non-integers in the input
19821 are rounded down to integers. Any vector elements outside the specified
19822 range are ignored. (You can tell if elements have been ignored by noting
19823 that the counts in the result vector don't add up to the length of the
19827 With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
19828 The second-to-top vector is the list of numbers as before. The top
19829 vector is an equal-sized list of ``weights'' to attach to the elements
19830 of the data vector. For example, if the first data element is 4.2 and
19831 the first weight is 10, then 10 will be added to bin 4 of the result
19832 vector. Without the hyperbolic flag, every element has a weight of one.
19835 @pindex calc-transpose
19837 The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
19838 the transpose of the matrix at the top of the stack. If the argument
19839 is a plain vector, it is treated as a row vector and transposed into
19840 a one-column matrix.
19843 @pindex calc-reverse-vector
19845 The @kbd{v v} (@code{calc-reverse-vector}) [@code{rev}] command reverses
19846 a vector end-for-end. Given a matrix, it reverses the order of the rows.
19847 (To reverse the columns instead, just use @kbd{v t v v v t}. The same
19848 principle can be used to apply other vector commands to the columns of
19852 @pindex calc-mask-vector
19854 The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
19855 one vector as a mask to extract elements of another vector. The mask
19856 is in the second-to-top position; the target vector is on the top of
19857 the stack. These vectors must have the same length. The result is
19858 the same as the target vector, but with all elements which correspond
19859 to zeros in the mask vector deleted. Thus, for example,
19860 @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
19861 @xref{Logical Operations}.
19864 @pindex calc-expand-vector
19866 The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
19867 expands a vector according to another mask vector. The result is a
19868 vector the same length as the mask, but with nonzero elements replaced
19869 by successive elements from the target vector. The length of the target
19870 vector is normally the number of nonzero elements in the mask. If the
19871 target vector is longer, its last few elements are lost. If the target
19872 vector is shorter, the last few nonzero mask elements are left
19873 unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
19874 produces @samp{[a, 0, b, 0, 7]}.
19877 With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
19878 top of the stack; the mask and target vectors come from the third and
19879 second elements of the stack. This filler is used where the mask is
19880 zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
19881 @samp{[a, z, c, z, 7]}. If the filler value is itself a vector,
19882 then successive values are taken from it, so that the effect is to
19883 interleave two vectors according to the mask:
19884 @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
19885 @samp{[a, x, b, 7, y, 0]}.
19887 Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
19888 with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
19889 You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
19890 operation across the two vectors. @xref{Logical Operations}. Note that
19891 the @code{? :} operation also discussed there allows other types of
19892 masking using vectors.
19894 @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
19895 @section Vector and Matrix Arithmetic
19898 Basic arithmetic operations like addition and multiplication are defined
19899 for vectors and matrices as well as for numbers. Division of matrices, in
19900 the sense of multiplying by the inverse, is supported. (Division by a
19901 matrix actually uses LU-decomposition for greater accuracy and speed.)
19902 @xref{Basic Arithmetic}.
19904 The following functions are applied element-wise if their arguments are
19905 vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
19906 @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
19907 @code{float}, @code{frac}. @xref{Function Index}.
19910 @pindex calc-conj-transpose
19912 The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
19913 the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
19918 @kindex A (vectors)
19919 @pindex calc-abs (vectors)
19923 @tindex abs (vectors)
19924 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
19925 Frobenius norm of a vector or matrix argument. This is the square
19926 root of the sum of the squares of the absolute values of the
19927 elements of the vector or matrix. If the vector is interpreted as
19928 a point in two- or three-dimensional space, this is the distance
19929 from that point to the origin.
19934 The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes
19935 the row norm, or infinity-norm, of a vector or matrix. For a plain
19936 vector, this is the maximum of the absolute values of the elements.
19937 For a matrix, this is the maximum of the row-absolute-value-sums,
19938 i.e., of the sums of the absolute values of the elements along the
19944 The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
19945 the column norm, or one-norm, of a vector or matrix. For a plain
19946 vector, this is the sum of the absolute values of the elements.
19947 For a matrix, this is the maximum of the column-absolute-value-sums.
19948 General @expr{k}-norms for @expr{k} other than one or infinity are
19954 The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
19955 right-handed cross product of two vectors, each of which must have
19956 exactly three elements.
19961 @kindex & (matrices)
19962 @pindex calc-inv (matrices)
19966 @tindex inv (matrices)
19967 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
19968 inverse of a square matrix. If the matrix is singular, the inverse
19969 operation is left in symbolic form. Matrix inverses are recorded so
19970 that once an inverse (or determinant) of a particular matrix has been
19971 computed, the inverse and determinant of the matrix can be recomputed
19972 quickly in the future.
19974 If the argument to @kbd{&} is a plain number @expr{x}, this
19975 command simply computes @expr{1/x}. This is okay, because the
19976 @samp{/} operator also does a matrix inversion when dividing one
19982 The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
19983 determinant of a square matrix.
19988 The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
19989 LU decomposition of a matrix. The result is a list of three matrices
19990 which, when multiplied together left-to-right, form the original matrix.
19991 The first is a permutation matrix that arises from pivoting in the
19992 algorithm, the second is lower-triangular with ones on the diagonal,
19993 and the third is upper-triangular.
19996 @pindex calc-mtrace
19998 The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
19999 trace of a square matrix. This is defined as the sum of the diagonal
20000 elements of the matrix.
20002 @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
20003 @section Set Operations using Vectors
20006 @cindex Sets, as vectors
20007 Calc includes several commands which interpret vectors as @dfn{sets} of
20008 objects. A set is a collection of objects; any given object can appear
20009 only once in the set. Calc stores sets as vectors of objects in
20010 sorted order. Objects in a Calc set can be any of the usual things,
20011 such as numbers, variables, or formulas. Two set elements are considered
20012 equal if they are identical, except that numerically equal numbers like
20013 the integer 4 and the float 4.0 are considered equal even though they
20014 are not ``identical.'' Variables are treated like plain symbols without
20015 attached values by the set operations; subtracting the set @samp{[b]}
20016 from @samp{[a, b]} always yields the set @samp{[a]} even though if
20017 the variables @samp{a} and @samp{b} both equaled 17, you might
20018 expect the answer @samp{[]}.
20020 If a set contains interval forms, then it is assumed to be a set of
20021 real numbers. In this case, all set operations require the elements
20022 of the set to be only things that are allowed in intervals: Real
20023 numbers, plus and minus infinity, HMS forms, and date forms. If
20024 there are variables or other non-real objects present in a real set,
20025 all set operations on it will be left in unevaluated form.
20027 If the input to a set operation is a plain number or interval form
20028 @var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
20029 The result is always a vector, except that if the set consists of a
20030 single interval, the interval itself is returned instead.
20032 @xref{Logical Operations}, for the @code{in} function which tests if
20033 a certain value is a member of a given set. To test if the set @expr{A}
20034 is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}.
20037 @pindex calc-remove-duplicates
20039 The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
20040 converts an arbitrary vector into set notation. It works by sorting
20041 the vector as if by @kbd{V S}, then removing duplicates. (For example,
20042 @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
20043 reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as
20044 necessary. You rarely need to use @kbd{V +} explicitly, since all the
20045 other set-based commands apply @kbd{V +} to their inputs before using
20049 @pindex calc-set-union
20051 The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
20052 the union of two sets. An object is in the union of two sets if and
20053 only if it is in either (or both) of the input sets. (You could
20054 accomplish the same thing by concatenating the sets with @kbd{|},
20055 then using @kbd{V +}.)
20058 @pindex calc-set-intersect
20060 The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
20061 the intersection of two sets. An object is in the intersection if
20062 and only if it is in both of the input sets. Thus if the input
20063 sets are disjoint, i.e., if they share no common elements, the result
20064 will be the empty vector @samp{[]}. Note that the characters @kbd{V}
20065 and @kbd{^} were chosen to be close to the conventional mathematical
20067 @texline union@tie{}(@math{A \cup B})
20070 @texline intersection@tie{}(@math{A \cap B}).
20071 @infoline intersection.
20074 @pindex calc-set-difference
20076 The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
20077 the difference between two sets. An object is in the difference
20078 @expr{A - B} if and only if it is in @expr{A} but not in @expr{B}.
20079 Thus subtracting @samp{[y,z]} from a set will remove the elements
20080 @samp{y} and @samp{z} if they are present. You can also think of this
20081 as a general @dfn{set complement} operator; if @expr{A} is the set of
20082 all possible values, then @expr{A - B} is the ``complement'' of @expr{B}.
20083 Obviously this is only practical if the set of all possible values in
20084 your problem is small enough to list in a Calc vector (or simple
20085 enough to express in a few intervals).
20088 @pindex calc-set-xor
20090 The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
20091 the ``exclusive-or,'' or ``symmetric difference'' of two sets.
20092 An object is in the symmetric difference of two sets if and only
20093 if it is in one, but @emph{not} both, of the sets. Objects that
20094 occur in both sets ``cancel out.''
20097 @pindex calc-set-complement
20099 The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
20100 computes the complement of a set with respect to the real numbers.
20101 Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
20102 For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
20103 @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
20106 @pindex calc-set-floor
20108 The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
20109 reinterprets a set as a set of integers. Any non-integer values,
20110 and intervals that do not enclose any integers, are removed. Open
20111 intervals are converted to equivalent closed intervals. Successive
20112 integers are converted into intervals of integers. For example, the
20113 complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
20114 the complement with respect to the set of integers you could type
20115 @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
20118 @pindex calc-set-enumerate
20120 The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
20121 converts a set of integers into an explicit vector. Intervals in
20122 the set are expanded out to lists of all integers encompassed by
20123 the intervals. This only works for finite sets (i.e., sets which
20124 do not involve @samp{-inf} or @samp{inf}).
20127 @pindex calc-set-span
20129 The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
20130 set of reals into an interval form that encompasses all its elements.
20131 The lower limit will be the smallest element in the set; the upper
20132 limit will be the largest element. For an empty set, @samp{vspan([])}
20133 returns the empty interval @w{@samp{[0 .. 0)}}.
20136 @pindex calc-set-cardinality
20138 The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
20139 the number of integers in a set. The result is the length of the vector
20140 that would be produced by @kbd{V E}, although the computation is much
20141 more efficient than actually producing that vector.
20143 @cindex Sets, as binary numbers
20144 Another representation for sets that may be more appropriate in some
20145 cases is binary numbers. If you are dealing with sets of integers
20146 in the range 0 to 49, you can use a 50-bit binary number where a
20147 particular bit is 1 if the corresponding element is in the set.
20148 @xref{Binary Functions}, for a list of commands that operate on
20149 binary numbers. Note that many of the above set operations have
20150 direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}),
20151 @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
20152 @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
20153 respectively. You can use whatever representation for sets is most
20158 @pindex calc-pack-bits
20159 @pindex calc-unpack-bits
20162 The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
20163 converts an integer that represents a set in binary into a set
20164 in vector/interval notation. For example, @samp{vunpack(67)}
20165 returns @samp{[[0 .. 1], 6]}. If the input is negative, the set
20166 it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
20167 Use @kbd{V E} afterwards to expand intervals to individual
20168 values if you wish. Note that this command uses the @kbd{b}
20169 (binary) prefix key.
20171 The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
20172 converts the other way, from a vector or interval representing
20173 a set of nonnegative integers into a binary integer describing
20174 the same set. The set may include positive infinity, but must
20175 not include any negative numbers. The input is interpreted as a
20176 set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware
20177 that a simple input like @samp{[100]} can result in a huge integer
20179 @texline (@math{2^{100}}, a 31-digit integer, in this case).
20180 @infoline (@expr{2^100}, a 31-digit integer, in this case).
20182 @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
20183 @section Statistical Operations on Vectors
20186 @cindex Statistical functions
20187 The commands in this section take vectors as arguments and compute
20188 various statistical measures on the data stored in the vectors. The
20189 references used in the definitions of these functions are Bevington's
20190 @emph{Data Reduction and Error Analysis for the Physical Sciences},
20191 and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
20194 The statistical commands use the @kbd{u} prefix key followed by
20195 a shifted letter or other character.
20197 @xref{Manipulating Vectors}, for a description of @kbd{V H}
20198 (@code{calc-histogram}).
20200 @xref{Curve Fitting}, for the @kbd{a F} command for doing
20201 least-squares fits to statistical data.
20203 @xref{Probability Distribution Functions}, for several common
20204 probability distribution functions.
20207 * Single-Variable Statistics::
20208 * Paired-Sample Statistics::
20211 @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
20212 @subsection Single-Variable Statistics
20215 These functions do various statistical computations on single
20216 vectors. Given a numeric prefix argument, they actually pop
20217 @var{n} objects from the stack and combine them into a data
20218 vector. Each object may be either a number or a vector; if a
20219 vector, any sub-vectors inside it are ``flattened'' as if by
20220 @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object
20221 is popped, which (in order to be useful) is usually a vector.
20223 If an argument is a variable name, and the value stored in that
20224 variable is a vector, then the stored vector is used. This method
20225 has the advantage that if your data vector is large, you can avoid
20226 the slow process of manipulating it directly on the stack.
20228 These functions are left in symbolic form if any of their arguments
20229 are not numbers or vectors, e.g., if an argument is a formula, or
20230 a non-vector variable. However, formulas embedded within vector
20231 arguments are accepted; the result is a symbolic representation
20232 of the computation, based on the assumption that the formula does
20233 not itself represent a vector. All varieties of numbers such as
20234 error forms and interval forms are acceptable.
20236 Some of the functions in this section also accept a single error form
20237 or interval as an argument. They then describe a property of the
20238 normal or uniform (respectively) statistical distribution described
20239 by the argument. The arguments are interpreted in the same way as
20240 the @var{M} argument of the random number function @kbd{k r}. In
20241 particular, an interval with integer limits is considered an integer
20242 distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
20243 An interval with at least one floating-point limit is a continuous
20244 distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as
20245 @samp{[2.0 .. 5.0]}!
20248 @pindex calc-vector-count
20250 The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
20251 computes the number of data values represented by the inputs.
20252 For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
20253 If the argument is a single vector with no sub-vectors, this
20254 simply computes the length of the vector.
20258 @pindex calc-vector-sum
20259 @pindex calc-vector-prod
20262 @cindex Summations (statistical)
20263 The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
20264 computes the sum of the data values. The @kbd{u *}
20265 (@code{calc-vector-prod}) [@code{vprod}] command computes the
20266 product of the data values. If the input is a single flat vector,
20267 these are the same as @kbd{V R +} and @kbd{V R *}
20268 (@pxref{Reducing and Mapping}).
20272 @pindex calc-vector-max
20273 @pindex calc-vector-min
20276 The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
20277 computes the maximum of the data values, and the @kbd{u N}
20278 (@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
20279 If the argument is an interval, this finds the minimum or maximum
20280 value in the interval. (Note that @samp{vmax([2..6)) = 5} as
20281 described above.) If the argument is an error form, this returns
20282 plus or minus infinity.
20285 @pindex calc-vector-mean
20287 @cindex Mean of data values
20288 The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
20289 computes the average (arithmetic mean) of the data values.
20290 If the inputs are error forms
20291 @texline @math{x \pm \sigma},
20292 @infoline @samp{x +/- s},
20293 this is the weighted mean of the @expr{x} values with weights
20294 @texline @math{1 /\sigma^2}.
20295 @infoline @expr{1 / s^2}.
20298 $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
20299 \displaystyle \sum { 1 \over \sigma_i^2 } } $$
20301 If the inputs are not error forms, this is simply the sum of the
20302 values divided by the count of the values.
20304 Note that a plain number can be considered an error form with
20306 @texline @math{\sigma = 0}.
20307 @infoline @expr{s = 0}.
20308 If the input to @kbd{u M} is a mixture of
20309 plain numbers and error forms, the result is the mean of the
20310 plain numbers, ignoring all values with non-zero errors. (By the
20311 above definitions it's clear that a plain number effectively
20312 has an infinite weight, next to which an error form with a finite
20313 weight is completely negligible.)
20315 This function also works for distributions (error forms or
20316 intervals). The mean of an error form `@var{a} @tfn{+/-} @var{b}' is simply
20317 @expr{a}. The mean of an interval is the mean of the minimum
20318 and maximum values of the interval.
20321 @pindex calc-vector-mean-error
20323 The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
20324 command computes the mean of the data points expressed as an
20325 error form. This includes the estimated error associated with
20326 the mean. If the inputs are error forms, the error is the square
20327 root of the reciprocal of the sum of the reciprocals of the squares
20328 of the input errors. (I.e., the variance is the reciprocal of the
20329 sum of the reciprocals of the variances.)
20332 $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
20334 If the inputs are plain
20335 numbers, the error is equal to the standard deviation of the values
20336 divided by the square root of the number of values. (This works
20337 out to be equivalent to calculating the standard deviation and
20338 then assuming each value's error is equal to this standard
20342 $$ \sigma_\mu^2 = {\sigma^2 \over N} $$
20346 @pindex calc-vector-median
20348 @cindex Median of data values
20349 The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
20350 command computes the median of the data values. The values are
20351 first sorted into numerical order; the median is the middle
20352 value after sorting. (If the number of data values is even,
20353 the median is taken to be the average of the two middle values.)
20354 The median function is different from the other functions in
20355 this section in that the arguments must all be real numbers;
20356 variables are not accepted even when nested inside vectors.
20357 (Otherwise it is not possible to sort the data values.) If
20358 any of the input values are error forms, their error parts are
20361 The median function also accepts distributions. For both normal
20362 (error form) and uniform (interval) distributions, the median is
20363 the same as the mean.
20366 @pindex calc-vector-harmonic-mean
20368 @cindex Harmonic mean
20369 The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
20370 command computes the harmonic mean of the data values. This is
20371 defined as the reciprocal of the arithmetic mean of the reciprocals
20375 $$ { N \over \displaystyle \sum {1 \over x_i} } $$
20379 @pindex calc-vector-geometric-mean
20381 @cindex Geometric mean
20382 The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
20383 command computes the geometric mean of the data values. This
20384 is the @var{n}th root of the product of the values. This is also
20385 equal to the @code{exp} of the arithmetic mean of the logarithms
20386 of the data values.
20389 $$ \exp \left ( \sum { \ln x_i } \right ) =
20390 \left ( \prod { x_i } \right)^{1 / N} $$
20395 The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
20396 mean'' of two numbers taken from the stack. This is computed by
20397 replacing the two numbers with their arithmetic mean and geometric
20398 mean, then repeating until the two values converge.
20401 $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
20404 @cindex Root-mean-square
20405 Another commonly used mean, the RMS (root-mean-square), can be computed
20406 for a vector of numbers simply by using the @kbd{A} command.
20409 @pindex calc-vector-sdev
20411 @cindex Standard deviation
20412 @cindex Sample statistics
20413 The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
20414 computes the standard
20415 @texline deviation@tie{}@math{\sigma}
20416 @infoline deviation
20417 of the data values. If the values are error forms, the errors are used
20418 as weights just as for @kbd{u M}. This is the @emph{sample} standard
20419 deviation, whose value is the square root of the sum of the squares of
20420 the differences between the values and the mean of the @expr{N} values,
20421 divided by @expr{N-1}.
20424 $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
20427 This function also applies to distributions. The standard deviation
20428 of a single error form is simply the error part. The standard deviation
20429 of a continuous interval happens to equal the difference between the
20431 @texline @math{\sqrt{12}}.
20432 @infoline @expr{sqrt(12)}.
20433 The standard deviation of an integer interval is the same as the
20434 standard deviation of a vector of those integers.
20437 @pindex calc-vector-pop-sdev
20439 @cindex Population statistics
20440 The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
20441 command computes the @emph{population} standard deviation.
20442 It is defined by the same formula as above but dividing
20443 by @expr{N} instead of by @expr{N-1}. The population standard
20444 deviation is used when the input represents the entire set of
20445 data values in the distribution; the sample standard deviation
20446 is used when the input represents a sample of the set of all
20447 data values, so that the mean computed from the input is itself
20448 only an estimate of the true mean.
20451 $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
20454 For error forms and continuous intervals, @code{vpsdev} works
20455 exactly like @code{vsdev}. For integer intervals, it computes the
20456 population standard deviation of the equivalent vector of integers.
20460 @pindex calc-vector-variance
20461 @pindex calc-vector-pop-variance
20464 @cindex Variance of data values
20465 The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
20466 @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
20467 commands compute the variance of the data values. The variance
20469 @texline square@tie{}@math{\sigma^2}
20471 of the standard deviation, i.e., the sum of the
20472 squares of the deviations of the data values from the mean.
20473 (This definition also applies when the argument is a distribution.)
20479 The @code{vflat} algebraic function returns a vector of its
20480 arguments, interpreted in the same way as the other functions
20481 in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)}
20482 returns @samp{[1, 2, 3, 4, 5]}.
20484 @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
20485 @subsection Paired-Sample Statistics
20488 The functions in this section take two arguments, which must be
20489 vectors of equal size. The vectors are each flattened in the same
20490 way as by the single-variable statistical functions. Given a numeric
20491 prefix argument of 1, these functions instead take one object from
20492 the stack, which must be an
20493 @texline @math{N\times2}
20495 matrix of data values. Once again, variable names can be used in place
20496 of actual vectors and matrices.
20499 @pindex calc-vector-covariance
20502 The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
20503 computes the sample covariance of two vectors. The covariance
20504 of vectors @var{x} and @var{y} is the sum of the products of the
20505 differences between the elements of @var{x} and the mean of @var{x}
20506 times the differences between the corresponding elements of @var{y}
20507 and the mean of @var{y}, all divided by @expr{N-1}. Note that
20508 the variance of a vector is just the covariance of the vector
20509 with itself. Once again, if the inputs are error forms the
20510 errors are used as weight factors. If both @var{x} and @var{y}
20511 are composed of error forms, the error for a given data point
20512 is taken as the square root of the sum of the squares of the two
20516 $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
20517 $$ \sigma_{x\!y}^2 =
20518 {\displaystyle {1 \over N-1}
20519 \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
20520 \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
20525 @pindex calc-vector-pop-covariance
20527 The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
20528 command computes the population covariance, which is the same as the
20529 sample covariance computed by @kbd{u C} except dividing by @expr{N}
20530 instead of @expr{N-1}.
20533 @pindex calc-vector-correlation
20535 @cindex Correlation coefficient
20536 @cindex Linear correlation
20537 The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
20538 command computes the linear correlation coefficient of two vectors.
20539 This is defined by the covariance of the vectors divided by the
20540 product of their standard deviations. (There is no difference
20541 between sample or population statistics here.)
20544 $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
20547 @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
20548 @section Reducing and Mapping Vectors
20551 The commands in this section allow for more general operations on the
20552 elements of vectors.
20557 The simplest of these operations is @kbd{V A} (@code{calc-apply})
20558 [@code{apply}], which applies a given operator to the elements of a vector.
20559 For example, applying the hypothetical function @code{f} to the vector
20560 @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
20561 Applying the @code{+} function to the vector @samp{[a, b]} gives
20562 @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an
20563 error, since the @code{+} function expects exactly two arguments.
20565 While @kbd{V A} is useful in some cases, you will usually find that either
20566 @kbd{V R} or @kbd{V M}, described below, is closer to what you want.
20569 * Specifying Operators::
20572 * Nesting and Fixed Points::
20573 * Generalized Products::
20576 @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
20577 @subsection Specifying Operators
20580 Commands in this section (like @kbd{V A}) prompt you to press the key
20581 corresponding to the desired operator. Press @kbd{?} for a partial
20582 list of the available operators. Generally, an operator is any key or
20583 sequence of keys that would normally take one or more arguments from
20584 the stack and replace them with a result. For example, @kbd{V A H C}
20585 uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh}
20586 expects one argument, @kbd{V A H C} requires a vector with a single
20587 element as its argument.)
20589 You can press @kbd{x} at the operator prompt to select any algebraic
20590 function by name to use as the operator. This includes functions you
20591 have defined yourself using the @kbd{Z F} command. (@xref{Algebraic
20592 Definitions}.) If you give a name for which no function has been
20593 defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
20594 Calc will prompt for the number of arguments the function takes if it
20595 can't figure it out on its own (say, because you named a function that
20596 is currently undefined). It is also possible to type a digit key before
20597 the function name to specify the number of arguments, e.g.,
20598 @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
20599 looks like it ought to have only two. This technique may be necessary
20600 if the function allows a variable number of arguments. For example,
20601 the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
20602 if you want to map with the three-argument version, you will have to
20603 type @kbd{V M 3 v e}.
20605 It is also possible to apply any formula to a vector by treating that
20606 formula as a function. When prompted for the operator to use, press
20607 @kbd{'} (the apostrophe) and type your formula as an algebraic entry.
20608 You will then be prompted for the argument list, which defaults to a
20609 list of all variables that appear in the formula, sorted into alphabetic
20610 order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
20611 The default argument list would be @samp{(x y)}, which means that if
20612 this function is applied to the arguments @samp{[3, 10]} the result will
20613 be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this
20614 way often, you might consider defining it as a function with @kbd{Z F}.)
20616 Another way to specify the arguments to the formula you enter is with
20617 @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$}
20618 has the same effect as the previous example. The argument list is
20619 automatically taken to be @samp{($$ $)}. (The order of the arguments
20620 may seem backwards, but it is analogous to the way normal algebraic
20621 entry interacts with the stack.)
20623 If you press @kbd{$} at the operator prompt, the effect is similar to
20624 the apostrophe except that the relevant formula is taken from top-of-stack
20625 instead. The actual vector arguments of the @kbd{V A $} or related command
20626 then start at the second-to-top stack position. You will still be
20627 prompted for an argument list.
20629 @cindex Nameless functions
20630 @cindex Generic functions
20631 A function can be written without a name using the notation @samp{<#1 - #2>},
20632 which means ``a function of two arguments that computes the first
20633 argument minus the second argument.'' The symbols @samp{#1} and @samp{#2}
20634 are placeholders for the arguments. You can use any names for these
20635 placeholders if you wish, by including an argument list followed by a
20636 colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
20637 Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
20638 to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
20639 Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both
20640 cases, Calc also writes the nameless function to the Trail so that you
20641 can get it back later if you wish.
20643 If there is only one argument, you can write @samp{#} in place of @samp{#1}.
20644 (Note that @samp{< >} notation is also used for date forms. Calc tells
20645 that @samp{<@var{stuff}>} is a nameless function by the presence of
20646 @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
20647 begins with a list of variables followed by a colon.)
20649 You can type a nameless function directly to @kbd{V A '}, or put one on
20650 the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an
20651 argument list in this case, since the nameless function specifies the
20652 argument list as well as the function itself. In @kbd{V A '}, you can
20653 omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
20654 so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
20655 which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
20657 @cindex Lambda expressions
20662 The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
20663 (The word @code{lambda} derives from Lisp notation and the theory of
20664 functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
20665 ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called
20666 @code{lambda}; the whole point is that the @code{lambda} expression is
20667 used in its symbolic form, not evaluated for an answer until it is applied
20668 to specific arguments by a command like @kbd{V A} or @kbd{V M}.
20670 (Actually, @code{lambda} does have one special property: Its arguments
20671 are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
20672 will not simplify the @samp{2/3} until the nameless function is actually
20701 As usual, commands like @kbd{V A} have algebraic function name equivalents.
20702 For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
20703 @samp{apply(gcd, v)}. The first argument specifies the operator name,
20704 and is either a variable whose name is the same as the function name,
20705 or a nameless function like @samp{<#^3+1>}. Operators that are normally
20706 written as algebraic symbols have the names @code{add}, @code{sub},
20707 @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
20714 The @code{call} function builds a function call out of several arguments:
20715 @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
20716 in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call},
20717 like the other functions described here, may be either a variable naming a
20718 function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
20721 (Experts will notice that it's not quite proper to use a variable to name
20722 a function, since the name @code{gcd} corresponds to the Lisp variable
20723 @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc
20724 automatically makes this translation, so you don't have to worry
20727 @node Mapping, Reducing, Specifying Operators, Reducing and Mapping
20728 @subsection Mapping
20734 The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
20735 operator elementwise to one or more vectors. For example, mapping
20736 @code{A} [@code{abs}] produces a vector of the absolute values of the
20737 elements in the input vector. Mapping @code{+} pops two vectors from
20738 the stack, which must be of equal length, and produces a vector of the
20739 pairwise sums of the elements. If either argument is a non-vector, it
20740 is duplicated for each element of the other vector. For example,
20741 @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
20742 With the 2 listed first, it would have computed a vector of powers of
20743 two. Mapping a user-defined function pops as many arguments from the
20744 stack as the function requires. If you give an undefined name, you will
20745 be prompted for the number of arguments to use.
20747 If any argument to @kbd{V M} is a matrix, the operator is normally mapped
20748 across all elements of the matrix. For example, given the matrix
20749 @expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
20751 @texline @math{3\times2}
20753 matrix, @expr{[[1, 2, 3], [4, 5, 6]]}.
20756 The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
20757 operator prompt) maps by rows instead. For example, @kbd{V M _ A} views
20758 the above matrix as a vector of two 3-element row vectors. It produces
20759 a new vector which contains the absolute values of those row vectors,
20760 namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is
20761 defined as the square root of the sum of the squares of the elements.)
20762 Some operators accept vectors and return new vectors; for example,
20763 @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
20764 of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}.
20766 Sometimes a vector of vectors (representing, say, strings, sets, or lists)
20767 happens to look like a matrix. If so, remember to use @kbd{V M _} if you
20768 want to map a function across the whole strings or sets rather than across
20769 their individual elements.
20772 The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it
20773 transposes the input matrix, maps by rows, and then, if the result is a
20774 matrix, transposes again. For example, @kbd{V M : A} takes the absolute
20775 values of the three columns of the matrix, treating each as a 2-vector,
20776 and @kbd{V M : v v} reverses the columns to get the matrix
20777 @expr{[[-4, 5, -6], [1, -2, 3]]}.
20779 (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
20780 and column-like appearances, and were not already taken by useful
20781 operators. Also, they appear shifted on most keyboards so they are easy
20782 to type after @kbd{V M}.)
20784 The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
20785 not matrices (so if none of the arguments are matrices, they have no
20786 effect at all). If some of the arguments are matrices and others are
20787 plain numbers, the plain numbers are held constant for all rows of the
20788 matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
20789 a vector takes a dot product of the vector with itself).
20791 If some of the arguments are vectors with the same lengths as the
20792 rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
20793 arguments, those vectors are also held constant for every row or
20796 Sometimes it is useful to specify another mapping command as the operator
20797 to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +}
20798 to each row of the input matrix, which in turn adds the two values on that
20799 row. If you give another vector-operator command as the operator for
20800 @kbd{V M}, it automatically uses map-by-rows mode if you don't specify
20801 otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If
20802 you really want to map-by-elements another mapping command, you can use
20803 a triple-nested mapping command: @kbd{V M V M V A +} means to map
20804 @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
20805 mapped over the elements of each row.)
20809 Previous versions of Calc had ``map across'' and ``map down'' modes
20810 that are now considered obsolete; the old ``map across'' is now simply
20811 @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic
20812 functions @code{mapa} and @code{mapd} are still supported, though.
20813 Note also that, while the old mapping modes were persistent (once you
20814 set the mode, it would apply to later mapping commands until you reset
20815 it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
20816 mapping command. The default @kbd{V M} always means map-by-elements.
20818 @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
20819 @kbd{V M} but for equations and inequalities instead of vectors.
20820 @xref{Storing Variables}, for the @kbd{s m} command which modifies a
20821 variable's stored value using a @kbd{V M}-like operator.
20823 @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
20824 @subsection Reducing
20828 @pindex calc-reduce
20830 The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
20831 binary operator across all the elements of a vector. A binary operator is
20832 a function such as @code{+} or @code{max} which takes two arguments. For
20833 example, reducing @code{+} over a vector computes the sum of the elements
20834 of the vector. Reducing @code{-} computes the first element minus each of
20835 the remaining elements. Reducing @code{max} computes the maximum element
20836 and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
20837 produces @samp{f(f(f(a, b), c), d)}.
20841 The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
20842 that works from right to left through the vector. For example, plain
20843 @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
20844 but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
20845 or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently
20846 in power series expansions.
20850 The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
20851 accumulation operation. Here Calc does the corresponding reduction
20852 operation, but instead of producing only the final result, it produces
20853 a vector of all the intermediate results. Accumulating @code{+} over
20854 the vector @samp{[a, b, c, d]} produces the vector
20855 @samp{[a, a + b, a + b + c, a + b + c + d]}.
20859 The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
20860 For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
20861 vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
20867 As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For
20868 example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
20869 compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or
20870 @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}]
20871 command reduces ``across'' the matrix; it reduces each row of the matrix
20872 as a vector, then collects the results. Thus @kbd{V R _ +} of this
20873 matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :}
20874 [@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d,
20879 There is a third ``by rows'' mode for reduction that is occasionally
20880 useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
20881 the rows of the matrix themselves. Thus @kbd{V R = +} on the above
20882 matrix would get the same result as @kbd{V R : +}, since adding two
20883 row vectors is equivalent to adding their elements. But @kbd{V R = *}
20884 would multiply the two rows (to get a single number, their dot product),
20885 while @kbd{V R : *} would produce a vector of the products of the columns.
20887 These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
20888 but they are not currently supported with @kbd{V U} or @kbd{I V U}.
20892 The obsolete reduce-by-columns function, @code{reducec}, is still
20893 supported but there is no way to get it through the @kbd{V R} command.
20895 The commands @kbd{C-x * :} and @kbd{C-x * _} are equivalent to typing
20896 @kbd{C-x * r} to grab a rectangle of data into Calc, and then typing
20897 @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
20898 rows of the matrix. @xref{Grabbing From Buffers}.
20900 @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
20901 @subsection Nesting and Fixed Points
20906 The @kbd{H V R} [@code{nest}] command applies a function to a given
20907 argument repeatedly. It takes two values, @samp{a} and @samp{n}, from
20908 the stack, where @samp{n} must be an integer. It then applies the
20909 function nested @samp{n} times; if the function is @samp{f} and @samp{n}
20910 is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be
20911 negative if Calc knows an inverse for the function @samp{f}; for
20912 example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
20916 The @kbd{H V U} [@code{anest}] command is an accumulating version of
20917 @code{nest}: It returns a vector of @samp{n+1} values, e.g.,
20918 @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and
20919 @samp{F} is the inverse of @samp{f}, then the result is of the
20920 form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
20924 @cindex Fixed points
20925 The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
20926 that it takes only an @samp{a} value from the stack; the function is
20927 applied until it reaches a ``fixed point,'' i.e., until the result
20932 The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
20933 The first element of the return vector will be the initial value @samp{a};
20934 the last element will be the final result that would have been returned
20937 For example, 0.739085 is a fixed point of the cosine function (in radians):
20938 @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say,
20939 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating
20940 version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553,
20941 0.65329, ...]}. With a precision of six, this command will take 36 steps
20942 to converge to 0.739085.)
20944 Newton's method for finding roots is a classic example of iteration
20945 to a fixed point. To find the square root of five starting with an
20946 initial guess, Newton's method would look for a fixed point of the
20947 function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack
20948 and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
20949 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root})
20950 command to find a root of the equation @samp{x^2 = 5}.
20952 These examples used numbers for @samp{a} values. Calc keeps applying
20953 the function until two successive results are equal to within the
20954 current precision. For complex numbers, both the real parts and the
20955 imaginary parts must be equal to within the current precision. If
20956 @samp{a} is a formula (say, a variable name), then the function is
20957 applied until two successive results are exactly the same formula.
20958 It is up to you to ensure that the function will eventually converge;
20959 if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
20961 The algebraic @code{fixp} function takes two optional arguments, @samp{n}
20962 and @samp{tol}. The first is the maximum number of steps to be allowed,
20963 and must be either an integer or the symbol @samp{inf} (infinity, the
20964 default). The second is a convergence tolerance. If a tolerance is
20965 specified, all results during the calculation must be numbers, not
20966 formulas, and the iteration stops when the magnitude of the difference
20967 between two successive results is less than or equal to the tolerance.
20968 (This implies that a tolerance of zero iterates until the results are
20971 Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
20972 computes the square root of @samp{A} given the initial guess @samp{B},
20973 stopping when the result is correct within the specified tolerance, or
20974 when 20 steps have been taken, whichever is sooner.
20976 @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
20977 @subsection Generalized Products
20980 @pindex calc-outer-product
20982 The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
20983 a given binary operator to all possible pairs of elements from two
20984 vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]}
20985 and @samp{[x, y, z]} on the stack produces a multiplication table:
20986 @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of
20987 the result matrix is obtained by applying the operator to element @var{r}
20988 of the lefthand vector and element @var{c} of the righthand vector.
20991 @pindex calc-inner-product
20993 The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
20994 the generalized inner product of two vectors or matrices, given a
20995 ``multiplicative'' operator and an ``additive'' operator. These can each
20996 actually be any binary operators; if they are @samp{*} and @samp{+},
20997 respectively, the result is a standard matrix multiplication. Element
20998 @var{r},@var{c} of the result matrix is obtained by mapping the
20999 multiplicative operator across row @var{r} of the lefthand matrix and
21000 column @var{c} of the righthand matrix, and then reducing with the additive
21001 operator. Just as for the standard @kbd{*} command, this can also do a
21002 vector-matrix or matrix-vector inner product, or a vector-vector
21003 generalized dot product.
21005 Since @kbd{V I} requires two operators, it prompts twice. In each case,
21006 you can use any of the usual methods for entering the operator. If you
21007 use @kbd{$} twice to take both operator formulas from the stack, the
21008 first (multiplicative) operator is taken from the top of the stack
21009 and the second (additive) operator is taken from second-to-top.
21011 @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
21012 @section Vector and Matrix Display Formats
21015 Commands for controlling vector and matrix display use the @kbd{v} prefix
21016 instead of the usual @kbd{d} prefix. But they are display modes; in
21017 particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
21018 in the same way (@pxref{Display Modes}). Matrix display is also
21019 influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
21020 @pxref{Normal Language Modes}.
21023 @pindex calc-matrix-left-justify
21025 @pindex calc-matrix-center-justify
21027 @pindex calc-matrix-right-justify
21028 The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
21029 (@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
21030 (@code{calc-matrix-center-justify}) control whether matrix elements
21031 are justified to the left, right, or center of their columns.
21034 @pindex calc-vector-brackets
21036 @pindex calc-vector-braces
21038 @pindex calc-vector-parens
21039 The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
21040 brackets that surround vectors and matrices displayed in the stack on
21041 and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
21042 (@code{calc-vector-parens}) commands use curly braces or parentheses,
21043 respectively, instead of square brackets. For example, @kbd{v @{} might
21044 be used in preparation for yanking a matrix into a buffer running
21045 Mathematica. (In fact, the Mathematica language mode uses this mode;
21046 @pxref{Mathematica Language Mode}.) Note that, regardless of the
21047 display mode, either brackets or braces may be used to enter vectors,
21048 and parentheses may never be used for this purpose.
21051 @pindex calc-matrix-brackets
21052 The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
21053 ``big'' style display of matrices. It prompts for a string of code
21054 letters; currently implemented letters are @code{R}, which enables
21055 brackets on each row of the matrix; @code{O}, which enables outer
21056 brackets in opposite corners of the matrix; and @code{C}, which
21057 enables commas or semicolons at the ends of all rows but the last.
21058 The default format is @samp{RO}. (Before Calc 2.00, the format
21059 was fixed at @samp{ROC}.) Here are some example matrices:
21063 [ [ 123, 0, 0 ] [ [ 123, 0, 0 ],
21064 [ 0, 123, 0 ] [ 0, 123, 0 ],
21065 [ 0, 0, 123 ] ] [ 0, 0, 123 ] ]
21074 [ 123, 0, 0 [ 123, 0, 0 ;
21075 0, 123, 0 0, 123, 0 ;
21076 0, 0, 123 ] 0, 0, 123 ]
21085 [ 123, 0, 0 ] 123, 0, 0
21086 [ 0, 123, 0 ] 0, 123, 0
21087 [ 0, 0, 123 ] 0, 0, 123
21094 Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
21095 @samp{OC} are all recognized as matrices during reading, while
21096 the others are useful for display only.
21099 @pindex calc-vector-commas
21100 The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
21101 off in vector and matrix display.
21103 In vectors of length one, and in all vectors when commas have been
21104 turned off, Calc adds extra parentheses around formulas that might
21105 otherwise be ambiguous. For example, @samp{[a b]} could be a vector
21106 of the one formula @samp{a b}, or it could be a vector of two
21107 variables with commas turned off. Calc will display the former
21108 case as @samp{[(a b)]}. You can disable these extra parentheses
21109 (to make the output less cluttered at the expense of allowing some
21110 ambiguity) by adding the letter @code{P} to the control string you
21111 give to @kbd{v ]} (as described above).
21114 @pindex calc-full-vectors
21115 The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
21116 display of long vectors on and off. In this mode, vectors of six
21117 or more elements, or matrices of six or more rows or columns, will
21118 be displayed in an abbreviated form that displays only the first
21119 three elements and the last element: @samp{[a, b, c, ..., z]}.
21120 When very large vectors are involved this will substantially
21121 improve Calc's display speed.
21124 @pindex calc-full-trail-vectors
21125 The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
21126 similar mode for recording vectors in the Trail. If you turn on
21127 this mode, vectors of six or more elements and matrices of six or
21128 more rows or columns will be abbreviated when they are put in the
21129 Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be
21130 unable to recover those vectors. If you are working with very
21131 large vectors, this mode will improve the speed of all operations
21132 that involve the trail.
21135 @pindex calc-break-vectors
21136 The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
21137 vector display on and off. Normally, matrices are displayed with one
21138 row per line but all other types of vectors are displayed in a single
21139 line. This mode causes all vectors, whether matrices or not, to be
21140 displayed with a single element per line. Sub-vectors within the
21141 vectors will still use the normal linear form.
21143 @node Algebra, Units, Matrix Functions, Top
21147 This section covers the Calc features that help you work with
21148 algebraic formulas. First, the general sub-formula selection
21149 mechanism is described; this works in conjunction with any Calc
21150 commands. Then, commands for specific algebraic operations are
21151 described. Finally, the flexible @dfn{rewrite rule} mechanism
21154 The algebraic commands use the @kbd{a} key prefix; selection
21155 commands use the @kbd{j} (for ``just a letter that wasn't used
21156 for anything else'') prefix.
21158 @xref{Editing Stack Entries}, to see how to manipulate formulas
21159 using regular Emacs editing commands.
21161 When doing algebraic work, you may find several of the Calculator's
21162 modes to be helpful, including Algebraic Simplification mode (@kbd{m A})
21163 or No-Simplification mode (@kbd{m O}),
21164 Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and
21165 Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions
21166 of these modes. You may also wish to select Big display mode (@kbd{d B}).
21167 @xref{Normal Language Modes}.
21170 * Selecting Subformulas::
21171 * Algebraic Manipulation::
21172 * Simplifying Formulas::
21175 * Solving Equations::
21176 * Numerical Solutions::
21179 * Logical Operations::
21183 @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
21184 @section Selecting Sub-Formulas
21188 @cindex Sub-formulas
21189 @cindex Parts of formulas
21190 When working with an algebraic formula it is often necessary to
21191 manipulate a portion of the formula rather than the formula as a
21192 whole. Calc allows you to ``select'' a portion of any formula on
21193 the stack. Commands which would normally operate on that stack
21194 entry will now operate only on the sub-formula, leaving the
21195 surrounding part of the stack entry alone.
21197 One common non-algebraic use for selection involves vectors. To work
21198 on one element of a vector in-place, simply select that element as a
21199 ``sub-formula'' of the vector.
21202 * Making Selections::
21203 * Changing Selections::
21204 * Displaying Selections::
21205 * Operating on Selections::
21206 * Rearranging with Selections::
21209 @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
21210 @subsection Making Selections
21214 @pindex calc-select-here
21215 To select a sub-formula, move the Emacs cursor to any character in that
21216 sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will
21217 highlight the smallest portion of the formula that contains that
21218 character. By default the sub-formula is highlighted by blanking out
21219 all of the rest of the formula with dots. Selection works in any
21220 display mode but is perhaps easiest in Big mode (@kbd{d B}).
21221 Suppose you enter the following formula:
21233 (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the
21234 cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
21247 Every character not part of the sub-formula @samp{b} has been changed
21248 to a dot. The @samp{*} next to the line number is to remind you that
21249 the formula has a portion of it selected. (In this case, it's very
21250 obvious, but it might not always be. If Embedded mode is enabled,
21251 the word @samp{Sel} also appears in the mode line because the stack
21252 may not be visible. @pxref{Embedded Mode}.)
21254 If you had instead placed the cursor on the parenthesis immediately to
21255 the right of the @samp{b}, the selection would have been:
21267 The portion selected is always large enough to be considered a complete
21268 formula all by itself, so selecting the parenthesis selects the whole
21269 formula that it encloses. Putting the cursor on the @samp{+} sign
21270 would have had the same effect.
21272 (Strictly speaking, the Emacs cursor is really the manifestation of
21273 the Emacs ``point,'' which is a position @emph{between} two characters
21274 in the buffer. So purists would say that Calc selects the smallest
21275 sub-formula which contains the character to the right of ``point.'')
21277 If you supply a numeric prefix argument @var{n}, the selection is
21278 expanded to the @var{n}th enclosing sub-formula. Thus, positioning
21279 the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
21280 @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
21283 If the cursor is not on any part of the formula, or if you give a
21284 numeric prefix that is too large, the entire formula is selected.
21286 If the cursor is on the @samp{.} line that marks the top of the stack
21287 (i.e., its normal ``rest position''), this command selects the entire
21288 formula at stack level 1. Most selection commands similarly operate
21289 on the formula at the top of the stack if you haven't positioned the
21290 cursor on any stack entry.
21293 @pindex calc-select-additional
21294 The @kbd{j a} (@code{calc-select-additional}) command enlarges the
21295 current selection to encompass the cursor. To select the smallest
21296 sub-formula defined by two different points, move to the first and
21297 press @kbd{j s}, then move to the other and press @kbd{j a}. This
21298 is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
21299 select the two ends of a region of text during normal Emacs editing.
21302 @pindex calc-select-once
21303 The @kbd{j o} (@code{calc-select-once}) command selects a formula in
21304 exactly the same way as @kbd{j s}, except that the selection will
21305 last only as long as the next command that uses it. For example,
21306 @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
21309 (A somewhat more precise definition: The @kbd{j o} command sets a flag
21310 such that the next command involving selected stack entries will clear
21311 the selections on those stack entries afterwards. All other selection
21312 commands except @kbd{j a} and @kbd{j O} clear this flag.)
21316 @pindex calc-select-here-maybe
21317 @pindex calc-select-once-maybe
21318 The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
21319 (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
21320 and @kbd{j o}, respectively, except that if the formula already
21321 has a selection they have no effect. This is analogous to the
21322 behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
21323 @pxref{Selections with Rewrite Rules}) and is mainly intended to be
21324 used in keyboard macros that implement your own selection-oriented
21327 Selection of sub-formulas normally treats associative terms like
21328 @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
21329 If you place the cursor anywhere inside @samp{a + b - c + d} except
21330 on one of the variable names and use @kbd{j s}, you will select the
21331 entire four-term sum.
21334 @pindex calc-break-selections
21335 The @kbd{j b} (@code{calc-break-selections}) command controls a mode
21336 in which the ``deep structure'' of these associative formulas shows
21337 through. Calc actually stores the above formulas as @samp{((a + b) - c) + d}
21338 and @samp{x * (y * z)}. (Note that for certain obscure reasons, Calc
21339 treats multiplication as right-associative.) Once you have enabled
21340 @kbd{j b} mode, selecting with the cursor on the @samp{-} sign would
21341 only select the @samp{a + b - c} portion, which makes sense when the
21342 deep structure of the sum is considered. There is no way to select
21343 the @samp{b - c + d} portion; although this might initially look
21344 like just as legitimate a sub-formula as @samp{a + b - c}, the deep
21345 structure shows that it isn't. The @kbd{d U} command can be used
21346 to view the deep structure of any formula (@pxref{Normal Language Modes}).
21348 When @kbd{j b} mode has not been enabled, the deep structure is
21349 generally hidden by the selection commands---what you see is what
21353 @pindex calc-unselect
21354 The @kbd{j u} (@code{calc-unselect}) command unselects the formula
21355 that the cursor is on. If there was no selection in the formula,
21356 this command has no effect. With a numeric prefix argument, it
21357 unselects the @var{n}th stack element rather than using the cursor
21361 @pindex calc-clear-selections
21362 The @kbd{j c} (@code{calc-clear-selections}) command unselects all
21365 @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
21366 @subsection Changing Selections
21370 @pindex calc-select-more
21371 Once you have selected a sub-formula, you can expand it using the
21372 @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is
21373 selected, pressing @w{@kbd{j m}} repeatedly works as follows:
21378 (a + b) . . . (a + b) + V c (a + b) + V c
21379 1* ............... 1* ............... 1* ---------------
21380 . . . . . . . . 2 x + 1
21385 In the last example, the entire formula is selected. This is roughly
21386 the same as having no selection at all, but because there are subtle
21387 differences the @samp{*} character is still there on the line number.
21389 With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
21390 times (or until the entire formula is selected). Note that @kbd{j s}
21391 with argument @var{n} is equivalent to plain @kbd{j s} followed by
21392 @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there
21393 is no current selection, it is equivalent to @w{@kbd{j s}}.
21395 Even though @kbd{j m} does not explicitly use the location of the
21396 cursor within the formula, it nevertheless uses the cursor to determine
21397 which stack element to operate on. As usual, @kbd{j m} when the cursor
21398 is not on any stack element operates on the top stack element.
21401 @pindex calc-select-less
21402 The @kbd{j l} (@code{calc-select-less}) command reduces the current
21403 selection around the cursor position. That is, it selects the
21404 immediate sub-formula of the current selection which contains the
21405 cursor, the opposite of @kbd{j m}. If the cursor is not inside the
21406 current selection, the command de-selects the formula.
21409 @pindex calc-select-part
21410 The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
21411 select the @var{n}th sub-formula of the current selection. They are
21412 like @kbd{j l} (@code{calc-select-less}) except they use counting
21413 rather than the cursor position to decide which sub-formula to select.
21414 For example, if the current selection is @kbd{a + b + c} or
21415 @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
21416 @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
21417 these cases, @kbd{j 4} through @kbd{j 9} would be errors.
21419 If there is no current selection, @kbd{j 1} through @kbd{j 9} select
21420 the @var{n}th top-level sub-formula. (In other words, they act as if
21421 the entire stack entry were selected first.) To select the @var{n}th
21422 sub-formula where @var{n} is greater than nine, you must instead invoke
21423 @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.
21427 @pindex calc-select-next
21428 @pindex calc-select-previous
21429 The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
21430 (@code{calc-select-previous}) commands change the current selection
21431 to the next or previous sub-formula at the same level. For example,
21432 if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
21433 selects @samp{c}. Further @kbd{j n} commands would be in error because,
21434 even though there is something to the right of @samp{c} (namely, @samp{x}),
21435 it is not at the same level; in this case, it is not a term of the
21436 same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select
21437 the whole product @samp{a*b*c} as a term of the sum) followed by
21438 @w{@kbd{j n}} would successfully select the @samp{x}.
21440 Similarly, @kbd{j p} moves the selection from the @samp{b} in this
21441 sample formula to the @samp{a}. Both commands accept numeric prefix
21442 arguments to move several steps at a time.
21444 It is interesting to compare Calc's selection commands with the
21445 Emacs Info system's commands for navigating through hierarchically
21446 organized documentation. Calc's @kbd{j n} command is completely
21447 analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to
21448 @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
21449 (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
21450 The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
21451 @kbd{j l}; in each case, you can jump directly to a sub-component
21452 of the hierarchy simply by pointing to it with the cursor.
21454 @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
21455 @subsection Displaying Selections
21459 @pindex calc-show-selections
21460 The @kbd{j d} (@code{calc-show-selections}) command controls how
21461 selected sub-formulas are displayed. One of the alternatives is
21462 illustrated in the above examples; if we press @kbd{j d} we switch
21463 to the other style in which the selected portion itself is obscured
21469 (a + b) . . . ## # ## + V c
21470 1* ............... 1* ---------------
21475 @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
21476 @subsection Operating on Selections
21479 Once a selection is made, all Calc commands that manipulate items
21480 on the stack will operate on the selected portions of the items
21481 instead. (Note that several stack elements may have selections
21482 at once, though there can be only one selection at a time in any
21483 given stack element.)
21486 @pindex calc-enable-selections
21487 The @kbd{j e} (@code{calc-enable-selections}) command disables the
21488 effect that selections have on Calc commands. The current selections
21489 still exist, but Calc commands operate on whole stack elements anyway.
21490 This mode can be identified by the fact that the @samp{*} markers on
21491 the line numbers are gone, even though selections are visible. To
21492 reactivate the selections, press @kbd{j e} again.
21494 To extract a sub-formula as a new formula, simply select the
21495 sub-formula and press @key{RET}. This normally duplicates the top
21496 stack element; here it duplicates only the selected portion of that
21499 To replace a sub-formula with something different, you can enter the
21500 new value onto the stack and press @key{TAB}. This normally exchanges
21501 the top two stack elements; here it swaps the value you entered into
21502 the selected portion of the formula, returning the old selected
21503 portion to the top of the stack.
21508 (a + b) . . . 17 x y . . . 17 x y + V c
21509 2* ............... 2* ............. 2: -------------
21510 . . . . . . . . 2 x + 1
21513 1: 17 x y 1: (a + b) 1: (a + b)
21517 In this example we select a sub-formula of our original example,
21518 enter a new formula, @key{TAB} it into place, then deselect to see
21519 the complete, edited formula.
21521 If you want to swap whole formulas around even though they contain
21522 selections, just use @kbd{j e} before and after.
21525 @pindex calc-enter-selection
21526 The @kbd{j '} (@code{calc-enter-selection}) command is another way
21527 to replace a selected sub-formula. This command does an algebraic
21528 entry just like the regular @kbd{'} key. When you press @key{RET},
21529 the formula you type replaces the original selection. You can use
21530 the @samp{$} symbol in the formula to refer to the original
21531 selection. If there is no selection in the formula under the cursor,
21532 the cursor is used to make a temporary selection for the purposes of
21533 the command. Thus, to change a term of a formula, all you have to
21534 do is move the Emacs cursor to that term and press @kbd{j '}.
21537 @pindex calc-edit-selection
21538 The @kbd{j `} (@code{calc-edit-selection}) command is a similar
21539 analogue of the @kbd{`} (@code{calc-edit}) command. It edits the
21540 selected sub-formula in a separate buffer. If there is no
21541 selection, it edits the sub-formula indicated by the cursor.
21543 To delete a sub-formula, press @key{DEL}. This generally replaces
21544 the sub-formula with the constant zero, but in a few suitable contexts
21545 it uses the constant one instead. The @key{DEL} key automatically
21546 deselects and re-simplifies the entire formula afterwards. Thus:
21551 17 x y + # # 17 x y 17 # y 17 y
21552 1* ------------- 1: ------- 1* ------- 1: -------
21553 2 x + 1 2 x + 1 2 x + 1 2 x + 1
21557 In this example, we first delete the @samp{sqrt(c)} term; Calc
21558 accomplishes this by replacing @samp{sqrt(c)} with zero and
21559 resimplifying. We then delete the @kbd{x} in the numerator;
21560 since this is part of a product, Calc replaces it with @samp{1}
21563 If you select an element of a vector and press @key{DEL}, that
21564 element is deleted from the vector. If you delete one side of
21565 an equation or inequality, only the opposite side remains.
21567 @kindex j @key{DEL}
21568 @pindex calc-del-selection
21569 The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
21570 @key{DEL} but with the auto-selecting behavior of @kbd{j '} and
21571 @kbd{j `}. It deletes the selected portion of the formula
21572 indicated by the cursor, or, in the absence of a selection, it
21573 deletes the sub-formula indicated by the cursor position.
21575 @kindex j @key{RET}
21576 @pindex calc-grab-selection
21577 (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
21580 Normal arithmetic operations also apply to sub-formulas. Here we
21581 select the denominator, press @kbd{5 -} to subtract five from the
21582 denominator, press @kbd{n} to negate the denominator, then
21583 press @kbd{Q} to take the square root.
21587 .. . .. . .. . .. .
21588 1* ....... 1* ....... 1* ....... 1* ..........
21589 2 x + 1 2 x - 4 4 - 2 x _________
21594 Certain types of operations on selections are not allowed. For
21595 example, for an arithmetic function like @kbd{-} no more than one of
21596 the arguments may be a selected sub-formula. (As the above example
21597 shows, the result of the subtraction is spliced back into the argument
21598 which had the selection; if there were more than one selection involved,
21599 this would not be well-defined.) If you try to subtract two selections,
21600 the command will abort with an error message.
21602 Operations on sub-formulas sometimes leave the formula as a whole
21603 in an ``un-natural'' state. Consider negating the @samp{2 x} term
21604 of our sample formula by selecting it and pressing @kbd{n}
21605 (@code{calc-change-sign}).
21610 1* .......... 1* ...........
21611 ......... ..........
21612 . . . 2 x . . . -2 x
21616 Unselecting the sub-formula reveals that the minus sign, which would
21617 normally have cancelled out with the subtraction automatically, has
21618 not been able to do so because the subtraction was not part of the
21619 selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
21620 any other mathematical operation on the whole formula will cause it
21626 1: ----------- 1: ----------
21627 __________ _________
21628 V 4 - -2 x V 4 + 2 x
21632 @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
21633 @subsection Rearranging Formulas using Selections
21637 @pindex calc-commute-right
21638 The @kbd{j R} (@code{calc-commute-right}) command moves the selected
21639 sub-formula to the right in its surrounding formula. Generally the
21640 selection is one term of a sum or product; the sum or product is
21641 rearranged according to the commutative laws of algebra.
21643 As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
21644 if there is no selection in the current formula. All commands described
21645 in this section share this property. In this example, we place the
21646 cursor on the @samp{a} and type @kbd{j R}, then repeat.
21649 1: a + b - c 1: b + a - c 1: b - c + a
21653 Note that in the final step above, the @samp{a} is switched with
21654 the @samp{c} but the signs are adjusted accordingly. When moving
21655 terms of sums and products, @kbd{j R} will never change the
21656 mathematical meaning of the formula.
21658 The selected term may also be an element of a vector or an argument
21659 of a function. The term is exchanged with the one to its right.
21660 In this case, the ``meaning'' of the vector or function may of
21661 course be drastically changed.
21664 1: [a, b, c] 1: [b, a, c] 1: [b, c, a]
21666 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a)
21670 @pindex calc-commute-left
21671 The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
21672 except that it swaps the selected term with the one to its left.
21674 With numeric prefix arguments, these commands move the selected
21675 term several steps at a time. It is an error to try to move a
21676 term left or right past the end of its enclosing formula.
21677 With numeric prefix arguments of zero, these commands move the
21678 selected term as far as possible in the given direction.
21681 @pindex calc-sel-distribute
21682 The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
21683 sum or product into the surrounding formula using the distributive
21684 law. For example, in @samp{a * (b - c)} with the @samp{b - c}
21685 selected, the result is @samp{a b - a c}. This also distributes
21686 products or quotients into surrounding powers, and can also do
21687 transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
21688 where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
21689 to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
21691 For multiple-term sums or products, @kbd{j D} takes off one term
21692 at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
21693 with the @samp{c - d} selected so that you can type @kbd{j D}
21694 repeatedly to expand completely. The @kbd{j D} command allows a
21695 numeric prefix argument which specifies the maximum number of
21696 times to expand at once; the default is one time only.
21698 @vindex DistribRules
21699 The @kbd{j D} command is implemented using rewrite rules.
21700 @xref{Selections with Rewrite Rules}. The rules are stored in
21701 the Calc variable @code{DistribRules}. A convenient way to view
21702 these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
21703 displays and edits the stored value of a variable. Press @kbd{C-c C-c}
21704 to return from editing mode; be careful not to make any actual changes
21705 or else you will affect the behavior of future @kbd{j D} commands!
21707 To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
21708 as described above. You can then use the @kbd{s p} command to save
21709 this variable's value permanently for future Calc sessions.
21710 @xref{Operations on Variables}.
21713 @pindex calc-sel-merge
21715 The @kbd{j M} (@code{calc-sel-merge}) command is the complement
21716 of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
21717 @samp{a c} selected, the result is @samp{a * (b - c)}. Once
21718 again, @kbd{j M} can also merge calls to functions like @code{exp}
21719 and @code{ln}; examine the variable @code{MergeRules} to see all
21720 the relevant rules.
21723 @pindex calc-sel-commute
21724 @vindex CommuteRules
21725 The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
21726 of the selected sum, product, or equation. It always behaves as
21727 if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
21728 treated as the nested sums @samp{(a + b) + c} by this command.
21729 If you put the cursor on the first @samp{+}, the result is
21730 @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
21731 result is @samp{c + (a + b)} (which the default simplifications
21732 will rearrange to @samp{(c + a) + b}). The relevant rules are stored
21733 in the variable @code{CommuteRules}.
21735 You may need to turn default simplifications off (with the @kbd{m O}
21736 command) in order to get the full benefit of @kbd{j C}. For example,
21737 commuting @samp{a - b} produces @samp{-b + a}, but the default
21738 simplifications will ``simplify'' this right back to @samp{a - b} if
21739 you don't turn them off. The same is true of some of the other
21740 manipulations described in this section.
21743 @pindex calc-sel-negate
21744 @vindex NegateRules
21745 The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
21746 term with the negative of that term, then adjusts the surrounding
21747 formula in order to preserve the meaning. For example, given
21748 @samp{exp(a - b)} where @samp{a - b} is selected, the result is
21749 @samp{1 / exp(b - a)}. By contrast, selecting a term and using the
21750 regular @kbd{n} (@code{calc-change-sign}) command negates the
21751 term without adjusting the surroundings, thus changing the meaning
21752 of the formula as a whole. The rules variable is @code{NegateRules}.
21755 @pindex calc-sel-invert
21756 @vindex InvertRules
21757 The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
21758 except it takes the reciprocal of the selected term. For example,
21759 given @samp{a - ln(b)} with @samp{b} selected, the result is
21760 @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}.
21763 @pindex calc-sel-jump-equals
21765 The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
21766 selected term from one side of an equation to the other. Given
21767 @samp{a + b = c + d} with @samp{c} selected, the result is
21768 @samp{a + b - c = d}. This command also works if the selected
21769 term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The
21770 relevant rules variable is @code{JumpRules}.
21774 @pindex calc-sel-isolate
21775 The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
21776 selected term on its side of an equation. It uses the @kbd{a S}
21777 (@code{calc-solve-for}) command to solve the equation, and the
21778 Hyperbolic flag affects it in the same way. @xref{Solving Equations}.
21779 When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
21780 It understands more rules of algebra, and works for inequalities
21781 as well as equations.
21785 @pindex calc-sel-mult-both-sides
21786 @pindex calc-sel-div-both-sides
21787 The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
21788 formula using algebraic entry, then multiplies both sides of the
21789 selected quotient or equation by that formula. It simplifies each
21790 side with @kbd{a s} (@code{calc-simplify}) before re-forming the
21791 quotient or equation. You can suppress this simplification by
21792 providing any numeric prefix argument. There is also a @kbd{j /}
21793 (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
21794 dividing instead of multiplying by the factor you enter.
21796 As a special feature, if the numerator of the quotient is 1, then
21797 the denominator is expanded at the top level using the distributive
21798 law (i.e., using the @kbd{C-u -1 a x} command). Suppose the
21799 formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish
21800 to eliminate the square root in the denominator by multiplying both
21801 sides by @samp{sqrt(a) - 1}. Calc's default simplifications would
21802 change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)}
21803 right back to the original form by cancellation; Calc expands the
21804 denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent
21805 this. (You would now want to use an @kbd{a x} command to expand
21806 the rest of the way, whereupon the denominator would cancel out to
21807 the desired form, @samp{a - 1}.) When the numerator is not 1, this
21808 initial expansion is not necessary because Calc's default
21809 simplifications will not notice the potential cancellation.
21811 If the selection is an inequality, @kbd{j *} and @kbd{j /} will
21812 accept any factor, but will warn unless they can prove the factor
21813 is either positive or negative. (In the latter case the direction
21814 of the inequality will be switched appropriately.) @xref{Declarations},
21815 for ways to inform Calc that a given variable is positive or
21816 negative. If Calc can't tell for sure what the sign of the factor
21817 will be, it will assume it is positive and display a warning
21820 For selections that are not quotients, equations, or inequalities,
21821 these commands pull out a multiplicative factor: They divide (or
21822 multiply) by the entered formula, simplify, then multiply (or divide)
21823 back by the formula.
21827 @pindex calc-sel-add-both-sides
21828 @pindex calc-sel-sub-both-sides
21829 The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
21830 (@code{calc-sel-sub-both-sides}) commands analogously add to or
21831 subtract from both sides of an equation or inequality. For other
21832 types of selections, they extract an additive factor. A numeric
21833 prefix argument suppresses simplification of the intermediate
21837 @pindex calc-sel-unpack
21838 The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
21839 selected function call with its argument. For example, given
21840 @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
21841 is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you
21842 wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
21843 now to take the cosine of the selected part.)
21846 @pindex calc-sel-evaluate
21847 The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
21848 normal default simplifications on the selected sub-formula.
21849 These are the simplifications that are normally done automatically
21850 on all results, but which may have been partially inhibited by
21851 previous selection-related operations, or turned off altogether
21852 by the @kbd{m O} command. This command is just an auto-selecting
21853 version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
21855 With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
21856 the @kbd{a s} (@code{calc-simplify}) command to the selected
21857 sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
21858 applies the @kbd{a e} (@code{calc-simplify-extended}) command.
21859 @xref{Simplifying Formulas}. With a negative prefix argument
21860 it simplifies at the top level only, just as with @kbd{a v}.
21861 Here the ``top'' level refers to the top level of the selected
21865 @pindex calc-sel-expand-formula
21866 The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
21867 (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
21869 You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
21870 to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}.
21872 @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
21873 @section Algebraic Manipulation
21876 The commands in this section perform general-purpose algebraic
21877 manipulations. They work on the whole formula at the top of the
21878 stack (unless, of course, you have made a selection in that
21881 Many algebra commands prompt for a variable name or formula. If you
21882 answer the prompt with a blank line, the variable or formula is taken
21883 from top-of-stack, and the normal argument for the command is taken
21884 from the second-to-top stack level.
21887 @pindex calc-alg-evaluate
21888 The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
21889 default simplifications on a formula; for example, @samp{a - -b} is
21890 changed to @samp{a + b}. These simplifications are normally done
21891 automatically on all Calc results, so this command is useful only if
21892 you have turned default simplifications off with an @kbd{m O}
21893 command. @xref{Simplification Modes}.
21895 It is often more convenient to type @kbd{=}, which is like @kbd{a v}
21896 but which also substitutes stored values for variables in the formula.
21897 Use @kbd{a v} if you want the variables to ignore their stored values.
21899 If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
21900 as if in Algebraic Simplification mode. This is equivalent to typing
21901 @kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix
21902 of 3 or more, it uses Extended Simplification mode (@kbd{a e}).
21904 If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3},
21905 it simplifies in the corresponding mode but only works on the top-level
21906 function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will
21907 simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
21908 @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector
21909 @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
21910 in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to
21911 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
21912 (@xref{Reducing and Mapping}.)
21916 The @kbd{=} command corresponds to the @code{evalv} function, and
21917 the related @kbd{N} command, which is like @kbd{=} but temporarily
21918 disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds
21919 to the @code{evalvn} function. (These commands interpret their prefix
21920 arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
21921 the number of stack elements to evaluate at once, and @kbd{N} treats
21922 it as a temporary different working precision.)
21924 The @code{evalvn} function can take an alternate working precision
21925 as an optional second argument. This argument can be either an
21926 integer, to set the precision absolutely, or a vector containing
21927 a single integer, to adjust the precision relative to the current
21928 precision. Note that @code{evalvn} with a larger than current
21929 precision will do the calculation at this higher precision, but the
21930 result will as usual be rounded back down to the current precision
21931 afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision
21932 of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
21933 will return @samp{9.26535897932e-5} (computing a 25-digit result which
21934 is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
21935 will return @samp{9.2654e-5}.
21938 @pindex calc-expand-formula
21939 The @kbd{a "} (@code{calc-expand-formula}) command expands functions
21940 into their defining formulas wherever possible. For example,
21941 @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions,
21942 like @code{sin} and @code{gcd}, are not defined by simple formulas
21943 and so are unaffected by this command. One important class of
21944 functions which @emph{can} be expanded is the user-defined functions
21945 created by the @kbd{Z F} command. @xref{Algebraic Definitions}.
21946 Other functions which @kbd{a "} can expand include the probability
21947 distribution functions, most of the financial functions, and the
21948 hyperbolic and inverse hyperbolic functions. A numeric prefix argument
21949 affects @kbd{a "} in the same way as it does @kbd{a v}: A positive
21950 argument expands all functions in the formula and then simplifies in
21951 various ways; a negative argument expands and simplifies only the
21952 top-level function call.
21955 @pindex calc-map-equation
21957 The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
21958 a given function or operator to one or more equations. It is analogous
21959 to @kbd{V M}, which operates on vectors instead of equations.
21960 @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes
21961 @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
21962 @samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}.
21963 With two equations on the stack, @kbd{a M +} would add the lefthand
21964 sides together and the righthand sides together to get the two
21965 respective sides of a new equation.
21967 Mapping also works on inequalities. Mapping two similar inequalities
21968 produces another inequality of the same type. Mapping an inequality
21969 with an equation produces an inequality of the same type. Mapping a
21970 @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
21971 If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
21972 are mapped, the direction of the second inequality is reversed to
21973 match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
21974 reverses the latter to get @samp{2 < a}, which then allows the
21975 combination @samp{a + 2 < b + a}, which the @kbd{a s} command can
21976 then simplify to get @samp{2 < b}.
21978 Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
21979 or invert an inequality will reverse the direction of the inequality.
21980 Other adjustments to inequalities are @emph{not} done automatically;
21981 @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
21982 though this is not true for all values of the variables.
21986 With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
21987 mapping operation without reversing the direction of any inequalities.
21988 Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
21989 (This change is mathematically incorrect, but perhaps you were
21990 fixing an inequality which was already incorrect.)
21994 With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
21995 the direction of the inequality. You might use @kbd{I a M C} to
21996 change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
21997 working with small positive angles.
22000 @pindex calc-substitute
22002 The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
22004 of some variable or sub-expression of an expression with a new
22005 sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)}
22006 in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
22007 @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
22008 Note that this is a purely structural substitution; the lone @samp{x} and
22009 the @samp{sin(2 x)} stayed the same because they did not look like
22010 @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for
22011 doing substitutions.
22013 The @kbd{a b} command normally prompts for two formulas, the old
22014 one and the new one. If you enter a blank line for the first
22015 prompt, all three arguments are taken from the stack (new, then old,
22016 then target expression). If you type an old formula but then enter a
22017 blank line for the new one, the new formula is taken from top-of-stack
22018 and the target from second-to-top. If you answer both prompts, the
22019 target is taken from top-of-stack as usual.
22021 Note that @kbd{a b} has no understanding of commutativity or
22022 associativity. The pattern @samp{x+y} will not match the formula
22023 @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
22024 because the @samp{+} operator is left-associative, so the ``deep
22025 structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U}
22026 (@code{calc-unformatted-language}) mode to see the true structure of
22027 a formula. The rewrite rule mechanism, discussed later, does not have
22030 As an algebraic function, @code{subst} takes three arguments:
22031 Target expression, old, new. Note that @code{subst} is always
22032 evaluated immediately, even if its arguments are variables, so if
22033 you wish to put a call to @code{subst} onto the stack you must
22034 turn the default simplifications off first (with @kbd{m O}).
22036 @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
22037 @section Simplifying Formulas
22041 @pindex calc-simplify
22043 The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies
22044 various algebraic rules to simplify a formula. This includes rules which
22045 are not part of the default simplifications because they may be too slow
22046 to apply all the time, or may not be desirable all of the time. For
22047 example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a}
22048 to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are
22049 simplified to @samp{x}.
22051 The sections below describe all the various kinds of algebraic
22052 simplifications Calc provides in full detail. None of Calc's
22053 simplification commands are designed to pull rabbits out of hats;
22054 they simply apply certain specific rules to put formulas into
22055 less redundant or more pleasing forms. Serious algebra in Calc
22056 must be done manually, usually with a combination of selections
22057 and rewrite rules. @xref{Rearranging with Selections}.
22058 @xref{Rewrite Rules}.
22060 @xref{Simplification Modes}, for commands to control what level of
22061 simplification occurs automatically. Normally only the ``default
22062 simplifications'' occur.
22065 * Default Simplifications::
22066 * Algebraic Simplifications::
22067 * Unsafe Simplifications::
22068 * Simplification of Units::
22071 @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
22072 @subsection Default Simplifications
22075 @cindex Default simplifications
22076 This section describes the ``default simplifications,'' those which are
22077 normally applied to all results. For example, if you enter the variable
22078 @expr{x} on the stack twice and push @kbd{+}, Calc's default
22079 simplifications automatically change @expr{x + x} to @expr{2 x}.
22081 The @kbd{m O} command turns off the default simplifications, so that
22082 @expr{x + x} will remain in this form unless you give an explicit
22083 ``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic
22084 Manipulation}. The @kbd{m D} command turns the default simplifications
22087 The most basic default simplification is the evaluation of functions.
22088 For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@tfn{sqrt}(9)}
22089 is evaluated to @expr{3}. Evaluation does not occur if the arguments
22090 to a function are somehow of the wrong type @expr{@tfn{tan}([2,3,4])}),
22091 range (@expr{@tfn{tan}(90)}), or number (@expr{@tfn{tan}(3,5)}),
22092 or if the function name is not recognized (@expr{@tfn{f}(5)}), or if
22093 Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation
22094 (@expr{@tfn{sqrt}(2)}).
22096 Calc simplifies (evaluates) the arguments to a function before it
22097 simplifies the function itself. Thus @expr{@tfn{sqrt}(5+4)} is
22098 simplified to @expr{@tfn{sqrt}(9)} before the @code{sqrt} function
22099 itself is applied. There are very few exceptions to this rule:
22100 @code{quote}, @code{lambda}, and @code{condition} (the @code{::}
22101 operator) do not evaluate their arguments, @code{if} (the @code{? :}
22102 operator) does not evaluate all of its arguments, and @code{evalto}
22103 does not evaluate its lefthand argument.
22105 Most commands apply the default simplifications to all arguments they
22106 take from the stack, perform a particular operation, then simplify
22107 the result before pushing it back on the stack. In the common special
22108 case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}],
22109 the arguments are simply popped from the stack and collected into a
22110 suitable function call, which is then simplified (the arguments being
22111 simplified first as part of the process, as described above).
22113 The default simplifications are too numerous to describe completely
22114 here, but this section will describe the ones that apply to the
22115 major arithmetic operators. This list will be rather technical in
22116 nature, and will probably be interesting to you only if you are
22117 a serious user of Calc's algebra facilities.
22123 As well as the simplifications described here, if you have stored
22124 any rewrite rules in the variable @code{EvalRules} then these rules
22125 will also be applied before any built-in default simplifications.
22126 @xref{Automatic Rewrites}, for details.
22132 And now, on with the default simplifications:
22134 Arithmetic operators like @kbd{+} and @kbd{*} always take two
22135 arguments in Calc's internal form. Sums and products of three or
22136 more terms are arranged by the associative law of algebra into
22137 a left-associative form for sums, @expr{((a + b) + c) + d}, and
22138 a right-associative form for products, @expr{a * (b * (c * d))}.
22139 Formulas like @expr{(a + b) + (c + d)} are rearranged to
22140 left-associative form, though this rarely matters since Calc's
22141 algebra commands are designed to hide the inner structure of
22142 sums and products as much as possible. Sums and products in
22143 their proper associative form will be written without parentheses
22144 in the examples below.
22146 Sums and products are @emph{not} rearranged according to the
22147 commutative law (@expr{a + b} to @expr{b + a}) except in a few
22148 special cases described below. Some algebra programs always
22149 rearrange terms into a canonical order, which enables them to
22150 see that @expr{a b + b a} can be simplified to @expr{2 a b}.
22151 Calc assumes you have put the terms into the order you want
22152 and generally leaves that order alone, with the consequence
22153 that formulas like the above will only be simplified if you
22154 explicitly give the @kbd{a s} command. @xref{Algebraic
22157 Differences @expr{a - b} are treated like sums @expr{a + (-b)}
22158 for purposes of simplification; one of the default simplifications
22159 is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b}
22160 represents a ``negative-looking'' term, into @expr{a - b} form.
22161 ``Negative-looking'' means negative numbers, negated formulas like
22162 @expr{-x}, and products or quotients in which either term is
22165 Other simplifications involving negation are @expr{-(-x)} to @expr{x};
22166 @expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is
22167 negative-looking, simplified by negating that term, or else where
22168 @expr{a} or @expr{b} is any number, by negating that number;
22169 @expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}.
22170 (This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only
22171 cases where the order of terms in a sum is changed by the default
22174 The distributive law is used to simplify sums in some cases:
22175 @expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents
22176 a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x})
22177 and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or
22178 @kbd{j M} commands to merge sums with non-numeric coefficients
22179 using the distributive law.
22181 The distributive law is only used for sums of two terms, or
22182 for adjacent terms in a larger sum. Thus @expr{a + b + b + c}
22183 is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b}
22184 is not simplified. The reason is that comparing all terms of a
22185 sum with one another would require time proportional to the
22186 square of the number of terms; Calc relegates potentially slow
22187 operations like this to commands that have to be invoked
22188 explicitly, like @kbd{a s}.
22190 Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}.
22191 A consequence of the above rules is that @expr{0 - a} is simplified
22198 The products @expr{1 a} and @expr{a 1} are simplified to @expr{a};
22199 @expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a};
22200 @expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that
22201 in Matrix mode where @expr{a} is not provably scalar the result
22202 is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is
22203 infinite the result is @samp{nan}.
22205 Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)},
22206 where this occurs for negated formulas but not for regular negative
22209 Products are commuted only to move numbers to the front:
22210 @expr{a b 2} is commuted to @expr{2 a b}.
22212 The product @expr{a (b + c)} is distributed over the sum only if
22213 @expr{a} and at least one of @expr{b} and @expr{c} are numbers:
22214 @expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula
22215 @expr{(-a) (b - c)}, where @expr{-a} is a negative number, is
22216 rewritten to @expr{a (c - b)}.
22218 The distributive law of products and powers is used for adjacent
22219 terms of the product: @expr{x^a x^b} goes to
22220 @texline @math{x^{a+b}}
22221 @infoline @expr{x^(a+b)}
22222 where @expr{a} is a number, or an implicit 1 (as in @expr{x}),
22223 or the implicit one-half of @expr{@tfn{sqrt}(x)}, and similarly for
22224 @expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt}
22225 if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively.
22226 If the sum of the powers is zero, the product is simplified to
22227 @expr{1} or to @samp{idn(1)} if Matrix mode is enabled.
22229 The product of a negative power times anything but another negative
22230 power is changed to use division:
22231 @texline @math{x^{-2} y}
22232 @infoline @expr{x^(-2) y}
22233 goes to @expr{y / x^2} unless Matrix mode is
22234 in effect and neither @expr{x} nor @expr{y} are scalar (in which
22235 case it is considered unsafe to rearrange the order of the terms).
22237 Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also
22238 @expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode.
22244 Simplifications for quotients are analogous to those for products.
22245 The quotient @expr{0 / x} is simplified to @expr{0}, with the same
22246 exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1}
22247 and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x},
22250 The quotient @expr{x / 0} is left unsimplified or changed to an
22251 infinite quantity, as directed by the current infinite mode.
22252 @xref{Infinite Mode}.
22255 @texline @math{a / b^{-c}}
22256 @infoline @expr{a / b^(-c)}
22257 is changed to @expr{a b^c}, where @expr{-c} is any negative-looking
22258 power. Also, @expr{1 / b^c} is changed to
22259 @texline @math{b^{-c}}
22260 @infoline @expr{b^(-c)}
22261 for any power @expr{c}.
22263 Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)};
22264 @expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)}
22265 goes to @expr{(a c) / b} unless Matrix mode prevents this
22266 rearrangement. Similarly, @expr{a / (b:c)} is simplified to
22267 @expr{(c:b) a} for any fraction @expr{b:c}.
22269 The distributive law is applied to @expr{(a + b) / c} only if
22270 @expr{c} and at least one of @expr{a} and @expr{b} are numbers.
22271 Quotients of powers and square roots are distributed just as
22272 described for multiplication.
22274 Quotients of products cancel only in the leading terms of the
22275 numerator and denominator. In other words, @expr{a x b / a y b}
22276 is cancelled to @expr{x b / y b} but not to @expr{x / y}. Once
22277 again this is because full cancellation can be slow; use @kbd{a s}
22278 to cancel all terms of the quotient.
22280 Quotients of negative-looking values are simplified according
22281 to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)}
22282 to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}.
22288 The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)}
22289 in Matrix mode. The formula @expr{0^x} is simplified to @expr{0}
22290 unless @expr{x} is a negative number, complex number or zero.
22291 If @expr{x} is negative, complex or @expr{0.0}, @expr{0^x} is an
22292 infinity or an unsimplified formula according to the current infinite
22293 mode. The expression @expr{0^0} is simplified to @expr{1}.
22295 Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c}
22296 are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c}
22297 is an integer, or if either @expr{a} or @expr{b} are nonnegative
22298 real numbers. Powers of powers @expr{(a^b)^c} are simplified to
22299 @texline @math{a^{b c}}
22300 @infoline @expr{a^(b c)}
22301 only when @expr{c} is an integer and @expr{b c} also
22302 evaluates to an integer. Without these restrictions these simplifications
22303 would not be safe because of problems with principal values.
22305 @texline @math{((-3)^{1/2})^2}
22306 @infoline @expr{((-3)^1:2)^2}
22307 is safe to simplify, but
22308 @texline @math{((-3)^2)^{1/2}}
22309 @infoline @expr{((-3)^2)^1:2}
22310 is not.) @xref{Declarations}, for ways to inform Calc that your
22311 variables satisfy these requirements.
22313 As a special case of this rule, @expr{@tfn{sqrt}(x)^n} is simplified to
22314 @texline @math{x^{n/2}}
22315 @infoline @expr{x^(n/2)}
22316 only for even integers @expr{n}.
22318 If @expr{a} is known to be real, @expr{b} is an even integer, and
22319 @expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is
22320 simplified to @expr{@tfn{abs}(a^(b c))}.
22322 Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an
22323 even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer,
22324 for any negative-looking expression @expr{-a}.
22326 Square roots @expr{@tfn{sqrt}(x)} generally act like one-half powers
22327 @texline @math{x^{1:2}}
22328 @infoline @expr{x^1:2}
22329 for the purposes of the above-listed simplifications.
22332 @texline @math{1 / x^{1:2}}
22333 @infoline @expr{1 / x^1:2}
22335 @texline @math{x^{-1:2}},
22336 @infoline @expr{x^(-1:2)},
22337 but @expr{1 / @tfn{sqrt}(x)} is left alone.
22343 Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
22344 following rules: @expr{@tfn{idn}(a) + b} to @expr{a + b} if @expr{b}
22345 is provably scalar, or expanded out if @expr{b} is a matrix;
22346 @expr{@tfn{idn}(a) + @tfn{idn}(b)} to @expr{@tfn{idn}(a + b)};
22347 @expr{-@tfn{idn}(a)} to @expr{@tfn{idn}(-a)}; @expr{a @tfn{idn}(b)} to
22348 @expr{@tfn{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b}
22349 if @expr{a} is provably non-scalar; @expr{@tfn{idn}(a) @tfn{idn}(b)} to
22350 @expr{@tfn{idn}(a b)}; analogous simplifications for quotients involving
22351 @code{idn}; and @expr{@tfn{idn}(a)^n} to @expr{@tfn{idn}(a^n)} where
22352 @expr{n} is an integer.
22358 The @code{floor} function and other integer truncation functions
22359 vanish if the argument is provably integer-valued, so that
22360 @expr{@tfn{floor}(@tfn{round}(x))} simplifies to @expr{@tfn{round}(x)}.
22361 Also, combinations of @code{float}, @code{floor} and its friends,
22362 and @code{ffloor} and its friends, are simplified in appropriate
22363 ways. @xref{Integer Truncation}.
22365 The expression @expr{@tfn{abs}(-x)} changes to @expr{@tfn{abs}(x)}.
22366 The expression @expr{@tfn{abs}(@tfn{abs}(x))} changes to
22367 @expr{@tfn{abs}(x)}; in fact, @expr{@tfn{abs}(x)} changes to @expr{x} or
22368 @expr{-x} if @expr{x} is provably nonnegative or nonpositive
22369 (@pxref{Declarations}).
22371 While most functions do not recognize the variable @code{i} as an
22372 imaginary number, the @code{arg} function does handle the two cases
22373 @expr{@tfn{arg}(@tfn{i})} and @expr{@tfn{arg}(-@tfn{i})} just for convenience.
22375 The expression @expr{@tfn{conj}(@tfn{conj}(x))} simplifies to @expr{x}.
22376 Various other expressions involving @code{conj}, @code{re}, and
22377 @code{im} are simplified, especially if some of the arguments are
22378 provably real or involve the constant @code{i}. For example,
22379 @expr{@tfn{conj}(a + b i)} is changed to
22380 @expr{@tfn{conj}(a) - @tfn{conj}(b) i}, or to @expr{a - b i} if @expr{a}
22381 and @expr{b} are known to be real.
22383 Functions like @code{sin} and @code{arctan} generally don't have
22384 any default simplifications beyond simply evaluating the functions
22385 for suitable numeric arguments and infinity. The @kbd{a s} command
22386 described in the next section does provide some simplifications for
22387 these functions, though.
22389 One important simplification that does occur is that
22390 @expr{@tfn{ln}(@tfn{e})} is simplified to 1, and @expr{@tfn{ln}(@tfn{e}^x)} is
22391 simplified to @expr{x} for any @expr{x}. This occurs even if you have
22392 stored a different value in the Calc variable @samp{e}; but this would
22393 be a bad idea in any case if you were also using natural logarithms!
22395 Among the logical functions, @tfn{!(@var{a} <= @var{b})} changes to
22396 @tfn{@var{a} > @var{b}} and so on. Equations and inequalities where both sides
22397 are either negative-looking or zero are simplified by negating both sides
22398 and reversing the inequality. While it might seem reasonable to simplify
22399 @expr{!!x} to @expr{x}, this would not be valid in general because
22400 @expr{!!2} is 1, not 2.
22402 Most other Calc functions have few if any default simplifications
22403 defined, aside of course from evaluation when the arguments are
22406 @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas
22407 @subsection Algebraic Simplifications
22410 @cindex Algebraic simplifications
22411 The @kbd{a s} command makes simplifications that may be too slow to
22412 do all the time, or that may not be desirable all of the time.
22413 If you find these simplifications are worthwhile, you can type
22414 @kbd{m A} to have Calc apply them automatically.
22416 This section describes all simplifications that are performed by
22417 the @kbd{a s} command. Note that these occur in addition to the
22418 default simplifications; even if the default simplifications have
22419 been turned off by an @kbd{m O} command, @kbd{a s} will turn them
22420 back on temporarily while it simplifies the formula.
22422 There is a variable, @code{AlgSimpRules}, in which you can put rewrites
22423 to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules},
22424 but without the special restrictions. Basically, the simplifier does
22425 @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
22426 expression being simplified, then it traverses the expression applying
22427 the built-in rules described below. If the result is different from
22428 the original expression, the process repeats with the default
22429 simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
22430 then the built-in simplifications, and so on.
22436 Sums are simplified in two ways. Constant terms are commuted to the
22437 end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}.
22438 The only exception is that a constant will not be commuted away
22439 from the first position of a difference, i.e., @expr{2 - x} is not
22440 commuted to @expr{-x + 2}.
22442 Also, terms of sums are combined by the distributive law, as in
22443 @expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for
22444 adjacent terms, but @kbd{a s} compares all pairs of terms including
22451 Products are sorted into a canonical order using the commutative
22452 law. For example, @expr{b c a} is commuted to @expr{a b c}.
22453 This allows easier comparison of products; for example, the default
22454 simplifications will not change @expr{x y + y x} to @expr{2 x y},
22455 but @kbd{a s} will; it first rewrites the sum to @expr{x y + x y},
22456 and then the default simplifications are able to recognize a sum
22457 of identical terms.
22459 The canonical ordering used to sort terms of products has the
22460 property that real-valued numbers, interval forms and infinities
22461 come first, and are sorted into increasing order. The @kbd{V S}
22462 command uses the same ordering when sorting a vector.
22464 Sorting of terms of products is inhibited when Matrix mode is
22465 turned on; in this case, Calc will never exchange the order of
22466 two terms unless it knows at least one of the terms is a scalar.
22468 Products of powers are distributed by comparing all pairs of
22469 terms, using the same method that the default simplifications
22470 use for adjacent terms of products.
22472 Even though sums are not sorted, the commutative law is still
22473 taken into account when terms of a product are being compared.
22474 Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}.
22475 A subtle point is that @expr{(x - y) (y - x)} will @emph{not}
22476 be simplified to @expr{-(x - y)^2}; Calc does not notice that
22477 one term can be written as a constant times the other, even if
22478 that constant is @mathit{-1}.
22480 A fraction times any expression, @expr{(a:b) x}, is changed to
22481 a quotient involving integers: @expr{a x / b}. This is not
22482 done for floating-point numbers like @expr{0.5}, however. This
22483 is one reason why you may find it convenient to turn Fraction mode
22484 on while doing algebra; @pxref{Fraction Mode}.
22490 Quotients are simplified by comparing all terms in the numerator
22491 with all terms in the denominator for possible cancellation using
22492 the distributive law. For example, @expr{a x^2 b / c x^3 d} will
22493 cancel @expr{x^2} from the top and bottom to get @expr{a b / c x d}.
22494 (The terms in the denominator will then be rearranged to @expr{c d x}
22495 as described above.) If there is any common integer or fractional
22496 factor in the numerator and denominator, it is cancelled out;
22497 for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}.
22499 Non-constant common factors are not found even by @kbd{a s}. To
22500 cancel the factor @expr{a} in @expr{(a x + a) / a^2} you could first
22501 use @kbd{j M} on the product @expr{a x} to Merge the numerator to
22502 @expr{a (1+x)}, which can then be simplified successfully.
22508 Integer powers of the variable @code{i} are simplified according
22509 to the identity @expr{i^2 = -1}. If you store a new value other
22510 than the complex number @expr{(0,1)} in @code{i}, this simplification
22511 will no longer occur. This is done by @kbd{a s} instead of by default
22512 in case someone (unwisely) uses the name @code{i} for a variable
22513 unrelated to complex numbers; it would be unfortunate if Calc
22514 quietly and automatically changed this formula for reasons the
22515 user might not have been thinking of.
22517 Square roots of integer or rational arguments are simplified in
22518 several ways. (Note that these will be left unevaluated only in
22519 Symbolic mode.) First, square integer or rational factors are
22520 pulled out so that @expr{@tfn{sqrt}(8)} is rewritten as
22521 @texline @math{2\,@tfn{sqrt}(2)}.
22522 @infoline @expr{2 sqrt(2)}.
22523 Conceptually speaking this implies factoring the argument into primes
22524 and moving pairs of primes out of the square root, but for reasons of
22525 efficiency Calc only looks for primes up to 29.
22527 Square roots in the denominator of a quotient are moved to the
22528 numerator: @expr{1 / @tfn{sqrt}(3)} changes to @expr{@tfn{sqrt}(3) / 3}.
22529 The same effect occurs for the square root of a fraction:
22530 @expr{@tfn{sqrt}(2:3)} changes to @expr{@tfn{sqrt}(6) / 3}.
22536 The @code{%} (modulo) operator is simplified in several ways
22537 when the modulus @expr{M} is a positive real number. First, if
22538 the argument is of the form @expr{x + n} for some real number
22539 @expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For
22540 example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
22542 If the argument is multiplied by a constant, and this constant
22543 has a common integer divisor with the modulus, then this factor is
22544 cancelled out. For example, @samp{12 x % 15} is changed to
22545 @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
22546 is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
22547 not seem ``simpler,'' they allow Calc to discover useful information
22548 about modulo forms in the presence of declarations.
22550 If the modulus is 1, then Calc can use @code{int} declarations to
22551 evaluate the expression. For example, the idiom @samp{x % 2} is
22552 often used to check whether a number is odd or even. As described
22553 above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
22554 @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
22555 can simplify these to 0 and 1 (respectively) if @code{n} has been
22556 declared to be an integer.
22562 Trigonometric functions are simplified in several ways. Whenever a
22563 products of two trigonometric functions can be replaced by a single
22564 function, the replacement is made; for example,
22565 @expr{@tfn{tan}(x) @tfn{cos}(x)} is simplified to @expr{@tfn{sin}(x)}.
22566 Reciprocals of trigonometric functions are replaced by their reciprocal
22567 function; for example, @expr{1/@tfn{sec}(x)} is simplified to
22568 @expr{@tfn{cos}(x)}. The corresponding simplifications for the
22569 hyperbolic functions are also handled.
22571 Trigonometric functions of their inverse functions are
22572 simplified. The expression @expr{@tfn{sin}(@tfn{arcsin}(x))} is
22573 simplified to @expr{x}, and similarly for @code{cos} and @code{tan}.
22574 Trigonometric functions of inverses of different trigonometric
22575 functions can also be simplified, as in @expr{@tfn{sin}(@tfn{arccos}(x))}
22576 to @expr{@tfn{sqrt}(1 - x^2)}.
22578 If the argument to @code{sin} is negative-looking, it is simplified to
22579 @expr{-@tfn{sin}(x)}, and similarly for @code{cos} and @code{tan}.
22580 Finally, certain special values of the argument are recognized;
22581 @pxref{Trigonometric and Hyperbolic Functions}.
22583 Hyperbolic functions of their inverses and of negative-looking
22584 arguments are also handled, as are exponentials of inverse
22585 hyperbolic functions.
22587 No simplifications for inverse trigonometric and hyperbolic
22588 functions are known, except for negative arguments of @code{arcsin},
22589 @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that
22590 @expr{@tfn{arcsin}(@tfn{sin}(x))} can @emph{not} safely change to
22591 @expr{x}, since this only correct within an integer multiple of
22592 @texline @math{2 \pi}
22593 @infoline @expr{2 pi}
22594 radians or 360 degrees. However, @expr{@tfn{arcsinh}(@tfn{sinh}(x))} is
22595 simplified to @expr{x} if @expr{x} is known to be real.
22597 Several simplifications that apply to logarithms and exponentials
22598 are that @expr{@tfn{exp}(@tfn{ln}(x))},
22599 @texline @tfn{e}@math{^{\ln(x)}},
22600 @infoline @expr{e^@tfn{ln}(x)},
22602 @texline @math{10^{{\rm log10}(x)}}
22603 @infoline @expr{10^@tfn{log10}(x)}
22604 all reduce to @expr{x}. Also, @expr{@tfn{ln}(@tfn{exp}(x))}, etc., can
22605 reduce to @expr{x} if @expr{x} is provably real. The form
22606 @expr{@tfn{exp}(x)^y} is simplified to @expr{@tfn{exp}(x y)}. If @expr{x}
22607 is a suitable multiple of
22608 @texline @math{\pi i}
22609 @infoline @expr{pi i}
22610 (as described above for the trigonometric functions), then
22611 @expr{@tfn{exp}(x)} or @expr{e^x} will be expanded. Finally,
22612 @expr{@tfn{ln}(x)} is simplified to a form involving @code{pi} and
22613 @code{i} where @expr{x} is provably negative, positive imaginary, or
22614 negative imaginary.
22616 The error functions @code{erf} and @code{erfc} are simplified when
22617 their arguments are negative-looking or are calls to the @code{conj}
22624 Equations and inequalities are simplified by cancelling factors
22625 of products, quotients, or sums on both sides. Inequalities
22626 change sign if a negative multiplicative factor is cancelled.
22627 Non-constant multiplicative factors as in @expr{a b = a c} are
22628 cancelled from equations only if they are provably nonzero (generally
22629 because they were declared so; @pxref{Declarations}). Factors
22630 are cancelled from inequalities only if they are nonzero and their
22633 Simplification also replaces an equation or inequality with
22634 1 or 0 (``true'' or ``false'') if it can through the use of
22635 declarations. If @expr{x} is declared to be an integer greater
22636 than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are
22637 all simplified to 0, but @expr{x > 3} is simplified to 1.
22638 By a similar analysis, @expr{abs(x) >= 0} is simplified to 1,
22639 as is @expr{x^2 >= 0} if @expr{x} is known to be real.
22641 @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
22642 @subsection ``Unsafe'' Simplifications
22645 @cindex Unsafe simplifications
22646 @cindex Extended simplification
22648 @pindex calc-simplify-extended
22650 @mindex esimpl@idots
22653 The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command
22655 except that it applies some additional simplifications which are not
22656 ``safe'' in all cases. Use this only if you know the values in your
22657 formula lie in the restricted ranges for which these simplifications
22658 are valid. The symbolic integrator uses @kbd{a e};
22659 one effect of this is that the integrator's results must be used with
22660 caution. Where an integral table will often attach conditions like
22661 ``for positive @expr{a} only,'' Calc (like most other symbolic
22662 integration programs) will simply produce an unqualified result.
22664 Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
22665 to type @kbd{C-u -3 a v}, which does extended simplification only
22666 on the top level of the formula without affecting the sub-formulas.
22667 In fact, @kbd{C-u -3 j v} allows you to target extended simplification
22668 to any specific part of a formula.
22670 The variable @code{ExtSimpRules} contains rewrites to be applied by
22671 the @kbd{a e} command. These are applied in addition to
22672 @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules}
22673 step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
22675 Following is a complete list of ``unsafe'' simplifications performed
22682 Inverse trigonometric or hyperbolic functions, called with their
22683 corresponding non-inverse functions as arguments, are simplified
22684 by @kbd{a e}. For example, @expr{@tfn{arcsin}(@tfn{sin}(x))} changes
22685 to @expr{x}. Also, @expr{@tfn{arcsin}(@tfn{cos}(x))} and
22686 @expr{@tfn{arccos}(@tfn{sin}(x))} both change to @expr{@tfn{pi}/2 - x}.
22687 These simplifications are unsafe because they are valid only for
22688 values of @expr{x} in a certain range; outside that range, values
22689 are folded down to the 360-degree range that the inverse trigonometric
22690 functions always produce.
22692 Powers of powers @expr{(x^a)^b} are simplified to
22693 @texline @math{x^{a b}}
22694 @infoline @expr{x^(a b)}
22695 for all @expr{a} and @expr{b}. These results will be valid only
22696 in a restricted range of @expr{x}; for example, in
22697 @texline @math{(x^2)^{1:2}}
22698 @infoline @expr{(x^2)^1:2}
22699 the powers cancel to get @expr{x}, which is valid for positive values
22700 of @expr{x} but not for negative or complex values.
22702 Similarly, @expr{@tfn{sqrt}(x^a)} and @expr{@tfn{sqrt}(x)^a} are both
22703 simplified (possibly unsafely) to
22704 @texline @math{x^{a/2}}.
22705 @infoline @expr{x^(a/2)}.
22707 Forms like @expr{@tfn{sqrt}(1 - sin(x)^2)} are simplified to, e.g.,
22708 @expr{@tfn{cos}(x)}. Calc has identities of this sort for @code{sin},
22709 @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
22711 Arguments of square roots are partially factored to look for
22712 squared terms that can be extracted. For example,
22713 @expr{@tfn{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to
22714 @expr{a b @tfn{sqrt}(a+b)}.
22716 The simplifications of @expr{@tfn{ln}(@tfn{exp}(x))},
22717 @expr{@tfn{ln}(@tfn{e}^x)}, and @expr{@tfn{log10}(10^x)} to @expr{x} are also
22718 unsafe because of problems with principal values (although these
22719 simplifications are safe if @expr{x} is known to be real).
22721 Common factors are cancelled from products on both sides of an
22722 equation, even if those factors may be zero: @expr{a x / b x}
22723 to @expr{a / b}. Such factors are never cancelled from
22724 inequalities: Even @kbd{a e} is not bold enough to reduce
22725 @expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending
22726 on whether you believe @expr{x} is positive or negative).
22727 The @kbd{a M /} command can be used to divide a factor out of
22728 both sides of an inequality.
22730 @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
22731 @subsection Simplification of Units
22734 The simplifications described in this section are applied by the
22735 @kbd{u s} (@code{calc-simplify-units}) command. These are in addition
22736 to the regular @kbd{a s} (but not @kbd{a e}) simplifications described
22737 earlier. @xref{Basic Operations on Units}.
22739 The variable @code{UnitSimpRules} contains rewrites to be applied by
22740 the @kbd{u s} command. These are applied in addition to @code{EvalRules}
22741 and @code{AlgSimpRules}.
22743 Scalar mode is automatically put into effect when simplifying units.
22744 @xref{Matrix Mode}.
22746 Sums @expr{a + b} involving units are simplified by extracting the
22747 units of @expr{a} as if by the @kbd{u x} command (call the result
22748 @expr{u_a}), then simplifying the expression @expr{b / u_a}
22749 using @kbd{u b} and @kbd{u s}. If the result has units then the sum
22750 is inconsistent and is left alone. Otherwise, it is rewritten
22751 in terms of the units @expr{u_a}.
22753 If units auto-ranging mode is enabled, products or quotients in
22754 which the first argument is a number which is out of range for the
22755 leading unit are modified accordingly.
22757 When cancelling and combining units in products and quotients,
22758 Calc accounts for unit names that differ only in the prefix letter.
22759 For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
22760 However, compatible but different units like @code{ft} and @code{in}
22761 are not combined in this way.
22763 Quotients @expr{a / b} are simplified in three additional ways. First,
22764 if @expr{b} is a number or a product beginning with a number, Calc
22765 computes the reciprocal of this number and moves it to the numerator.
22767 Second, for each pair of unit names from the numerator and denominator
22768 of a quotient, if the units are compatible (e.g., they are both
22769 units of area) then they are replaced by the ratio between those
22770 units. For example, in @samp{3 s in N / kg cm} the units
22771 @samp{in / cm} will be replaced by @expr{2.54}.
22773 Third, if the units in the quotient exactly cancel out, so that
22774 a @kbd{u b} command on the quotient would produce a dimensionless
22775 number for an answer, then the quotient simplifies to that number.
22777 For powers and square roots, the ``unsafe'' simplifications
22778 @expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c},
22779 and @expr{(a^b)^c} to
22780 @texline @math{a^{b c}}
22781 @infoline @expr{a^(b c)}
22782 are done if the powers are real numbers. (These are safe in the context
22783 of units because all numbers involved can reasonably be assumed to be
22786 Also, if a unit name is raised to a fractional power, and the
22787 base units in that unit name all occur to powers which are a
22788 multiple of the denominator of the power, then the unit name
22789 is expanded out into its base units, which can then be simplified
22790 according to the previous paragraph. For example, @samp{acre^1.5}
22791 is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre}
22792 is defined in terms of @samp{m^2}, and that the 2 in the power of
22793 @code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is
22794 replaced by approximately
22795 @texline @math{(4046 m^2)^{1.5}}
22796 @infoline @expr{(4046 m^2)^1.5},
22797 which is then changed to
22798 @texline @math{4046^{1.5} \, (m^2)^{1.5}},
22799 @infoline @expr{4046^1.5 (m^2)^1.5},
22800 then to @expr{257440 m^3}.
22802 The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
22803 as well as @code{floor} and the other integer truncation functions,
22804 applied to unit names or products or quotients involving units, are
22805 simplified. For example, @samp{round(1.6 in)} is changed to
22806 @samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
22807 and the righthand term simplifies to @code{in}.
22809 The functions @code{sin}, @code{cos}, and @code{tan} with arguments
22810 that have angular units like @code{rad} or @code{arcmin} are
22811 simplified by converting to base units (radians), then evaluating
22812 with the angular mode temporarily set to radians.
22814 @node Polynomials, Calculus, Simplifying Formulas, Algebra
22815 @section Polynomials
22817 A @dfn{polynomial} is a sum of terms which are coefficients times
22818 various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4}
22819 is a polynomial in @expr{x}. Some formulas can be considered
22820 polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2}
22821 is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients
22822 are often numbers, but they may in general be any formulas not
22823 involving the base variable.
22826 @pindex calc-factor
22828 The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
22829 polynomial into a product of terms. For example, the polynomial
22830 @expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another
22831 example, @expr{a c + b d + b c + a d} is factored into the product
22832 @expr{(a + b) (c + d)}.
22834 Calc currently has three algorithms for factoring. Formulas which are
22835 linear in several variables, such as the second example above, are
22836 merged according to the distributive law. Formulas which are
22837 polynomials in a single variable, with constant integer or fractional
22838 coefficients, are factored into irreducible linear and/or quadratic
22839 terms. The first example above factors into three linear terms
22840 (@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas
22841 which do not fit the above criteria are handled by the algebraic
22844 Calc's polynomial factorization algorithm works by using the general
22845 root-finding command (@w{@kbd{a P}}) to solve for the roots of the
22846 polynomial. It then looks for roots which are rational numbers
22847 or complex-conjugate pairs, and converts these into linear and
22848 quadratic terms, respectively. Because it uses floating-point
22849 arithmetic, it may be unable to find terms that involve large
22850 integers (whose number of digits approaches the current precision).
22851 Also, irreducible factors of degree higher than quadratic are not
22852 found, and polynomials in more than one variable are not treated.
22853 (A more robust factorization algorithm may be included in a future
22856 @vindex FactorRules
22868 The rewrite-based factorization method uses rules stored in the variable
22869 @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the
22870 operation of rewrite rules. The default @code{FactorRules} are able
22871 to factor quadratic forms symbolically into two linear terms,
22872 @expr{(a x + b) (c x + d)}. You can edit these rules to include other
22873 cases if you wish. To use the rules, Calc builds the formula
22874 @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
22875 base variable and @code{a}, @code{b}, etc., are polynomial coefficients
22876 (which may be numbers or formulas). The constant term is written first,
22877 i.e., in the @code{a} position. When the rules complete, they should have
22878 changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
22879 where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
22880 Calc then multiplies these terms together to get the complete
22881 factored form of the polynomial. If the rules do not change the
22882 @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
22883 polynomial alone on the assumption that it is unfactorable. (Note that
22884 the function names @code{thecoefs} and @code{thefactors} are used only
22885 as placeholders; there are no actual Calc functions by those names.)
22889 The @kbd{H a f} [@code{factors}] command also factors a polynomial,
22890 but it returns a list of factors instead of an expression which is the
22891 product of the factors. Each factor is represented by a sub-vector
22892 of the factor, and the power with which it appears. For example,
22893 @expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2}
22894 in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
22895 If there is an overall numeric factor, it always comes first in the list.
22896 The functions @code{factor} and @code{factors} allow a second argument
22897 when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with
22898 respect to the specific variable @expr{v}. The default is to factor with
22899 respect to all the variables that appear in @expr{x}.
22902 @pindex calc-collect
22904 The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
22906 polynomial in a given variable, ordered in decreasing powers of that
22907 variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on
22908 the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)},
22909 and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}.
22910 The polynomial will be expanded out using the distributive law as
22911 necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces
22912 @expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will
22915 The ``variable'' you specify at the prompt can actually be any
22916 expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
22917 by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears
22918 in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
22919 treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
22922 @pindex calc-expand
22924 The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
22925 expression by applying the distributive law everywhere. It applies to
22926 products, quotients, and powers involving sums. By default, it fully
22927 distributes all parts of the expression. With a numeric prefix argument,
22928 the distributive law is applied only the specified number of times, then
22929 the partially expanded expression is left on the stack.
22931 The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use
22932 @kbd{a x} if you want to expand all products of sums in your formula.
22933 Use @kbd{j D} if you want to expand a particular specified term of
22934 the formula. There is an exactly analogous correspondence between
22935 @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands
22936 also know many other kinds of expansions, such as
22937 @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
22940 Calc's automatic simplifications will sometimes reverse a partial
22941 expansion. For example, the first step in expanding @expr{(x+1)^3} is
22942 to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries
22943 to put this formula onto the stack, though, Calc will automatically
22944 simplify it back to @expr{(x+1)^3} form. The solution is to turn
22945 simplification off first (@pxref{Simplification Modes}), or to run
22946 @kbd{a x} without a numeric prefix argument so that it expands all
22947 the way in one step.
22952 The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
22953 rational function by partial fractions. A rational function is the
22954 quotient of two polynomials; @code{apart} pulls this apart into a
22955 sum of rational functions with simple denominators. In algebraic
22956 notation, the @code{apart} function allows a second argument that
22957 specifies which variable to use as the ``base''; by default, Calc
22958 chooses the base variable automatically.
22961 @pindex calc-normalize-rat
22963 The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
22964 attempts to arrange a formula into a quotient of two polynomials.
22965 For example, given @expr{1 + (a + b/c) / d}, the result would be
22966 @expr{(b + a c + c d) / c d}. The quotient is reduced, so that
22967 @kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
22968 out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}.
22971 @pindex calc-poly-div
22973 The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
22974 two polynomials @expr{u} and @expr{v}, yielding a new polynomial
22975 @expr{q}. If several variables occur in the inputs, the inputs are
22976 considered multivariate polynomials. (Calc divides by the variable
22977 with the largest power in @expr{u} first, or, in the case of equal
22978 powers, chooses the variables in alphabetical order.) For example,
22979 dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}.
22980 The remainder from the division, if any, is reported at the bottom
22981 of the screen and is also placed in the Trail along with the quotient.
22983 Using @code{pdiv} in algebraic notation, you can specify the particular
22984 variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
22985 If @code{pdiv} is given only two arguments (as is always the case with
22986 the @kbd{a \} command), then it does a multivariate division as outlined
22990 @pindex calc-poly-rem
22992 The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
22993 two polynomials and keeps the remainder @expr{r}. The quotient
22994 @expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the
22995 results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}.
22996 (This is analogous to plain @kbd{\} and @kbd{%}, which compute the
22997 integer quotient and remainder from dividing two numbers.)
23001 @pindex calc-poly-div-rem
23004 The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
23005 divides two polynomials and reports both the quotient and the
23006 remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}]
23007 command divides two polynomials and constructs the formula
23008 @expr{q + r/b} on the stack. (Naturally if the remainder is zero,
23009 this will immediately simplify to @expr{q}.)
23012 @pindex calc-poly-gcd
23014 The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
23015 the greatest common divisor of two polynomials. (The GCD actually
23016 is unique only to within a constant multiplier; Calc attempts to
23017 choose a GCD which will be unsurprising.) For example, the @kbd{a n}
23018 command uses @kbd{a g} to take the GCD of the numerator and denominator
23019 of a quotient, then divides each by the result using @kbd{a \}. (The
23020 definition of GCD ensures that this division can take place without
23021 leaving a remainder.)
23023 While the polynomials used in operations like @kbd{a /} and @kbd{a g}
23024 often have integer coefficients, this is not required. Calc can also
23025 deal with polynomials over the rationals or floating-point reals.
23026 Polynomials with modulo-form coefficients are also useful in many
23027 applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
23028 automatically transforms this into a polynomial over the field of
23029 integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
23031 Congratulations and thanks go to Ove Ewerlid
23032 (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
23033 polynomial routines used in the above commands.
23035 @xref{Decomposing Polynomials}, for several useful functions for
23036 extracting the individual coefficients of a polynomial.
23038 @node Calculus, Solving Equations, Polynomials, Algebra
23042 The following calculus commands do not automatically simplify their
23043 inputs or outputs using @code{calc-simplify}. You may find it helps
23044 to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help
23045 to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
23049 * Differentiation::
23051 * Customizing the Integrator::
23052 * Numerical Integration::
23056 @node Differentiation, Integration, Calculus, Calculus
23057 @subsection Differentiation
23062 @pindex calc-derivative
23065 The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
23066 the derivative of the expression on the top of the stack with respect to
23067 some variable, which it will prompt you to enter. Normally, variables
23068 in the formula other than the specified differentiation variable are
23069 considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With
23070 the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
23071 instead, in which derivatives of variables are not reduced to zero
23072 unless those variables are known to be ``constant,'' i.e., independent
23073 of any other variables. (The built-in special variables like @code{pi}
23074 are considered constant, as are variables that have been declared
23075 @code{const}; @pxref{Declarations}.)
23077 With a numeric prefix argument @var{n}, this command computes the
23078 @var{n}th derivative.
23080 When working with trigonometric functions, it is best to switch to
23081 Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)}
23082 in degrees is @samp{(pi/180) cos(x)}, probably not the expected
23085 If you use the @code{deriv} function directly in an algebraic formula,
23086 you can write @samp{deriv(f,x,x0)} which represents the derivative
23087 of @expr{f} with respect to @expr{x}, evaluated at the point
23088 @texline @math{x=x_0}.
23089 @infoline @expr{x=x0}.
23091 If the formula being differentiated contains functions which Calc does
23092 not know, the derivatives of those functions are produced by adding
23093 primes (apostrophe characters). For example, @samp{deriv(f(2x), x)}
23094 produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
23095 derivative of @code{f}.
23097 For functions you have defined with the @kbd{Z F} command, Calc expands
23098 the functions according to their defining formulas unless you have
23099 also defined @code{f'} suitably. For example, suppose we define
23100 @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate
23101 the formula @samp{sinc(2 x)}, the formula will be expanded to
23102 @samp{sin(2 x) / (2 x)} and differentiated. However, if we also
23103 define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
23104 result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}.
23106 For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
23107 to the first argument is written @samp{f'(x,y,z)}; derivatives with
23108 respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
23109 Various higher-order derivatives can be formed in the obvious way, e.g.,
23110 @samp{f'@var{}'(x)} (the second derivative of @code{f}) or
23111 @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
23114 @node Integration, Customizing the Integrator, Differentiation, Calculus
23115 @subsection Integration
23119 @pindex calc-integral
23121 The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
23122 indefinite integral of the expression on the top of the stack with
23123 respect to a prompted-for variable. The integrator is not guaranteed to
23124 work for all integrable functions, but it is able to integrate several
23125 large classes of formulas. In particular, any polynomial or rational
23126 function (a polynomial divided by a polynomial) is acceptable.
23127 (Rational functions don't have to be in explicit quotient form, however;
23128 @texline @math{x/(1+x^{-2})}
23129 @infoline @expr{x/(1+x^-2)}
23130 is not strictly a quotient of polynomials, but it is equivalent to
23131 @expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving
23132 @expr{x} and @expr{x^2} may appear in rational functions being
23133 integrated. Finally, rational functions involving trigonometric or
23134 hyperbolic functions can be integrated.
23136 With an argument (@kbd{C-u a i}), this command will compute the definite
23137 integral of the expression on top of the stack. In this case, the
23138 command will again prompt for an integration variable, then prompt for a
23139 lower limit and an upper limit.
23142 If you use the @code{integ} function directly in an algebraic formula,
23143 you can also write @samp{integ(f,x,v)} which expresses the resulting
23144 indefinite integral in terms of variable @code{v} instead of @code{x}.
23145 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23146 integral from @code{a} to @code{b}.
23149 If you use the @code{integ} function directly in an algebraic formula,
23150 you can also write @samp{integ(f,x,v)} which expresses the resulting
23151 indefinite integral in terms of variable @code{v} instead of @code{x}.
23152 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23153 integral $\int_a^b f(x) \, dx$.
23156 Please note that the current implementation of Calc's integrator sometimes
23157 produces results that are significantly more complex than they need to
23158 be. For example, the integral Calc finds for
23159 @texline @math{1/(x+\sqrt{x^2+1})}
23160 @infoline @expr{1/(x+sqrt(x^2+1))}
23161 is several times more complicated than the answer Mathematica
23162 returns for the same input, although the two forms are numerically
23163 equivalent. Also, any indefinite integral should be considered to have
23164 an arbitrary constant of integration added to it, although Calc does not
23165 write an explicit constant of integration in its result. For example,
23166 Calc's solution for
23167 @texline @math{1/(1+\tan x)}
23168 @infoline @expr{1/(1+tan(x))}
23169 differs from the solution given in the @emph{CRC Math Tables} by a
23171 @texline @math{\pi i / 2}
23172 @infoline @expr{pi i / 2},
23173 due to a different choice of constant of integration.
23175 The Calculator remembers all the integrals it has done. If conditions
23176 change in a way that would invalidate the old integrals, say, a switch
23177 from Degrees to Radians mode, then they will be thrown out. If you
23178 suspect this is not happening when it should, use the
23179 @code{calc-flush-caches} command; @pxref{Caches}.
23182 Calc normally will pursue integration by substitution or integration by
23183 parts up to 3 nested times before abandoning an approach as fruitless.
23184 If the integrator is taking too long, you can lower this limit by storing
23185 a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I}
23186 command is a convenient way to edit @code{IntegLimit}.) If this variable
23187 has no stored value or does not contain a nonnegative integer, a limit
23188 of 3 is used. The lower this limit is, the greater the chance that Calc
23189 will be unable to integrate a function it could otherwise handle. Raising
23190 this limit allows the Calculator to solve more integrals, though the time
23191 it takes may grow exponentially. You can monitor the integrator's actions
23192 by creating an Emacs buffer called @code{*Trace*}. If such a buffer
23193 exists, the @kbd{a i} command will write a log of its actions there.
23195 If you want to manipulate integrals in a purely symbolic way, you can
23196 set the integration nesting limit to 0 to prevent all but fast
23197 table-lookup solutions of integrals. You might then wish to define
23198 rewrite rules for integration by parts, various kinds of substitutions,
23199 and so on. @xref{Rewrite Rules}.
23201 @node Customizing the Integrator, Numerical Integration, Integration, Calculus
23202 @subsection Customizing the Integrator
23206 Calc has two built-in rewrite rules called @code{IntegRules} and
23207 @code{IntegAfterRules} which you can edit to define new integration
23208 methods. @xref{Rewrite Rules}. At each step of the integration process,
23209 Calc wraps the current integrand in a call to the fictitious function
23210 @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
23211 integrand and @var{var} is the integration variable. If your rules
23212 rewrite this to be a plain formula (not a call to @code{integtry}), then
23213 Calc will use this formula as the integral of @var{expr}. For example,
23214 the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
23215 integrate a function @code{mysin} that acts like the sine function.
23216 Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
23217 will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has
23218 automatically made various transformations on the integral to allow it
23219 to use your rule; integral tables generally give rules for
23220 @samp{mysin(a x + b)}, but you don't need to use this much generality
23221 in your @code{IntegRules}.
23223 @cindex Exponential integral Ei(x)
23228 As a more serious example, the expression @samp{exp(x)/x} cannot be
23229 integrated in terms of the standard functions, so the ``exponential
23230 integral'' function
23231 @texline @math{{\rm Ei}(x)}
23232 @infoline @expr{Ei(x)}
23233 was invented to describe it.
23234 We can get Calc to do this integral in terms of a made-up @code{Ei}
23235 function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
23236 to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack
23237 and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will
23238 work with Calc's various built-in integration methods (such as
23239 integration by substitution) to solve a variety of other problems
23240 involving @code{Ei}: For example, now Calc will also be able to
23241 integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
23242 and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
23244 Your rule may do further integration by calling @code{integ}. For
23245 example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
23246 to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
23247 Note that @code{integ} was called with only one argument. This notation
23248 is allowed only within @code{IntegRules}; it means ``integrate this
23249 with respect to the same integration variable.'' If Calc is unable
23250 to integrate @code{u}, the integration that invoked @code{IntegRules}
23251 also fails. Thus integrating @samp{twice(f(x))} fails, returning the
23252 unevaluated integral @samp{integ(twice(f(x)), x)}. It is still valid
23253 to call @code{integ} with two or more arguments, however; in this case,
23254 if @code{u} is not integrable, @code{twice} itself will still be
23255 integrated: If the above rule is changed to @samp{... := twice(integ(u,x))},
23256 then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
23258 If a rule instead produces the formula @samp{integsubst(@var{sexpr},
23259 @var{svar})}, either replacing the top-level @code{integtry} call or
23260 nested anywhere inside the expression, then Calc will apply the
23261 substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
23262 integrate the original @var{expr}. For example, the rule
23263 @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
23264 a square root in the integrand, it should attempt the substitution
23265 @samp{u = sqrt(x)}. (This particular rule is unnecessary because
23266 Calc always tries ``obvious'' substitutions where @var{sexpr} actually
23267 appears in the integrand.) The variable @var{svar} may be the same
23268 as the @var{var} that appeared in the call to @code{integtry}, but
23271 When integrating according to an @code{integsubst}, Calc uses the
23272 equation solver to find the inverse of @var{sexpr} (if the integrand
23273 refers to @var{var} anywhere except in subexpressions that exactly
23274 match @var{sexpr}). It uses the differentiator to find the derivative
23275 of @var{sexpr} and/or its inverse (it has two methods that use one
23276 derivative or the other). You can also specify these items by adding
23277 extra arguments to the @code{integsubst} your rules construct; the
23278 general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
23279 @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
23280 written as a function of @var{svar}), and @var{sprime} is the
23281 derivative of @var{sexpr} with respect to @var{svar}. If you don't
23282 specify these things, and Calc is not able to work them out on its
23283 own with the information it knows, then your substitution rule will
23284 work only in very specific, simple cases.
23286 Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
23287 in other words, Calc stops rewriting as soon as any rule in your rule
23288 set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
23289 example above would keep on adding layers of @code{integsubst} calls
23292 @vindex IntegSimpRules
23293 Another set of rules, stored in @code{IntegSimpRules}, are applied
23294 every time the integrator uses @kbd{a s} to simplify an intermediate
23295 result. For example, putting the rule @samp{twice(x) := 2 x} into
23296 @code{IntegSimpRules} would tell Calc to convert the @code{twice}
23297 function into a form it knows whenever integration is attempted.
23299 One more way to influence the integrator is to define a function with
23300 the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's
23301 integrator automatically expands such functions according to their
23302 defining formulas, even if you originally asked for the function to
23303 be left unevaluated for symbolic arguments. (Certain other Calc
23304 systems, such as the differentiator and the equation solver, also
23307 @vindex IntegAfterRules
23308 Sometimes Calc is able to find a solution to your integral, but it
23309 expresses the result in a way that is unnecessarily complicated. If
23310 this happens, you can either use @code{integsubst} as described
23311 above to try to hint at a more direct path to the desired result, or
23312 you can use @code{IntegAfterRules}. This is an extra rule set that
23313 runs after the main integrator returns its result; basically, Calc does
23314 an @kbd{a r IntegAfterRules} on the result before showing it to you.
23315 (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that
23316 to further simplify the result.) For example, Calc's integrator
23317 sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
23318 the default @code{IntegAfterRules} rewrite this into the more readable
23319 form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules},
23320 @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
23321 of times until no further changes are possible. Rewriting by
23322 @code{IntegAfterRules} occurs only after the main integrator has
23323 finished, not at every step as for @code{IntegRules} and
23324 @code{IntegSimpRules}.
23326 @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
23327 @subsection Numerical Integration
23331 @pindex calc-num-integral
23333 If you want a purely numerical answer to an integration problem, you can
23334 use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This
23335 command prompts for an integration variable, a lower limit, and an
23336 upper limit. Except for the integration variable, all other variables
23337 that appear in the integrand formula must have stored values. (A stored
23338 value, if any, for the integration variable itself is ignored.)
23340 Numerical integration works by evaluating your formula at many points in
23341 the specified interval. Calc uses an ``open Romberg'' method; this means
23342 that it does not evaluate the formula actually at the endpoints (so that
23343 it is safe to integrate @samp{sin(x)/x} from zero, for example). Also,
23344 the Romberg method works especially well when the function being
23345 integrated is fairly smooth. If the function is not smooth, Calc will
23346 have to evaluate it at quite a few points before it can accurately
23347 determine the value of the integral.
23349 Integration is much faster when the current precision is small. It is
23350 best to set the precision to the smallest acceptable number of digits
23351 before you use @kbd{a I}. If Calc appears to be taking too long, press
23352 @kbd{C-g} to halt it and try a lower precision. If Calc still appears
23353 to need hundreds of evaluations, check to make sure your function is
23354 well-behaved in the specified interval.
23356 It is possible for the lower integration limit to be @samp{-inf} (minus
23357 infinity). Likewise, the upper limit may be plus infinity. Calc
23358 internally transforms the integral into an equivalent one with finite
23359 limits. However, integration to or across singularities is not supported:
23360 The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
23361 by Calc's symbolic integrator, for example), but @kbd{a I} will fail
23362 because the integrand goes to infinity at one of the endpoints.
23364 @node Taylor Series, , Numerical Integration, Calculus
23365 @subsection Taylor Series
23369 @pindex calc-taylor
23371 The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
23372 power series expansion or Taylor series of a function. You specify the
23373 variable and the desired number of terms. You may give an expression of
23374 the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
23375 of just a variable to produce a Taylor expansion about the point @var{a}.
23376 You may specify the number of terms with a numeric prefix argument;
23377 otherwise the command will prompt you for the number of terms. Note that
23378 many series expansions have coefficients of zero for some terms, so you
23379 may appear to get fewer terms than you asked for.
23381 If the @kbd{a i} command is unable to find a symbolic integral for a
23382 function, you can get an approximation by integrating the function's
23385 @node Solving Equations, Numerical Solutions, Calculus, Algebra
23386 @section Solving Equations
23390 @pindex calc-solve-for
23392 @cindex Equations, solving
23393 @cindex Solving equations
23394 The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
23395 an equation to solve for a specific variable. An equation is an
23396 expression of the form @expr{L = R}. For example, the command @kbd{a S x}
23397 will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the
23398 input is not an equation, it is treated like an equation of the
23401 This command also works for inequalities, as in @expr{y < 3x + 6}.
23402 Some inequalities cannot be solved where the analogous equation could
23403 be; for example, solving
23404 @texline @math{a < b \, c}
23405 @infoline @expr{a < b c}
23406 for @expr{b} is impossible
23407 without knowing the sign of @expr{c}. In this case, @kbd{a S} will
23409 @texline @math{b \mathbin{\hbox{\code{!=}}} a/c}
23410 @infoline @expr{b != a/c}
23411 (using the not-equal-to operator) to signify that the direction of the
23412 inequality is now unknown. The inequality
23413 @texline @math{a \le b \, c}
23414 @infoline @expr{a <= b c}
23415 is not even partially solved. @xref{Declarations}, for a way to tell
23416 Calc that the signs of the variables in a formula are in fact known.
23418 Two useful commands for working with the result of @kbd{a S} are
23419 @kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2}
23420 to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
23421 another formula with @expr{x} set equal to @expr{y/3 - 2}.
23424 * Multiple Solutions::
23425 * Solving Systems of Equations::
23426 * Decomposing Polynomials::
23429 @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
23430 @subsection Multiple Solutions
23435 Some equations have more than one solution. The Hyperbolic flag
23436 (@code{H a S}) [@code{fsolve}] tells the solver to report the fully
23437 general family of solutions. It will invent variables @code{n1},
23438 @code{n2}, @dots{}, which represent independent arbitrary integers, and
23439 @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
23440 signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic
23441 flag, Calc will use zero in place of all arbitrary integers, and plus
23442 one in place of all arbitrary signs. Note that variables like @code{n1}
23443 and @code{s1} are not given any special interpretation in Calc except by
23444 the equation solver itself. As usual, you can use the @w{@kbd{s l}}
23445 (@code{calc-let}) command to obtain solutions for various actual values
23446 of these variables.
23448 For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
23449 get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
23450 equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to
23451 think about it is that the square-root operation is really a
23452 two-valued function; since every Calc function must return a
23453 single result, @code{sqrt} chooses to return the positive result.
23454 Then @kbd{H a S} doctors this result using @code{s1} to indicate
23455 the full set of possible values of the mathematical square-root.
23457 There is a similar phenomenon going the other direction: Suppose
23458 we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides
23459 to get @samp{y = x^2}. This is correct, except that it introduces
23460 some dubious solutions. Consider solving @samp{sqrt(y) = -3}:
23461 Calc will report @expr{y = 9} as a valid solution, which is true
23462 in the mathematical sense of square-root, but false (there is no
23463 solution) for the actual Calc positive-valued @code{sqrt}. This
23464 happens for both @kbd{a S} and @kbd{H a S}.
23466 @cindex @code{GenCount} variable
23476 If you store a positive integer in the Calc variable @code{GenCount},
23477 then Calc will generate formulas of the form @samp{as(@var{n})} for
23478 arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
23479 where @var{n} represents successive values taken by incrementing
23480 @code{GenCount} by one. While the normal arbitrary sign and
23481 integer symbols start over at @code{s1} and @code{n1} with each
23482 new Calc command, the @code{GenCount} approach will give each
23483 arbitrary value a name that is unique throughout the entire Calc
23484 session. Also, the arbitrary values are function calls instead
23485 of variables, which is advantageous in some cases. For example,
23486 you can make a rewrite rule that recognizes all arbitrary signs
23487 using a pattern like @samp{as(n)}. The @kbd{s l} command only works
23488 on variables, but you can use the @kbd{a b} (@code{calc-substitute})
23489 command to substitute actual values for function calls like @samp{as(3)}.
23491 The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
23492 way to create or edit this variable. Press @kbd{C-c C-c} to finish.
23494 If you have not stored a value in @code{GenCount}, or if the value
23495 in that variable is not a positive integer, the regular
23496 @code{s1}/@code{n1} notation is used.
23502 With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
23503 on top of the stack as a function of the specified variable and solves
23504 to find the inverse function, written in terms of the same variable.
23505 For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}.
23506 You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
23507 fully general inverse, as described above.
23510 @pindex calc-poly-roots
23512 Some equations, specifically polynomials, have a known, finite number
23513 of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
23514 command uses @kbd{H a S} to solve an equation in general form, then, for
23515 all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
23516 variables like @code{n1} for which @code{n1} only usefully varies over
23517 a finite range, it expands these variables out to all their possible
23518 values. The results are collected into a vector, which is returned.
23519 For example, @samp{roots(x^4 = 1, x)} returns the four solutions
23520 @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree
23521 polynomial will always have @var{n} roots on the complex plane.
23522 (If you have given a @code{real} declaration for the solution
23523 variable, then only the real-valued solutions, if any, will be
23524 reported; @pxref{Declarations}.)
23526 Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
23527 symbolic solutions if the polynomial has symbolic coefficients. Also
23528 note that Calc's solver is not able to get exact symbolic solutions
23529 to all polynomials. Polynomials containing powers up to @expr{x^4}
23530 can always be solved exactly; polynomials of higher degree sometimes
23531 can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1},
23532 which can be solved for @expr{x^3} using the quadratic equation, and then
23533 for @expr{x} by taking cube roots. But in many cases, like
23534 @expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
23535 into a form it can solve. The @kbd{a P} command can still deliver a
23536 list of numerical roots, however, provided that Symbolic mode (@kbd{m s})
23537 is not turned on. (If you work with Symbolic mode on, recall that the
23538 @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
23539 formula on the stack with Symbolic mode temporarily off.) Naturally,
23540 @kbd{a P} can only provide numerical roots if the polynomial coefficients
23541 are all numbers (real or complex).
23543 @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
23544 @subsection Solving Systems of Equations
23547 @cindex Systems of equations, symbolic
23548 You can also use the commands described above to solve systems of
23549 simultaneous equations. Just create a vector of equations, then
23550 specify a vector of variables for which to solve. (You can omit
23551 the surrounding brackets when entering the vector of variables
23554 For example, putting @samp{[x + y = a, x - y = b]} on the stack
23555 and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
23556 @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will
23557 have the same length as the variables vector, and the variables
23558 will be listed in the same order there. Note that the solutions
23559 are not always simplified as far as possible; the solution for
23560 @expr{x} here could be improved by an application of the @kbd{a n}
23563 Calc's algorithm works by trying to eliminate one variable at a
23564 time by solving one of the equations for that variable and then
23565 substituting into the other equations. Calc will try all the
23566 possibilities, but you can speed things up by noting that Calc
23567 first tries to eliminate the first variable with the first
23568 equation, then the second variable with the second equation,
23569 and so on. It also helps to put the simpler (e.g., more linear)
23570 equations toward the front of the list. Calc's algorithm will
23571 solve any system of linear equations, and also many kinds of
23578 Normally there will be as many variables as equations. If you
23579 give fewer variables than equations (an ``over-determined'' system
23580 of equations), Calc will find a partial solution. For example,
23581 typing @kbd{a S y @key{RET}} with the above system of equations
23582 would produce @samp{[y = a - x]}. There are now several ways to
23583 express this solution in terms of the original variables; Calc uses
23584 the first one that it finds. You can control the choice by adding
23585 variable specifiers of the form @samp{elim(@var{v})} to the
23586 variables list. This says that @var{v} should be eliminated from
23587 the equations; the variable will not appear at all in the solution.
23588 For example, typing @kbd{a S y,elim(x)} would yield
23589 @samp{[y = a - (b+a)/2]}.
23591 If the variables list contains only @code{elim} specifiers,
23592 Calc simply eliminates those variables from the equations
23593 and then returns the resulting set of equations. For example,
23594 @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable
23595 eliminated will reduce the number of equations in the system
23598 Again, @kbd{a S} gives you one solution to the system of
23599 equations. If there are several solutions, you can use @kbd{H a S}
23600 to get a general family of solutions, or, if there is a finite
23601 number of solutions, you can use @kbd{a P} to get a list. (In
23602 the latter case, the result will take the form of a matrix where
23603 the rows are different solutions and the columns correspond to the
23604 variables you requested.)
23606 Another way to deal with certain kinds of overdetermined systems of
23607 equations is the @kbd{a F} command, which does least-squares fitting
23608 to satisfy the equations. @xref{Curve Fitting}.
23610 @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
23611 @subsection Decomposing Polynomials
23618 The @code{poly} function takes a polynomial and a variable as
23619 arguments, and returns a vector of polynomial coefficients (constant
23620 coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns
23621 @expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x},
23622 the call to @code{poly} is left in symbolic form. If the input does
23623 not involve the variable @expr{x}, the input is returned in a list
23624 of length one, representing a polynomial with only a constant
23625 coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}.
23626 The last element of the returned vector is guaranteed to be nonzero;
23627 note that @samp{poly(0, x)} returns the empty vector @expr{[]}.
23628 Note also that @expr{x} may actually be any formula; for example,
23629 @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}.
23631 @cindex Coefficients of polynomial
23632 @cindex Degree of polynomial
23633 To get the @expr{x^k} coefficient of polynomial @expr{p}, use
23634 @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p},
23635 use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)}
23636 returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
23637 gives the @expr{x^2} coefficient of this polynomial, 6.
23643 One important feature of the solver is its ability to recognize
23644 formulas which are ``essentially'' polynomials. This ability is
23645 made available to the user through the @code{gpoly} function, which
23646 is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}.
23647 If @var{expr} is a polynomial in some term which includes @var{var}, then
23648 this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
23649 where @var{x} is the term that depends on @var{var}, @var{c} is a
23650 vector of polynomial coefficients (like the one returned by @code{poly}),
23651 and @var{a} is a multiplier which is usually 1. Basically,
23652 @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
23653 @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is
23654 guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
23655 (i.e., the trivial decomposition @var{expr} = @var{x} is not
23656 considered a polynomial). One side effect is that @samp{gpoly(x, x)}
23657 and @samp{gpoly(6, x)}, both of which might be expected to recognize
23658 their arguments as polynomials, will not because the decomposition
23659 is considered trivial.
23661 For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
23662 since the expanded form of this polynomial is @expr{4 - 4 x + x^2}.
23664 The term @var{x} may itself be a polynomial in @var{var}. This is
23665 done to reduce the size of the @var{c} vector. For example,
23666 @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
23667 since a quadratic polynomial in @expr{x^2} is easier to solve than
23668 a quartic polynomial in @expr{x}.
23670 A few more examples of the kinds of polynomials @code{gpoly} can
23674 sin(x) - 1 [sin(x), [-1, 1], 1]
23675 x + 1/x - 1 [x, [1, -1, 1], 1/x]
23676 x + 1/x [x^2, [1, 1], 1/x]
23677 x^3 + 2 x [x^2, [2, 1], x]
23678 x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2]
23679 x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1]
23680 (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x]
23683 The @code{poly} and @code{gpoly} functions accept a third integer argument
23684 which specifies the largest degree of polynomial that is acceptable.
23685 If this is @expr{n}, then only @var{c} vectors of length @expr{n+1}
23686 or less will be returned. Otherwise, the @code{poly} or @code{gpoly}
23687 call will remain in symbolic form. For example, the equation solver
23688 can handle quartics and smaller polynomials, so it calls
23689 @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
23690 can be treated by its linear, quadratic, cubic, or quartic formulas.
23696 The @code{pdeg} function computes the degree of a polynomial;
23697 @samp{pdeg(p,x)} is the highest power of @code{x} that appears in
23698 @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is
23699 much more efficient. If @code{p} is constant with respect to @code{x},
23700 then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x}
23701 (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
23702 It is possible to omit the second argument @code{x}, in which case
23703 @samp{pdeg(p)} returns the highest total degree of any term of the
23704 polynomial, counting all variables that appear in @code{p}. Note
23705 that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
23706 the degree of the constant zero is considered to be @code{-inf}
23713 The @code{plead} function finds the leading term of a polynomial.
23714 Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
23715 though again more efficient. In particular, @samp{plead((2x+1)^10, x)}
23716 returns 1024 without expanding out the list of coefficients. The
23717 value of @code{plead(p,x)} will be zero only if @expr{p = 0}.
23723 The @code{pcont} function finds the @dfn{content} of a polynomial. This
23724 is the greatest common divisor of all the coefficients of the polynomial.
23725 With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
23726 to get a list of coefficients, then uses @code{pgcd} (the polynomial
23727 GCD function) to combine these into an answer. For example,
23728 @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is
23729 basically the ``biggest'' polynomial that can be divided into @code{p}
23730 exactly. The sign of the content is the same as the sign of the leading
23733 With only one argument, @samp{pcont(p)} computes the numerical
23734 content of the polynomial, i.e., the @code{gcd} of the numerical
23735 coefficients of all the terms in the formula. Note that @code{gcd}
23736 is defined on rational numbers as well as integers; it computes
23737 the @code{gcd} of the numerators and the @code{lcm} of the
23738 denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
23739 Dividing the polynomial by this number will clear all the
23740 denominators, as well as dividing by any common content in the
23741 numerators. The numerical content of a polynomial is negative only
23742 if all the coefficients in the polynomial are negative.
23748 The @code{pprim} function finds the @dfn{primitive part} of a
23749 polynomial, which is simply the polynomial divided (using @code{pdiv}
23750 if necessary) by its content. If the input polynomial has rational
23751 coefficients, the result will have integer coefficients in simplest
23754 @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
23755 @section Numerical Solutions
23758 Not all equations can be solved symbolically. The commands in this
23759 section use numerical algorithms that can find a solution to a specific
23760 instance of an equation to any desired accuracy. Note that the
23761 numerical commands are slower than their algebraic cousins; it is a
23762 good idea to try @kbd{a S} before resorting to these commands.
23764 (@xref{Curve Fitting}, for some other, more specialized, operations
23765 on numerical data.)
23770 * Numerical Systems of Equations::
23773 @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
23774 @subsection Root Finding
23778 @pindex calc-find-root
23780 @cindex Newton's method
23781 @cindex Roots of equations
23782 @cindex Numerical root-finding
23783 The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
23784 numerical solution (or @dfn{root}) of an equation. (This command treats
23785 inequalities the same as equations. If the input is any other kind
23786 of formula, it is interpreted as an equation of the form @expr{X = 0}.)
23788 The @kbd{a R} command requires an initial guess on the top of the
23789 stack, and a formula in the second-to-top position. It prompts for a
23790 solution variable, which must appear in the formula. All other variables
23791 that appear in the formula must have assigned values, i.e., when
23792 a value is assigned to the solution variable and the formula is
23793 evaluated with @kbd{=}, it should evaluate to a number. Any assigned
23794 value for the solution variable itself is ignored and unaffected by
23797 When the command completes, the initial guess is replaced on the stack
23798 by a vector of two numbers: The value of the solution variable that
23799 solves the equation, and the difference between the lefthand and
23800 righthand sides of the equation at that value. Ordinarily, the second
23801 number will be zero or very nearly zero. (Note that Calc uses a
23802 slightly higher precision while finding the root, and thus the second
23803 number may be slightly different from the value you would compute from
23804 the equation yourself.)
23806 The @kbd{v h} (@code{calc-head}) command is a handy way to extract
23807 the first element of the result vector, discarding the error term.
23809 The initial guess can be a real number, in which case Calc searches
23810 for a real solution near that number, or a complex number, in which
23811 case Calc searches the whole complex plane near that number for a
23812 solution, or it can be an interval form which restricts the search
23813 to real numbers inside that interval.
23815 Calc tries to use @kbd{a d} to take the derivative of the equation.
23816 If this succeeds, it uses Newton's method. If the equation is not
23817 differentiable Calc uses a bisection method. (If Newton's method
23818 appears to be going astray, Calc switches over to bisection if it
23819 can, or otherwise gives up. In this case it may help to try again
23820 with a slightly different initial guess.) If the initial guess is a
23821 complex number, the function must be differentiable.
23823 If the formula (or the difference between the sides of an equation)
23824 is negative at one end of the interval you specify and positive at
23825 the other end, the root finder is guaranteed to find a root.
23826 Otherwise, Calc subdivides the interval into small parts looking for
23827 positive and negative values to bracket the root. When your guess is
23828 an interval, Calc will not look outside that interval for a root.
23832 The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
23833 that if the initial guess is an interval for which the function has
23834 the same sign at both ends, then rather than subdividing the interval
23835 Calc attempts to widen it to enclose a root. Use this mode if
23836 you are not sure if the function has a root in your interval.
23838 If the function is not differentiable, and you give a simple number
23839 instead of an interval as your initial guess, Calc uses this widening
23840 process even if you did not type the Hyperbolic flag. (If the function
23841 @emph{is} differentiable, Calc uses Newton's method which does not
23842 require a bounding interval in order to work.)
23844 If Calc leaves the @code{root} or @code{wroot} function in symbolic
23845 form on the stack, it will normally display an explanation for why
23846 no root was found. If you miss this explanation, press @kbd{w}
23847 (@code{calc-why}) to get it back.
23849 @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
23850 @subsection Minimization
23857 @pindex calc-find-minimum
23858 @pindex calc-find-maximum
23861 @cindex Minimization, numerical
23862 The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
23863 finds a minimum value for a formula. It is very similar in operation
23864 to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial
23865 guess on the stack, and are prompted for the name of a variable. The guess
23866 may be either a number near the desired minimum, or an interval enclosing
23867 the desired minimum. The function returns a vector containing the
23868 value of the variable which minimizes the formula's value, along
23869 with the minimum value itself.
23871 Note that this command looks for a @emph{local} minimum. Many functions
23872 have more than one minimum; some, like
23873 @texline @math{x \sin x},
23874 @infoline @expr{x sin(x)},
23875 have infinitely many. In fact, there is no easy way to define the
23876 ``global'' minimum of
23877 @texline @math{x \sin x}
23878 @infoline @expr{x sin(x)}
23879 but Calc can still locate any particular local minimum
23880 for you. Calc basically goes downhill from the initial guess until it
23881 finds a point at which the function's value is greater both to the left
23882 and to the right. Calc does not use derivatives when minimizing a function.
23884 If your initial guess is an interval and it looks like the minimum
23885 occurs at one or the other endpoint of the interval, Calc will return
23886 that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x}
23887 over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over
23888 @expr{(2..3]} would report no minimum found. In general, you should
23889 use closed intervals to find literally the minimum value in that
23890 range of @expr{x}, or open intervals to find the local minimum, if
23891 any, that happens to lie in that range.
23893 Most functions are smooth and flat near their minimum values. Because
23894 of this flatness, if the current precision is, say, 12 digits, the
23895 variable can only be determined meaningfully to about six digits. Thus
23896 you should set the precision to twice as many digits as you need in your
23907 The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
23908 expands the guess interval to enclose a minimum rather than requiring
23909 that the minimum lie inside the interval you supply.
23911 The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
23912 @kbd{H a X} [@code{wmaximize}] commands effectively minimize the
23913 negative of the formula you supply.
23915 The formula must evaluate to a real number at all points inside the
23916 interval (or near the initial guess if the guess is a number). If
23917 the initial guess is a complex number the variable will be minimized
23918 over the complex numbers; if it is real or an interval it will
23919 be minimized over the reals.
23921 @node Numerical Systems of Equations, , Minimization, Numerical Solutions
23922 @subsection Systems of Equations
23925 @cindex Systems of equations, numerical
23926 The @kbd{a R} command can also solve systems of equations. In this
23927 case, the equation should instead be a vector of equations, the
23928 guess should instead be a vector of numbers (intervals are not
23929 supported), and the variable should be a vector of variables. You
23930 can omit the brackets while entering the list of variables. Each
23931 equation must be differentiable by each variable for this mode to
23932 work. The result will be a vector of two vectors: The variable
23933 values that solved the system of equations, and the differences
23934 between the sides of the equations with those variable values.
23935 There must be the same number of equations as variables. Since
23936 only plain numbers are allowed as guesses, the Hyperbolic flag has
23937 no effect when solving a system of equations.
23939 It is also possible to minimize over many variables with @kbd{a N}
23940 (or maximize with @kbd{a X}). Once again the variable name should
23941 be replaced by a vector of variables, and the initial guess should
23942 be an equal-sized vector of initial guesses. But, unlike the case of
23943 multidimensional @kbd{a R}, the formula being minimized should
23944 still be a single formula, @emph{not} a vector. Beware that
23945 multidimensional minimization is currently @emph{very} slow.
23947 @node Curve Fitting, Summations, Numerical Solutions, Algebra
23948 @section Curve Fitting
23951 The @kbd{a F} command fits a set of data to a @dfn{model formula},
23952 such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters
23953 to be determined. For a typical set of measured data there will be
23954 no single @expr{m} and @expr{b} that exactly fit the data; in this
23955 case, Calc chooses values of the parameters that provide the closest
23956 possible fit. The model formula can be entered in various ways after
23957 the key sequence @kbd{a F} is pressed.
23959 If the letter @kbd{P} is pressed after @kbd{a F} but before the model
23960 description is entered, the data as well as the model formula will be
23961 plotted after the formula is determined. This will be indicated by a
23962 ``P'' in the minibuffer after the help message.
23966 * Polynomial and Multilinear Fits::
23967 * Error Estimates for Fits::
23968 * Standard Nonlinear Models::
23969 * Curve Fitting Details::
23973 @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
23974 @subsection Linear Fits
23978 @pindex calc-curve-fit
23980 @cindex Linear regression
23981 @cindex Least-squares fits
23982 The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
23983 to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a
23984 straight line, polynomial, or other function of @expr{x}. For the
23985 moment we will consider only the case of fitting to a line, and we
23986 will ignore the issue of whether or not the model was in fact a good
23989 In a standard linear least-squares fit, we have a set of @expr{(x,y)}
23990 data points that we wish to fit to the model @expr{y = m x + b}
23991 by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y}
23992 values calculated from the formula be as close as possible to the actual
23993 @expr{y} values in the data set. (In a polynomial fit, the model is
23994 instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit,
23995 we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is
23996 @expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.)
23998 In the model formula, variables like @expr{x} and @expr{x_2} are called
23999 the @dfn{independent variables}, and @expr{y} is the @dfn{dependent
24000 variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called
24001 the @dfn{parameters} of the model.
24003 The @kbd{a F} command takes the data set to be fitted from the stack.
24004 By default, it expects the data in the form of a matrix. For example,
24005 for a linear or polynomial fit, this would be a
24006 @texline @math{2\times N}
24008 matrix where the first row is a list of @expr{x} values and the second
24009 row has the corresponding @expr{y} values. For the multilinear fit
24010 shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2},
24011 @expr{x_3}, and @expr{y}, respectively).
24013 If you happen to have an
24014 @texline @math{N\times2}
24016 matrix instead of a
24017 @texline @math{2\times N}
24019 matrix, just press @kbd{v t} first to transpose the matrix.
24021 After you type @kbd{a F}, Calc prompts you to select a model. For a
24022 linear fit, press the digit @kbd{1}.
24024 Calc then prompts for you to name the variables. By default it chooses
24025 high letters like @expr{x} and @expr{y} for independent variables and
24026 low letters like @expr{a} and @expr{b} for parameters. (The dependent
24027 variable doesn't need a name.) The two kinds of variables are separated
24028 by a semicolon. Since you generally care more about the names of the
24029 independent variables than of the parameters, Calc also allows you to
24030 name only those and let the parameters use default names.
24032 For example, suppose the data matrix
24037 [ [ 1, 2, 3, 4, 5 ]
24038 [ 5, 7, 9, 11, 13 ] ]
24046 $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr
24047 5 & 7 & 9 & 11 & 13 }
24053 is on the stack and we wish to do a simple linear fit. Type
24054 @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
24055 the default names. The result will be the formula @expr{3. + 2. x}
24056 on the stack. Calc has created the model expression @kbd{a + b x},
24057 then found the optimal values of @expr{a} and @expr{b} to fit the
24058 data. (In this case, it was able to find an exact fit.) Calc then
24059 substituted those values for @expr{a} and @expr{b} in the model
24062 The @kbd{a F} command puts two entries in the trail. One is, as
24063 always, a copy of the result that went to the stack; the other is
24064 a vector of the actual parameter values, written as equations:
24065 @expr{[a = 3, b = 2]}, in case you'd rather read them in a list
24066 than pick them out of the formula. (You can type @kbd{t y}
24067 to move this vector to the stack; see @ref{Trail Commands}.
24069 Specifying a different independent variable name will affect the
24070 resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
24071 Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
24072 the equations that go into the trail.
24078 To see what happens when the fit is not exact, we could change
24079 the number 13 in the data matrix to 14 and try the fit again.
24086 Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
24087 a reasonably close match to the y-values in the data.
24090 [4.8, 7., 9.2, 11.4, 13.6]
24093 Since there is no line which passes through all the @var{n} data points,
24094 Calc has chosen a line that best approximates the data points using
24095 the method of least squares. The idea is to define the @dfn{chi-square}
24100 chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
24106 $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
24111 which is clearly zero if @expr{a + b x} exactly fits all data points,
24112 and increases as various @expr{a + b x_i} values fail to match the
24113 corresponding @expr{y_i} values. There are several reasons why the
24114 summand is squared, one of them being to ensure that
24115 @texline @math{\chi^2 \ge 0}.
24116 @infoline @expr{chi^2 >= 0}.
24117 Least-squares fitting simply chooses the values of @expr{a} and @expr{b}
24118 for which the error
24119 @texline @math{\chi^2}
24120 @infoline @expr{chi^2}
24121 is as small as possible.
24123 Other kinds of models do the same thing but with a different model
24124 formula in place of @expr{a + b x_i}.
24130 A numeric prefix argument causes the @kbd{a F} command to take the
24131 data in some other form than one big matrix. A positive argument @var{n}
24132 will take @var{N} items from the stack, corresponding to the @var{n} rows
24133 of a data matrix. In the linear case, @var{n} must be 2 since there
24134 is always one independent variable and one dependent variable.
24136 A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
24137 items from the stack, an @var{n}-row matrix of @expr{x} values, and a
24138 vector of @expr{y} values. If there is only one independent variable,
24139 the @expr{x} values can be either a one-row matrix or a plain vector,
24140 in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
24142 @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
24143 @subsection Polynomial and Multilinear Fits
24146 To fit the data to higher-order polynomials, just type one of the
24147 digits @kbd{2} through @kbd{9} when prompted for a model. For example,
24148 we could fit the original data matrix from the previous section
24149 (with 13, not 14) to a parabola instead of a line by typing
24150 @kbd{a F 2 @key{RET}}.
24153 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
24156 Note that since the constant and linear terms are enough to fit the
24157 data exactly, it's no surprise that Calc chose a tiny contribution
24158 for @expr{x^2}. (The fact that it's not exactly zero is due only
24159 to roundoff error. Since our data are exact integers, we could get
24160 an exact answer by typing @kbd{m f} first to get Fraction mode.
24161 Then the @expr{x^2} term would vanish altogether. Usually, though,
24162 the data being fitted will be approximate floats so Fraction mode
24165 Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
24166 gives a much larger @expr{x^2} contribution, as Calc bends the
24167 line slightly to improve the fit.
24170 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
24173 An important result from the theory of polynomial fitting is that it
24174 is always possible to fit @var{n} data points exactly using a polynomial
24175 of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
24176 Using the modified (14) data matrix, a model number of 4 gives
24177 a polynomial that exactly matches all five data points:
24180 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
24183 The actual coefficients we get with a precision of 12, like
24184 @expr{0.0416666663588}, clearly suffer from loss of precision.
24185 It is a good idea to increase the working precision to several
24186 digits beyond what you need when you do a fitting operation.
24187 Or, if your data are exact, use Fraction mode to get exact
24190 You can type @kbd{i} instead of a digit at the model prompt to fit
24191 the data exactly to a polynomial. This just counts the number of
24192 columns of the data matrix to choose the degree of the polynomial
24195 Fitting data ``exactly'' to high-degree polynomials is not always
24196 a good idea, though. High-degree polynomials have a tendency to
24197 wiggle uncontrollably in between the fitting data points. Also,
24198 if the exact-fit polynomial is going to be used to interpolate or
24199 extrapolate the data, it is numerically better to use the @kbd{a p}
24200 command described below. @xref{Interpolation}.
24206 Another generalization of the linear model is to assume the
24207 @expr{y} values are a sum of linear contributions from several
24208 @expr{x} values. This is a @dfn{multilinear} fit, and it is also
24209 selected by the @kbd{1} digit key. (Calc decides whether the fit
24210 is linear or multilinear by counting the rows in the data matrix.)
24212 Given the data matrix,
24216 [ [ 1, 2, 3, 4, 5 ]
24218 [ 14.5, 15, 18.5, 22.5, 24 ] ]
24223 the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the
24224 second row @expr{y}, and will fit the values in the third row to the
24225 model @expr{a + b x + c y}.
24231 Calc can do multilinear fits with any number of independent variables
24232 (i.e., with any number of data rows).
24238 Yet another variation is @dfn{homogeneous} linear models, in which
24239 the constant term is known to be zero. In the linear case, this
24240 means the model formula is simply @expr{a x}; in the multilinear
24241 case, the model might be @expr{a x + b y + c z}; and in the polynomial
24242 case, the model could be @expr{a x + b x^2 + c x^3}. You can get
24243 a homogeneous linear or multilinear model by pressing the letter
24244 @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
24245 This will be indicated by an ``h'' in the minibuffer after the help
24248 It is certainly possible to have other constrained linear models,
24249 like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single
24250 key to select models like these, a later section shows how to enter
24251 any desired model by hand. In the first case, for example, you
24252 would enter @kbd{a F ' 2.3 + a x}.
24254 Another class of models that will work but must be entered by hand
24255 are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}.
24257 @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
24258 @subsection Error Estimates for Fits
24263 With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
24264 fitting operation as @kbd{a F}, but reports the coefficients as error
24265 forms instead of plain numbers. Fitting our two data matrices (first
24266 with 13, then with 14) to a line with @kbd{H a F} gives the results,
24270 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
24273 In the first case the estimated errors are zero because the linear
24274 fit is perfect. In the second case, the errors are nonzero but
24275 moderately small, because the data are still very close to linear.
24277 It is also possible for the @emph{input} to a fitting operation to
24278 contain error forms. The data values must either all include errors
24279 or all be plain numbers. Error forms can go anywhere but generally
24280 go on the numbers in the last row of the data matrix. If the last
24281 row contains error forms
24282 @texline `@var{y_i}@w{ @tfn{+/-} }@math{\sigma_i}',
24283 @infoline `@var{y_i}@w{ @tfn{+/-} }@var{sigma_i}',
24285 @texline @math{\chi^2}
24286 @infoline @expr{chi^2}
24291 chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
24297 $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
24302 so that data points with larger error estimates contribute less to
24303 the fitting operation.
24305 If there are error forms on other rows of the data matrix, all the
24306 errors for a given data point are combined; the square root of the
24307 sum of the squares of the errors forms the
24308 @texline @math{\sigma_i}
24309 @infoline @expr{sigma_i}
24310 used for the data point.
24312 Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
24313 matrix, although if you are concerned about error analysis you will
24314 probably use @kbd{H a F} so that the output also contains error
24317 If the input contains error forms but all the
24318 @texline @math{\sigma_i}
24319 @infoline @expr{sigma_i}
24320 values are the same, it is easy to see that the resulting fitted model
24321 will be the same as if the input did not have error forms at all
24322 @texline (@math{\chi^2}
24323 @infoline (@expr{chi^2}
24324 is simply scaled uniformly by
24325 @texline @math{1 / \sigma^2},
24326 @infoline @expr{1 / sigma^2},
24327 which doesn't affect where it has a minimum). But there @emph{will} be
24328 a difference in the estimated errors of the coefficients reported by
24331 Consult any text on statistical modeling of data for a discussion
24332 of where these error estimates come from and how they should be
24341 With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
24342 information. The result is a vector of six items:
24346 The model formula with error forms for its coefficients or
24347 parameters. This is the result that @kbd{H a F} would have
24351 A vector of ``raw'' parameter values for the model. These are the
24352 polynomial coefficients or other parameters as plain numbers, in the
24353 same order as the parameters appeared in the final prompt of the
24354 @kbd{I a F} command. For polynomials of degree @expr{d}, this vector
24355 will have length @expr{M = d+1} with the constant term first.
24358 The covariance matrix @expr{C} computed from the fit. This is
24359 an @var{m}x@var{m} symmetric matrix; the diagonal elements
24360 @texline @math{C_{jj}}
24361 @infoline @expr{C_j_j}
24363 @texline @math{\sigma_j^2}
24364 @infoline @expr{sigma_j^2}
24365 of the parameters. The other elements are covariances
24366 @texline @math{\sigma_{ij}^2}
24367 @infoline @expr{sigma_i_j^2}
24368 that describe the correlation between pairs of parameters. (A related
24369 set of numbers, the @dfn{linear correlation coefficients}
24370 @texline @math{r_{ij}},
24371 @infoline @expr{r_i_j},
24373 @texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.)
24374 @infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.)
24377 A vector of @expr{M} ``parameter filter'' functions whose
24378 meanings are described below. If no filters are necessary this
24379 will instead be an empty vector; this is always the case for the
24380 polynomial and multilinear fits described so far.
24384 @texline @math{\chi^2}
24385 @infoline @expr{chi^2}
24386 for the fit, calculated by the formulas shown above. This gives a
24387 measure of the quality of the fit; statisticians consider
24388 @texline @math{\chi^2 \approx N - M}
24389 @infoline @expr{chi^2 = N - M}
24390 to indicate a moderately good fit (where again @expr{N} is the number of
24391 data points and @expr{M} is the number of parameters).
24394 A measure of goodness of fit expressed as a probability @expr{Q}.
24395 This is computed from the @code{utpc} probability distribution
24397 @texline @math{\chi^2}
24398 @infoline @expr{chi^2}
24399 with @expr{N - M} degrees of freedom. A
24400 value of 0.5 implies a good fit; some texts recommend that often
24401 @expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In
24403 @texline @math{\chi^2}
24404 @infoline @expr{chi^2}
24405 statistics assume the errors in your inputs
24406 follow a normal (Gaussian) distribution; if they don't, you may
24407 have to accept smaller values of @expr{Q}.
24409 The @expr{Q} value is computed only if the input included error
24410 estimates. Otherwise, Calc will report the symbol @code{nan}
24411 for @expr{Q}. The reason is that in this case the
24412 @texline @math{\chi^2}
24413 @infoline @expr{chi^2}
24414 value has effectively been used to estimate the original errors
24415 in the input, and thus there is no redundant information left
24416 over to use for a confidence test.
24419 @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
24420 @subsection Standard Nonlinear Models
24423 The @kbd{a F} command also accepts other kinds of models besides
24424 lines and polynomials. Some common models have quick single-key
24425 abbreviations; others must be entered by hand as algebraic formulas.
24427 Here is a complete list of the standard models recognized by @kbd{a F}:
24431 Linear or multilinear. @mathit{a + b x + c y + d z}.
24433 Polynomials. @mathit{a + b x + c x^2 + d x^3}.
24435 Exponential. @mathit{a} @tfn{exp}@mathit{(b x)} @tfn{exp}@mathit{(c y)}.
24437 Base-10 exponential. @mathit{a} @tfn{10^}@mathit{(b x)} @tfn{10^}@mathit{(c y)}.
24439 Exponential (alternate notation). @tfn{exp}@mathit{(a + b x + c y)}.
24441 Base-10 exponential (alternate). @tfn{10^}@mathit{(a + b x + c y)}.
24443 Logarithmic. @mathit{a + b} @tfn{ln}@mathit{(x) + c} @tfn{ln}@mathit{(y)}.
24445 Base-10 logarithmic. @mathit{a + b} @tfn{log10}@mathit{(x) + c} @tfn{log10}@mathit{(y)}.
24447 General exponential. @mathit{a b^x c^y}.
24449 Power law. @mathit{a x^b y^c}.
24451 Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}.
24454 @texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}.
24455 @infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
24457 Logistic @emph{s} curve.
24458 @texline @math{a/(1+e^{b(x-c)})}.
24459 @infoline @mathit{a/(1 + exp(b (x - c)))}.
24461 Logistic bell curve.
24462 @texline @math{ae^{b(x-c)}/(1+e^{b(x-c)})^2}.
24463 @infoline @mathit{a exp(b (x - c))/(1 + exp(b (x - c)))^2}.
24465 Hubbert linearization.
24466 @texline @math{{y \over x} = a(1-x/b)}.
24467 @infoline @mathit{(y/x) = a (1 - x/b)}.
24470 All of these models are used in the usual way; just press the appropriate
24471 letter at the model prompt, and choose variable names if you wish. The
24472 result will be a formula as shown in the above table, with the best-fit
24473 values of the parameters substituted. (You may find it easier to read
24474 the parameter values from the vector that is placed in the trail.)
24476 All models except Gaussian, logistics, Hubbert and polynomials can
24477 generalize as shown to any number of independent variables. Also, all
24478 the built-in models except for the logistic and Hubbert curves have an
24479 additive or multiplicative parameter shown as @expr{a} in the above table
24480 which can be replaced by zero or one, as appropriate, by typing @kbd{h}
24481 before the model key.
24483 Note that many of these models are essentially equivalent, but express
24484 the parameters slightly differently. For example, @expr{a b^x} and
24485 the other two exponential models are all algebraic rearrangements of
24486 each other. Also, the ``quadratic'' model is just a degree-2 polynomial
24487 with the parameters expressed differently. Use whichever form best
24488 matches the problem.
24490 The HP-28/48 calculators support four different models for curve
24491 fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
24492 These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
24493 @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case,
24494 @expr{a} is what the HP-48 identifies as the ``intercept,'' and
24495 @expr{b} is what it calls the ``slope.''
24501 If the model you want doesn't appear on this list, press @kbd{'}
24502 (the apostrophe key) at the model prompt to enter any algebraic
24503 formula, such as @kbd{m x - b}, as the model. (Not all models
24504 will work, though---see the next section for details.)
24506 The model can also be an equation like @expr{y = m x + b}.
24507 In this case, Calc thinks of all the rows of the data matrix on
24508 equal terms; this model effectively has two parameters
24509 (@expr{m} and @expr{b}) and two independent variables (@expr{x}
24510 and @expr{y}), with no ``dependent'' variables. Model equations
24511 do not need to take this @expr{y =} form. For example, the
24512 implicit line equation @expr{a x + b y = 1} works fine as a
24515 When you enter a model, Calc makes an alphabetical list of all
24516 the variables that appear in the model. These are used for the
24517 default parameters, independent variables, and dependent variable
24518 (in that order). If you enter a plain formula (not an equation),
24519 Calc assumes the dependent variable does not appear in the formula
24520 and thus does not need a name.
24522 For example, if the model formula has the variables @expr{a,mu,sigma,t,x},
24523 and the data matrix has three rows (meaning two independent variables),
24524 Calc will use @expr{a,mu,sigma} as the default parameters, and the
24525 data rows will be named @expr{t} and @expr{x}, respectively. If you
24526 enter an equation instead of a plain formula, Calc will use @expr{a,mu}
24527 as the parameters, and @expr{sigma,t,x} as the three independent
24530 You can, of course, override these choices by entering something
24531 different at the prompt. If you leave some variables out of the list,
24532 those variables must have stored values and those stored values will
24533 be used as constants in the model. (Stored values for the parameters
24534 and independent variables are ignored by the @kbd{a F} command.)
24535 If you list only independent variables, all the remaining variables
24536 in the model formula will become parameters.
24538 If there are @kbd{$} signs in the model you type, they will stand
24539 for parameters and all other variables (in alphabetical order)
24540 will be independent. Use @kbd{$} for one parameter, @kbd{$$} for
24541 another, and so on. Thus @kbd{$ x + $$} is another way to describe
24544 If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
24545 Calc will take the model formula from the stack. (The data must then
24546 appear at the second stack level.) The same conventions are used to
24547 choose which variables in the formula are independent by default and
24548 which are parameters.
24550 Models taken from the stack can also be expressed as vectors of
24551 two or three elements, @expr{[@var{model}, @var{vars}]} or
24552 @expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars}
24553 and @var{params} may be either a variable or a vector of variables.
24554 (If @var{params} is omitted, all variables in @var{model} except
24555 those listed as @var{vars} are parameters.)
24557 When you enter a model manually with @kbd{'}, Calc puts a 3-vector
24558 describing the model in the trail so you can get it back if you wish.
24566 Finally, you can store a model in one of the Calc variables
24567 @code{Model1} or @code{Model2}, then use this model by typing
24568 @kbd{a F u} or @kbd{a F U} (respectively). The value stored in
24569 the variable can be any of the formats that @kbd{a F $} would
24570 accept for a model on the stack.
24576 Calc uses the principal values of inverse functions like @code{ln}
24577 and @code{arcsin} when doing fits. For example, when you enter
24578 the model @samp{y = sin(a t + b)} Calc actually uses the easier
24579 form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always
24580 returns results in the range from @mathit{-90} to 90 degrees (or the
24581 equivalent range in radians). Suppose you had data that you
24582 believed to represent roughly three oscillations of a sine wave,
24583 so that the argument of the sine might go from zero to
24584 @texline @math{3\times360}
24585 @infoline @mathit{3*360}
24587 The above model would appear to be a good way to determine the
24588 true frequency and phase of the sine wave, but in practice it
24589 would fail utterly. The righthand side of the actual model
24590 @samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but
24591 the lefthand side will bounce back and forth between @mathit{-90} and 90.
24592 No values of @expr{a} and @expr{b} can make the two sides match,
24593 even approximately.
24595 There is no good solution to this problem at present. You could
24596 restrict your data to small enough ranges so that the above problem
24597 doesn't occur (i.e., not straddling any peaks in the sine wave).
24598 Or, in this case, you could use a totally different method such as
24599 Fourier analysis, which is beyond the scope of the @kbd{a F} command.
24600 (Unfortunately, Calc does not currently have any facilities for
24601 taking Fourier and related transforms.)
24603 @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
24604 @subsection Curve Fitting Details
24607 Calc's internal least-squares fitter can only handle multilinear
24608 models. More precisely, it can handle any model of the form
24609 @expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c}
24610 are the parameters and @expr{x,y,z} are the independent variables
24611 (of course there can be any number of each, not just three).
24613 In a simple multilinear or polynomial fit, it is easy to see how
24614 to convert the model into this form. For example, if the model
24615 is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x},
24616 and @expr{h(x) = x^2} are suitable functions.
24618 For most other models, Calc uses a variety of algebraic manipulations
24619 to try to put the problem into the form
24622 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)
24626 where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes
24627 @expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points,
24628 does a standard linear fit to find the values of @expr{A}, @expr{B},
24629 and @expr{C}, then uses the equation solver to solve for @expr{a,b,c}
24630 in terms of @expr{A,B,C}.
24632 A remarkable number of models can be cast into this general form.
24633 We'll look at two examples here to see how it works. The power-law
24634 model @expr{y = a x^b} with two independent variables and two parameters
24635 can be rewritten as follows:
24640 y = exp(ln(a) + b ln(x))
24641 ln(y) = ln(a) + b ln(x)
24645 which matches the desired form with
24646 @texline @math{Y = \ln(y)},
24647 @infoline @expr{Y = ln(y)},
24648 @texline @math{A = \ln(a)},
24649 @infoline @expr{A = ln(a)},
24650 @expr{F = 1}, @expr{B = b}, and
24651 @texline @math{G = \ln(x)}.
24652 @infoline @expr{G = ln(x)}.
24653 Calc thus computes the logarithms of your @expr{y} and @expr{x} values,
24654 does a linear fit for @expr{A} and @expr{B}, then solves to get
24655 @texline @math{a = \exp(A)}
24656 @infoline @expr{a = exp(A)}
24659 Another interesting example is the ``quadratic'' model, which can
24660 be handled by expanding according to the distributive law.
24663 y = a + b*(x - c)^2
24664 y = a + b c^2 - 2 b c x + b x^2
24668 which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1},
24669 @expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily
24670 have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and
24673 The Gaussian model looks quite complicated, but a closer examination
24674 shows that it's actually similar to the quadratic model but with an
24675 exponential that can be brought to the top and moved into @expr{Y}.
24677 The logistic models cannot be put into general linear form. For these
24678 models, and the Hubbert linearization, Calc computes a rough
24679 approximation for the parameters, then uses the Levenberg-Marquardt
24680 iterative method to refine the approximations.
24682 Another model that cannot be put into general linear
24683 form is a Gaussian with a constant background added on, i.e.,
24684 @expr{d} + the regular Gaussian formula. If you have a model like
24685 this, your best bet is to replace enough of your parameters with
24686 constants to make the model linearizable, then adjust the constants
24687 manually by doing a series of fits. You can compare the fits by
24688 graphing them, by examining the goodness-of-fit measures returned by
24689 @kbd{I a F}, or by some other method suitable to your application.
24690 Note that some models can be linearized in several ways. The
24691 Gaussian-plus-@var{d} model can be linearized by setting @expr{d}
24692 (the background) to a constant, or by setting @expr{b} (the standard
24693 deviation) and @expr{c} (the mean) to constants.
24695 To fit a model with constants substituted for some parameters, just
24696 store suitable values in those parameter variables, then omit them
24697 from the list of parameters when you answer the variables prompt.
24703 A last desperate step would be to use the general-purpose
24704 @code{minimize} function rather than @code{fit}. After all, both
24705 functions solve the problem of minimizing an expression (the
24706 @texline @math{\chi^2}
24707 @infoline @expr{chi^2}
24708 sum) by adjusting certain parameters in the expression. The @kbd{a F}
24709 command is able to use a vastly more efficient algorithm due to its
24710 special knowledge about linear chi-square sums, but the @kbd{a N}
24711 command can do the same thing by brute force.
24713 A compromise would be to pick out a few parameters without which the
24714 fit is linearizable, and use @code{minimize} on a call to @code{fit}
24715 which efficiently takes care of the rest of the parameters. The thing
24716 to be minimized would be the value of
24717 @texline @math{\chi^2}
24718 @infoline @expr{chi^2}
24719 returned as the fifth result of the @code{xfit} function:
24722 minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
24726 where @code{gaus} represents the Gaussian model with background,
24727 @code{data} represents the data matrix, and @code{guess} represents
24728 the initial guess for @expr{d} that @code{minimize} requires.
24729 This operation will only be, shall we say, extraordinarily slow
24730 rather than astronomically slow (as would be the case if @code{minimize}
24731 were used by itself to solve the problem).
24737 The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
24738 nonlinear models are used. The second item in the result is the
24739 vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The
24740 covariance matrix is written in terms of those raw parameters.
24741 The fifth item is a vector of @dfn{filter} expressions. This
24742 is the empty vector @samp{[]} if the raw parameters were the same
24743 as the requested parameters, i.e., if @expr{A = a}, @expr{B = b},
24744 and so on (which is always true if the model is already linear
24745 in the parameters as written, e.g., for polynomial fits). If the
24746 parameters had to be rearranged, the fifth item is instead a vector
24747 of one formula per parameter in the original model. The raw
24748 parameters are expressed in these ``filter'' formulas as
24749 @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B},
24752 When Calc needs to modify the model to return the result, it replaces
24753 @samp{fitdummy(1)} in all the filters with the first item in the raw
24754 parameters list, and so on for the other raw parameters, then
24755 evaluates the resulting filter formulas to get the actual parameter
24756 values to be substituted into the original model. In the case of
24757 @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
24758 Calc uses the square roots of the diagonal entries of the covariance
24759 matrix as error values for the raw parameters, then lets Calc's
24760 standard error-form arithmetic take it from there.
24762 If you use @kbd{I a F} with a nonlinear model, be sure to remember
24763 that the covariance matrix is in terms of the raw parameters,
24764 @emph{not} the actual requested parameters. It's up to you to
24765 figure out how to interpret the covariances in the presence of
24766 nontrivial filter functions.
24768 Things are also complicated when the input contains error forms.
24769 Suppose there are three independent and dependent variables, @expr{x},
24770 @expr{y}, and @expr{z}, one or more of which are error forms in the
24771 data. Calc combines all the error values by taking the square root
24772 of the sum of the squares of the errors. It then changes @expr{x}
24773 and @expr{y} to be plain numbers, and makes @expr{z} into an error
24774 form with this combined error. The @expr{Y(x,y,z)} part of the
24775 linearized model is evaluated, and the result should be an error
24776 form. The error part of that result is used for
24777 @texline @math{\sigma_i}
24778 @infoline @expr{sigma_i}
24779 for the data point. If for some reason @expr{Y(x,y,z)} does not return
24780 an error form, the combined error from @expr{z} is used directly for
24781 @texline @math{\sigma_i}.
24782 @infoline @expr{sigma_i}.
24783 Finally, @expr{z} is also stripped of its error
24784 for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on;
24785 the righthand side of the linearized model is computed in regular
24786 arithmetic with no error forms.
24788 (While these rules may seem complicated, they are designed to do
24789 the most reasonable thing in the typical case that @expr{Y(x,y,z)}
24790 depends only on the dependent variable @expr{z}, and in fact is
24791 often simply equal to @expr{z}. For common cases like polynomials
24792 and multilinear models, the combined error is simply used as the
24793 @texline @math{\sigma}
24794 @infoline @expr{sigma}
24795 for the data point with no further ado.)
24802 It may be the case that the model you wish to use is linearizable,
24803 but Calc's built-in rules are unable to figure it out. Calc uses
24804 its algebraic rewrite mechanism to linearize a model. The rewrite
24805 rules are kept in the variable @code{FitRules}. You can edit this
24806 variable using the @kbd{s e FitRules} command; in fact, there is
24807 a special @kbd{s F} command just for editing @code{FitRules}.
24808 @xref{Operations on Variables}.
24810 @xref{Rewrite Rules}, for a discussion of rewrite rules.
24844 Calc uses @code{FitRules} as follows. First, it converts the model
24845 to an equation if necessary and encloses the model equation in a
24846 call to the function @code{fitmodel} (which is not actually a defined
24847 function in Calc; it is only used as a placeholder by the rewrite rules).
24848 Parameter variables are renamed to function calls @samp{fitparam(1)},
24849 @samp{fitparam(2)}, and so on, and independent variables are renamed
24850 to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable
24851 is the highest-numbered @code{fitvar}. For example, the power law
24852 model @expr{a x^b} is converted to @expr{y = a x^b}, then to
24856 fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
24860 Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
24861 (The zero prefix means that rewriting should continue until no further
24862 changes are possible.)
24864 When rewriting is complete, the @code{fitmodel} call should have
24865 been replaced by a @code{fitsystem} call that looks like this:
24868 fitsystem(@var{Y}, @var{FGH}, @var{abc})
24872 where @var{Y} is a formula that describes the function @expr{Y(x,y,z)},
24873 @var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]},
24874 and @var{abc} is the vector of parameter filters which refer to the
24875 raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)}
24876 for @expr{B}, etc. While the number of raw parameters (the length of
24877 the @var{FGH} vector) is usually the same as the number of original
24878 parameters (the length of the @var{abc} vector), this is not required.
24880 The power law model eventually boils down to
24884 fitsystem(ln(fitvar(2)),
24885 [1, ln(fitvar(1))],
24886 [exp(fitdummy(1)), fitdummy(2)])
24890 The actual implementation of @code{FitRules} is complicated; it
24891 proceeds in four phases. First, common rearrangements are done
24892 to try to bring linear terms together and to isolate functions like
24893 @code{exp} and @code{ln} either all the way ``out'' (so that they
24894 can be put into @var{Y}) or all the way ``in'' (so that they can
24895 be put into @var{abc} or @var{FGH}). In particular, all
24896 non-constant powers are converted to logs-and-exponentials form,
24897 and the distributive law is used to expand products of sums.
24898 Quotients are rewritten to use the @samp{fitinv} function, where
24899 @samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules}
24900 are operating. (The use of @code{fitinv} makes recognition of
24901 linear-looking forms easier.) If you modify @code{FitRules}, you
24902 will probably only need to modify the rules for this phase.
24904 Phase two, whose rules can actually also apply during phases one
24905 and three, first rewrites @code{fitmodel} to a two-argument
24906 form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
24907 initially zero and @var{model} has been changed from @expr{a=b}
24908 to @expr{a-b} form. It then tries to peel off invertible functions
24909 from the outside of @var{model} and put them into @var{Y} instead,
24910 calling the equation solver to invert the functions. Finally, when
24911 this is no longer possible, the @code{fitmodel} is changed to a
24912 four-argument @code{fitsystem}, where the fourth argument is
24913 @var{model} and the @var{FGH} and @var{abc} vectors are initially
24914 empty. (The last vector is really @var{ABC}, corresponding to
24915 raw parameters, for now.)
24917 Phase three converts a sum of items in the @var{model} to a sum
24918 of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
24919 terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
24920 is all factors that do not involve any variables, @var{b} is all
24921 factors that involve only parameters, and @var{c} is the factors
24922 that involve only independent variables. (If this decomposition
24923 is not possible, the rule set will not complete and Calc will
24924 complain that the model is too complex.) Then @code{fitpart}s
24925 with equal @var{b} or @var{c} components are merged back together
24926 using the distributive law in order to minimize the number of
24927 raw parameters needed.
24929 Phase four moves the @code{fitpart} terms into the @var{FGH} and
24930 @var{ABC} vectors. Also, some of the algebraic expansions that
24931 were done in phase 1 are undone now to make the formulas more
24932 computationally efficient. Finally, it calls the solver one more
24933 time to convert the @var{ABC} vector to an @var{abc} vector, and
24934 removes the fourth @var{model} argument (which by now will be zero)
24935 to obtain the three-argument @code{fitsystem} that the linear
24936 least-squares solver wants to see.
24942 @mindex hasfit@idots
24944 @tindex hasfitparams
24952 Two functions which are useful in connection with @code{FitRules}
24953 are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
24954 whether @expr{x} refers to any parameters or independent variables,
24955 respectively. Specifically, these functions return ``true'' if the
24956 argument contains any @code{fitparam} (or @code{fitvar}) function
24957 calls, and ``false'' otherwise. (Recall that ``true'' means a
24958 nonzero number, and ``false'' means zero. The actual nonzero number
24959 returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
24960 or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
24966 The @code{fit} function in algebraic notation normally takes four
24967 arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
24968 where @var{model} is the model formula as it would be typed after
24969 @kbd{a F '}, @var{vars} is the independent variable or a vector of
24970 independent variables, @var{params} likewise gives the parameter(s),
24971 and @var{data} is the data matrix. Note that the length of @var{vars}
24972 must be equal to the number of rows in @var{data} if @var{model} is
24973 an equation, or one less than the number of rows if @var{model} is
24974 a plain formula. (Actually, a name for the dependent variable is
24975 allowed but will be ignored in the plain-formula case.)
24977 If @var{params} is omitted, the parameters are all variables in
24978 @var{model} except those that appear in @var{vars}. If @var{vars}
24979 is also omitted, Calc sorts all the variables that appear in
24980 @var{model} alphabetically and uses the higher ones for @var{vars}
24981 and the lower ones for @var{params}.
24983 Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
24984 where @var{modelvec} is a 2- or 3-vector describing the model
24985 and variables, as discussed previously.
24987 If Calc is unable to do the fit, the @code{fit} function is left
24988 in symbolic form, ordinarily with an explanatory message. The
24989 message will be ``Model expression is too complex'' if the
24990 linearizer was unable to put the model into the required form.
24992 The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
24993 (for @kbd{I a F}) functions are completely analogous.
24995 @node Interpolation, , Curve Fitting Details, Curve Fitting
24996 @subsection Polynomial Interpolation
24999 @pindex calc-poly-interp
25001 The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
25002 a polynomial interpolation at a particular @expr{x} value. It takes
25003 two arguments from the stack: A data matrix of the sort used by
25004 @kbd{a F}, and a single number which represents the desired @expr{x}
25005 value. Calc effectively does an exact polynomial fit as if by @kbd{a F i},
25006 then substitutes the @expr{x} value into the result in order to get an
25007 approximate @expr{y} value based on the fit. (Calc does not actually
25008 use @kbd{a F i}, however; it uses a direct method which is both more
25009 efficient and more numerically stable.)
25011 The result of @kbd{a p} is actually a vector of two values: The @expr{y}
25012 value approximation, and an error measure @expr{dy} that reflects Calc's
25013 estimation of the probable error of the approximation at that value of
25014 @expr{x}. If the input @expr{x} is equal to any of the @expr{x} values
25015 in the data matrix, the output @expr{y} will be the corresponding @expr{y}
25016 value from the matrix, and the output @expr{dy} will be exactly zero.
25018 A prefix argument of 2 causes @kbd{a p} to take separate x- and
25019 y-vectors from the stack instead of one data matrix.
25021 If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of
25022 interpolated results for each of those @expr{x} values. (The matrix will
25023 have two columns, the @expr{y} values and the @expr{dy} values.)
25024 If @expr{x} is a formula instead of a number, the @code{polint} function
25025 remains in symbolic form; use the @kbd{a "} command to expand it out to
25026 a formula that describes the fit in symbolic terms.
25028 In all cases, the @kbd{a p} command leaves the data vectors or matrix
25029 on the stack. Only the @expr{x} value is replaced by the result.
25033 The @kbd{H a p} [@code{ratint}] command does a rational function
25034 interpolation. It is used exactly like @kbd{a p}, except that it
25035 uses as its model the quotient of two polynomials. If there are
25036 @expr{N} data points, the numerator and denominator polynomials will
25037 each have degree @expr{N/2} (if @expr{N} is odd, the denominator will
25038 have degree one higher than the numerator).
25040 Rational approximations have the advantage that they can accurately
25041 describe functions that have poles (points at which the function's value
25042 goes to infinity, so that the denominator polynomial of the approximation
25043 goes to zero). If @expr{x} corresponds to a pole of the fitted rational
25044 function, then the result will be a division by zero. If Infinite mode
25045 is enabled, the result will be @samp{[uinf, uinf]}.
25047 There is no way to get the actual coefficients of the rational function
25048 used by @kbd{H a p}. (The algorithm never generates these coefficients
25049 explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
25050 capabilities to fit.)
25052 @node Summations, Logical Operations, Curve Fitting, Algebra
25053 @section Summations
25056 @cindex Summation of a series
25058 @pindex calc-summation
25060 The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
25061 the sum of a formula over a certain range of index values. The formula
25062 is taken from the top of the stack; the command prompts for the
25063 name of the summation index variable, the lower limit of the
25064 sum (any formula), and the upper limit of the sum. If you
25065 enter a blank line at any of these prompts, that prompt and
25066 any later ones are answered by reading additional elements from
25067 the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
25068 produces the result 55.
25071 $$ \sum_{k=1}^5 k^2 = 55 $$
25074 The choice of index variable is arbitrary, but it's best not to
25075 use a variable with a stored value. In particular, while
25076 @code{i} is often a favorite index variable, it should be avoided
25077 in Calc because @code{i} has the imaginary constant @expr{(0, 1)}
25078 as a value. If you pressed @kbd{=} on a sum over @code{i}, it would
25079 be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}!
25080 If you really want to use @code{i} as an index variable, use
25081 @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
25082 (@xref{Storing Variables}.)
25084 A numeric prefix argument steps the index by that amount rather
25085 than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
25086 yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix
25087 argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
25088 step value, in which case you can enter any formula or enter
25089 a blank line to take the step value from the stack. With the
25090 @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
25091 the stack: The formula, the variable, the lower limit, the
25092 upper limit, and (at the top of the stack), the step value.
25094 Calc knows how to do certain sums in closed form. For example,
25095 @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular,
25096 this is possible if the formula being summed is polynomial or
25097 exponential in the index variable. Sums of logarithms are
25098 transformed into logarithms of products. Sums of trigonometric
25099 and hyperbolic functions are transformed to sums of exponentials
25100 and then done in closed form. Also, of course, sums in which the
25101 lower and upper limits are both numbers can always be evaluated
25102 just by grinding them out, although Calc will use closed forms
25103 whenever it can for the sake of efficiency.
25105 The notation for sums in algebraic formulas is
25106 @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
25107 If @var{step} is omitted, it defaults to one. If @var{high} is
25108 omitted, @var{low} is actually the upper limit and the lower limit
25109 is one. If @var{low} is also omitted, the limits are @samp{-inf}
25110 and @samp{inf}, respectively.
25112 Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)}
25113 returns @expr{1}. This is done by evaluating the sum in closed
25114 form (to @samp{1. - 0.5^n} in this case), then evaluating this
25115 formula with @code{n} set to @code{inf}. Calc's usual rules
25116 for ``infinite'' arithmetic can find the answer from there. If
25117 infinite arithmetic yields a @samp{nan}, or if the sum cannot be
25118 solved in closed form, Calc leaves the @code{sum} function in
25119 symbolic form. @xref{Infinities}.
25121 As a special feature, if the limits are infinite (or omitted, as
25122 described above) but the formula includes vectors subscripted by
25123 expressions that involve the iteration variable, Calc narrows
25124 the limits to include only the range of integers which result in
25125 valid subscripts for the vector. For example, the sum
25126 @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
25128 The limits of a sum do not need to be integers. For example,
25129 @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
25130 Calc computes the number of iterations using the formula
25131 @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
25132 after simplification as if by @kbd{a s}, evaluate to an integer.
25134 If the number of iterations according to the above formula does
25135 not come out to an integer, the sum is invalid and will be left
25136 in symbolic form. However, closed forms are still supplied, and
25137 you are on your honor not to misuse the resulting formulas by
25138 substituting mismatched bounds into them. For example,
25139 @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
25140 evaluate the closed form solution for the limits 1 and 10 to get
25141 the rather dubious answer, 29.25.
25143 If the lower limit is greater than the upper limit (assuming a
25144 positive step size), the result is generally zero. However,
25145 Calc only guarantees a zero result when the upper limit is
25146 exactly one step less than the lower limit, i.e., if the number
25147 of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero
25148 but the sum from @samp{n} to @samp{n-2} may report a nonzero value
25149 if Calc used a closed form solution.
25151 Calc's logical predicates like @expr{a < b} return 1 for ``true''
25152 and 0 for ``false.'' @xref{Logical Operations}. This can be
25153 used to advantage for building conditional sums. For example,
25154 @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
25155 prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
25156 its argument is prime and 0 otherwise. You can read this expression
25157 as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed,
25158 @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
25159 squared, since the limits default to plus and minus infinity, but
25160 there are no such sums that Calc's built-in rules can do in
25163 As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
25164 sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding
25165 one value @expr{k_0}. Slightly more tricky is the summand
25166 @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
25167 the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where
25168 this would be a division by zero. But at @expr{k = k_0}, this
25169 formula works out to the indeterminate form @expr{0 / 0}, which
25170 Calc will not assume is zero. Better would be to use
25171 @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
25172 an ``if-then-else'' test: This expression says, ``if
25173 @texline @math{k \ne k_0},
25174 @infoline @expr{k != k_0},
25175 then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)}
25176 will not even be evaluated by Calc when @expr{k = k_0}.
25178 @cindex Alternating sums
25180 @pindex calc-alt-summation
25182 The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
25183 computes an alternating sum. Successive terms of the sequence
25184 are given alternating signs, with the first term (corresponding
25185 to the lower index value) being positive. Alternating sums
25186 are converted to normal sums with an extra term of the form
25187 @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately
25188 if the step value is other than one. For example, the Taylor
25189 series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
25190 (Calc cannot evaluate this infinite series, but it can approximate
25191 it if you replace @code{inf} with any particular odd number.)
25192 Calc converts this series to a regular sum with a step of one,
25193 namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
25195 @cindex Product of a sequence
25197 @pindex calc-product
25199 The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
25200 the analogous way to take a product of many terms. Calc also knows
25201 some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
25202 Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
25203 or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
25206 @pindex calc-tabulate
25208 The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
25209 evaluates a formula at a series of iterated index values, just
25210 like @code{sum} and @code{prod}, but its result is simply a
25211 vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)}
25212 produces @samp{[a_1, a_3, a_5, a_7]}.
25214 @node Logical Operations, Rewrite Rules, Summations, Algebra
25215 @section Logical Operations
25218 The following commands and algebraic functions return true/false values,
25219 where 1 represents ``true'' and 0 represents ``false.'' In cases where
25220 a truth value is required (such as for the condition part of a rewrite
25221 rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
25222 nonzero value is accepted to mean ``true.'' (Specifically, anything
25223 for which @code{dnonzero} returns 1 is ``true,'' and anything for
25224 which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
25225 Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
25226 portion if its condition is provably true, but it will execute the
25227 ``else'' portion for any condition like @expr{a = b} that is not
25228 provably true, even if it might be true. Algebraic functions that
25229 have conditions as arguments, like @code{? :} and @code{&&}, remain
25230 unevaluated if the condition is neither provably true nor provably
25231 false. @xref{Declarations}.)
25234 @pindex calc-equal-to
25238 The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
25239 (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
25240 formula) is true if @expr{a} and @expr{b} are equal, either because they
25241 are identical expressions, or because they are numbers which are
25242 numerically equal. (Thus the integer 1 is considered equal to the float
25243 1.0.) If the equality of @expr{a} and @expr{b} cannot be determined,
25244 the comparison is left in symbolic form. Note that as a command, this
25245 operation pops two values from the stack and pushes back either a 1 or
25246 a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
25248 Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
25249 For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
25250 an equation to solve for a given variable. The @kbd{a M}
25251 (@code{calc-map-equation}) command can be used to apply any
25252 function to both sides of an equation; for example, @kbd{2 a M *}
25253 multiplies both sides of the equation by two. Note that just
25254 @kbd{2 *} would not do the same thing; it would produce the formula
25255 @samp{2 (a = b)} which represents 2 if the equality is true or
25258 The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
25259 or @samp{a = b = c}) tests if all of its arguments are equal. In
25260 algebraic notation, the @samp{=} operator is unusual in that it is
25261 neither left- nor right-associative: @samp{a = b = c} is not the
25262 same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
25263 one variable with the 1 or 0 that results from comparing two other
25267 @pindex calc-not-equal-to
25270 The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
25271 @samp{a != b} function, is true if @expr{a} and @expr{b} are not equal.
25272 This also works with more than two arguments; @samp{a != b != c != d}
25273 tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are
25290 @pindex calc-less-than
25291 @pindex calc-greater-than
25292 @pindex calc-less-equal
25293 @pindex calc-greater-equal
25322 The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
25323 operation is true if @expr{a} is less than @expr{b}. Similar functions
25324 are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
25325 @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
25326 @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
25328 While the inequality functions like @code{lt} do not accept more
25329 than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
25330 equivalent expression involving intervals: @samp{b in [a .. c)}.
25331 (See the description of @code{in} below.) All four combinations
25332 of @samp{<} and @samp{<=} are allowed, or any of the four combinations
25333 of @samp{>} and @samp{>=}. Four-argument constructions like
25334 @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
25335 involve both equalities and inequalities, are not allowed.
25338 @pindex calc-remove-equal
25340 The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
25341 the righthand side of the equation or inequality on the top of the
25342 stack. It also works elementwise on vectors. For example, if
25343 @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
25344 @samp{[2.34, z / 2]}. As a special case, if the righthand side is a
25345 variable and the lefthand side is a number (as in @samp{2.34 = x}), then
25346 Calc keeps the lefthand side instead. Finally, this command works with
25347 assignments @samp{x := 2.34} as well as equations, always taking the
25348 righthand side, and for @samp{=>} (evaluates-to) operators, always
25349 taking the lefthand side.
25352 @pindex calc-logical-and
25355 The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
25356 function is true if both of its arguments are true, i.e., are
25357 non-zero numbers. In this case, the result will be either @expr{a} or
25358 @expr{b}, chosen arbitrarily. If either argument is zero, the result is
25359 zero. Otherwise, the formula is left in symbolic form.
25362 @pindex calc-logical-or
25365 The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
25366 function is true if either or both of its arguments are true (nonzero).
25367 The result is whichever argument was nonzero, choosing arbitrarily if both
25368 are nonzero. If both @expr{a} and @expr{b} are zero, the result is
25372 @pindex calc-logical-not
25375 The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
25376 function is true if @expr{a} is false (zero), or false if @expr{a} is
25377 true (nonzero). It is left in symbolic form if @expr{a} is not a
25381 @pindex calc-logical-if
25391 @cindex Arguments, not evaluated
25392 The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
25393 function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero
25394 number or zero, respectively. If @expr{a} is not a number, the test is
25395 left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in
25396 any way. In algebraic formulas, this is one of the few Calc functions
25397 whose arguments are not automatically evaluated when the function itself
25398 is evaluated. The others are @code{lambda}, @code{quote}, and
25401 One minor surprise to watch out for is that the formula @samp{a?3:4}
25402 will not work because the @samp{3:4} is parsed as a fraction instead of
25403 as three separate symbols. Type something like @samp{a ? 3 : 4} or
25404 @samp{a?(3):4} instead.
25406 As a special case, if @expr{a} evaluates to a vector, then both @expr{b}
25407 and @expr{c} are evaluated; the result is a vector of the same length
25408 as @expr{a} whose elements are chosen from corresponding elements of
25409 @expr{b} and @expr{c} according to whether each element of @expr{a}
25410 is zero or nonzero. Each of @expr{b} and @expr{c} must be either a
25411 vector of the same length as @expr{a}, or a non-vector which is matched
25412 with all elements of @expr{a}.
25415 @pindex calc-in-set
25417 The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
25418 the number @expr{a} is in the set of numbers represented by @expr{b}.
25419 If @expr{b} is an interval form, @expr{a} must be one of the values
25420 encompassed by the interval. If @expr{b} is a vector, @expr{a} must be
25421 equal to one of the elements of the vector. (If any vector elements are
25422 intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a
25423 plain number, @expr{a} must be numerically equal to @expr{b}.
25424 @xref{Set Operations}, for a group of commands that manipulate sets
25431 The @samp{typeof(a)} function produces an integer or variable which
25432 characterizes @expr{a}. If @expr{a} is a number, vector, or variable,
25433 the result will be one of the following numbers:
25438 3 Floating-point number
25440 5 Rectangular complex number
25441 6 Polar complex number
25447 12 Infinity (inf, uinf, or nan)
25449 101 Vector (but not a matrix)
25453 Otherwise, @expr{a} is a formula, and the result is a variable which
25454 represents the name of the top-level function call.
25468 The @samp{integer(a)} function returns true if @expr{a} is an integer.
25469 The @samp{real(a)} function
25470 is true if @expr{a} is a real number, either integer, fraction, or
25471 float. The @samp{constant(a)} function returns true if @expr{a} is
25472 any of the objects for which @code{typeof} would produce an integer
25473 code result except for variables, and provided that the components of
25474 an object like a vector or error form are themselves constant.
25475 Note that infinities do not satisfy any of these tests, nor do
25476 special constants like @code{pi} and @code{e}.
25478 @xref{Declarations}, for a set of similar functions that recognize
25479 formulas as well as actual numbers. For example, @samp{dint(floor(x))}
25480 is true because @samp{floor(x)} is provably integer-valued, but
25481 @samp{integer(floor(x))} does not because @samp{floor(x)} is not
25482 literally an integer constant.
25488 The @samp{refers(a,b)} function is true if the variable (or sub-expression)
25489 @expr{b} appears in @expr{a}, or false otherwise. Unlike the other
25490 tests described here, this function returns a definite ``no'' answer
25491 even if its arguments are still in symbolic form. The only case where
25492 @code{refers} will be left unevaluated is if @expr{a} is a plain
25493 variable (different from @expr{b}).
25499 The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative,
25500 because it is a negative number, because it is of the form @expr{-x},
25501 or because it is a product or quotient with a term that looks negative.
25502 This is most useful in rewrite rules. Beware that @samp{negative(a)}
25503 evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only
25504 be stored in a formula if the default simplifications are turned off
25505 first with @kbd{m O} (or if it appears in an unevaluated context such
25506 as a rewrite rule condition).
25512 The @samp{variable(a)} function is true if @expr{a} is a variable,
25513 or false if not. If @expr{a} is a function call, this test is left
25514 in symbolic form. Built-in variables like @code{pi} and @code{inf}
25515 are considered variables like any others by this test.
25521 The @samp{nonvar(a)} function is true if @expr{a} is a non-variable.
25522 If its argument is a variable it is left unsimplified; it never
25523 actually returns zero. However, since Calc's condition-testing
25524 commands consider ``false'' anything not provably true, this is
25543 @cindex Linearity testing
25544 The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
25545 check if an expression is ``linear,'' i.e., can be written in the form
25546 @expr{a + b x} for some constants @expr{a} and @expr{b}, and some
25547 variable or subformula @expr{x}. The function @samp{islin(f,x)} checks
25548 if formula @expr{f} is linear in @expr{x}, returning 1 if so. For
25549 example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
25550 @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function
25551 is similar, except that instead of returning 1 it returns the vector
25552 @expr{[a, b, x]}. For the above examples, this vector would be
25553 @expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and
25554 @expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin}
25555 generally remain unevaluated for expressions which are not linear,
25556 e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second
25557 argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
25560 The @code{linnt} and @code{islinnt} functions perform a similar check,
25561 but require a ``non-trivial'' linear form, which means that the
25562 @expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)}
25563 returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]},
25564 but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
25565 (in other words, these formulas are considered to be only ``trivially''
25566 linear in @expr{x}).
25568 All four linearity-testing functions allow you to omit the second
25569 argument, in which case the input may be linear in any non-constant
25570 formula. Here, the @expr{a=0}, @expr{b=1} case is also considered
25571 trivial, and only constant values for @expr{a} and @expr{b} are
25572 recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]},
25573 @samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)}
25574 returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the
25575 first two cases but not the third. Also, neither @code{lin} nor
25576 @code{linnt} accept plain constants as linear in the one-argument
25577 case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
25583 The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero
25584 number or provably nonzero formula, or 0 if @expr{a} is anything else.
25585 Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
25586 used to make sure they are not evaluated prematurely. (Note that
25587 declarations are used when deciding whether a formula is true;
25588 @code{istrue} returns 1 when @code{dnonzero} would return 1, and
25589 it returns 0 when @code{dnonzero} would return 0 or leave itself
25592 @node Rewrite Rules, , Logical Operations, Algebra
25593 @section Rewrite Rules
25596 @cindex Rewrite rules
25597 @cindex Transformations
25598 @cindex Pattern matching
25600 @pindex calc-rewrite
25602 The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
25603 substitutions in a formula according to a specified pattern or patterns
25604 known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute})
25605 matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
25606 matches only the @code{sin} function applied to the variable @code{x},
25607 rewrite rules match general kinds of formulas; rewriting using the rule
25608 @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
25609 it with @code{cos} of that same argument. The only significance of the
25610 name @code{x} is that the same name is used on both sides of the rule.
25612 Rewrite rules rearrange formulas already in Calc's memory.
25613 @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
25614 similar to algebraic rewrite rules but operate when new algebraic
25615 entries are being parsed, converting strings of characters into
25619 * Entering Rewrite Rules::
25620 * Basic Rewrite Rules::
25621 * Conditional Rewrite Rules::
25622 * Algebraic Properties of Rewrite Rules::
25623 * Other Features of Rewrite Rules::
25624 * Composing Patterns in Rewrite Rules::
25625 * Nested Formulas with Rewrite Rules::
25626 * Multi-Phase Rewrite Rules::
25627 * Selections with Rewrite Rules::
25628 * Matching Commands::
25629 * Automatic Rewrites::
25630 * Debugging Rewrites::
25631 * Examples of Rewrite Rules::
25634 @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
25635 @subsection Entering Rewrite Rules
25638 Rewrite rules normally use the ``assignment'' operator
25639 @samp{@var{old} := @var{new}}.
25640 This operator is equivalent to the function call @samp{assign(old, new)}.
25641 The @code{assign} function is undefined by itself in Calc, so an
25642 assignment formula such as a rewrite rule will be left alone by ordinary
25643 Calc commands. But certain commands, like the rewrite system, interpret
25644 assignments in special ways.
25646 For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
25647 every occurrence of the sine of something, squared, with one minus the
25648 square of the cosine of that same thing. All by itself as a formula
25649 on the stack it does nothing, but when given to the @kbd{a r} command
25650 it turns that command into a sine-squared-to-cosine-squared converter.
25652 To specify a set of rules to be applied all at once, make a vector of
25655 When @kbd{a r} prompts you to enter the rewrite rules, you can answer
25660 With a rule: @kbd{f(x) := g(x) @key{RET}}.
25662 With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
25663 (You can omit the enclosing square brackets if you wish.)
25665 With the name of a variable that contains the rule or rules vector:
25666 @kbd{myrules @key{RET}}.
25668 With any formula except a rule, a vector, or a variable name; this
25669 will be interpreted as the @var{old} half of a rewrite rule,
25670 and you will be prompted a second time for the @var{new} half:
25671 @kbd{f(x) @key{RET} g(x) @key{RET}}.
25673 With a blank line, in which case the rule, rules vector, or variable
25674 will be taken from the top of the stack (and the formula to be
25675 rewritten will come from the second-to-top position).
25678 If you enter the rules directly (as opposed to using rules stored
25679 in a variable), those rules will be put into the Trail so that you
25680 can retrieve them later. @xref{Trail Commands}.
25682 It is most convenient to store rules you use often in a variable and
25683 invoke them by giving the variable name. The @kbd{s e}
25684 (@code{calc-edit-variable}) command is an easy way to create or edit a
25685 rule set stored in a variable. You may also wish to use @kbd{s p}
25686 (@code{calc-permanent-variable}) to save your rules permanently;
25687 @pxref{Operations on Variables}.
25689 Rewrite rules are compiled into a special internal form for faster
25690 matching. If you enter a rule set directly it must be recompiled
25691 every time. If you store the rules in a variable and refer to them
25692 through that variable, they will be compiled once and saved away
25693 along with the variable for later reference. This is another good
25694 reason to store your rules in a variable.
25696 Calc also accepts an obsolete notation for rules, as vectors
25697 @samp{[@var{old}, @var{new}]}. But because it is easily confused with a
25698 vector of two rules, the use of this notation is no longer recommended.
25700 @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
25701 @subsection Basic Rewrite Rules
25704 To match a particular formula @expr{x} with a particular rewrite rule
25705 @samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with
25706 the structure of @var{old}. Variables that appear in @var{old} are
25707 treated as @dfn{meta-variables}; the corresponding positions in @expr{x}
25708 may contain any sub-formulas. For example, the pattern @samp{f(x,y)}
25709 would match the expression @samp{f(12, a+1)} with the meta-variable
25710 @samp{x} corresponding to 12 and with @samp{y} corresponding to
25711 @samp{a+1}. However, this pattern would not match @samp{f(12)} or
25712 @samp{g(12, a+1)}, since there is no assignment of the meta-variables
25713 that will make the pattern match these expressions. Notice that if
25714 the pattern is a single meta-variable, it will match any expression.
25716 If a given meta-variable appears more than once in @var{old}, the
25717 corresponding sub-formulas of @expr{x} must be identical. Thus
25718 the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
25719 @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
25720 (@xref{Conditional Rewrite Rules}, for a way to match the latter.)
25722 Things other than variables must match exactly between the pattern
25723 and the target formula. To match a particular variable exactly, use
25724 the pseudo-function @samp{quote(v)} in the pattern. For example, the
25725 pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
25728 The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
25729 @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
25730 literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like
25731 @samp{sin(d + quote(e) + f)}.
25733 If the @var{old} pattern is found to match a given formula, that
25734 formula is replaced by @var{new}, where any occurrences in @var{new}
25735 of meta-variables from the pattern are replaced with the sub-formulas
25736 that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
25737 to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
25739 The normal @kbd{a r} command applies rewrite rules over and over
25740 throughout the target formula until no further changes are possible
25741 (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one
25744 @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
25745 @subsection Conditional Rewrite Rules
25748 A rewrite rule can also be @dfn{conditional}, written in the form
25749 @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete
25750 form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part
25752 rule, this is an additional condition that must be satisfied before
25753 the rule is accepted. Once @var{old} has been successfully matched
25754 to the target expression, @var{cond} is evaluated (with all the
25755 meta-variables substituted for the values they matched) and simplified
25756 with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero
25757 number or any other object known to be nonzero (@pxref{Declarations}),
25758 the rule is accepted. If the result is zero or if it is a symbolic
25759 formula that is not known to be nonzero, the rule is rejected.
25760 @xref{Logical Operations}, for a number of functions that return
25761 1 or 0 according to the results of various tests.
25763 For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n}
25764 is replaced by a positive or nonpositive number, respectively (or if
25765 @expr{n} has been declared to be positive or nonpositive). Thus,
25766 the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
25767 @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
25768 (assuming no outstanding declarations for @expr{a}). In the case of
25769 @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
25770 the case of @samp{f(12, a+1)}, the condition merely cannot be shown
25771 to be satisfied, but that is enough to reject the rule.
25773 While Calc will use declarations to reason about variables in the
25774 formula being rewritten, declarations do not apply to meta-variables.
25775 For example, the rule @samp{f(a) := g(a+1)} will match for any values
25776 of @samp{a}, such as complex numbers, vectors, or formulas, even if
25777 @samp{a} has been declared to be real or scalar. If you want the
25778 meta-variable @samp{a} to match only literal real numbers, use
25779 @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only
25780 reals and formulas which are provably real, use @samp{dreal(a)} as
25783 The @samp{::} operator is a shorthand for the @code{condition}
25784 function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
25785 the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
25787 If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
25788 or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent.
25790 It is also possible to embed conditions inside the pattern:
25791 @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational
25792 convenience, though; where a condition appears in a rule has no
25793 effect on when it is tested. The rewrite-rule compiler automatically
25794 decides when it is best to test each condition while a rule is being
25797 Certain conditions are handled as special cases by the rewrite rule
25798 system and are tested very efficiently: Where @expr{x} is any
25799 meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
25800 @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y}
25801 is either a constant or another meta-variable and @samp{>=} may be
25802 replaced by any of the six relational operators, and @samp{x % a = b}
25803 where @expr{a} and @expr{b} are constants. Other conditions, like
25804 @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
25805 since Calc must bring the whole evaluator and simplifier into play.
25807 An interesting property of @samp{::} is that neither of its arguments
25808 will be touched by Calc's default simplifications. This is important
25809 because conditions often are expressions that cannot safely be
25810 evaluated early. For example, the @code{typeof} function never
25811 remains in symbolic form; entering @samp{typeof(a)} will put the
25812 number 100 (the type code for variables like @samp{a}) on the stack.
25813 But putting the condition @samp{... :: typeof(a) = 6} on the stack
25814 is safe since @samp{::} prevents the @code{typeof} from being
25815 evaluated until the condition is actually used by the rewrite system.
25817 Since @samp{::} protects its lefthand side, too, you can use a dummy
25818 condition to protect a rule that must itself not evaluate early.
25819 For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
25820 the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
25821 where the meta-variable-ness of @code{f} on the righthand side has been
25822 lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
25823 the condition @samp{1} is always true (nonzero) so it has no effect on
25824 the functioning of the rule. (The rewrite compiler will ensure that
25825 it doesn't even impact the speed of matching the rule.)
25827 @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
25828 @subsection Algebraic Properties of Rewrite Rules
25831 The rewrite mechanism understands the algebraic properties of functions
25832 like @samp{+} and @samp{*}. In particular, pattern matching takes
25833 the associativity and commutativity of the following functions into
25837 + - * = != && || and or xor vint vunion vxor gcd lcm max min beta
25840 For example, the rewrite rule:
25843 a x + b x := (a + b) x
25847 will match formulas of the form,
25850 a x + b x, x a + x b, a x + x b, x a + b x
25853 Rewrites also understand the relationship between the @samp{+} and @samp{-}
25854 operators. The above rewrite rule will also match the formulas,
25857 a x - b x, x a - x b, a x - x b, x a - b x
25861 by matching @samp{b} in the pattern to @samp{-b} from the formula.
25863 Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
25864 pattern will check all pairs of terms for possible matches. The rewrite
25865 will take whichever suitable pair it discovers first.
25867 In general, a pattern using an associative operator like @samp{a + b}
25868 will try @var{2 n} different ways to match a sum of @var{n} terms
25869 like @samp{x + y + z - w}. First, @samp{a} is matched against each
25870 of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
25871 being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
25872 If none of these succeed, then @samp{b} is matched against each of the
25873 four terms with @samp{a} matching the remainder. Half-and-half matches,
25874 like @samp{(x + y) + (z - w)}, are not tried.
25876 Note that @samp{*} is not commutative when applied to matrices, but
25877 rewrite rules pretend that it is. If you type @kbd{m v} to enable
25878 Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
25879 literally, ignoring its usual commutativity property. (In the
25880 current implementation, the associativity also vanishes---it is as
25881 if the pattern had been enclosed in a @code{plain} marker; see below.)
25882 If you are applying rewrites to formulas with matrices, it's best to
25883 enable Matrix mode first to prevent algebraically incorrect rewrites
25886 The pattern @samp{-x} will actually match any expression. For example,
25894 will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use
25895 a @code{plain} marker as described below, or add a @samp{negative(x)}
25896 condition. The @code{negative} function is true if its argument
25897 ``looks'' negative, for example, because it is a negative number or
25898 because it is a formula like @samp{-x}. The new rule using this
25902 f(x) := -f(-x) :: negative(x) @r{or, equivalently,}
25903 f(-x) := -f(x) :: negative(-x)
25906 In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
25907 by matching @samp{y} to @samp{-b}.
25909 The pattern @samp{a b} will also match the formula @samp{x/y} if
25910 @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x}
25911 will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
25912 @samp{(a + 1:2) x}, depending on the current fraction mode).
25914 Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
25915 @samp{^}. For example, the pattern @samp{f(a b)} will not match
25916 @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
25917 though conceivably these patterns could match with @samp{a = b = x}.
25918 Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
25919 constant, even though it could be considered to match with @samp{a = x}
25920 and @samp{b = 1/y}. The reasons are partly for efficiency, and partly
25921 because while few mathematical operations are substantively different
25922 for addition and subtraction, often it is preferable to treat the cases
25923 of multiplication, division, and integer powers separately.
25925 Even more subtle is the rule set
25928 [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ]
25932 attempting to match @samp{f(x) - f(y)}. You might think that Calc
25933 will view this subtraction as @samp{f(x) + (-f(y))} and then apply
25934 the above two rules in turn, but actually this will not work because
25935 Calc only does this when considering rules for @samp{+} (like the
25936 first rule in this set). So it will see first that @samp{f(x) + (-f(y))}
25937 does not match @samp{f(a) + f(b)} for any assignments of the
25938 meta-variables, and then it will see that @samp{f(x) - f(y)} does
25939 not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc
25940 tries only one rule at a time, it will not be able to rewrite
25941 @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)}
25942 rule will have to be added.
25944 Another thing patterns will @emph{not} do is break up complex numbers.
25945 The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
25946 involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
25947 it will not match actual complex numbers like @samp{(3, -4)}. A version
25948 of the above rule for complex numbers would be
25951 myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0
25955 (Because the @code{re} and @code{im} functions understand the properties
25956 of the special constant @samp{i}, this rule will also work for
25957 @samp{3 - 4 i}. In fact, this particular rule would probably be better
25958 without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
25959 righthand side of the rule will still give the correct answer for the
25960 conjugate of a real number.)
25962 It is also possible to specify optional arguments in patterns. The rule
25965 opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d)
25969 will match the formula
25976 in a fairly straightforward manner, but it will also match reduced
25980 x + x^2, 2(x + 1) - x, x + x
25984 producing, respectively,
25987 f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0)
25990 (The latter two formulas can be entered only if default simplifications
25991 have been turned off with @kbd{m O}.)
25993 The default value for a term of a sum is zero. The default value
25994 for a part of a product, for a power, or for the denominator of a
25995 quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b}
25996 with @samp{a = -1}.
25998 In particular, the distributive-law rule can be refined to
26001 opt(a) x + opt(b) x := (a + b) x
26005 so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
26007 The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
26008 are linear in @samp{x}. You can also use the @code{lin} and @code{islin}
26009 functions with rewrite conditions to test for this; @pxref{Logical
26010 Operations}. These functions are not as convenient to use in rewrite
26011 rules, but they recognize more kinds of formulas as linear:
26012 @samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin},
26013 but it will not match the above pattern because that pattern calls
26014 for a multiplication, not a division.
26016 As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
26020 sin(x)^2 + cos(x)^2 := 1
26024 misses many cases because the sine and cosine may both be multiplied by
26025 an equal factor. Here's a more successful rule:
26028 opt(a) sin(x)^2 + opt(a) cos(x)^2 := a
26031 Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
26032 because one @expr{a} would have ``matched'' 1 while the other matched 6.
26034 Calc automatically converts a rule like
26044 f(temp, x) := g(x) :: temp = x-1
26048 (where @code{temp} stands for a new, invented meta-variable that
26049 doesn't actually have a name). This modified rule will successfully
26050 match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
26051 respectively, then verifying that they differ by one even though
26052 @samp{6} does not superficially look like @samp{x-1}.
26054 However, Calc does not solve equations to interpret a rule. The
26058 f(x-1, x+1) := g(x)
26062 will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
26063 but not @samp{f(6, 8)}. Calc always interprets at least one occurrence
26064 of a variable by literal matching. If the variable appears ``isolated''
26065 then Calc is smart enough to use it for literal matching. But in this
26066 last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
26067 := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
26068 actual ``something-minus-one'' in the target formula.
26070 A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
26071 You could make this resemble the original form more closely by using
26072 @code{let} notation, which is described in the next section:
26075 f(xm1, x+1) := g(x) :: let(x := xm1+1)
26078 Calc does this rewriting or ``conditionalizing'' for any sub-pattern
26079 which involves only the functions in the following list, operating
26080 only on constants and meta-variables which have already been matched
26081 elsewhere in the pattern. When matching a function call, Calc is
26082 careful to match arguments which are plain variables before arguments
26083 which are calls to any of the functions below, so that a pattern like
26084 @samp{f(x-1, x)} can be conditionalized even though the isolated
26085 @samp{x} comes after the @samp{x-1}.
26088 + - * / \ % ^ abs sign round rounde roundu trunc floor ceil
26089 max min re im conj arg
26092 You can suppress all of the special treatments described in this
26093 section by surrounding a function call with a @code{plain} marker.
26094 This marker causes the function call which is its argument to be
26095 matched literally, without regard to commutativity, associativity,
26096 negation, or conditionalization. When you use @code{plain}, the
26097 ``deep structure'' of the formula being matched can show through.
26101 plain(a - a b) := f(a, b)
26105 will match only literal subtractions. However, the @code{plain}
26106 marker does not affect its arguments' arguments. In this case,
26107 commutativity and associativity is still considered while matching
26108 the @w{@samp{a b}} sub-pattern, so the whole pattern will match
26109 @samp{x - y x} as well as @samp{x - x y}. We could go still
26113 plain(a - plain(a b)) := f(a, b)
26117 which would do a completely strict match for the pattern.
26119 By contrast, the @code{quote} marker means that not only the
26120 function name but also the arguments must be literally the same.
26121 The above pattern will match @samp{x - x y} but
26124 quote(a - a b) := f(a, b)
26128 will match only the single formula @samp{a - a b}. Also,
26131 quote(a - quote(a b)) := f(a, b)
26135 will match only @samp{a - quote(a b)}---probably not the desired
26138 A certain amount of algebra is also done when substituting the
26139 meta-variables on the righthand side of a rule. For example,
26143 a + f(b) := f(a + b)
26147 matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
26148 taken literally, but the rewrite mechanism will simplify the
26149 righthand side to @samp{f(x - y)} automatically. (Of course,
26150 the default simplifications would do this anyway, so this
26151 special simplification is only noticeable if you have turned the
26152 default simplifications off.) This rewriting is done only when
26153 a meta-variable expands to a ``negative-looking'' expression.
26154 If this simplification is not desirable, you can use a @code{plain}
26155 marker on the righthand side:
26158 a + f(b) := f(plain(a + b))
26162 In this example, we are still allowing the pattern-matcher to
26163 use all the algebra it can muster, but the righthand side will
26164 always simplify to a literal addition like @samp{f((-y) + x)}.
26166 @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
26167 @subsection Other Features of Rewrite Rules
26170 Certain ``function names'' serve as markers in rewrite rules.
26171 Here is a complete list of these markers. First are listed the
26172 markers that work inside a pattern; then come the markers that
26173 work in the righthand side of a rule.
26179 One kind of marker, @samp{import(x)}, takes the place of a whole
26180 rule. Here @expr{x} is the name of a variable containing another
26181 rule set; those rules are ``spliced into'' the rule set that
26182 imports them. For example, if @samp{[f(a+b) := f(a) + f(b),
26183 f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
26184 then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
26185 all three rules. It is possible to modify the imported rules
26186 slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports
26187 the rule set @expr{x} with all occurrences of
26188 @texline @math{v_1},
26189 @infoline @expr{v1},
26190 as either a variable name or a function name, replaced with
26191 @texline @math{x_1}
26192 @infoline @expr{x1}
26194 @texline @math{v_1}
26195 @infoline @expr{v1}
26196 is used as a function name, then
26197 @texline @math{x_1}
26198 @infoline @expr{x1}
26199 must be either a function name itself or a @w{@samp{< >}} nameless
26200 function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0,
26201 import(linearF, f, g)]} applies the linearity rules to the function
26202 @samp{g} instead of @samp{f}. Imports can be nested, but the
26203 import-with-renaming feature may fail to rename sub-imports properly.
26205 The special functions allowed in patterns are:
26213 This pattern matches exactly @expr{x}; variable names in @expr{x} are
26214 not interpreted as meta-variables. The only flexibility is that
26215 numbers are compared for numeric equality, so that the pattern
26216 @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
26217 (Numbers are always treated this way by the rewrite mechanism:
26218 The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
26219 The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
26220 as a result in this case.)
26227 Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This
26228 pattern matches a call to function @expr{f} with the specified
26229 argument patterns. No special knowledge of the properties of the
26230 function @expr{f} is used in this case; @samp{+} is not commutative or
26231 associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
26232 are treated as patterns. If you wish them to be treated ``plainly''
26233 as well, you must enclose them with more @code{plain} markers:
26234 @samp{plain(plain(@w{-a}) + plain(b c))}.
26241 Here @expr{x} must be a variable name. This must appear as an
26242 argument to a function or an element of a vector; it specifies that
26243 the argument or element is optional.
26244 As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
26245 or as the second argument to @samp{/} or @samp{^}, the value @var{def}
26246 may be omitted. The pattern @samp{x + opt(y)} matches a sum by
26247 binding one summand to @expr{x} and the other to @expr{y}, and it
26248 matches anything else by binding the whole expression to @expr{x} and
26249 zero to @expr{y}. The other operators above work similarly.
26251 For general miscellaneous functions, the default value @code{def}
26252 must be specified. Optional arguments are dropped starting with
26253 the rightmost one during matching. For example, the pattern
26254 @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
26255 or @samp{f(a,b,c)}. Default values of zero and @expr{b} are
26256 supplied in this example for the omitted arguments. Note that
26257 the literal variable @expr{b} will be the default in the latter
26258 case, @emph{not} the value that matched the meta-variable @expr{b}.
26259 In other words, the default @var{def} is effectively quoted.
26261 @item condition(x,c)
26267 This matches the pattern @expr{x}, with the attached condition
26268 @expr{c}. It is the same as @samp{x :: c}.
26276 This matches anything that matches both pattern @expr{x} and
26277 pattern @expr{y}. It is the same as @samp{x &&& y}.
26278 @pxref{Composing Patterns in Rewrite Rules}.
26286 This matches anything that matches either pattern @expr{x} or
26287 pattern @expr{y}. It is the same as @w{@samp{x ||| y}}.
26295 This matches anything that does not match pattern @expr{x}.
26296 It is the same as @samp{!!! x}.
26302 @tindex cons (rewrites)
26303 This matches any vector of one or more elements. The first
26304 element is matched to @expr{h}; a vector of the remaining
26305 elements is matched to @expr{t}. Note that vectors of fixed
26306 length can also be matched as actual vectors: The rule
26307 @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
26308 to the rule @samp{[a,b] := [a+b]}.
26314 @tindex rcons (rewrites)
26315 This is like @code{cons}, except that the @emph{last} element
26316 is matched to @expr{h}, with the remaining elements matched
26319 @item apply(f,args)
26323 @tindex apply (rewrites)
26324 This matches any function call. The name of the function, in
26325 the form of a variable, is matched to @expr{f}. The arguments
26326 of the function, as a vector of zero or more objects, are
26327 matched to @samp{args}. Constants, variables, and vectors
26328 do @emph{not} match an @code{apply} pattern. For example,
26329 @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
26330 matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
26331 matches any function call with exactly two arguments, and
26332 @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
26333 to the function @samp{f} with two or more arguments. Another
26334 way to implement the latter, if the rest of the rule does not
26335 need to refer to the first two arguments of @samp{f} by name,
26336 would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
26337 Here's a more interesting sample use of @code{apply}:
26340 apply(f,[x+n]) := n + apply(f,[x])
26341 :: in(f, [floor,ceil,round,trunc]) :: integer(n)
26344 Note, however, that this will be slower to match than a rule
26345 set with four separate rules. The reason is that Calc sorts
26346 the rules of a rule set according to top-level function name;
26347 if the top-level function is @code{apply}, Calc must try the
26348 rule for every single formula and sub-formula. If the top-level
26349 function in the pattern is, say, @code{floor}, then Calc invokes
26350 the rule only for sub-formulas which are calls to @code{floor}.
26352 Formulas normally written with operators like @code{+} are still
26353 considered function calls: @code{apply(f,x)} matches @samp{a+b}
26354 with @samp{f = add}, @samp{x = [a,b]}.
26356 You must use @code{apply} for meta-variables with function names
26357 on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)}
26358 is @emph{not} correct, because it rewrites @samp{spam(6)} into
26359 @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}.
26360 Also note that you will have to use No-Simplify mode (@kbd{m O})
26361 when entering this rule so that the @code{apply} isn't
26362 evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
26363 Or, use @kbd{s e} to enter the rule without going through the stack,
26364 or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
26365 @xref{Conditional Rewrite Rules}.
26372 This is used for applying rules to formulas with selections;
26373 @pxref{Selections with Rewrite Rules}.
26376 Special functions for the righthand sides of rules are:
26380 The notation @samp{quote(x)} is changed to @samp{x} when the
26381 righthand side is used. As far as the rewrite rule is concerned,
26382 @code{quote} is invisible. However, @code{quote} has the special
26383 property in Calc that its argument is not evaluated. Thus,
26384 while it will not work to put the rule @samp{t(a) := typeof(a)}
26385 on the stack because @samp{typeof(a)} is evaluated immediately
26386 to produce @samp{t(a) := 100}, you can use @code{quote} to
26387 protect the righthand side: @samp{t(a) := quote(typeof(a))}.
26388 (@xref{Conditional Rewrite Rules}, for another trick for
26389 protecting rules from evaluation.)
26392 Special properties of and simplifications for the function call
26393 @expr{x} are not used. One interesting case where @code{plain}
26394 is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
26395 shorthand notation for the @code{quote} function. This rule will
26396 not work as shown; instead of replacing @samp{q(foo)} with
26397 @samp{quote(foo)}, it will replace it with @samp{foo}! The correct
26398 rule would be @samp{q(x) := plain(quote(x))}.
26401 Where @expr{t} is a vector, this is converted into an expanded
26402 vector during rewrite processing. Note that @code{cons} is a regular
26403 Calc function which normally does this anyway; the only way @code{cons}
26404 is treated specially by rewrites is that @code{cons} on the righthand
26405 side of a rule will be evaluated even if default simplifications
26406 have been turned off.
26409 Analogous to @code{cons} except putting @expr{h} at the @emph{end} of
26410 the vector @expr{t}.
26412 @item apply(f,args)
26413 Where @expr{f} is a variable and @var{args} is a vector, this
26414 is converted to a function call. Once again, note that @code{apply}
26415 is also a regular Calc function.
26422 The formula @expr{x} is handled in the usual way, then the
26423 default simplifications are applied to it even if they have
26424 been turned off normally. This allows you to treat any function
26425 similarly to the way @code{cons} and @code{apply} are always
26426 treated. However, there is a slight difference: @samp{cons(2+3, [])}
26427 with default simplifications off will be converted to @samp{[2+3]},
26428 whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
26435 The formula @expr{x} has meta-variables substituted in the usual
26436 way, then algebraically simplified as if by the @kbd{a s} command.
26438 @item evalextsimp(x)
26442 @tindex evalextsimp
26443 The formula @expr{x} has meta-variables substituted in the normal
26444 way, then ``extendedly'' simplified as if by the @kbd{a e} command.
26447 @xref{Selections with Rewrite Rules}.
26450 There are also some special functions you can use in conditions.
26458 The expression @expr{x} is evaluated with meta-variables substituted.
26459 The @kbd{a s} command's simplifications are @emph{not} applied by
26460 default, but @expr{x} can include calls to @code{evalsimp} or
26461 @code{evalextsimp} as described above to invoke higher levels
26462 of simplification. The
26463 result of @expr{x} is then bound to the meta-variable @expr{v}. As
26464 usual, if this meta-variable has already been matched to something
26465 else the two values must be equal; if the meta-variable is new then
26466 it is bound to the result of the expression. This variable can then
26467 appear in later conditions, and on the righthand side of the rule.
26468 In fact, @expr{v} may be any pattern in which case the result of
26469 evaluating @expr{x} is matched to that pattern, binding any
26470 meta-variables that appear in that pattern. Note that @code{let}
26471 can only appear by itself as a condition, or as one term of an
26472 @samp{&&} which is a whole condition: It cannot be inside
26473 an @samp{||} term or otherwise buried.
26475 The alternate, equivalent form @samp{let(v, x)} is also recognized.
26476 Note that the use of @samp{:=} by @code{let}, while still being
26477 assignment-like in character, is unrelated to the use of @samp{:=}
26478 in the main part of a rewrite rule.
26480 As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
26481 replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
26482 that inverse exists and is constant. For example, if @samp{a} is a
26483 singular matrix the operation @samp{1/a} is left unsimplified and
26484 @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
26485 then the rule succeeds. Without @code{let} there would be no way
26486 to express this rule that didn't have to invert the matrix twice.
26487 Note that, because the meta-variable @samp{ia} is otherwise unbound
26488 in this rule, the @code{let} condition itself always ``succeeds''
26489 because no matter what @samp{1/a} evaluates to, it can successfully
26490 be bound to @code{ia}.
26492 Here's another example, for integrating cosines of linear
26493 terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
26494 The @code{lin} function returns a 3-vector if its argument is linear,
26495 or leaves itself unevaluated if not. But an unevaluated @code{lin}
26496 call will not match the 3-vector on the lefthand side of the @code{let},
26497 so this @code{let} both verifies that @code{y} is linear, and binds
26498 the coefficients @code{a} and @code{b} for use elsewhere in the rule.
26499 (It would have been possible to use @samp{sin(a x + b)/b} for the
26500 righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
26501 rearrangement of the argument of the sine.)
26507 Similarly, here is a rule that implements an inverse-@code{erf}
26508 function. It uses @code{root} to search for a solution. If
26509 @code{root} succeeds, it will return a vector of two numbers
26510 where the first number is the desired solution. If no solution
26511 is found, @code{root} remains in symbolic form. So we use
26512 @code{let} to check that the result was indeed a vector.
26515 ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5))
26519 The meta-variable @var{v}, which must already have been matched
26520 to something elsewhere in the rule, is compared against pattern
26521 @var{p}. Since @code{matches} is a standard Calc function, it
26522 can appear anywhere in a condition. But if it appears alone or
26523 as a term of a top-level @samp{&&}, then you get the special
26524 extra feature that meta-variables which are bound to things
26525 inside @var{p} can be used elsewhere in the surrounding rewrite
26528 The only real difference between @samp{let(p := v)} and
26529 @samp{matches(v, p)} is that the former evaluates @samp{v} using
26530 the default simplifications, while the latter does not.
26534 This is actually a variable, not a function. If @code{remember}
26535 appears as a condition in a rule, then when that rule succeeds
26536 the original expression and rewritten expression are added to the
26537 front of the rule set that contained the rule. If the rule set
26538 was not stored in a variable, @code{remember} is ignored. The
26539 lefthand side is enclosed in @code{quote} in the added rule if it
26540 contains any variables.
26542 For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
26543 to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
26544 of the rule set. The rule set @code{EvalRules} works slightly
26545 differently: There, the evaluation of @samp{f(6)} will complete before
26546 the result is added to the rule set, in this case as @samp{f(7) := 5040}.
26547 Thus @code{remember} is most useful inside @code{EvalRules}.
26549 It is up to you to ensure that the optimization performed by
26550 @code{remember} is safe. For example, the rule @samp{foo(n) := n
26551 :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
26552 the function equivalent of the @kbd{=} command); if the variable
26553 @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
26554 be added to the rule set and will continue to operate even if
26555 @code{eatfoo} is later changed to 0.
26562 Remember the match as described above, but only if condition @expr{c}
26563 is true. For example, @samp{remember(n % 4 = 0)} in the above factorial
26564 rule remembers only every fourth result. Note that @samp{remember(1)}
26565 is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
26568 @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
26569 @subsection Composing Patterns in Rewrite Rules
26572 There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
26573 that combine rewrite patterns to make larger patterns. The
26574 combinations are ``and,'' ``or,'' and ``not,'' respectively, and
26575 these operators are the pattern equivalents of @samp{&&}, @samp{||}
26576 and @samp{!} (which operate on zero-or-nonzero logical values).
26578 Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
26579 form by all regular Calc features; they have special meaning only in
26580 the context of rewrite rule patterns.
26582 The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
26583 matches both @var{p1} and @var{p2}. One especially useful case is
26584 when one of @var{p1} or @var{p2} is a meta-variable. For example,
26585 here is a rule that operates on error forms:
26588 f(x &&& a +/- b, x) := g(x)
26591 This does the same thing, but is arguably simpler than, the rule
26594 f(a +/- b, a +/- b) := g(a +/- b)
26601 Here's another interesting example:
26604 ends(cons(a, x) &&& rcons(y, b)) := [a, b]
26608 which effectively clips out the middle of a vector leaving just
26609 the first and last elements. This rule will change a one-element
26610 vector @samp{[a]} to @samp{[a, a]}. The similar rule
26613 ends(cons(a, rcons(y, b))) := [a, b]
26617 would do the same thing except that it would fail to match a
26618 one-element vector.
26624 The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
26625 matches either @var{p1} or @var{p2}. Calc first tries matching
26626 against @var{p1}; if that fails, it goes on to try @var{p2}.
26632 A simple example of @samp{|||} is
26635 curve(inf ||| -inf) := 0
26639 which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
26641 Here is a larger example:
26644 log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b)
26647 This matches both generalized and natural logarithms in a single rule.
26648 Note that the @samp{::} term must be enclosed in parentheses because
26649 that operator has lower precedence than @samp{|||} or @samp{:=}.
26651 (In practice this rule would probably include a third alternative,
26652 omitted here for brevity, to take care of @code{log10}.)
26654 While Calc generally treats interior conditions exactly the same as
26655 conditions on the outside of a rule, it does guarantee that if all the
26656 variables in the condition are special names like @code{e}, or already
26657 bound in the pattern to which the condition is attached (say, if
26658 @samp{a} had appeared in this condition), then Calc will process this
26659 condition right after matching the pattern to the left of the @samp{::}.
26660 Thus, we know that @samp{b} will be bound to @samp{e} only if the
26661 @code{ln} branch of the @samp{|||} was taken.
26663 Note that this rule was careful to bind the same set of meta-variables
26664 on both sides of the @samp{|||}. Calc does not check this, but if
26665 you bind a certain meta-variable only in one branch and then use that
26666 meta-variable elsewhere in the rule, results are unpredictable:
26669 f(a,b) ||| g(b) := h(a,b)
26672 Here if the pattern matches @samp{g(17)}, Calc makes no promises about
26673 the value that will be substituted for @samp{a} on the righthand side.
26679 The pattern @samp{!!! @var{pat}} matches anything that does not
26680 match @var{pat}. Any meta-variables that are bound while matching
26681 @var{pat} remain unbound outside of @var{pat}.
26686 f(x &&& !!! a +/- b, !!![]) := g(x)
26690 converts @code{f} whose first argument is anything @emph{except} an
26691 error form, and whose second argument is not the empty vector, into
26692 a similar call to @code{g} (but without the second argument).
26694 If we know that the second argument will be a vector (empty or not),
26695 then an equivalent rule would be:
26698 f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0
26702 where of course 7 is the @code{typeof} code for error forms.
26703 Another final condition, that works for any kind of @samp{y},
26704 would be @samp{!istrue(y == [])}. (The @code{istrue} function
26705 returns an explicit 0 if its argument was left in symbolic form;
26706 plain @samp{!(y == [])} or @samp{y != []} would not work to replace
26707 @samp{!!![]} since these would be left unsimplified, and thus cause
26708 the rule to fail, if @samp{y} was something like a variable name.)
26710 It is possible for a @samp{!!!} to refer to meta-variables bound
26711 elsewhere in the pattern. For example,
26718 matches any call to @code{f} with different arguments, changing
26719 this to @code{g} with only the first argument.
26721 If a function call is to be matched and one of the argument patterns
26722 contains a @samp{!!!} somewhere inside it, that argument will be
26730 will be careful to bind @samp{a} to the second argument of @code{f}
26731 before testing the first argument. If Calc had tried to match the
26732 first argument of @code{f} first, the results would have been
26733 disastrous: since @code{a} was unbound so far, the pattern @samp{a}
26734 would have matched anything at all, and the pattern @samp{!!!a}
26735 therefore would @emph{not} have matched anything at all!
26737 @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
26738 @subsection Nested Formulas with Rewrite Rules
26741 When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
26742 the top of the stack and attempts to match any of the specified rules
26743 to any part of the expression, starting with the whole expression
26744 and then, if that fails, trying deeper and deeper sub-expressions.
26745 For each part of the expression, the rules are tried in the order
26746 they appear in the rules vector. The first rule to match the first
26747 sub-expression wins; it replaces the matched sub-expression according
26748 to the @var{new} part of the rule.
26750 Often, the rule set will match and change the formula several times.
26751 The top-level formula is first matched and substituted repeatedly until
26752 it no longer matches the pattern; then, sub-formulas are tried, and
26753 so on. Once every part of the formula has gotten its chance, the
26754 rewrite mechanism starts over again with the top-level formula
26755 (in case a substitution of one of its arguments has caused it again
26756 to match). This continues until no further matches can be made
26757 anywhere in the formula.
26759 It is possible for a rule set to get into an infinite loop. The
26760 most obvious case, replacing a formula with itself, is not a problem
26761 because a rule is not considered to ``succeed'' unless the righthand
26762 side actually comes out to something different than the original
26763 formula or sub-formula that was matched. But if you accidentally
26764 had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
26765 @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
26766 run forever switching a formula back and forth between the two
26769 To avoid disaster, Calc normally stops after 100 changes have been
26770 made to the formula. This will be enough for most multiple rewrites,
26771 but it will keep an endless loop of rewrites from locking up the
26772 computer forever. (On most systems, you can also type @kbd{C-g} to
26773 halt any Emacs command prematurely.)
26775 To change this limit, give a positive numeric prefix argument.
26776 In particular, @kbd{M-1 a r} applies only one rewrite at a time,
26777 useful when you are first testing your rule (or just if repeated
26778 rewriting is not what is called for by your application).
26787 You can also put a ``function call'' @samp{iterations(@var{n})}
26788 in place of a rule anywhere in your rules vector (but usually at
26789 the top). Then, @var{n} will be used instead of 100 as the default
26790 number of iterations for this rule set. You can use
26791 @samp{iterations(inf)} if you want no iteration limit by default.
26792 A prefix argument will override the @code{iterations} limit in the
26800 More precisely, the limit controls the number of ``iterations,''
26801 where each iteration is a successful matching of a rule pattern whose
26802 righthand side, after substituting meta-variables and applying the
26803 default simplifications, is different from the original sub-formula
26806 A prefix argument of zero sets the limit to infinity. Use with caution!
26808 Given a negative numeric prefix argument, @kbd{a r} will match and
26809 substitute the top-level expression up to that many times, but
26810 will not attempt to match the rules to any sub-expressions.
26812 In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
26813 does a rewriting operation. Here @var{expr} is the expression
26814 being rewritten, @var{rules} is the rule, vector of rules, or
26815 variable containing the rules, and @var{n} is the optional
26816 iteration limit, which may be a positive integer, a negative
26817 integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted
26818 the @code{iterations} value from the rule set is used; if both
26819 are omitted, 100 is used.
26821 @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
26822 @subsection Multi-Phase Rewrite Rules
26825 It is possible to separate a rewrite rule set into several @dfn{phases}.
26826 During each phase, certain rules will be enabled while certain others
26827 will be disabled. A @dfn{phase schedule} controls the order in which
26828 phases occur during the rewriting process.
26835 If a call to the marker function @code{phase} appears in the rules
26836 vector in place of a rule, all rules following that point will be
26837 members of the phase(s) identified in the arguments to @code{phase}.
26838 Phases are given integer numbers. The markers @samp{phase()} and
26839 @samp{phase(all)} both mean the following rules belong to all phases;
26840 this is the default at the start of the rule set.
26842 If you do not explicitly schedule the phases, Calc sorts all phase
26843 numbers that appear in the rule set and executes the phases in
26844 ascending order. For example, the rule set
26861 has three phases, 1 through 3. Phase 1 consists of the @code{f0},
26862 @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of
26863 @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0}
26866 When Calc rewrites a formula using this rule set, it first rewrites
26867 the formula using only the phase 1 rules until no further changes are
26868 possible. Then it switches to the phase 2 rule set and continues
26869 until no further changes occur, then finally rewrites with phase 3.
26870 When no more phase 3 rules apply, rewriting finishes. (This is
26871 assuming @kbd{a r} with a large enough prefix argument to allow the
26872 rewriting to run to completion; the sequence just described stops
26873 early if the number of iterations specified in the prefix argument,
26874 100 by default, is reached.)
26876 During each phase, Calc descends through the nested levels of the
26877 formula as described previously. (@xref{Nested Formulas with Rewrite
26878 Rules}.) Rewriting starts at the top of the formula, then works its
26879 way down to the parts, then goes back to the top and works down again.
26880 The phase 2 rules do not begin until no phase 1 rules apply anywhere
26887 A @code{schedule} marker appearing in the rule set (anywhere, but
26888 conventionally at the top) changes the default schedule of phases.
26889 In the simplest case, @code{schedule} has a sequence of phase numbers
26890 for arguments; each phase number is invoked in turn until the
26891 arguments to @code{schedule} are exhausted. Thus adding
26892 @samp{schedule(3,2,1)} at the top of the above rule set would
26893 reverse the order of the phases; @samp{schedule(1,2,3)} would have
26894 no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
26895 would give phase 1 a second chance after phase 2 has completed, before
26896 moving on to phase 3.
26898 Any argument to @code{schedule} can instead be a vector of phase
26899 numbers (or even of sub-vectors). Then the sub-sequence of phases
26900 described by the vector are tried repeatedly until no change occurs
26901 in any phase in the sequence. For example, @samp{schedule([1, 2], 3)}
26902 tries phase 1, then phase 2, then, if either phase made any changes
26903 to the formula, repeats these two phases until they can make no
26904 further progress. Finally, it goes on to phase 3 for finishing
26907 Also, items in @code{schedule} can be variable names as well as
26908 numbers. A variable name is interpreted as the name of a function
26909 to call on the whole formula. For example, @samp{schedule(1, simplify)}
26910 says to apply the phase-1 rules (presumably, all of them), then to
26911 call @code{simplify} which is the function name equivalent of @kbd{a s}.
26912 Likewise, @samp{schedule([1, simplify])} says to alternate between
26913 phase 1 and @kbd{a s} until no further changes occur.
26915 Phases can be used purely to improve efficiency; if it is known that
26916 a certain group of rules will apply only at the beginning of rewriting,
26917 and a certain other group will apply only at the end, then rewriting
26918 will be faster if these groups are identified as separate phases.
26919 Once the phase 1 rules are done, Calc can put them aside and no longer
26920 spend any time on them while it works on phase 2.
26922 There are also some problems that can only be solved with several
26923 rewrite phases. For a real-world example of a multi-phase rule set,
26924 examine the set @code{FitRules}, which is used by the curve-fitting
26925 command to convert a model expression to linear form.
26926 @xref{Curve Fitting Details}. This set is divided into four phases.
26927 The first phase rewrites certain kinds of expressions to be more
26928 easily linearizable, but less computationally efficient. After the
26929 linear components have been picked out, the final phase includes the
26930 opposite rewrites to put each component back into an efficient form.
26931 If both sets of rules were included in one big phase, Calc could get
26932 into an infinite loop going back and forth between the two forms.
26934 Elsewhere in @code{FitRules}, the components are first isolated,
26935 then recombined where possible to reduce the complexity of the linear
26936 fit, then finally packaged one component at a time into vectors.
26937 If the packaging rules were allowed to begin before the recombining
26938 rules were finished, some components might be put away into vectors
26939 before they had a chance to recombine. By putting these rules in
26940 two separate phases, this problem is neatly avoided.
26942 @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
26943 @subsection Selections with Rewrite Rules
26946 If a sub-formula of the current formula is selected (as by @kbd{j s};
26947 @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
26948 command applies only to that sub-formula. Together with a negative
26949 prefix argument, you can use this fact to apply a rewrite to one
26950 specific part of a formula without affecting any other parts.
26953 @pindex calc-rewrite-selection
26954 The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
26955 sophisticated operations on selections. This command prompts for
26956 the rules in the same way as @kbd{a r}, but it then applies those
26957 rules to the whole formula in question even though a sub-formula
26958 of it has been selected. However, the selected sub-formula will
26959 first have been surrounded by a @samp{select( )} function call.
26960 (Calc's evaluator does not understand the function name @code{select};
26961 this is only a tag used by the @kbd{j r} command.)
26963 For example, suppose the formula on the stack is @samp{2 (a + b)^2}
26964 and the sub-formula @samp{a + b} is selected. This formula will
26965 be rewritten to @samp{2 select(a + b)^2} and then the rewrite
26966 rules will be applied in the usual way. The rewrite rules can
26967 include references to @code{select} to tell where in the pattern
26968 the selected sub-formula should appear.
26970 If there is still exactly one @samp{select( )} function call in
26971 the formula after rewriting is done, it indicates which part of
26972 the formula should be selected afterwards. Otherwise, the
26973 formula will be unselected.
26975 You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
26976 of the rewrite rule with @samp{select()}. However, @kbd{j r}
26977 allows you to use the current selection in more flexible ways.
26978 Suppose you wished to make a rule which removed the exponent from
26979 the selected term; the rule @samp{select(a)^x := select(a)} would
26980 work. In the above example, it would rewrite @samp{2 select(a + b)^2}
26981 to @samp{2 select(a + b)}. This would then be returned to the
26982 stack as @samp{2 (a + b)} with the @samp{a + b} selected.
26984 The @kbd{j r} command uses one iteration by default, unlike
26985 @kbd{a r} which defaults to 100 iterations. A numeric prefix
26986 argument affects @kbd{j r} in the same way as @kbd{a r}.
26987 @xref{Nested Formulas with Rewrite Rules}.
26989 As with other selection commands, @kbd{j r} operates on the stack
26990 entry that contains the cursor. (If the cursor is on the top-of-stack
26991 @samp{.} marker, it works as if the cursor were on the formula
26994 If you don't specify a set of rules, the rules are taken from the
26995 top of the stack, just as with @kbd{a r}. In this case, the
26996 cursor must indicate stack entry 2 or above as the formula to be
26997 rewritten (otherwise the same formula would be used as both the
26998 target and the rewrite rules).
27000 If the indicated formula has no selection, the cursor position within
27001 the formula temporarily selects a sub-formula for the purposes of this
27002 command. If the cursor is not on any sub-formula (e.g., it is in
27003 the line-number area to the left of the formula), the @samp{select( )}
27004 markers are ignored by the rewrite mechanism and the rules are allowed
27005 to apply anywhere in the formula.
27007 As a special feature, the normal @kbd{a r} command also ignores
27008 @samp{select( )} calls in rewrite rules. For example, if you used the
27009 above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
27010 the rule as if it were @samp{a^x := a}. Thus, you can write general
27011 purpose rules with @samp{select( )} hints inside them so that they
27012 will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
27013 both with and without selections.
27015 @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
27016 @subsection Matching Commands
27022 The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
27023 vector of formulas and a rewrite-rule-style pattern, and produces
27024 a vector of all formulas which match the pattern. The command
27025 prompts you to enter the pattern; as for @kbd{a r}, you can enter
27026 a single pattern (i.e., a formula with meta-variables), or a
27027 vector of patterns, or a variable which contains patterns, or
27028 you can give a blank response in which case the patterns are taken
27029 from the top of the stack. The pattern set will be compiled once
27030 and saved if it is stored in a variable. If there are several
27031 patterns in the set, vector elements are kept if they match any
27034 For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
27035 will return @samp{[x+y, x-y, x+y+z]}.
27037 The @code{import} mechanism is not available for pattern sets.
27039 The @kbd{a m} command can also be used to extract all vector elements
27040 which satisfy any condition: The pattern @samp{x :: x>0} will select
27041 all the positive vector elements.
27045 With the Inverse flag [@code{matchnot}], this command extracts all
27046 vector elements which do @emph{not} match the given pattern.
27052 There is also a function @samp{matches(@var{x}, @var{p})} which
27053 evaluates to 1 if expression @var{x} matches pattern @var{p}, or
27054 to 0 otherwise. This is sometimes useful for including into the
27055 conditional clauses of other rewrite rules.
27061 The function @code{vmatches} is just like @code{matches}, except
27062 that if the match succeeds it returns a vector of assignments to
27063 the meta-variables instead of the number 1. For example,
27064 @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
27065 If the match fails, the function returns the number 0.
27067 @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
27068 @subsection Automatic Rewrites
27071 @cindex @code{EvalRules} variable
27073 It is possible to get Calc to apply a set of rewrite rules on all
27074 results, effectively adding to the built-in set of default
27075 simplifications. To do this, simply store your rule set in the
27076 variable @code{EvalRules}. There is a convenient @kbd{s E} command
27077 for editing @code{EvalRules}; @pxref{Operations on Variables}.
27079 For example, suppose you want @samp{sin(a + b)} to be expanded out
27080 to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
27081 similarly for @samp{cos(a + b)}. The corresponding rewrite rule
27086 [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b),
27087 cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ]
27091 To apply these manually, you could put them in a variable called
27092 @code{trigexp} and then use @kbd{a r trigexp} every time you wanted
27093 to expand trig functions. But if instead you store them in the
27094 variable @code{EvalRules}, they will automatically be applied to all
27095 sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on
27096 the stack, typing @kbd{+ S} will (assuming Degrees mode) result in
27097 @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
27099 As each level of a formula is evaluated, the rules from
27100 @code{EvalRules} are applied before the default simplifications.
27101 Rewriting continues until no further @code{EvalRules} apply.
27102 Note that this is different from the usual order of application of
27103 rewrite rules: @code{EvalRules} works from the bottom up, simplifying
27104 the arguments to a function before the function itself, while @kbd{a r}
27105 applies rules from the top down.
27107 Because the @code{EvalRules} are tried first, you can use them to
27108 override the normal behavior of any built-in Calc function.
27110 It is important not to write a rule that will get into an infinite
27111 loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
27112 appears to be a good definition of a factorial function, but it is
27113 unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc
27114 will continue to subtract 1 from this argument forever without reaching
27115 zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
27116 Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting
27117 @samp{g(2, 4)}, this would bounce back and forth between that and
27118 @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules}
27119 occurs, Emacs will eventually stop with a ``Computation got stuck
27120 or ran too long'' message.
27122 Another subtle difference between @code{EvalRules} and regular rewrites
27123 concerns rules that rewrite a formula into an identical formula. For
27124 example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is
27125 already an integer. But in @code{EvalRules} this case is detected only
27126 if the righthand side literally becomes the original formula before any
27127 further simplification. This means that @samp{f(n) := f(floor(n))} will
27128 get into an infinite loop if it occurs in @code{EvalRules}. Calc will
27129 replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
27130 @samp{f(6)}, so it will consider the rule to have matched and will
27131 continue simplifying that formula; first the argument is simplified
27132 to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
27133 again, ad infinitum. A much safer rule would check its argument first,
27134 say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
27136 (What really happens is that the rewrite mechanism substitutes the
27137 meta-variables in the righthand side of a rule, compares to see if the
27138 result is the same as the original formula and fails if so, then uses
27139 the default simplifications to simplify the result and compares again
27140 (and again fails if the formula has simplified back to its original
27141 form). The only special wrinkle for the @code{EvalRules} is that the
27142 same rules will come back into play when the default simplifications
27143 are used. What Calc wants to do is build @samp{f(floor(6))}, see that
27144 this is different from the original formula, simplify to @samp{f(6)},
27145 see that this is the same as the original formula, and thus halt the
27146 rewriting. But while simplifying, @samp{f(6)} will again trigger
27147 the same @code{EvalRules} rule and Calc will get into a loop inside
27148 the rewrite mechanism itself.)
27150 The @code{phase}, @code{schedule}, and @code{iterations} markers do
27151 not work in @code{EvalRules}. If the rule set is divided into phases,
27152 only the phase 1 rules are applied, and the schedule is ignored.
27153 The rules are always repeated as many times as possible.
27155 The @code{EvalRules} are applied to all function calls in a formula,
27156 but not to numbers (and other number-like objects like error forms),
27157 nor to vectors or individual variable names. (Though they will apply
27158 to @emph{components} of vectors and error forms when appropriate.) You
27159 might try to make a variable @code{phihat} which automatically expands
27160 to its definition without the need to press @kbd{=} by writing the
27161 rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
27162 will not work as part of @code{EvalRules}.
27164 Finally, another limitation is that Calc sometimes calls its built-in
27165 functions directly rather than going through the default simplifications.
27166 When it does this, @code{EvalRules} will not be able to override those
27167 functions. For example, when you take the absolute value of the complex
27168 number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
27169 the multiplication, addition, and square root functions directly rather
27170 than applying the default simplifications to this formula. So an
27171 @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
27172 would not apply. (However, if you put Calc into Symbolic mode so that
27173 @samp{sqrt(13)} will be left in symbolic form by the built-in square
27174 root function, your rule will be able to apply. But if the complex
27175 number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated,
27176 then Symbolic mode will not help because @samp{sqrt(25)} can be
27177 evaluated exactly to 5.)
27179 One subtle restriction that normally only manifests itself with
27180 @code{EvalRules} is that while a given rewrite rule is in the process
27181 of being checked, that same rule cannot be recursively applied. Calc
27182 effectively removes the rule from its rule set while checking the rule,
27183 then puts it back once the match succeeds or fails. (The technical
27184 reason for this is that compiled pattern programs are not reentrant.)
27185 For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
27186 attempting to match @samp{foo(8)}. This rule will be inactive while
27187 the condition @samp{foo(4) > 0} is checked, even though it might be
27188 an integral part of evaluating that condition. Note that this is not
27189 a problem for the more usual recursive type of rule, such as
27190 @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
27191 been reactivated by the time the righthand side is evaluated.
27193 If @code{EvalRules} has no stored value (its default state), or if
27194 anything but a vector is stored in it, then it is ignored.
27196 Even though Calc's rewrite mechanism is designed to compare rewrite
27197 rules to formulas as quickly as possible, storing rules in
27198 @code{EvalRules} may make Calc run substantially slower. This is
27199 particularly true of rules where the top-level call is a commonly used
27200 function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will
27201 only activate the rewrite mechanism for calls to the function @code{f},
27202 but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
27205 apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
27209 may seem more ``efficient'' than two separate rules for @code{ln} and
27210 @code{log10}, but actually it is vastly less efficient because rules
27211 with @code{apply} as the top-level pattern must be tested against
27212 @emph{every} function call that is simplified.
27214 @cindex @code{AlgSimpRules} variable
27215 @vindex AlgSimpRules
27216 Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
27217 but only when @kbd{a s} is used to simplify the formula. The variable
27218 @code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command
27219 will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as
27220 well as all of its built-in simplifications.
27222 Most of the special limitations for @code{EvalRules} don't apply to
27223 @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules}
27224 command with an infinite repeat count as the first step of @kbd{a s}.
27225 It then applies its own built-in simplifications throughout the
27226 formula, and then repeats these two steps (along with applying the
27227 default simplifications) until no further changes are possible.
27229 @cindex @code{ExtSimpRules} variable
27230 @cindex @code{UnitSimpRules} variable
27231 @vindex ExtSimpRules
27232 @vindex UnitSimpRules
27233 There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
27234 that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
27235 also apply @code{EvalRules} and @code{AlgSimpRules}. The variable
27236 @code{IntegSimpRules} contains simplification rules that are used
27237 only during integration by @kbd{a i}.
27239 @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
27240 @subsection Debugging Rewrites
27243 If a buffer named @samp{*Trace*} exists, the rewrite mechanism will
27244 record some useful information there as it operates. The original
27245 formula is written there, as is the result of each successful rewrite,
27246 and the final result of the rewriting. All phase changes are also
27249 Calc always appends to @samp{*Trace*}. You must empty this buffer
27250 yourself periodically if it is in danger of growing unwieldy.
27252 Note that the rewriting mechanism is substantially slower when the
27253 @samp{*Trace*} buffer exists, even if the buffer is not visible on
27254 the screen. Once you are done, you will probably want to kill this
27255 buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in
27256 existence and forget about it, all your future rewrite commands will
27257 be needlessly slow.
27259 @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
27260 @subsection Examples of Rewrite Rules
27263 Returning to the example of substituting the pattern
27264 @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
27265 @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
27266 finding suitable cases. Another solution would be to use the rule
27267 @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
27268 if necessary. This rule will be the most effective way to do the job,
27269 but at the expense of making some changes that you might not desire.
27271 Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
27272 To make this work with the @w{@kbd{j r}} command so that it can be
27273 easily targeted to a particular exponential in a large formula,
27274 you might wish to write the rule as @samp{select(exp(x+y)) :=
27275 select(exp(x) exp(y))}. The @samp{select} markers will be
27276 ignored by the regular @kbd{a r} command
27277 (@pxref{Selections with Rewrite Rules}).
27279 A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
27280 This will simplify the formula whenever @expr{b} and/or @expr{c} can
27281 be made simpler by squaring. For example, applying this rule to
27282 @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
27283 Symbolic mode has been enabled to keep the square root from being
27284 evaluated to a floating-point approximation). This rule is also
27285 useful when working with symbolic complex numbers, e.g.,
27286 @samp{(a + b i) / (c + d i)}.
27288 As another example, we could define our own ``triangular numbers'' function
27289 with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter
27290 this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given
27291 a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
27292 to apply these rules repeatedly. After six applications, @kbd{a r} will
27293 stop with 15 on the stack. Once these rules are debugged, it would probably
27294 be most useful to add them to @code{EvalRules} so that Calc will evaluate
27295 the new @code{tri} function automatically. We could then use @kbd{Z K} on
27296 the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
27297 @code{tri} to the value on the top of the stack. @xref{Programming}.
27299 @cindex Quaternions
27300 The following rule set, contributed by
27301 @texline Fran\c cois
27303 Pinard, implements @dfn{quaternions}, a generalization of the concept of
27304 complex numbers. Quaternions have four components, and are here
27305 represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y},
27306 @var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts
27307 collected into a vector. Various arithmetical operations on quaternions
27308 are supported. To use these rules, either add them to @code{EvalRules},
27309 or create a command based on @kbd{a r} for simplifying quaternion
27310 formulas. A convenient way to enter quaternions would be a command
27311 defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $])
27315 [ quat(w, x, y, z) := quat(w, [x, y, z]),
27316 quat(w, [0, 0, 0]) := w,
27317 abs(quat(w, v)) := hypot(w, v),
27318 -quat(w, v) := quat(-w, -v),
27319 r + quat(w, v) := quat(r + w, v) :: real(r),
27320 r - quat(w, v) := quat(r - w, -v) :: real(r),
27321 quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
27322 r * quat(w, v) := quat(r * w, r * v) :: real(r),
27323 plain(quat(w1, v1) * quat(w2, v2))
27324 := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
27325 quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
27326 z / quat(w, v) := z * quatinv(quat(w, v)),
27327 quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
27328 quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
27329 quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
27330 :: integer(k) :: k > 0 :: k % 2 = 0,
27331 quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
27332 :: integer(k) :: k > 2,
27333 quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
27336 Quaternions, like matrices, have non-commutative multiplication.
27337 In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if
27338 @expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat}
27339 rule above uses @code{plain} to prevent Calc from rearranging the
27340 product. It may also be wise to add the line @samp{[quat(), matrix]}
27341 to the @code{Decls} matrix, to ensure that Calc's other algebraic
27342 operations will not rearrange a quaternion product. @xref{Declarations}.
27344 These rules also accept a four-argument @code{quat} form, converting
27345 it to the preferred form in the first rule. If you would rather see
27346 results in the four-argument form, just append the two items
27347 @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
27348 of the rule set. (But remember that multi-phase rule sets don't work
27349 in @code{EvalRules}.)
27351 @node Units, Store and Recall, Algebra, Top
27352 @chapter Operating on Units
27355 One special interpretation of algebraic formulas is as numbers with units.
27356 For example, the formula @samp{5 m / s^2} can be read ``five meters
27357 per second squared.'' The commands in this chapter help you
27358 manipulate units expressions in this form. Units-related commands
27359 begin with the @kbd{u} prefix key.
27362 * Basic Operations on Units::
27363 * The Units Table::
27364 * Predefined Units::
27365 * User-Defined Units::
27368 @node Basic Operations on Units, The Units Table, Units, Units
27369 @section Basic Operations on Units
27372 A @dfn{units expression} is a formula which is basically a number
27373 multiplied and/or divided by one or more @dfn{unit names}, which may
27374 optionally be raised to integer powers. Actually, the value part need not
27375 be a number; any product or quotient involving unit names is a units
27376 expression. Many of the units commands will also accept any formula,
27377 where the command applies to all units expressions which appear in the
27380 A unit name is a variable whose name appears in the @dfn{unit table},
27381 or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
27382 or @samp{u} (for ``micro'') followed by a name in the unit table.
27383 A substantial table of built-in units is provided with Calc;
27384 @pxref{Predefined Units}. You can also define your own unit names;
27385 @pxref{User-Defined Units}.
27387 Note that if the value part of a units expression is exactly @samp{1},
27388 it will be removed by the Calculator's automatic algebra routines: The
27389 formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a
27390 display anomaly, however; @samp{mm} will work just fine as a
27391 representation of one millimeter.
27393 You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working
27394 with units expressions easier. Otherwise, you will have to remember
27395 to hit the apostrophe key every time you wish to enter units.
27398 @pindex calc-simplify-units
27400 @mindex usimpl@idots
27403 The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
27405 expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the
27406 expression first as a regular algebraic formula; it then looks for
27407 features that can be further simplified by converting one object's units
27408 to be compatible with another's. For example, @samp{5 m + 23 mm} will
27409 simplify to @samp{5.023 m}. When different but compatible units are
27410 added, the righthand term's units are converted to match those of the
27411 lefthand term. @xref{Simplification Modes}, for a way to have this done
27412 automatically at all times.
27414 Units simplification also handles quotients of two units with the same
27415 dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
27416 powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
27417 @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
27418 @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
27419 @code{float}, @code{frac}, @code{abs}, and @code{clean}
27420 applied to units expressions, in which case
27421 the operation in question is applied only to the numeric part of the
27422 expression. Finally, trigonometric functions of quantities with units
27423 of angle are evaluated, regardless of the current angular mode.
27426 @pindex calc-convert-units
27427 The @kbd{u c} (@code{calc-convert-units}) command converts a units
27428 expression to new, compatible units. For example, given the units
27429 expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
27430 @samp{24.5872 m/s}. If you have previously converted a units expression
27431 with the same type of units (in this case, distance over time), you will
27432 be offered the previous choice of new units as a default. Continuing
27433 the above example, entering the units expression @samp{100 km/hr} and
27434 typing @kbd{u c @key{RET}} (without specifying new units) produces
27435 @samp{27.7777777778 m/s}.
27437 While many of Calc's conversion factors are exact, some are necessarily
27438 approximate. If Calc is in fraction mode (@pxref{Fraction Mode}), then
27439 unit conversions will try to give exact, rational conversions, but it
27440 isn't always possible. Given @samp{55 mph} in fraction mode, typing
27441 @kbd{u c m/s @key{RET}} produces @samp{15367:625 m/s}, for example,
27442 while typing @kbd{u c au/yr @key{RET}} produces
27443 @samp{5.18665819999e-3 au/yr}.
27445 If the units you request are inconsistent with the original units, the
27446 number will be converted into your units times whatever ``remainder''
27447 units are left over. For example, converting @samp{55 mph} into acres
27448 produces @samp{6.08e-3 acre / m s}. (Recall that multiplication binds
27449 more strongly than division in Calc formulas, so the units here are
27450 acres per meter-second.) Remainder units are expressed in terms of
27451 ``fundamental'' units like @samp{m} and @samp{s}, regardless of the
27454 One special exception is that if you specify a single unit name, and
27455 a compatible unit appears somewhere in the units expression, then
27456 that compatible unit will be converted to the new unit and the
27457 remaining units in the expression will be left alone. For example,
27458 given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
27459 change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
27460 The ``remainder unit'' @samp{cm} is left alone rather than being
27461 changed to the base unit @samp{m}.
27463 You can use explicit unit conversion instead of the @kbd{u s} command
27464 to gain more control over the units of the result of an expression.
27465 For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
27466 @kbd{u c mm} to express the result in either meters or millimeters.
27467 (For that matter, you could type @kbd{u c fath} to express the result
27468 in fathoms, if you preferred!)
27470 In place of a specific set of units, you can also enter one of the
27471 units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
27472 For example, @kbd{u c si @key{RET}} converts the expression into
27473 International System of Units (SI) base units. Also, @kbd{u c base}
27474 converts to Calc's base units, which are the same as @code{si} units
27475 except that @code{base} uses @samp{g} as the fundamental unit of mass
27476 whereas @code{si} uses @samp{kg}.
27478 @cindex Composite units
27479 The @kbd{u c} command also accepts @dfn{composite units}, which
27480 are expressed as the sum of several compatible unit names. For
27481 example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
27482 feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first
27483 sorts the unit names into order of decreasing relative size.
27484 It then accounts for as much of the input quantity as it can
27485 using an integer number times the largest unit, then moves on
27486 to the next smaller unit, and so on. Only the smallest unit
27487 may have a non-integer amount attached in the result. A few
27488 standard unit names exist for common combinations, such as
27489 @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
27490 Composite units are expanded as if by @kbd{a x}, so that
27491 @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
27493 If the value on the stack does not contain any units, @kbd{u c} will
27494 prompt first for the old units which this value should be considered
27495 to have, then for the new units. Assuming the old and new units you
27496 give are consistent with each other, the result also will not contain
27497 any units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts the number
27498 2 on the stack to 5.08.
27501 @pindex calc-base-units
27502 The @kbd{u b} (@code{calc-base-units}) command is shorthand for
27503 @kbd{u c base}; it converts the units expression on the top of the
27504 stack into @code{base} units. If @kbd{u s} does not simplify a
27505 units expression as far as you would like, try @kbd{u b}.
27507 The @kbd{u c} and @kbd{u b} commands treat temperature units (like
27508 @samp{degC} and @samp{K}) as relative temperatures. For example,
27509 @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10
27510 degrees Celsius corresponds to a change of 18 degrees Fahrenheit.
27513 @pindex calc-convert-temperature
27514 @cindex Temperature conversion
27515 The @kbd{u t} (@code{calc-convert-temperature}) command converts
27516 absolute temperatures. The value on the stack must be a simple units
27517 expression with units of temperature only. This command would convert
27518 @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the
27522 @pindex calc-remove-units
27524 @pindex calc-extract-units
27525 The @kbd{u r} (@code{calc-remove-units}) command removes units from the
27526 formula at the top of the stack. The @kbd{u x}
27527 (@code{calc-extract-units}) command extracts only the units portion of a
27528 formula. These commands essentially replace every term of the formula
27529 that does or doesn't (respectively) look like a unit name by the
27530 constant 1, then resimplify the formula.
27533 @pindex calc-autorange-units
27534 The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
27535 mode in which unit prefixes like @code{k} (``kilo'') are automatically
27536 applied to keep the numeric part of a units expression in a reasonable
27537 range. This mode affects @kbd{u s} and all units conversion commands
27538 except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz}
27539 will be simplified to @samp{12.345 kHz}. Autoranging is useful for
27540 some kinds of units (like @code{Hz} and @code{m}), but is probably
27541 undesirable for non-metric units like @code{ft} and @code{tbsp}.
27542 (Composite units are more appropriate for those; see above.)
27544 Autoranging always applies the prefix to the leftmost unit name.
27545 Calc chooses the largest prefix that causes the number to be greater
27546 than or equal to 1.0. Thus an increasing sequence of adjusted times
27547 would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
27548 Generally the rule of thumb is that the number will be adjusted
27549 to be in the interval @samp{[1 .. 1000)}, although there are several
27550 exceptions to this rule. First, if the unit has a power then this
27551 is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
27552 Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
27553 but will not apply to other units. The ``deci-,'' ``deka-,'' and
27554 ``hecto-'' prefixes are never used. Thus the allowable interval is
27555 @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
27556 Finally, a prefix will not be added to a unit if the resulting name
27557 is also the actual name of another unit; @samp{1e-15 t} would normally
27558 be considered a ``femto-ton,'' but it is written as @samp{1000 at}
27559 (1000 atto-tons) instead because @code{ft} would be confused with feet.
27561 @node The Units Table, Predefined Units, Basic Operations on Units, Units
27562 @section The Units Table
27566 @pindex calc-enter-units-table
27567 The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
27568 in another buffer called @code{*Units Table*}. Each entry in this table
27569 gives the unit name as it would appear in an expression, the definition
27570 of the unit in terms of simpler units, and a full name or description of
27571 the unit. Fundamental units are defined as themselves; these are the
27572 units produced by the @kbd{u b} command. The fundamental units are
27573 meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
27576 The Units Table buffer also displays the Unit Prefix Table. Note that
27577 two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
27578 prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M}
27579 prefix. Whenever a unit name can be interpreted as either a built-in name
27580 or a prefix followed by another built-in name, the former interpretation
27581 wins. For example, @samp{2 pt} means two pints, not two pico-tons.
27583 The Units Table buffer, once created, is not rebuilt unless you define
27584 new units. To force the buffer to be rebuilt, give any numeric prefix
27585 argument to @kbd{u v}.
27588 @pindex calc-view-units-table
27589 The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
27590 that the cursor is not moved into the Units Table buffer. You can
27591 type @kbd{u V} again to remove the Units Table from the display. To
27592 return from the Units Table buffer after a @kbd{u v}, type @kbd{C-x * c}
27593 again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
27594 command. You can also kill the buffer with @kbd{C-x k} if you wish;
27595 the actual units table is safely stored inside the Calculator.
27598 @pindex calc-get-unit-definition
27599 The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
27600 defining expression and pushes it onto the Calculator stack. For example,
27601 @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the
27602 same definition for the unit that would appear in the Units Table buffer.
27603 Note that this command works only for actual unit names; @kbd{u g km}
27604 will report that no such unit exists, for example, because @code{km} is
27605 really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a
27606 definition of a unit in terms of base units, it is easier to push the
27607 unit name on the stack and then reduce it to base units with @kbd{u b}.
27610 @pindex calc-explain-units
27611 The @kbd{u e} (@code{calc-explain-units}) command displays an English
27612 description of the units of the expression on the stack. For example,
27613 for the expression @samp{62 km^2 g / s^2 mol K}, the description is
27614 ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This
27615 command uses the English descriptions that appear in the righthand
27616 column of the Units Table.
27618 @node Predefined Units, User-Defined Units, The Units Table, Units
27619 @section Predefined Units
27622 Since the exact definitions of many kinds of units have evolved over the
27623 years, and since certain countries sometimes have local differences in
27624 their definitions, it is a good idea to examine Calc's definition of a
27625 unit before depending on its exact value. For example, there are three
27626 different units for gallons, corresponding to the US (@code{gal}),
27627 Canadian (@code{galC}), and British (@code{galUK}) definitions. Also,
27628 note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
27629 ounce, and @code{ozfl} is a fluid ounce.
27631 The temperature units corresponding to degrees Kelvin and Centigrade
27632 (Celsius) are the same in this table, since most units commands treat
27633 temperatures as being relative. The @code{calc-convert-temperature}
27634 command has special rules for handling the different absolute magnitudes
27635 of the various temperature scales.
27637 The unit of volume ``liters'' can be referred to by either the lower-case
27638 @code{l} or the upper-case @code{L}.
27640 The unit @code{A} stands for Amperes; the name @code{Ang} is used
27648 The unit @code{pt} stands for pints; the name @code{point} stands for
27649 a typographical point, defined by @samp{72 point = 1 in}. This is
27650 slightly different than the point defined by the American Typefounder's
27651 Association in 1886, but the point used by Calc has become standard
27652 largely due to its use by the PostScript page description language.
27653 There is also @code{texpt}, which stands for a printer's point as
27654 defined by the @TeX{} typesetting system: @samp{72.27 texpt = 1 in}.
27655 Other units used by @TeX{} are available; they are @code{texpc} (a pica),
27656 @code{texbp} (a ``big point'', equal to a standard point which is larger
27657 than the point used by @TeX{}), @code{texdd} (a Didot point),
27658 @code{texcc} (a Cicero) and @code{texsp} (a scaled @TeX{} point,
27659 all dimensions representable in @TeX{} are multiples of this value).
27661 The unit @code{e} stands for the elementary (electron) unit of charge;
27662 because algebra command could mistake this for the special constant
27663 @expr{e}, Calc provides the alternate unit name @code{ech} which is
27664 preferable to @code{e}.
27666 The name @code{g} stands for one gram of mass; there is also @code{gf},
27667 one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
27668 Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}.
27670 The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
27671 a metric ton of @samp{1000 kg}.
27673 The names @code{s} (or @code{sec}) and @code{min} refer to units of
27674 time; @code{arcsec} and @code{arcmin} are units of angle.
27676 Some ``units'' are really physical constants; for example, @code{c}
27677 represents the speed of light, and @code{h} represents Planck's
27678 constant. You can use these just like other units: converting
27679 @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
27680 meters per second. You can also use this merely as a handy reference;
27681 the @kbd{u g} command gets the definition of one of these constants
27682 in its normal terms, and @kbd{u b} expresses the definition in base
27685 Two units, @code{pi} and @code{alpha} (the fine structure constant,
27686 approximately @mathit{1/137}) are dimensionless. The units simplification
27687 commands simply treat these names as equivalent to their corresponding
27688 values. However you can, for example, use @kbd{u c} to convert a pure
27689 number into multiples of the fine structure constant, or @kbd{u b} to
27690 convert this back into a pure number. (When @kbd{u c} prompts for the
27691 ``old units,'' just enter a blank line to signify that the value
27692 really is unitless.)
27694 @c Describe angular units, luminosity vs. steradians problem.
27696 @node User-Defined Units, , Predefined Units, Units
27697 @section User-Defined Units
27700 Calc provides ways to get quick access to your selected ``favorite''
27701 units, as well as ways to define your own new units.
27704 @pindex calc-quick-units
27706 @cindex @code{Units} variable
27707 @cindex Quick units
27708 To select your favorite units, store a vector of unit names or
27709 expressions in the Calc variable @code{Units}. The @kbd{u 1}
27710 through @kbd{u 9} commands (@code{calc-quick-units}) provide access
27711 to these units. If the value on the top of the stack is a plain
27712 number (with no units attached), then @kbd{u 1} gives it the
27713 specified units. (Basically, it multiplies the number by the
27714 first item in the @code{Units} vector.) If the number on the
27715 stack @emph{does} have units, then @kbd{u 1} converts that number
27716 to the new units. For example, suppose the vector @samp{[in, ft]}
27717 is stored in @code{Units}. Then @kbd{30 u 1} will create the
27718 expression @samp{30 in}, and @kbd{u 2} will convert that expression
27721 The @kbd{u 0} command accesses the tenth element of @code{Units}.
27722 Only ten quick units may be defined at a time. If the @code{Units}
27723 variable has no stored value (the default), or if its value is not
27724 a vector, then the quick-units commands will not function. The
27725 @kbd{s U} command is a convenient way to edit the @code{Units}
27726 variable; @pxref{Operations on Variables}.
27729 @pindex calc-define-unit
27730 @cindex User-defined units
27731 The @kbd{u d} (@code{calc-define-unit}) command records the units
27732 expression on the top of the stack as the definition for a new,
27733 user-defined unit. For example, putting @samp{16.5 ft} on the stack and
27734 typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
27735 16.5 feet. The unit conversion and simplification commands will now
27736 treat @code{rod} just like any other unit of length. You will also be
27737 prompted for an optional English description of the unit, which will
27738 appear in the Units Table.
27741 @pindex calc-undefine-unit
27742 The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
27743 unit. It is not possible to remove one of the predefined units,
27746 If you define a unit with an existing unit name, your new definition
27747 will replace the original definition of that unit. If the unit was a
27748 predefined unit, the old definition will not be replaced, only
27749 ``shadowed.'' The built-in definition will reappear if you later use
27750 @kbd{u u} to remove the shadowing definition.
27752 To create a new fundamental unit, use either 1 or the unit name itself
27753 as the defining expression. Otherwise the expression can involve any
27754 other units that you like (except for composite units like @samp{mfi}).
27755 You can create a new composite unit with a sum of other units as the
27756 defining expression. The next unit operation like @kbd{u c} or @kbd{u v}
27757 will rebuild the internal unit table incorporating your modifications.
27758 Note that erroneous definitions (such as two units defined in terms of
27759 each other) will not be detected until the unit table is next rebuilt;
27760 @kbd{u v} is a convenient way to force this to happen.
27762 Temperature units are treated specially inside the Calculator; it is not
27763 possible to create user-defined temperature units.
27766 @pindex calc-permanent-units
27767 @cindex Calc init file, user-defined units
27768 The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
27769 units in your Calc init file (the file given by the variable
27770 @code{calc-settings-file}, typically @file{~/.calc.el}), so that the
27771 units will still be available in subsequent Emacs sessions. If there
27772 was already a set of user-defined units in your Calc init file, it
27773 is replaced by the new set. (@xref{General Mode Commands}, for a way to
27774 tell Calc to use a different file for the Calc init file.)
27776 @node Store and Recall, Graphics, Units, Top
27777 @chapter Storing and Recalling
27780 Calculator variables are really just Lisp variables that contain numbers
27781 or formulas in a form that Calc can understand. The commands in this
27782 section allow you to manipulate variables conveniently. Commands related
27783 to variables use the @kbd{s} prefix key.
27786 * Storing Variables::
27787 * Recalling Variables::
27788 * Operations on Variables::
27790 * Evaluates-To Operator::
27793 @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
27794 @section Storing Variables
27799 @cindex Storing variables
27800 @cindex Quick variables
27803 The @kbd{s s} (@code{calc-store}) command stores the value at the top of
27804 the stack into a specified variable. It prompts you to enter the
27805 name of the variable. If you press a single digit, the value is stored
27806 immediately in one of the ``quick'' variables @code{q0} through
27807 @code{q9}. Or you can enter any variable name.
27810 @pindex calc-store-into
27811 The @kbd{s s} command leaves the stored value on the stack. There is
27812 also an @kbd{s t} (@code{calc-store-into}) command, which removes a
27813 value from the stack and stores it in a variable.
27815 If the top of stack value is an equation @samp{a = 7} or assignment
27816 @samp{a := 7} with a variable on the lefthand side, then Calc will
27817 assign that variable with that value by default, i.e., if you type
27818 @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the
27819 value 7 would be stored in the variable @samp{a}. (If you do type
27820 a variable name at the prompt, the top-of-stack value is stored in
27821 its entirety, even if it is an equation: @samp{s s b @key{RET}}
27822 with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
27824 In fact, the top of stack value can be a vector of equations or
27825 assignments with different variables on their lefthand sides; the
27826 default will be to store all the variables with their corresponding
27827 righthand sides simultaneously.
27829 It is also possible to type an equation or assignment directly at
27830 the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}.
27831 In this case the expression to the right of the @kbd{=} or @kbd{:=}
27832 symbol is evaluated as if by the @kbd{=} command, and that value is
27833 stored in the variable. No value is taken from the stack; @kbd{s s}
27834 and @kbd{s t} are equivalent when used in this way.
27838 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
27839 digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
27840 equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used
27841 for trail and time/date commands.)
27877 @pindex calc-store-plus
27878 @pindex calc-store-minus
27879 @pindex calc-store-times
27880 @pindex calc-store-div
27881 @pindex calc-store-power
27882 @pindex calc-store-concat
27883 @pindex calc-store-neg
27884 @pindex calc-store-inv
27885 @pindex calc-store-decr
27886 @pindex calc-store-incr
27887 There are also several ``arithmetic store'' commands. For example,
27888 @kbd{s +} removes a value from the stack and adds it to the specified
27889 variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
27890 @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
27891 @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
27892 and @kbd{s ]} which decrease or increase a variable by one.
27894 All the arithmetic stores accept the Inverse prefix to reverse the
27895 order of the operands. If @expr{v} represents the contents of the
27896 variable, and @expr{a} is the value drawn from the stack, then regular
27897 @w{@kbd{s -}} assigns
27898 @texline @math{v \coloneq v - a},
27899 @infoline @expr{v := v - a},
27900 but @kbd{I s -} assigns
27901 @texline @math{v \coloneq a - v}.
27902 @infoline @expr{v := a - v}.
27903 While @kbd{I s *} might seem pointless, it is
27904 useful if matrix multiplication is involved. Actually, all the
27905 arithmetic stores use formulas designed to behave usefully both
27906 forwards and backwards:
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 / v := v / a v := a / v
27914 s ^ v := v ^ a v := a ^ v
27915 s | v := v | a v := a | v
27916 s n v := v / (-1) v := (-1) / v
27917 s & v := v ^ (-1) v := (-1) ^ v
27918 s [ v := v - 1 v := 1 - v
27919 s ] v := v - (-1) v := (-1) - v
27923 In the last four cases, a numeric prefix argument will be used in
27924 place of the number one. (For example, @kbd{M-2 s ]} increases
27925 a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
27926 minus-two minus the variable.
27928 The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
27929 etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
27930 arithmetic stores that don't remove the value @expr{a} from the stack.
27932 All arithmetic stores report the new value of the variable in the
27933 Trail for your information. They signal an error if the variable
27934 previously had no stored value. If default simplifications have been
27935 turned off, the arithmetic stores temporarily turn them on for numeric
27936 arguments only (i.e., they temporarily do an @kbd{m N} command).
27937 @xref{Simplification Modes}. Large vectors put in the trail by
27938 these commands always use abbreviated (@kbd{t .}) mode.
27941 @pindex calc-store-map
27942 The @kbd{s m} command is a general way to adjust a variable's value
27943 using any Calc function. It is a ``mapping'' command analogous to
27944 @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see
27945 how to specify a function for a mapping command. Basically,
27946 all you do is type the Calc command key that would invoke that
27947 function normally. For example, @kbd{s m n} applies the @kbd{n}
27948 key to negate the contents of the variable, so @kbd{s m n} is
27949 equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root
27950 of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
27951 reverse the vector stored in the variable, and @kbd{s m H I S}
27952 takes the hyperbolic arcsine of the variable contents.
27954 If the mapping function takes two or more arguments, the additional
27955 arguments are taken from the stack; the old value of the variable
27956 is provided as the first argument. Thus @kbd{s m -} with @expr{a}
27957 on the stack computes @expr{v - a}, just like @kbd{s -}. With the
27958 Inverse prefix, the variable's original value becomes the @emph{last}
27959 argument instead of the first. Thus @kbd{I s m -} is also
27960 equivalent to @kbd{I s -}.
27963 @pindex calc-store-exchange
27964 The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
27965 of a variable with the value on the top of the stack. Naturally, the
27966 variable must already have a stored value for this to work.
27968 You can type an equation or assignment at the @kbd{s x} prompt. The
27969 command @kbd{s x a=6} takes no values from the stack; instead, it
27970 pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
27973 @pindex calc-unstore
27974 @cindex Void variables
27975 @cindex Un-storing variables
27976 Until you store something in them, most variables are ``void,'' that is,
27977 they contain no value at all. If they appear in an algebraic formula
27978 they will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
27979 The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
27983 @pindex calc-copy-variable
27984 The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
27985 value of one variable to another. One way it differs from a simple
27986 @kbd{s r} followed by an @kbd{s t} (aside from saving keystrokes) is
27987 that the value never goes on the stack and thus is never rounded,
27988 evaluated, or simplified in any way; it is not even rounded down to the
27991 The only variables with predefined values are the ``special constants''
27992 @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free
27993 to unstore these variables or to store new values into them if you like,
27994 although some of the algebraic-manipulation functions may assume these
27995 variables represent their standard values. Calc displays a warning if
27996 you change the value of one of these variables, or of one of the other
27997 special variables @code{inf}, @code{uinf}, and @code{nan} (which are
28000 Note that @code{pi} doesn't actually have 3.14159265359 stored in it,
28001 but rather a special magic value that evaluates to @cpi{} at the current
28002 precision. Likewise @code{e}, @code{i}, and @code{phi} evaluate
28003 according to the current precision or polar mode. If you recall a value
28004 from @code{pi} and store it back, this magic property will be lost. The
28005 magic property is preserved, however, when a variable is copied with
28009 @pindex calc-copy-special-constant
28010 If one of the ``special constants'' is redefined (or undefined) so that
28011 it no longer has its magic property, the property can be restored with
28012 @kbd{s k} (@code{calc-copy-special-constant}). This command will prompt
28013 for a special constant and a variable to store it in, and so a special
28014 constant can be stored in any variable. Here, the special constant that
28015 you enter doesn't depend on the value of the corresponding variable;
28016 @code{pi} will represent 3.14159@dots{} regardless of what is currently
28017 stored in the Calc variable @code{pi}. If one of the other special
28018 variables, @code{inf}, @code{uinf} or @code{nan}, is given a value, its
28019 original behavior can be restored by voiding it with @kbd{s u}.
28021 @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
28022 @section Recalling Variables
28026 @pindex calc-recall
28027 @cindex Recalling variables
28028 The most straightforward way to extract the stored value from a variable
28029 is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts
28030 for a variable name (similarly to @code{calc-store}), looks up the value
28031 of the specified variable, and pushes that value onto the stack. It is
28032 an error to try to recall a void variable.
28034 It is also possible to recall the value from a variable by evaluating a
28035 formula containing that variable. For example, @kbd{' a @key{RET} =} is
28036 the same as @kbd{s r a @key{RET}} except that if the variable is void, the
28037 former will simply leave the formula @samp{a} on the stack whereas the
28038 latter will produce an error message.
28041 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
28042 equivalent to @kbd{s r 9}. (The @kbd{r} prefix is otherwise unused
28043 in the current version of Calc.)
28045 @node Operations on Variables, Let Command, Recalling Variables, Store and Recall
28046 @section Other Operations on Variables
28050 @pindex calc-edit-variable
28051 The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
28052 value of a variable without ever putting that value on the stack
28053 or simplifying or evaluating the value. It prompts for the name of
28054 the variable to edit. If the variable has no stored value, the
28055 editing buffer will start out empty. If the editing buffer is
28056 empty when you press @kbd{C-c C-c} to finish, the variable will
28057 be made void. @xref{Editing Stack Entries}, for a general
28058 description of editing.
28060 The @kbd{s e} command is especially useful for creating and editing
28061 rewrite rules which are stored in variables. Sometimes these rules
28062 contain formulas which must not be evaluated until the rules are
28063 actually used. (For example, they may refer to @samp{deriv(x,y)},
28064 where @code{x} will someday become some expression involving @code{y};
28065 if you let Calc evaluate the rule while you are defining it, Calc will
28066 replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
28067 not itself refer to @code{y}.) By contrast, recalling the variable,
28068 editing with @kbd{`}, and storing will evaluate the variable's value
28069 as a side effect of putting the value on the stack.
28117 @pindex calc-store-AlgSimpRules
28118 @pindex calc-store-Decls
28119 @pindex calc-store-EvalRules
28120 @pindex calc-store-FitRules
28121 @pindex calc-store-GenCount
28122 @pindex calc-store-Holidays
28123 @pindex calc-store-IntegLimit
28124 @pindex calc-store-LineStyles
28125 @pindex calc-store-PointStyles
28126 @pindex calc-store-PlotRejects
28127 @pindex calc-store-TimeZone
28128 @pindex calc-store-Units
28129 @pindex calc-store-ExtSimpRules
28130 There are several special-purpose variable-editing commands that
28131 use the @kbd{s} prefix followed by a shifted letter:
28135 Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}.
28137 Edit @code{Decls}. @xref{Declarations}.
28139 Edit @code{EvalRules}. @xref{Default Simplifications}.
28141 Edit @code{FitRules}. @xref{Curve Fitting}.
28143 Edit @code{GenCount}. @xref{Solving Equations}.
28145 Edit @code{Holidays}. @xref{Business Days}.
28147 Edit @code{IntegLimit}. @xref{Calculus}.
28149 Edit @code{LineStyles}. @xref{Graphics}.
28151 Edit @code{PointStyles}. @xref{Graphics}.
28153 Edit @code{PlotRejects}. @xref{Graphics}.
28155 Edit @code{TimeZone}. @xref{Time Zones}.
28157 Edit @code{Units}. @xref{User-Defined Units}.
28159 Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}.
28162 These commands are just versions of @kbd{s e} that use fixed variable
28163 names rather than prompting for the variable name.
28166 @pindex calc-permanent-variable
28167 @cindex Storing variables
28168 @cindex Permanent variables
28169 @cindex Calc init file, variables
28170 The @kbd{s p} (@code{calc-permanent-variable}) command saves a
28171 variable's value permanently in your Calc init file (the file given by
28172 the variable @code{calc-settings-file}, typically @file{~/.calc.el}), so
28173 that its value will still be available in future Emacs sessions. You
28174 can re-execute @w{@kbd{s p}} later on to update the saved value, but the
28175 only way to remove a saved variable is to edit your calc init file
28176 by hand. (@xref{General Mode Commands}, for a way to tell Calc to
28177 use a different file for the Calc init file.)
28179 If you do not specify the name of a variable to save (i.e.,
28180 @kbd{s p @key{RET}}), all Calc variables with defined values
28181 are saved except for the special constants @code{pi}, @code{e},
28182 @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
28183 and @code{PlotRejects};
28184 @code{FitRules}, @code{DistribRules}, and other built-in rewrite
28185 rules; and @code{PlotData@var{n}} variables generated
28186 by the graphics commands. (You can still save these variables by
28187 explicitly naming them in an @kbd{s p} command.)
28190 @pindex calc-insert-variables
28191 The @kbd{s i} (@code{calc-insert-variables}) command writes
28192 the values of all Calc variables into a specified buffer.
28193 The variables are written with the prefix @code{var-} in the form of
28194 Lisp @code{setq} commands
28195 which store the values in string form. You can place these commands
28196 in your Calc init file (or @file{.emacs}) if you wish, though in this case it
28197 would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i}
28198 omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
28199 is that @kbd{s i} will store the variables in any buffer, and it also
28200 stores in a more human-readable format.)
28202 @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
28203 @section The Let Command
28208 @cindex Variables, temporary assignment
28209 @cindex Temporary assignment to variables
28210 If you have an expression like @samp{a+b^2} on the stack and you wish to
28211 compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and
28212 then press @kbd{=} to reevaluate the formula. This has the side-effect
28213 of leaving the stored value of 3 in @expr{b} for future operations.
28215 The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
28216 @emph{temporary} assignment of a variable. It stores the value on the
28217 top of the stack into the specified variable, then evaluates the
28218 second-to-top stack entry, then restores the original value (or lack of one)
28219 in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
28220 the stack will contain the formula @samp{a + 9}. The subsequent command
28221 @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
28222 The variables @samp{a} and @samp{b} are not permanently affected in any way
28225 The value on the top of the stack may be an equation or assignment, or
28226 a vector of equations or assignments, in which case the default will be
28227 analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}.
28229 Also, you can answer the variable-name prompt with an equation or
28230 assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
28231 and typing @kbd{s l b @key{RET}}.
28233 The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
28234 a variable with a value in a formula. It does an actual substitution
28235 rather than temporarily assigning the variable and evaluating. For
28236 example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will
28237 produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
28238 since the evaluation step will also evaluate @code{pi}.
28240 @node Evaluates-To Operator, , Let Command, Store and Recall
28241 @section The Evaluates-To Operator
28246 @cindex Evaluates-to operator
28247 @cindex @samp{=>} operator
28248 The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
28249 operator}. (It will show up as an @code{evalto} function call in
28250 other language modes like Pascal and La@TeX{}.) This is a binary
28251 operator, that is, it has a lefthand and a righthand argument,
28252 although it can be entered with the righthand argument omitted.
28254 A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
28255 follows: First, @var{a} is not simplified or modified in any
28256 way. The previous value of argument @var{b} is thrown away; the
28257 formula @var{a} is then copied and evaluated as if by the @kbd{=}
28258 command according to all current modes and stored variable values,
28259 and the result is installed as the new value of @var{b}.
28261 For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
28262 The number 17 is ignored, and the lefthand argument is left in its
28263 unevaluated form; the result is the formula @samp{2 + 3 => 5}.
28266 @pindex calc-evalto
28267 You can enter an @samp{=>} formula either directly using algebraic
28268 entry (in which case the righthand side may be omitted since it is
28269 going to be replaced right away anyhow), or by using the @kbd{s =}
28270 (@code{calc-evalto}) command, which takes @var{a} from the stack
28271 and replaces it with @samp{@var{a} => @var{b}}.
28273 Calc keeps track of all @samp{=>} operators on the stack, and
28274 recomputes them whenever anything changes that might affect their
28275 values, i.e., a mode setting or variable value. This occurs only
28276 if the @samp{=>} operator is at the top level of the formula, or
28277 if it is part of a top-level vector. In other words, pushing
28278 @samp{2 + (a => 17)} will change the 17 to the actual value of
28279 @samp{a} when you enter the formula, but the result will not be
28280 dynamically updated when @samp{a} is changed later because the
28281 @samp{=>} operator is buried inside a sum. However, a vector
28282 of @samp{=>} operators will be recomputed, since it is convenient
28283 to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
28284 make a concise display of all the variables in your problem.
28285 (Another way to do this would be to use @samp{[a, b, c] =>},
28286 which provides a slightly different format of display. You
28287 can use whichever you find easiest to read.)
28290 @pindex calc-auto-recompute
28291 The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
28292 turn this automatic recomputation on or off. If you turn
28293 recomputation off, you must explicitly recompute an @samp{=>}
28294 operator on the stack in one of the usual ways, such as by
28295 pressing @kbd{=}. Turning recomputation off temporarily can save
28296 a lot of time if you will be changing several modes or variables
28297 before you look at the @samp{=>} entries again.
28299 Most commands are not especially useful with @samp{=>} operators
28300 as arguments. For example, given @samp{x + 2 => 17}, it won't
28301 work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want
28302 to operate on the lefthand side of the @samp{=>} operator on
28303 the top of the stack, type @kbd{j 1} (that's the digit ``one'')
28304 to select the lefthand side, execute your commands, then type
28305 @kbd{j u} to unselect.
28307 All current modes apply when an @samp{=>} operator is computed,
28308 including the current simplification mode. Recall that the
28309 formula @samp{x + y + x} is not handled by Calc's default
28310 simplifications, but the @kbd{a s} command will reduce it to
28311 the simpler form @samp{y + 2 x}. You can also type @kbd{m A}
28312 to enable an Algebraic Simplification mode in which the
28313 equivalent of @kbd{a s} is used on all of Calc's results.
28314 If you enter @samp{x + y + x =>} normally, the result will
28315 be @samp{x + y + x => x + y + x}. If you change to
28316 Algebraic Simplification mode, the result will be
28317 @samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s}
28318 once will have no effect on @samp{x + y + x => x + y + x},
28319 because the righthand side depends only on the lefthand side
28320 and the current mode settings, and the lefthand side is not
28321 affected by commands like @kbd{a s}.
28323 The ``let'' command (@kbd{s l}) has an interesting interaction
28324 with the @samp{=>} operator. The @kbd{s l} command evaluates the
28325 second-to-top stack entry with the top stack entry supplying
28326 a temporary value for a given variable. As you might expect,
28327 if that stack entry is an @samp{=>} operator its righthand
28328 side will temporarily show this value for the variable. In
28329 fact, all @samp{=>}s on the stack will be updated if they refer
28330 to that variable. But this change is temporary in the sense
28331 that the next command that causes Calc to look at those stack
28332 entries will make them revert to the old variable value.
28336 2: a => a 2: a => 17 2: a => a
28337 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1
28340 17 s l a @key{RET} p 8 @key{RET}
28344 Here the @kbd{p 8} command changes the current precision,
28345 thus causing the @samp{=>} forms to be recomputed after the
28346 influence of the ``let'' is gone. The @kbd{d @key{SPC}} command
28347 (@code{calc-refresh}) is a handy way to force the @samp{=>}
28348 operators on the stack to be recomputed without any other
28352 @pindex calc-assign
28355 Embedded mode also uses @samp{=>} operators. In Embedded mode,
28356 the lefthand side of an @samp{=>} operator can refer to variables
28357 assigned elsewhere in the file by @samp{:=} operators. The
28358 assignment operator @samp{a := 17} does not actually do anything
28359 by itself. But Embedded mode recognizes it and marks it as a sort
28360 of file-local definition of the variable. You can enter @samp{:=}
28361 operators in Algebraic mode, or by using the @kbd{s :}
28362 (@code{calc-assign}) [@code{assign}] command which takes a variable
28363 and value from the stack and replaces them with an assignment.
28365 @xref{TeX and LaTeX Language Modes}, for the way @samp{=>} appears in
28366 @TeX{} language output. The @dfn{eqn} mode gives similar
28367 treatment to @samp{=>}.
28369 @node Graphics, Kill and Yank, Store and Recall, Top
28373 The commands for graphing data begin with the @kbd{g} prefix key. Calc
28374 uses GNUPLOT 2.0 or later to do graphics. These commands will only work
28375 if GNUPLOT is available on your system. (While GNUPLOT sounds like
28376 a relative of GNU Emacs, it is actually completely unrelated.
28377 However, it is free software. It can be obtained from
28378 @samp{http://www.gnuplot.info}.)
28380 @vindex calc-gnuplot-name
28381 If you have GNUPLOT installed on your system but Calc is unable to
28382 find it, you may need to set the @code{calc-gnuplot-name} variable
28383 in your Calc init file or @file{.emacs}. You may also need to set some Lisp
28384 variables to show Calc how to run GNUPLOT on your system; these
28385 are described under @kbd{g D} and @kbd{g O} below. If you are
28386 using the X window system, Calc will configure GNUPLOT for you
28387 automatically. If you have GNUPLOT 3.0 or later and you are not using X,
28388 Calc will configure GNUPLOT to display graphs using simple character
28389 graphics that will work on any terminal.
28393 * Three Dimensional Graphics::
28394 * Managing Curves::
28395 * Graphics Options::
28399 @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
28400 @section Basic Graphics
28404 @pindex calc-graph-fast
28405 The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
28406 This command takes two vectors of equal length from the stack.
28407 The vector at the top of the stack represents the ``y'' values of
28408 the various data points. The vector in the second-to-top position
28409 represents the corresponding ``x'' values. This command runs
28410 GNUPLOT (if it has not already been started by previous graphing
28411 commands) and displays the set of data points. The points will
28412 be connected by lines, and there will also be some kind of symbol
28413 to indicate the points themselves.
28415 The ``x'' entry may instead be an interval form, in which case suitable
28416 ``x'' values are interpolated between the minimum and maximum values of
28417 the interval (whether the interval is open or closed is ignored).
28419 The ``x'' entry may also be a number, in which case Calc uses the
28420 sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc.
28421 (Generally the number 0 or 1 would be used for @expr{x} in this case.)
28423 The ``y'' entry may be any formula instead of a vector. Calc effectively
28424 uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
28425 the result of this must be a formula in a single (unassigned) variable.
28426 The formula is plotted with this variable taking on the various ``x''
28427 values. Graphs of formulas by default use lines without symbols at the
28428 computed data points. Note that if neither ``x'' nor ``y'' is a vector,
28429 Calc guesses at a reasonable number of data points to use. See the
28430 @kbd{g N} command below. (The ``x'' values must be either a vector
28431 or an interval if ``y'' is a formula.)
28437 If ``y'' is (or evaluates to) a formula of the form
28438 @samp{xy(@var{x}, @var{y})} then the result is a
28439 parametric plot. The two arguments of the fictitious @code{xy} function
28440 are used as the ``x'' and ``y'' coordinates of the curve, respectively.
28441 In this case the ``x'' vector or interval you specified is not directly
28442 visible in the graph. For example, if ``x'' is the interval @samp{[0..360]}
28443 and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
28446 Also, ``x'' and ``y'' may each be variable names, in which case Calc
28447 looks for suitable vectors, intervals, or formulas stored in those
28450 The ``x'' and ``y'' values for the data points (as pulled from the vectors,
28451 calculated from the formulas, or interpolated from the intervals) should
28452 be real numbers (integers, fractions, or floats). One exception to this
28453 is that the ``y'' entry can consist of a vector of numbers combined with
28454 error forms, in which case the points will be plotted with the
28455 appropriate error bars. Other than this, if either the ``x''
28456 value or the ``y'' value of a given data point is not a real number, that
28457 data point will be omitted from the graph. The points on either side
28458 of the invalid point will @emph{not} be connected by a line.
28460 See the documentation for @kbd{g a} below for a description of the way
28461 numeric prefix arguments affect @kbd{g f}.
28463 @cindex @code{PlotRejects} variable
28464 @vindex PlotRejects
28465 If you store an empty vector in the variable @code{PlotRejects}
28466 (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
28467 this vector for every data point which was rejected because its
28468 ``x'' or ``y'' values were not real numbers. The result will be
28469 a matrix where each row holds the curve number, data point number,
28470 ``x'' value, and ``y'' value for a rejected data point.
28471 @xref{Evaluates-To Operator}, for a handy way to keep tabs on the
28472 current value of @code{PlotRejects}. @xref{Operations on Variables},
28473 for the @kbd{s R} command which is another easy way to examine
28474 @code{PlotRejects}.
28477 @pindex calc-graph-clear
28478 To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
28479 If the GNUPLOT output device is an X window, the window will go away.
28480 Effects on other kinds of output devices will vary. You don't need
28481 to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
28482 or @kbd{g p} command later on, it will reuse the existing graphics
28483 window if there is one.
28485 @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
28486 @section Three-Dimensional Graphics
28489 @pindex calc-graph-fast-3d
28490 The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
28491 graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
28492 you will see a GNUPLOT error message if you try this command.
28494 The @kbd{g F} command takes three values from the stack, called ``x'',
28495 ``y'', and ``z'', respectively. As was the case for 2D graphs, there
28496 are several options for these values.
28498 In the first case, ``x'' and ``y'' are each vectors (not necessarily of
28499 the same length); either or both may instead be interval forms. The
28500 ``z'' value must be a matrix with the same number of rows as elements
28501 in ``x'', and the same number of columns as elements in ``y''. The
28502 result is a surface plot where
28503 @texline @math{z_{ij}}
28504 @infoline @expr{z_ij}
28505 is the height of the point
28506 at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will
28507 be displayed from a certain default viewpoint; you can change this
28508 viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*}
28509 buffer as described later. See the GNUPLOT documentation for a
28510 description of the @samp{set view} command.
28512 Each point in the matrix will be displayed as a dot in the graph,
28513 and these points will be connected by a grid of lines (@dfn{isolines}).
28515 In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
28516 length. The resulting graph displays a 3D line instead of a surface,
28517 where the coordinates of points along the line are successive triplets
28518 of values from the input vectors.
28520 In the third case, ``x'' and ``y'' are vectors or interval forms, and
28521 ``z'' is any formula involving two variables (not counting variables
28522 with assigned values). These variables are sorted into alphabetical
28523 order; the first takes on values from ``x'' and the second takes on
28524 values from ``y'' to form a matrix of results that are graphed as a
28531 If the ``z'' formula evaluates to a call to the fictitious function
28532 @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
28533 ``parametric surface.'' In this case, the axes of the graph are
28534 taken from the @var{x} and @var{y} values in these calls, and the
28535 ``x'' and ``y'' values from the input vectors or intervals are used only
28536 to specify the range of inputs to the formula. For example, plotting
28537 @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
28538 will draw a sphere. (Since the default resolution for 3D plots is
28539 5 steps in each of ``x'' and ``y'', this will draw a very crude
28540 sphere. You could use the @kbd{g N} command, described below, to
28541 increase this resolution, or specify the ``x'' and ``y'' values as
28542 vectors with more than 5 elements.
28544 It is also possible to have a function in a regular @kbd{g f} plot
28545 evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not
28546 a surface, the result will be a 3D parametric line. For example,
28547 @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
28548 helix (a three-dimensional spiral).
28550 As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
28551 variables containing the relevant data.
28553 @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
28554 @section Managing Curves
28557 The @kbd{g f} command is really shorthand for the following commands:
28558 @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for
28559 @kbd{C-u g d g A g p}. You can gain more control over your graph
28560 by using these commands directly.
28563 @pindex calc-graph-add
28564 The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
28565 represented by the two values on the top of the stack to the current
28566 graph. You can have any number of curves in the same graph. When
28567 you give the @kbd{g p} command, all the curves will be drawn superimposed
28570 The @kbd{g a} command (and many others that affect the current graph)
28571 will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed
28572 in another window. This buffer is a template of the commands that will
28573 be sent to GNUPLOT when it is time to draw the graph. The first
28574 @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding
28575 @kbd{g a} commands add extra curves onto that @code{plot} command.
28576 Other graph-related commands put other GNUPLOT commands into this
28577 buffer. In normal usage you never need to work with this buffer
28578 directly, but you can if you wish. The only constraint is that there
28579 must be only one @code{plot} command, and it must be the last command
28580 in the buffer. If you want to save and later restore a complete graph
28581 configuration, you can use regular Emacs commands to save and restore
28582 the contents of the @samp{*Gnuplot Commands*} buffer.
28586 If the values on the stack are not variable names, @kbd{g a} will invent
28587 variable names for them (of the form @samp{PlotData@var{n}}) and store
28588 the values in those variables. The ``x'' and ``y'' variables are what
28589 go into the @code{plot} command in the template. If you add a curve
28590 that uses a certain variable and then later change that variable, you
28591 can replot the graph without having to delete and re-add the curve.
28592 That's because the variable name, not the vector, interval or formula
28593 itself, is what was added by @kbd{g a}.
28595 A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
28596 stack entries are interpreted as curves. With a positive prefix
28597 argument @expr{n}, the top @expr{n} stack entries are ``y'' values
28598 for @expr{n} different curves which share a common ``x'' value in
28599 the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix
28600 argument is equivalent to @kbd{C-u 1 g a}.)
28602 A prefix of zero or plain @kbd{C-u} means to take two stack entries,
28603 ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
28604 ``y'' values for several curves that share a common ``x''.
28606 A negative prefix argument tells Calc to read @expr{n} vectors from
28607 the stack; each vector @expr{[x, y]} describes an independent curve.
28608 This is the only form of @kbd{g a} that creates several curves at once
28609 that don't have common ``x'' values. (Of course, the range of ``x''
28610 values covered by all the curves ought to be roughly the same if
28611 they are to look nice on the same graph.)
28613 For example, to plot
28614 @texline @math{\sin n x}
28615 @infoline @expr{sin(n x)}
28616 for integers @expr{n}
28617 from 1 to 5, you could use @kbd{v x} to create a vector of integers
28618 (@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
28619 across this vector. The resulting vector of formulas is suitable
28620 for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
28624 @pindex calc-graph-add-3d
28625 The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
28626 to the graph. It is not valid to intermix 2D and 3D curves in a
28627 single graph. This command takes three arguments, ``x'', ``y'',
28628 and ``z'', from the stack. With a positive prefix @expr{n}, it
28629 takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n}
28630 separate ``z''s). With a zero prefix, it takes three stack entries
28631 but the ``z'' entry is a vector of curve values. With a negative
28632 prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}.
28633 The @kbd{g A} command works by adding a @code{splot} (surface-plot)
28634 command to the @samp{*Gnuplot Commands*} buffer.
28636 (Although @kbd{g a} adds a 2D @code{plot} command to the
28637 @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
28638 before sending it to GNUPLOT if it notices that the data points are
28639 evaluating to @code{xyz} calls. It will not work to mix 2D and 3D
28640 @kbd{g a} curves in a single graph, although Calc does not currently
28644 @pindex calc-graph-delete
28645 The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
28646 recently added curve from the graph. It has no effect if there are
28647 no curves in the graph. With a numeric prefix argument of any kind,
28648 it deletes all of the curves from the graph.
28651 @pindex calc-graph-hide
28652 The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
28653 the most recently added curve. A hidden curve will not appear in
28654 the actual plot, but information about it such as its name and line and
28655 point styles will be retained.
28658 @pindex calc-graph-juggle
28659 The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
28660 at the end of the list (the ``most recently added curve'') to the
28661 front of the list. The next-most-recent curve is thus exposed for
28662 @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work
28663 with any curve in the graph even though curve-related commands only
28664 affect the last curve in the list.
28667 @pindex calc-graph-plot
28668 The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
28669 the graph described in the @samp{*Gnuplot Commands*} buffer. Any
28670 GNUPLOT parameters which are not defined by commands in this buffer
28671 are reset to their default values. The variables named in the @code{plot}
28672 command are written to a temporary data file and the variable names
28673 are then replaced by the file name in the template. The resulting
28674 plotting commands are fed to the GNUPLOT program. See the documentation
28675 for the GNUPLOT program for more specific information. All temporary
28676 files are removed when Emacs or GNUPLOT exits.
28678 If you give a formula for ``y'', Calc will remember all the values that
28679 it calculates for the formula so that later plots can reuse these values.
28680 Calc throws out these saved values when you change any circumstances
28681 that may affect the data, such as switching from Degrees to Radians
28682 mode, or changing the value of a parameter in the formula. You can
28683 force Calc to recompute the data from scratch by giving a negative
28684 numeric prefix argument to @kbd{g p}.
28686 Calc uses a fairly rough step size when graphing formulas over intervals.
28687 This is to ensure quick response. You can ``refine'' a plot by giving
28688 a positive numeric prefix argument to @kbd{g p}. Calc goes through
28689 the data points it has computed and saved from previous plots of the
28690 function, and computes and inserts a new data point midway between
28691 each of the existing points. You can refine a plot any number of times,
28692 but beware that the amount of calculation involved doubles each time.
28694 Calc does not remember computed values for 3D graphs. This means the
28695 numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
28696 the current graph is three-dimensional.
28699 @pindex calc-graph-print
28700 The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
28701 except that it sends the output to a printer instead of to the
28702 screen. More precisely, @kbd{g p} looks for @samp{set terminal}
28703 or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer;
28704 lacking these it uses the default settings. However, @kbd{g P}
28705 ignores @samp{set terminal} and @samp{set output} commands and
28706 uses a different set of default values. All of these values are
28707 controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
28708 Provided everything is set up properly, @kbd{g p} will plot to
28709 the screen unless you have specified otherwise and @kbd{g P} will
28710 always plot to the printer.
28712 @node Graphics Options, Devices, Managing Curves, Graphics
28713 @section Graphics Options
28717 @pindex calc-graph-grid
28718 The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
28719 on and off. It is off by default; tick marks appear only at the
28720 edges of the graph. With the grid turned on, dotted lines appear
28721 across the graph at each tick mark. Note that this command only
28722 changes the setting in @samp{*Gnuplot Commands*}; to see the effects
28723 of the change you must give another @kbd{g p} command.
28726 @pindex calc-graph-border
28727 The @kbd{g b} (@code{calc-graph-border}) command turns the border
28728 (the box that surrounds the graph) on and off. It is on by default.
28729 This command will only work with GNUPLOT 3.0 and later versions.
28732 @pindex calc-graph-key
28733 The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
28734 on and off. The key is a chart in the corner of the graph that
28735 shows the correspondence between curves and line styles. It is
28736 off by default, and is only really useful if you have several
28737 curves on the same graph.
28740 @pindex calc-graph-num-points
28741 The @kbd{g N} (@code{calc-graph-num-points}) command allows you
28742 to select the number of data points in the graph. This only affects
28743 curves where neither ``x'' nor ``y'' is specified as a vector.
28744 Enter a blank line to revert to the default value (initially 15).
28745 With no prefix argument, this command affects only the current graph.
28746 With a positive prefix argument this command changes or, if you enter
28747 a blank line, displays the default number of points used for all
28748 graphs created by @kbd{g a} that don't specify the resolution explicitly.
28749 With a negative prefix argument, this command changes or displays
28750 the default value (initially 5) used for 3D graphs created by @kbd{g A}.
28751 Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points
28752 will be computed for the surface.
28754 Data values in the graph of a function are normally computed to a
28755 precision of five digits, regardless of the current precision at the
28756 time. This is usually more than adequate, but there are cases where
28757 it will not be. For example, plotting @expr{1 + x} with @expr{x} in the
28758 interval @samp{[0 ..@: 1e-6]} will round all the data points down
28759 to 1.0! Putting the command @samp{set precision @var{n}} in the
28760 @samp{*Gnuplot Commands*} buffer will cause the data to be computed
28761 at precision @var{n} instead of 5. Since this is such a rare case,
28762 there is no keystroke-based command to set the precision.
28765 @pindex calc-graph-header
28766 The @kbd{g h} (@code{calc-graph-header}) command sets the title
28767 for the graph. This will show up centered above the graph.
28768 The default title is blank (no title).
28771 @pindex calc-graph-name
28772 The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
28773 individual curve. Like the other curve-manipulating commands, it
28774 affects the most recently added curve, i.e., the last curve on the
28775 list in the @samp{*Gnuplot Commands*} buffer. To set the title of
28776 the other curves you must first juggle them to the end of the list
28777 with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand.
28778 Curve titles appear in the key; if the key is turned off they are
28783 @pindex calc-graph-title-x
28784 @pindex calc-graph-title-y
28785 The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
28786 (@code{calc-graph-title-y}) commands set the titles on the ``x''
28787 and ``y'' axes, respectively. These titles appear next to the
28788 tick marks on the left and bottom edges of the graph, respectively.
28789 Calc does not have commands to control the tick marks themselves,
28790 but you can edit them into the @samp{*Gnuplot Commands*} buffer if
28791 you wish. See the GNUPLOT documentation for details.
28795 @pindex calc-graph-range-x
28796 @pindex calc-graph-range-y
28797 The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
28798 (@code{calc-graph-range-y}) commands set the range of values on the
28799 ``x'' and ``y'' axes, respectively. You are prompted to enter a
28800 suitable range. This should be either a pair of numbers of the
28801 form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
28802 default behavior of setting the range based on the range of values
28803 in the data, or @samp{$} to take the range from the top of the stack.
28804 Ranges on the stack can be represented as either interval forms or
28805 vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
28809 @pindex calc-graph-log-x
28810 @pindex calc-graph-log-y
28811 The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
28812 commands allow you to set either or both of the axes of the graph to
28813 be logarithmic instead of linear.
28818 @pindex calc-graph-log-z
28819 @pindex calc-graph-range-z
28820 @pindex calc-graph-title-z
28821 For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
28822 letters with the Control key held down) are the corresponding commands
28823 for the ``z'' axis.
28827 @pindex calc-graph-zero-x
28828 @pindex calc-graph-zero-y
28829 The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
28830 (@code{calc-graph-zero-y}) commands control whether a dotted line is
28831 drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same
28832 dotted lines that would be drawn there anyway if you used @kbd{g g} to
28833 turn the ``grid'' feature on.) Zero-axis lines are on by default, and
28834 may be turned off only in GNUPLOT 3.0 and later versions. They are
28835 not available for 3D plots.
28838 @pindex calc-graph-line-style
28839 The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
28840 lines on or off for the most recently added curve, and optionally selects
28841 the style of lines to be used for that curve. Plain @kbd{g s} simply
28842 toggles the lines on and off. With a numeric prefix argument, @kbd{g s}
28843 turns lines on and sets a particular line style. Line style numbers
28844 start at one and their meanings vary depending on the output device.
28845 GNUPLOT guarantees that there will be at least six different line styles
28846 available for any device.
28849 @pindex calc-graph-point-style
28850 The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
28851 the symbols at the data points on or off, or sets the point style.
28852 If you turn both lines and points off, the data points will show as
28853 tiny dots. If the ``y'' values being plotted contain error forms and
28854 the connecting lines are turned off, then this command will also turn
28855 the error bars on or off.
28857 @cindex @code{LineStyles} variable
28858 @cindex @code{PointStyles} variable
28860 @vindex PointStyles
28861 Another way to specify curve styles is with the @code{LineStyles} and
28862 @code{PointStyles} variables. These variables initially have no stored
28863 values, but if you store a vector of integers in one of these variables,
28864 the @kbd{g a} and @kbd{g f} commands will use those style numbers
28865 instead of the defaults for new curves that are added to the graph.
28866 An entry should be a positive integer for a specific style, or 0 to let
28867 the style be chosen automatically, or @mathit{-1} to turn off lines or points
28868 altogether. If there are more curves than elements in the vector, the
28869 last few curves will continue to have the default styles. Of course,
28870 you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
28872 For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
28873 to have lines in style number 2, the second curve to have no connecting
28874 lines, and the third curve to have lines in style 3. Point styles will
28875 still be assigned automatically, but you could store another vector in
28876 @code{PointStyles} to define them, too.
28878 @node Devices, , Graphics Options, Graphics
28879 @section Graphical Devices
28883 @pindex calc-graph-device
28884 The @kbd{g D} (@code{calc-graph-device}) command sets the device name
28885 (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
28886 on this graph. It does not affect the permanent default device name.
28887 If you enter a blank name, the device name reverts to the default.
28888 Enter @samp{?} to see a list of supported devices.
28890 With a positive numeric prefix argument, @kbd{g D} instead sets
28891 the default device name, used by all plots in the future which do
28892 not override it with a plain @kbd{g D} command. If you enter a
28893 blank line this command shows you the current default. The special
28894 name @code{default} signifies that Calc should choose @code{x11} if
28895 the X window system is in use (as indicated by the presence of a
28896 @code{DISPLAY} environment variable), or otherwise @code{dumb} under
28897 GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0.
28898 This is the initial default value.
28900 The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
28901 terminals with no special graphics facilities. It writes a crude
28902 picture of the graph composed of characters like @code{-} and @code{|}
28903 to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays.
28904 The graph is made the same size as the Emacs screen, which on most
28905 dumb terminals will be
28906 @texline @math{80\times24}
28908 characters. The graph is displayed in
28909 an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit
28910 the recursive edit and return to Calc. Note that the @code{dumb}
28911 device is present only in GNUPLOT 3.0 and later versions.
28913 The word @code{dumb} may be followed by two numbers separated by
28914 spaces. These are the desired width and height of the graph in
28915 characters. Also, the device name @code{big} is like @code{dumb}
28916 but creates a graph four times the width and height of the Emacs
28917 screen. You will then have to scroll around to view the entire
28918 graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
28919 @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
28920 of the four directions.
28922 With a negative numeric prefix argument, @kbd{g D} sets or displays
28923 the device name used by @kbd{g P} (@code{calc-graph-print}). This
28924 is initially @code{postscript}. If you don't have a PostScript
28925 printer, you may decide once again to use @code{dumb} to create a
28926 plot on any text-only printer.
28929 @pindex calc-graph-output
28930 The @kbd{g O} (@code{calc-graph-output}) command sets the name of
28931 the output file used by GNUPLOT. For some devices, notably @code{x11},
28932 there is no output file and this information is not used. Many other
28933 ``devices'' are really file formats like @code{postscript}; in these
28934 cases the output in the desired format goes into the file you name
28935 with @kbd{g O}. Type @kbd{g O stdout @key{RET}} to set GNUPLOT to write
28936 to its standard output stream, i.e., to @samp{*Gnuplot Trail*}.
28937 This is the default setting.
28939 Another special output name is @code{tty}, which means that GNUPLOT
28940 is going to write graphics commands directly to its standard output,
28941 which you wish Emacs to pass through to your terminal. Tektronix
28942 graphics terminals, among other devices, operate this way. Calc does
28943 this by telling GNUPLOT to write to a temporary file, then running a
28944 sub-shell executing the command @samp{cat tempfile >/dev/tty}. On
28945 typical Unix systems, this will copy the temporary file directly to
28946 the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l}
28947 to Emacs afterwards to refresh the screen.
28949 Once again, @kbd{g O} with a positive or negative prefix argument
28950 sets the default or printer output file names, respectively. In each
28951 case you can specify @code{auto}, which causes Calc to invent a temporary
28952 file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file
28953 will be deleted once it has been displayed or printed. If the output file
28954 name is not @code{auto}, the file is not automatically deleted.
28956 The default and printer devices and output files can be saved
28957 permanently by the @kbd{m m} (@code{calc-save-modes}) command. The
28958 default number of data points (see @kbd{g N}) and the X geometry
28959 (see @kbd{g X}) are also saved. Other graph information is @emph{not}
28960 saved; you can save a graph's configuration simply by saving the contents
28961 of the @samp{*Gnuplot Commands*} buffer.
28963 @vindex calc-gnuplot-plot-command
28964 @vindex calc-gnuplot-default-device
28965 @vindex calc-gnuplot-default-output
28966 @vindex calc-gnuplot-print-command
28967 @vindex calc-gnuplot-print-device
28968 @vindex calc-gnuplot-print-output
28969 You may wish to configure the default and
28970 printer devices and output files for the whole system. The relevant
28971 Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
28972 and @code{calc-gnuplot-print-device} and @code{-output}. The output
28973 file names must be either strings as described above, or Lisp
28974 expressions which are evaluated on the fly to get the output file names.
28976 Other important Lisp variables are @code{calc-gnuplot-plot-command} and
28977 @code{calc-gnuplot-print-command}, which give the system commands to
28978 display or print the output of GNUPLOT, respectively. These may be
28979 @code{nil} if no command is necessary, or strings which can include
28980 @samp{%s} to signify the name of the file to be displayed or printed.
28981 Or, these variables may contain Lisp expressions which are evaluated
28982 to display or print the output. These variables are customizable
28983 (@pxref{Customizing Calc}).
28986 @pindex calc-graph-display
28987 The @kbd{g x} (@code{calc-graph-display}) command lets you specify
28988 on which X window system display your graphs should be drawn. Enter
28989 a blank line to see the current display name. This command has no
28990 effect unless the current device is @code{x11}.
28993 @pindex calc-graph-geometry
28994 The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
28995 command for specifying the position and size of the X window.
28996 The normal value is @code{default}, which generally means your
28997 window manager will let you place the window interactively.
28998 Entering @samp{800x500+0+0} would create an 800-by-500 pixel
28999 window in the upper-left corner of the screen.
29001 The buffer called @samp{*Gnuplot Trail*} holds a transcript of the
29002 session with GNUPLOT. This shows the commands Calc has ``typed'' to
29003 GNUPLOT and the responses it has received. Calc tries to notice when an
29004 error message has appeared here and display the buffer for you when
29005 this happens. You can check this buffer yourself if you suspect
29006 something has gone wrong.
29009 @pindex calc-graph-command
29010 The @kbd{g C} (@code{calc-graph-command}) command prompts you to
29011 enter any line of text, then simply sends that line to the current
29012 GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively
29013 like a Shell buffer but you can't type commands in it yourself.
29014 Instead, you must use @kbd{g C} for this purpose.
29018 @pindex calc-graph-view-commands
29019 @pindex calc-graph-view-trail
29020 The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
29021 (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*}
29022 and @samp{*Gnuplot Trail*} buffers, respectively, in another window.
29023 This happens automatically when Calc thinks there is something you
29024 will want to see in either of these buffers. If you type @kbd{g v}
29025 or @kbd{g V} when the relevant buffer is already displayed, the
29026 buffer is hidden again.
29028 One reason to use @kbd{g v} is to add your own commands to the
29029 @samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use
29030 @kbd{C-x o} to switch into that window. For example, GNUPLOT has
29031 @samp{set label} and @samp{set arrow} commands that allow you to
29032 annotate your plots. Since Calc doesn't understand these commands,
29033 you have to add them to the @samp{*Gnuplot Commands*} buffer
29034 yourself, then use @w{@kbd{g p}} to replot using these new commands. Note
29035 that your commands must appear @emph{before} the @code{plot} command.
29036 To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
29037 You may have to type @kbd{g C @key{RET}} a few times to clear the
29038 ``press return for more'' or ``subtopic of @dots{}'' requests.
29039 Note that Calc always sends commands (like @samp{set nolabel}) to
29040 reset all plotting parameters to the defaults before each plot, so
29041 to delete a label all you need to do is delete the @samp{set label}
29042 line you added (or comment it out with @samp{#}) and then replot
29046 @pindex calc-graph-quit
29047 You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
29048 process that is running. The next graphing command you give will
29049 start a fresh GNUPLOT process. The word @samp{Graph} appears in
29050 the Calc window's mode line whenever a GNUPLOT process is currently
29051 running. The GNUPLOT process is automatically killed when you
29052 exit Emacs if you haven't killed it manually by then.
29055 @pindex calc-graph-kill
29056 The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
29057 except that it also views the @samp{*Gnuplot Trail*} buffer so that
29058 you can see the process being killed. This is better if you are
29059 killing GNUPLOT because you think it has gotten stuck.
29061 @node Kill and Yank, Keypad Mode, Graphics, Top
29062 @chapter Kill and Yank Functions
29065 The commands in this chapter move information between the Calculator and
29066 other Emacs editing buffers.
29068 In many cases Embedded mode is an easier and more natural way to
29069 work with Calc from a regular editing buffer. @xref{Embedded Mode}.
29072 * Killing From Stack::
29073 * Yanking Into Stack::
29074 * Grabbing From Buffers::
29075 * Yanking Into Buffers::
29076 * X Cut and Paste::
29079 @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
29080 @section Killing from the Stack
29086 @pindex calc-copy-as-kill
29088 @pindex calc-kill-region
29090 @pindex calc-copy-region-as-kill
29092 @dfn{Kill} commands are Emacs commands that insert text into the
29093 ``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y}
29094 command. Three common kill commands in normal Emacs are @kbd{C-k}, which
29095 kills one line, @kbd{C-w}, which kills the region between mark and point,
29096 and @kbd{M-w}, which puts the region into the kill ring without actually
29097 deleting it. All of these commands work in the Calculator, too. Also,
29098 @kbd{M-k} has been provided to complete the set; it puts the current line
29099 into the kill ring without deleting anything.
29101 The kill commands are unusual in that they pay attention to the location
29102 of the cursor in the Calculator buffer. If the cursor is on or below the
29103 bottom line, the kill commands operate on the top of the stack. Otherwise,
29104 they operate on whatever stack element the cursor is on. Calc's kill
29105 commands always operate on whole stack entries. (They act the same as their
29106 standard Emacs cousins except they ``round up'' the specified region to
29107 encompass full lines.) The text is copied into the kill ring exactly as
29108 it appears on the screen, including line numbers if they are enabled.
29110 A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
29111 of lines killed. A positive argument kills the current line and @expr{n-1}
29112 lines below it. A negative argument kills the @expr{-n} lines above the
29113 current line. Again this mirrors the behavior of the standard Emacs
29114 @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k}
29115 with no argument copies only the number itself into the kill ring, whereas
29116 @kbd{C-k} with a prefix argument of 1 copies the number with its trailing
29119 @node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank
29120 @section Yanking into the Stack
29125 The @kbd{C-y} command yanks the most recently killed text back into the
29126 Calculator. It pushes this value onto the top of the stack regardless of
29127 the cursor position. In general it re-parses the killed text as a number
29128 or formula (or a list of these separated by commas or newlines). However if
29129 the thing being yanked is something that was just killed from the Calculator
29130 itself, its full internal structure is yanked. For example, if you have
29131 set the floating-point display mode to show only four significant digits,
29132 then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
29133 full 3.14159, even though yanking it into any other buffer would yank the
29134 number in its displayed form, 3.142. (Since the default display modes
29135 show all objects to their full precision, this feature normally makes no
29138 @node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank
29139 @section Grabbing from Other Buffers
29143 @pindex calc-grab-region
29144 The @kbd{C-x * g} (@code{calc-grab-region}) command takes the text between
29145 point and mark in the current buffer and attempts to parse it as a
29146 vector of values. Basically, it wraps the text in vector brackets
29147 @samp{[ ]} unless the text already is enclosed in vector brackets,
29148 then reads the text as if it were an algebraic entry. The contents
29149 of the vector may be numbers, formulas, or any other Calc objects.
29150 If the @kbd{C-x * g} command works successfully, it does an automatic
29151 @kbd{C-x * c} to enter the Calculator buffer.
29153 A numeric prefix argument grabs the specified number of lines around
29154 point, ignoring the mark. A positive prefix grabs from point to the
29155 @expr{n}th following newline (so that @kbd{M-1 C-x * g} grabs from point
29156 to the end of the current line); a negative prefix grabs from point
29157 back to the @expr{n+1}st preceding newline. In these cases the text
29158 that is grabbed is exactly the same as the text that @kbd{C-k} would
29159 delete given that prefix argument.
29161 A prefix of zero grabs the current line; point may be anywhere on the
29164 A plain @kbd{C-u} prefix interprets the region between point and mark
29165 as a single number or formula rather than a vector. For example,
29166 @kbd{C-x * g} on the text @samp{2 a b} produces the vector of three
29167 values @samp{[2, a, b]}, but @kbd{C-u C-x * g} on the same region
29168 reads a formula which is a product of three things: @samp{2 a b}.
29169 (The text @samp{a + b}, on the other hand, will be grabbed as a
29170 vector of one element by plain @kbd{C-x * g} because the interpretation
29171 @samp{[a, +, b]} would be a syntax error.)
29173 If a different language has been specified (@pxref{Language Modes}),
29174 the grabbed text will be interpreted according to that language.
29177 @pindex calc-grab-rectangle
29178 The @kbd{C-x * r} (@code{calc-grab-rectangle}) command takes the text between
29179 point and mark and attempts to parse it as a matrix. If point and mark
29180 are both in the leftmost column, the lines in between are parsed in their
29181 entirety. Otherwise, point and mark define the corners of a rectangle
29182 whose contents are parsed.
29184 Each line of the grabbed area becomes a row of the matrix. The result
29185 will actually be a vector of vectors, which Calc will treat as a matrix
29186 only if every row contains the same number of values.
29188 If a line contains a portion surrounded by square brackets (or curly
29189 braces), that portion is interpreted as a vector which becomes a row
29190 of the matrix. Any text surrounding the bracketed portion on the line
29193 Otherwise, the entire line is interpreted as a row vector as if it
29194 were surrounded by square brackets. Leading line numbers (in the
29195 format used in the Calc stack buffer) are ignored. If you wish to
29196 force this interpretation (even if the line contains bracketed
29197 portions), give a negative numeric prefix argument to the
29198 @kbd{C-x * r} command.
29200 If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
29201 line is instead interpreted as a single formula which is converted into
29202 a one-element vector. Thus the result of @kbd{C-u C-x * r} will be a
29203 one-column matrix. For example, suppose one line of the data is the
29204 expression @samp{2 a}. A plain @w{@kbd{C-x * r}} will interpret this as
29205 @samp{[2 a]}, which in turn is read as a two-element vector that forms
29206 one row of the matrix. But a @kbd{C-u C-x * r} will interpret this row
29209 If you give a positive numeric prefix argument @var{n}, then each line
29210 will be split up into columns of width @var{n}; each column is parsed
29211 separately as a matrix element. If a line contained
29212 @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
29213 would correctly split the line into two error forms.
29215 @xref{Matrix Functions}, to see how to pull the matrix apart into its
29216 constituent rows and columns. (If it is a
29217 @texline @math{1\times1}
29219 matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.)
29223 @pindex calc-grab-sum-across
29224 @pindex calc-grab-sum-down
29225 @cindex Summing rows and columns of data
29226 The @kbd{C-x * :} (@code{calc-grab-sum-down}) command is a handy way to
29227 grab a rectangle of data and sum its columns. It is equivalent to
29228 typing @kbd{C-x * r}, followed by @kbd{V R : +} (the vector reduction
29229 command that sums the columns of a matrix; @pxref{Reducing}). The
29230 result of the command will be a vector of numbers, one for each column
29231 in the input data. The @kbd{C-x * _} (@code{calc-grab-sum-across}) command
29232 similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
29234 As well as being more convenient, @kbd{C-x * :} and @kbd{C-x * _} are also
29235 much faster because they don't actually place the grabbed vector on
29236 the stack. In a @kbd{C-x * r V R : +} sequence, formatting the vector
29237 for display on the stack takes a large fraction of the total time
29238 (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
29240 For example, suppose we have a column of numbers in a file which we
29241 wish to sum. Go to one corner of the column and press @kbd{C-@@} to
29242 set the mark; go to the other corner and type @kbd{C-x * :}. Since there
29243 is only one column, the result will be a vector of one number, the sum.
29244 (You can type @kbd{v u} to unpack this vector into a plain number if
29245 you want to do further arithmetic with it.)
29247 To compute the product of the column of numbers, we would have to do
29248 it ``by hand'' since there's no special grab-and-multiply command.
29249 Use @kbd{C-x * r} to grab the column of numbers into the calculator in
29250 the form of a column matrix. The statistics command @kbd{u *} is a
29251 handy way to find the product of a vector or matrix of numbers.
29252 @xref{Statistical Operations}. Another approach would be to use
29253 an explicit column reduction command, @kbd{V R : *}.
29255 @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
29256 @section Yanking into Other Buffers
29260 @pindex calc-copy-to-buffer
29261 The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
29262 at the top of the stack into the most recently used normal editing buffer.
29263 (More specifically, this is the most recently used buffer which is displayed
29264 in a window and whose name does not begin with @samp{*}. If there is no
29265 such buffer, this is the most recently used buffer except for Calculator
29266 and Calc Trail buffers.) The number is inserted exactly as it appears and
29267 without a newline. (If line-numbering is enabled, the line number is
29268 normally not included.) The number is @emph{not} removed from the stack.
29270 With a prefix argument, @kbd{y} inserts several numbers, one per line.
29271 A positive argument inserts the specified number of values from the top
29272 of the stack. A negative argument inserts the @expr{n}th value from the
29273 top of the stack. An argument of zero inserts the entire stack. Note
29274 that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
29275 with no argument; the former always copies full lines, whereas the
29276 latter strips off the trailing newline.
29278 With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
29279 region in the other buffer with the yanked text, then quits the
29280 Calculator, leaving you in that buffer. A typical use would be to use
29281 @kbd{C-x * g} to read a region of data into the Calculator, operate on the
29282 data to produce a new matrix, then type @kbd{C-u y} to replace the
29283 original data with the new data. One might wish to alter the matrix
29284 display style (@pxref{Vector and Matrix Formats}) or change the current
29285 display language (@pxref{Language Modes}) before doing this. Also, note
29286 that this command replaces a linear region of text (as grabbed by
29287 @kbd{C-x * g}), not a rectangle (as grabbed by @kbd{C-x * r}).
29289 If the editing buffer is in overwrite (as opposed to insert) mode,
29290 and the @kbd{C-u} prefix was not used, then the yanked number will
29291 overwrite the characters following point rather than being inserted
29292 before those characters. The usual conventions of overwrite mode
29293 are observed; for example, characters will be inserted at the end of
29294 a line rather than overflowing onto the next line. Yanking a multi-line
29295 object such as a matrix in overwrite mode overwrites the next @var{n}
29296 lines in the buffer, lengthening or shortening each line as necessary.
29297 Finally, if the thing being yanked is a simple integer or floating-point
29298 number (like @samp{-1.2345e-3}) and the characters following point also
29299 make up such a number, then Calc will replace that number with the new
29300 number, lengthening or shortening as necessary. The concept of
29301 ``overwrite mode'' has thus been generalized from overwriting characters
29302 to overwriting one complete number with another.
29305 The @kbd{C-x * y} key sequence is equivalent to @kbd{y} except that
29306 it can be typed anywhere, not just in Calc. This provides an easy
29307 way to guarantee that Calc knows which editing buffer you want to use!
29309 @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
29310 @section X Cut and Paste
29313 If you are using Emacs with the X window system, there is an easier
29314 way to move small amounts of data into and out of the calculator:
29315 Use the mouse-oriented cut and paste facilities of X.
29317 The default bindings for a three-button mouse cause the left button
29318 to move the Emacs cursor to the given place, the right button to
29319 select the text between the cursor and the clicked location, and
29320 the middle button to yank the selection into the buffer at the
29321 clicked location. So, if you have a Calc window and an editing
29322 window on your Emacs screen, you can use left-click/right-click
29323 to select a number, vector, or formula from one window, then
29324 middle-click to paste that value into the other window. When you
29325 paste text into the Calc window, Calc interprets it as an algebraic
29326 entry. It doesn't matter where you click in the Calc window; the
29327 new value is always pushed onto the top of the stack.
29329 The @code{xterm} program that is typically used for general-purpose
29330 shell windows in X interprets the mouse buttons in the same way.
29331 So you can use the mouse to move data between Calc and any other
29332 Unix program. One nice feature of @code{xterm} is that a double
29333 left-click selects one word, and a triple left-click selects a
29334 whole line. So you can usually transfer a single number into Calc
29335 just by double-clicking on it in the shell, then middle-clicking
29336 in the Calc window.
29338 @node Keypad Mode, Embedded Mode, Kill and Yank, Top
29339 @chapter Keypad Mode
29343 @pindex calc-keypad
29344 The @kbd{C-x * k} (@code{calc-keypad}) command starts the Calculator
29345 and displays a picture of a calculator-style keypad. If you are using
29346 the X window system, you can click on any of the ``keys'' in the
29347 keypad using the left mouse button to operate the calculator.
29348 The original window remains the selected window; in Keypad mode
29349 you can type in your file while simultaneously performing
29350 calculations with the mouse.
29352 @pindex full-calc-keypad
29353 If you have used @kbd{C-x * b} first, @kbd{C-x * k} instead invokes
29354 the @code{full-calc-keypad} command, which takes over the whole
29355 Emacs screen and displays the keypad, the Calc stack, and the Calc
29356 trail all at once. This mode would normally be used when running
29357 Calc standalone (@pxref{Standalone Operation}).
29359 If you aren't using the X window system, you must switch into
29360 the @samp{*Calc Keypad*} window, place the cursor on the desired
29361 ``key,'' and type @key{SPC} or @key{RET}. If you think this
29362 is easier than using Calc normally, go right ahead.
29364 Calc commands are more or less the same in Keypad mode. Certain
29365 keypad keys differ slightly from the corresponding normal Calc
29366 keystrokes; all such deviations are described below.
29368 Keypad mode includes many more commands than will fit on the keypad
29369 at once. Click the right mouse button [@code{calc-keypad-menu}]
29370 to switch to the next menu. The bottom five rows of the keypad
29371 stay the same; the top three rows change to a new set of commands.
29372 To return to earlier menus, click the middle mouse button
29373 [@code{calc-keypad-menu-back}] or simply advance through the menus
29374 until you wrap around. Typing @key{TAB} inside the keypad window
29375 is equivalent to clicking the right mouse button there.
29377 You can always click the @key{EXEC} button and type any normal
29378 Calc key sequence. This is equivalent to switching into the
29379 Calc buffer, typing the keys, then switching back to your
29383 * Keypad Main Menu::
29384 * Keypad Functions Menu::
29385 * Keypad Binary Menu::
29386 * Keypad Vectors Menu::
29387 * Keypad Modes Menu::
29390 @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
29395 |----+-----Calc 2.1------+----1
29396 |FLR |CEIL|RND |TRNC|CLN2|FLT |
29397 |----+----+----+----+----+----|
29398 | LN |EXP | |ABS |IDIV|MOD |
29399 |----+----+----+----+----+----|
29400 |SIN |COS |TAN |SQRT|y^x |1/x |
29401 |----+----+----+----+----+----|
29402 | ENTER |+/- |EEX |UNDO| <- |
29403 |-----+---+-+--+--+-+---++----|
29404 | INV | 7 | 8 | 9 | / |
29405 |-----+-----+-----+-----+-----|
29406 | HYP | 4 | 5 | 6 | * |
29407 |-----+-----+-----+-----+-----|
29408 |EXEC | 1 | 2 | 3 | - |
29409 |-----+-----+-----+-----+-----|
29410 | OFF | 0 | . | PI | + |
29411 |-----+-----+-----+-----+-----+
29416 This is the menu that appears the first time you start Keypad mode.
29417 It will show up in a vertical window on the right side of your screen.
29418 Above this menu is the traditional Calc stack display. On a 24-line
29419 screen you will be able to see the top three stack entries.
29421 The ten digit keys, decimal point, and @key{EEX} key are used for
29422 entering numbers in the obvious way. @key{EEX} begins entry of an
29423 exponent in scientific notation. Just as with regular Calc, the
29424 number is pushed onto the stack as soon as you press @key{ENTER}
29425 or any other function key.
29427 The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During
29428 numeric entry it changes the sign of the number or of the exponent.
29429 At other times it changes the sign of the number on the top of the
29432 The @key{INV} and @key{HYP} keys modify other keys. As well as
29433 having the effects described elsewhere in this manual, Keypad mode
29434 defines several other ``inverse'' operations. These are described
29435 below and in the following sections.
29437 The @key{ENTER} key finishes the current numeric entry, or otherwise
29438 duplicates the top entry on the stack.
29440 The @key{UNDO} key undoes the most recent Calc operation.
29441 @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
29442 ``last arguments'' (@kbd{M-@key{RET}}).
29444 The @key{<-} key acts as a ``backspace'' during numeric entry.
29445 At other times it removes the top stack entry. @kbd{INV <-}
29446 clears the entire stack. @kbd{HYP <-} takes an integer from
29447 the stack, then removes that many additional stack elements.
29449 The @key{EXEC} key prompts you to enter any keystroke sequence
29450 that would normally work in Calc mode. This can include a
29451 numeric prefix if you wish. It is also possible simply to
29452 switch into the Calc window and type commands in it; there is
29453 nothing ``magic'' about this window when Keypad mode is active.
29455 The other keys in this display perform their obvious calculator
29456 functions. @key{CLN2} rounds the top-of-stack by temporarily
29457 reducing the precision by 2 digits. @key{FLT} converts an
29458 integer or fraction on the top of the stack to floating-point.
29460 The @key{INV} and @key{HYP} keys combined with several of these keys
29461 give you access to some common functions even if the appropriate menu
29462 is not displayed. Obviously you don't need to learn these keys
29463 unless you find yourself wasting time switching among the menus.
29467 is the same as @key{1/x}.
29469 is the same as @key{SQRT}.
29471 is the same as @key{CONJ}.
29473 is the same as @key{y^x}.
29475 is the same as @key{INV y^x} (the @expr{x}th root of @expr{y}).
29477 are the same as @key{SIN} / @kbd{INV SIN}.
29479 are the same as @key{COS} / @kbd{INV COS}.
29481 are the same as @key{TAN} / @kbd{INV TAN}.
29483 are the same as @key{LN} / @kbd{HYP LN}.
29485 are the same as @key{EXP} / @kbd{HYP EXP}.
29487 is the same as @key{ABS}.
29489 is the same as @key{RND} (@code{calc-round}).
29491 is the same as @key{CLN2}.
29493 is the same as @key{FLT} (@code{calc-float}).
29495 is the same as @key{IMAG}.
29497 is the same as @key{PREC}.
29499 is the same as @key{SWAP}.
29501 is the same as @key{RLL3}.
29502 @item INV HYP ENTER
29503 is the same as @key{OVER}.
29505 packs the top two stack entries as an error form.
29507 packs the top two stack entries as a modulo form.
29509 creates an interval form; this removes an integer which is one
29510 of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
29511 by the two limits of the interval.
29514 The @kbd{OFF} key turns Calc off; typing @kbd{C-x * k} or @kbd{C-x * *}
29515 again has the same effect. This is analogous to typing @kbd{q} or
29516 hitting @kbd{C-x * c} again in the normal calculator. If Calc is
29517 running standalone (the @code{full-calc-keypad} command appeared in the
29518 command line that started Emacs), then @kbd{OFF} is replaced with
29519 @kbd{EXIT}; clicking on this actually exits Emacs itself.
29521 @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
29522 @section Functions Menu
29526 |----+----+----+----+----+----2
29527 |IGAM|BETA|IBET|ERF |BESJ|BESY|
29528 |----+----+----+----+----+----|
29529 |IMAG|CONJ| RE |ATN2|RAND|RAGN|
29530 |----+----+----+----+----+----|
29531 |GCD |FACT|DFCT|BNOM|PERM|NXTP|
29532 |----+----+----+----+----+----|
29537 This menu provides various operations from the @kbd{f} and @kbd{k}
29540 @key{IMAG} multiplies the number on the stack by the imaginary
29541 number @expr{i = (0, 1)}.
29543 @key{RE} extracts the real part a complex number. @kbd{INV RE}
29544 extracts the imaginary part.
29546 @key{RAND} takes a number from the top of the stack and computes
29547 a random number greater than or equal to zero but less than that
29548 number. (@xref{Random Numbers}.) @key{RAGN} is the ``random
29549 again'' command; it computes another random number using the
29550 same limit as last time.
29552 @key{INV GCD} computes the LCM (least common multiple) function.
29554 @key{INV FACT} is the gamma function.
29555 @texline @math{\Gamma(x) = (x-1)!}.
29556 @infoline @expr{gamma(x) = (x-1)!}.
29558 @key{PERM} is the number-of-permutations function, which is on the
29559 @kbd{H k c} key in normal Calc.
29561 @key{NXTP} finds the next prime after a number. @kbd{INV NXTP}
29562 finds the previous prime.
29564 @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
29565 @section Binary Menu
29569 |----+----+----+----+----+----3
29570 |AND | OR |XOR |NOT |LSH |RSH |
29571 |----+----+----+----+----+----|
29572 |DEC |HEX |OCT |BIN |WSIZ|ARSH|
29573 |----+----+----+----+----+----|
29574 | A | B | C | D | E | F |
29575 |----+----+----+----+----+----|
29580 The keys in this menu perform operations on binary integers.
29581 Note that both logical and arithmetic right-shifts are provided.
29582 @key{INV LSH} rotates one bit to the left.
29584 The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
29585 The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
29587 The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
29588 current radix for display and entry of numbers: Decimal, hexadecimal,
29589 octal, or binary. The six letter keys @key{A} through @key{F} are used
29590 for entering hexadecimal numbers.
29592 The @key{WSIZ} key displays the current word size for binary operations
29593 and allows you to enter a new word size. You can respond to the prompt
29594 using either the keyboard or the digits and @key{ENTER} from the keypad.
29595 The initial word size is 32 bits.
29597 @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
29598 @section Vectors Menu
29602 |----+----+----+----+----+----4
29603 |SUM |PROD|MAX |MAP*|MAP^|MAP$|
29604 |----+----+----+----+----+----|
29605 |MINV|MDET|MTRN|IDNT|CRSS|"x" |
29606 |----+----+----+----+----+----|
29607 |PACK|UNPK|INDX|BLD |LEN |... |
29608 |----+----+----+----+----+----|
29613 The keys in this menu operate on vectors and matrices.
29615 @key{PACK} removes an integer @var{n} from the top of the stack;
29616 the next @var{n} stack elements are removed and packed into a vector,
29617 which is replaced onto the stack. Thus the sequence
29618 @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
29619 @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row
29620 on the stack as a vector, then use a final @key{PACK} to collect the
29621 rows into a matrix.
29623 @key{UNPK} unpacks the vector on the stack, pushing each of its
29624 components separately.
29626 @key{INDX} removes an integer @var{n}, then builds a vector of
29627 integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers
29628 from the stack: The vector size @var{n}, the starting number,
29629 and the increment. @kbd{BLD} takes an integer @var{n} and any
29630 value @var{x} and builds a vector of @var{n} copies of @var{x}.
29632 @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
29635 @key{LEN} replaces a vector by its length, an integer.
29637 @key{...} turns on or off ``abbreviated'' display mode for large vectors.
29639 @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
29640 inverse, determinant, and transpose, and vector cross product.
29642 @key{SUM} replaces a vector by the sum of its elements. It is
29643 equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
29644 @key{PROD} computes the product of the elements of a vector, and
29645 @key{MAX} computes the maximum of all the elements of a vector.
29647 @key{INV SUM} computes the alternating sum of the first element
29648 minus the second, plus the third, minus the fourth, and so on.
29649 @key{INV MAX} computes the minimum of the vector elements.
29651 @key{HYP SUM} computes the mean of the vector elements.
29652 @key{HYP PROD} computes the sample standard deviation.
29653 @key{HYP MAX} computes the median.
29655 @key{MAP*} multiplies two vectors elementwise. It is equivalent
29656 to the @kbd{V M *} command. @key{MAP^} computes powers elementwise.
29657 The arguments must be vectors of equal length, or one must be a vector
29658 and the other must be a plain number. For example, @kbd{2 MAP^} squares
29659 all the elements of a vector.
29661 @key{MAP$} maps the formula on the top of the stack across the
29662 vector in the second-to-top position. If the formula contains
29663 several variables, Calc takes that many vectors starting at the
29664 second-to-top position and matches them to the variables in
29665 alphabetical order. The result is a vector of the same size as
29666 the input vectors, whose elements are the formula evaluated with
29667 the variables set to the various sets of numbers in those vectors.
29668 For example, you could simulate @key{MAP^} using @key{MAP$} with
29669 the formula @samp{x^y}.
29671 The @kbd{"x"} key pushes the variable name @expr{x} onto the
29672 stack. To build the formula @expr{x^2 + 6}, you would use the
29673 key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be
29674 suitable for use with the @key{MAP$} key described above.
29675 With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
29676 @kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and
29677 @expr{t}, respectively.
29679 @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
29680 @section Modes Menu
29684 |----+----+----+----+----+----5
29685 |FLT |FIX |SCI |ENG |GRP | |
29686 |----+----+----+----+----+----|
29687 |RAD |DEG |FRAC|POLR|SYMB|PREC|
29688 |----+----+----+----+----+----|
29689 |SWAP|RLL3|RLL4|OVER|STO |RCL |
29690 |----+----+----+----+----+----|
29695 The keys in this menu manipulate modes, variables, and the stack.
29697 The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
29698 floating-point, fixed-point, scientific, or engineering notation.
29699 @key{FIX} displays two digits after the decimal by default; the
29700 others display full precision. With the @key{INV} prefix, these
29701 keys pop a number-of-digits argument from the stack.
29703 The @key{GRP} key turns grouping of digits with commas on or off.
29704 @kbd{INV GRP} enables grouping to the right of the decimal point as
29705 well as to the left.
29707 The @key{RAD} and @key{DEG} keys switch between radians and degrees
29708 for trigonometric functions.
29710 The @key{FRAC} key turns Fraction mode on or off. This affects
29711 whether commands like @kbd{/} with integer arguments produce
29712 fractional or floating-point results.
29714 The @key{POLR} key turns Polar mode on or off, determining whether
29715 polar or rectangular complex numbers are used by default.
29717 The @key{SYMB} key turns Symbolic mode on or off, in which
29718 operations that would produce inexact floating-point results
29719 are left unevaluated as algebraic formulas.
29721 The @key{PREC} key selects the current precision. Answer with
29722 the keyboard or with the keypad digit and @key{ENTER} keys.
29724 The @key{SWAP} key exchanges the top two stack elements.
29725 The @key{RLL3} key rotates the top three stack elements upwards.
29726 The @key{RLL4} key rotates the top four stack elements upwards.
29727 The @key{OVER} key duplicates the second-to-top stack element.
29729 The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
29730 @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the
29731 @key{STO} or @key{RCL} key, then one of the ten digits. (Named
29732 variables are not available in Keypad mode.) You can also use,
29733 for example, @kbd{STO + 3} to add to register 3.
29735 @node Embedded Mode, Programming, Keypad Mode, Top
29736 @chapter Embedded Mode
29739 Embedded mode in Calc provides an alternative to copying numbers
29740 and formulas back and forth between editing buffers and the Calc
29741 stack. In Embedded mode, your editing buffer becomes temporarily
29742 linked to the stack and this copying is taken care of automatically.
29745 * Basic Embedded Mode::
29746 * More About Embedded Mode::
29747 * Assignments in Embedded Mode::
29748 * Mode Settings in Embedded Mode::
29749 * Customizing Embedded Mode::
29752 @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
29753 @section Basic Embedded Mode
29757 @pindex calc-embedded
29758 To enter Embedded mode, position the Emacs point (cursor) on a
29759 formula in any buffer and press @kbd{C-x * e} (@code{calc-embedded}).
29760 Note that @kbd{C-x * e} is not to be used in the Calc stack buffer
29761 like most Calc commands, but rather in regular editing buffers that
29762 are visiting your own files.
29764 Calc will try to guess an appropriate language based on the major mode
29765 of the editing buffer. (@xref{Language Modes}.) If the current buffer is
29766 in @code{latex-mode}, for example, Calc will set its language to La@TeX{}.
29767 Similarly, Calc will use @TeX{} language for @code{tex-mode},
29768 @code{plain-tex-mode} and @code{context-mode}, C language for
29769 @code{c-mode} and @code{c++-mode}, FORTRAN language for
29770 @code{fortran-mode} and @code{f90-mode}, Pascal for @code{pascal-mode},
29771 and eqn for @code{nroff-mode} (@pxref{Customizing Calc}).
29772 These can be overridden with Calc's mode
29773 changing commands (@pxref{Mode Settings in Embedded Mode}). If no
29774 suitable language is available, Calc will continue with its current language.
29776 Calc normally scans backward and forward in the buffer for the
29777 nearest opening and closing @dfn{formula delimiters}. The simplest
29778 delimiters are blank lines. Other delimiters that Embedded mode
29783 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
29784 @samp{\[ \]}, and @samp{\( \)};
29786 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
29788 Lines beginning with @samp{@@} (Texinfo delimiters).
29790 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
29792 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
29795 @xref{Customizing Embedded Mode}, to see how to make Calc recognize
29796 your own favorite delimiters. Delimiters like @samp{$ $} can appear
29797 on their own separate lines or in-line with the formula.
29799 If you give a positive or negative numeric prefix argument, Calc
29800 instead uses the current point as one end of the formula, and includes
29801 that many lines forward or backward (respectively, including the current
29802 line). Explicit delimiters are not necessary in this case.
29804 With a prefix argument of zero, Calc uses the current region (delimited
29805 by point and mark) instead of formula delimiters. With a prefix
29806 argument of @kbd{C-u} only, Calc uses the current line as the formula.
29809 @pindex calc-embedded-word
29810 The @kbd{C-x * w} (@code{calc-embedded-word}) command will start Embedded
29811 mode on the current ``word''; in this case Calc will scan for the first
29812 non-numeric character (i.e., the first character that is not a digit,
29813 sign, decimal point, or upper- or lower-case @samp{e}) forward and
29814 backward to delimit the formula.
29816 When you enable Embedded mode for a formula, Calc reads the text
29817 between the delimiters and tries to interpret it as a Calc formula.
29818 Calc can generally identify @TeX{} formulas and
29819 Big-style formulas even if the language mode is wrong. If Calc
29820 can't make sense of the formula, it beeps and refuses to enter
29821 Embedded mode. But if the current language is wrong, Calc can
29822 sometimes parse the formula successfully (but incorrectly);
29823 for example, the C expression @samp{atan(a[1])} can be parsed
29824 in Normal language mode, but the @code{atan} won't correspond to
29825 the built-in @code{arctan} function, and the @samp{a[1]} will be
29826 interpreted as @samp{a} times the vector @samp{[1]}!
29828 If you press @kbd{C-x * e} or @kbd{C-x * w} to activate an embedded
29829 formula which is blank, say with the cursor on the space between
29830 the two delimiters @samp{$ $}, Calc will immediately prompt for
29831 an algebraic entry.
29833 Only one formula in one buffer can be enabled at a time. If you
29834 move to another area of the current buffer and give Calc commands,
29835 Calc turns Embedded mode off for the old formula and then tries
29836 to restart Embedded mode at the new position. Other buffers are
29837 not affected by Embedded mode.
29839 When Embedded mode begins, Calc pushes the current formula onto
29840 the stack. No Calc stack window is created; however, Calc copies
29841 the top-of-stack position into the original buffer at all times.
29842 You can create a Calc window by hand with @kbd{C-x * o} if you
29843 find you need to see the entire stack.
29845 For example, typing @kbd{C-x * e} while somewhere in the formula
29846 @samp{n>2} in the following line enables Embedded mode on that
29850 We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
29854 The formula @expr{n>2} will be pushed onto the Calc stack, and
29855 the top of stack will be copied back into the editing buffer.
29856 This means that spaces will appear around the @samp{>} symbol
29857 to match Calc's usual display style:
29860 We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
29864 No spaces have appeared around the @samp{+} sign because it's
29865 in a different formula, one which we have not yet touched with
29868 Now that Embedded mode is enabled, keys you type in this buffer
29869 are interpreted as Calc commands. At this point we might use
29870 the ``commute'' command @kbd{j C} to reverse the inequality.
29871 This is a selection-based command for which we first need to
29872 move the cursor onto the operator (@samp{>} in this case) that
29873 needs to be commuted.
29876 We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
29879 The @kbd{C-x * o} command is a useful way to open a Calc window
29880 without actually selecting that window. Giving this command
29881 verifies that @samp{2 < n} is also on the Calc stack. Typing
29882 @kbd{17 @key{RET}} would produce:
29885 We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
29889 with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
29890 at this point will exchange the two stack values and restore
29891 @samp{2 < n} to the embedded formula. Even though you can't
29892 normally see the stack in Embedded mode, it is still there and
29893 it still operates in the same way. But, as with old-fashioned
29894 RPN calculators, you can only see the value at the top of the
29895 stack at any given time (unless you use @kbd{C-x * o}).
29897 Typing @kbd{C-x * e} again turns Embedded mode off. The Calc
29898 window reveals that the formula @w{@samp{2 < n}} is automatically
29899 removed from the stack, but the @samp{17} is not. Entering
29900 Embedded mode always pushes one thing onto the stack, and
29901 leaving Embedded mode always removes one thing. Anything else
29902 that happens on the stack is entirely your business as far as
29903 Embedded mode is concerned.
29905 If you press @kbd{C-x * e} in the wrong place by accident, it is
29906 possible that Calc will be able to parse the nearby text as a
29907 formula and will mangle that text in an attempt to redisplay it
29908 ``properly'' in the current language mode. If this happens,
29909 press @kbd{C-x * e} again to exit Embedded mode, then give the
29910 regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
29911 the text back the way it was before Calc edited it. Note that Calc's
29912 own Undo command (typed before you turn Embedded mode back off)
29913 will not do you any good, because as far as Calc is concerned
29914 you haven't done anything with this formula yet.
29916 @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
29917 @section More About Embedded Mode
29920 When Embedded mode ``activates'' a formula, i.e., when it examines
29921 the formula for the first time since the buffer was created or
29922 loaded, Calc tries to sense the language in which the formula was
29923 written. If the formula contains any La@TeX{}-like @samp{\} sequences,
29924 it is parsed (i.e., read) in La@TeX{} mode. If the formula appears to
29925 be written in multi-line Big mode, it is parsed in Big mode. Otherwise,
29926 it is parsed according to the current language mode.
29928 Note that Calc does not change the current language mode according
29929 the formula it reads in. Even though it can read a La@TeX{} formula when
29930 not in La@TeX{} mode, it will immediately rewrite this formula using
29931 whatever language mode is in effect.
29938 @pindex calc-show-plain
29939 Calc's parser is unable to read certain kinds of formulas. For
29940 example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
29941 specify matrix display styles which the parser is unable to
29942 recognize as matrices. The @kbd{d p} (@code{calc-show-plain})
29943 command turns on a mode in which a ``plain'' version of a
29944 formula is placed in front of the fully-formatted version.
29945 When Calc reads a formula that has such a plain version in
29946 front, it reads the plain version and ignores the formatted
29949 Plain formulas are preceded and followed by @samp{%%%} signs
29950 by default. This notation has the advantage that the @samp{%}
29951 character begins a comment in @TeX{} and La@TeX{}, so if your formula is
29952 embedded in a @TeX{} or La@TeX{} document its plain version will be
29953 invisible in the final printed copy. Certain major modes have different
29954 delimiters to ensure that the ``plain'' version will be
29955 in a comment for those modes, also.
29956 See @ref{Customizing Embedded Mode} to see how to change the ``plain''
29957 formula delimiters.
29959 There are several notations which Calc's parser for ``big''
29960 formatted formulas can't yet recognize. In particular, it can't
29961 read the large symbols for @code{sum}, @code{prod}, and @code{integ},
29962 and it can't handle @samp{=>} with the righthand argument omitted.
29963 Also, Calc won't recognize special formats you have defined with
29964 the @kbd{Z C} command (@pxref{User-Defined Compositions}). In
29965 these cases it is important to use ``plain'' mode to make sure
29966 Calc will be able to read your formula later.
29968 Another example where ``plain'' mode is important is if you have
29969 specified a float mode with few digits of precision. Normally
29970 any digits that are computed but not displayed will simply be
29971 lost when you save and re-load your embedded buffer, but ``plain''
29972 mode allows you to make sure that the complete number is present
29973 in the file as well as the rounded-down number.
29979 Embedded buffers remember active formulas for as long as they
29980 exist in Emacs memory. Suppose you have an embedded formula
29981 which is @cpi{} to the normal 12 decimal places, and then
29982 type @w{@kbd{C-u 5 d n}} to display only five decimal places.
29983 If you then type @kbd{d n}, all 12 places reappear because the
29984 full number is still there on the Calc stack. More surprisingly,
29985 even if you exit Embedded mode and later re-enter it for that
29986 formula, typing @kbd{d n} will restore all 12 places because
29987 each buffer remembers all its active formulas. However, if you
29988 save the buffer in a file and reload it in a new Emacs session,
29989 all non-displayed digits will have been lost unless you used
29996 In some applications of Embedded mode, you will want to have a
29997 sequence of copies of a formula that show its evolution as you
29998 work on it. For example, you might want to have a sequence
29999 like this in your file (elaborating here on the example from
30000 the ``Getting Started'' chapter):
30009 @r{(the derivative of }ln(ln(x))@r{)}
30011 whose value at x = 2 is
30021 @pindex calc-embedded-duplicate
30022 The @kbd{C-x * d} (@code{calc-embedded-duplicate}) command is a
30023 handy way to make sequences like this. If you type @kbd{C-x * d},
30024 the formula under the cursor (which may or may not have Embedded
30025 mode enabled for it at the time) is copied immediately below and
30026 Embedded mode is then enabled for that copy.
30028 For this example, you would start with just
30037 and press @kbd{C-x * d} with the cursor on this formula. The result
30050 with the second copy of the formula enabled in Embedded mode.
30051 You can now press @kbd{a d x @key{RET}} to take the derivative, and
30052 @kbd{C-x * d C-x * d} to make two more copies of the derivative.
30053 To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
30054 the last formula, then move up to the second-to-last formula
30055 and type @kbd{2 s l x @key{RET}}.
30057 Finally, you would want to press @kbd{C-x * e} to exit Embedded
30058 mode, then go up and insert the necessary text in between the
30059 various formulas and numbers.
30067 @pindex calc-embedded-new-formula
30068 The @kbd{C-x * f} (@code{calc-embedded-new-formula}) command
30069 creates a new embedded formula at the current point. It inserts
30070 some default delimiters, which are usually just blank lines,
30071 and then does an algebraic entry to get the formula (which is
30072 then enabled for Embedded mode). This is just shorthand for
30073 typing the delimiters yourself, positioning the cursor between
30074 the new delimiters, and pressing @kbd{C-x * e}. The key sequence
30075 @kbd{C-x * '} is equivalent to @kbd{C-x * f}.
30079 @pindex calc-embedded-next
30080 @pindex calc-embedded-previous
30081 The @kbd{C-x * n} (@code{calc-embedded-next}) and @kbd{C-x * p}
30082 (@code{calc-embedded-previous}) commands move the cursor to the
30083 next or previous active embedded formula in the buffer. They
30084 can take positive or negative prefix arguments to move by several
30085 formulas. Note that these commands do not actually examine the
30086 text of the buffer looking for formulas; they only see formulas
30087 which have previously been activated in Embedded mode. In fact,
30088 @kbd{C-x * n} and @kbd{C-x * p} are a useful way to tell which
30089 embedded formulas are currently active. Also, note that these
30090 commands do not enable Embedded mode on the next or previous
30091 formula, they just move the cursor.
30094 @pindex calc-embedded-edit
30095 The @kbd{C-x * `} (@code{calc-embedded-edit}) command edits the
30096 embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
30097 Embedded mode does not have to be enabled for this to work. Press
30098 @kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel.
30100 @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
30101 @section Assignments in Embedded Mode
30104 The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
30105 are especially useful in Embedded mode. They allow you to make
30106 a definition in one formula, then refer to that definition in
30107 other formulas embedded in the same buffer.
30109 An embedded formula which is an assignment to a variable, as in
30116 records @expr{5} as the stored value of @code{foo} for the
30117 purposes of Embedded mode operations in the current buffer. It
30118 does @emph{not} actually store @expr{5} as the ``global'' value
30119 of @code{foo}, however. Regular Calc operations, and Embedded
30120 formulas in other buffers, will not see this assignment.
30122 One way to use this assigned value is simply to create an
30123 Embedded formula elsewhere that refers to @code{foo}, and to press
30124 @kbd{=} in that formula. However, this permanently replaces the
30125 @code{foo} in the formula with its current value. More interesting
30126 is to use @samp{=>} elsewhere:
30132 @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
30134 If you move back and change the assignment to @code{foo}, any
30135 @samp{=>} formulas which refer to it are automatically updated.
30143 The obvious question then is, @emph{how} can one easily change the
30144 assignment to @code{foo}? If you simply select the formula in
30145 Embedded mode and type 17, the assignment itself will be replaced
30146 by the 17. The effect on the other formula will be that the
30147 variable @code{foo} becomes unassigned:
30155 The right thing to do is first to use a selection command (@kbd{j 2}
30156 will do the trick) to select the righthand side of the assignment.
30157 Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
30158 Subformulas}, to see how this works).
30161 @pindex calc-embedded-select
30162 The @kbd{C-x * j} (@code{calc-embedded-select}) command provides an
30163 easy way to operate on assignments. It is just like @kbd{C-x * e},
30164 except that if the enabled formula is an assignment, it uses
30165 @kbd{j 2} to select the righthand side. If the enabled formula
30166 is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
30167 A formula can also be a combination of both:
30170 bar := foo + 3 => 20
30174 in which case @kbd{C-x * j} will select the middle part (@samp{foo + 3}).
30176 The formula is automatically deselected when you leave Embedded
30180 @pindex calc-embedded-update-formula
30181 Another way to change the assignment to @code{foo} would simply be
30182 to edit the number using regular Emacs editing rather than Embedded
30183 mode. Then, we have to find a way to get Embedded mode to notice
30184 the change. The @kbd{C-x * u} (@code{calc-embedded-update-formula})
30185 command is a convenient way to do this.
30193 Pressing @kbd{C-x * u} is much like pressing @kbd{C-x * e = C-x * e}, that
30194 is, temporarily enabling Embedded mode for the formula under the
30195 cursor and then evaluating it with @kbd{=}. But @kbd{C-x * u} does
30196 not actually use @kbd{C-x * e}, and in fact another formula somewhere
30197 else can be enabled in Embedded mode while you use @kbd{C-x * u} and
30198 that formula will not be disturbed.
30200 With a numeric prefix argument, @kbd{C-x * u} updates all active
30201 @samp{=>} formulas in the buffer. Formulas which have not yet
30202 been activated in Embedded mode, and formulas which do not have
30203 @samp{=>} as their top-level operator, are not affected by this.
30204 (This is useful only if you have used @kbd{m C}; see below.)
30206 With a plain @kbd{C-u} prefix, @kbd{C-u C-x * u} updates only in the
30207 region between mark and point rather than in the whole buffer.
30209 @kbd{C-x * u} is also a handy way to activate a formula, such as an
30210 @samp{=>} formula that has freshly been typed in or loaded from a
30214 @pindex calc-embedded-activate
30215 The @kbd{C-x * a} (@code{calc-embedded-activate}) command scans
30216 through the current buffer and activates all embedded formulas
30217 that contain @samp{:=} or @samp{=>} symbols. This does not mean
30218 that Embedded mode is actually turned on, but only that the
30219 formulas' positions are registered with Embedded mode so that
30220 the @samp{=>} values can be properly updated as assignments are
30223 It is a good idea to type @kbd{C-x * a} right after loading a file
30224 that uses embedded @samp{=>} operators. Emacs includes a nifty
30225 ``buffer-local variables'' feature that you can use to do this
30226 automatically. The idea is to place near the end of your file
30227 a few lines that look like this:
30230 --- Local Variables: ---
30231 --- eval:(calc-embedded-activate) ---
30236 where the leading and trailing @samp{---} can be replaced by
30237 any suitable strings (which must be the same on all three lines)
30238 or omitted altogether; in a @TeX{} or La@TeX{} file, @samp{%} would be a good
30239 leading string and no trailing string would be necessary. In a
30240 C program, @samp{/*} and @samp{*/} would be good leading and
30243 When Emacs loads a file into memory, it checks for a Local Variables
30244 section like this one at the end of the file. If it finds this
30245 section, it does the specified things (in this case, running
30246 @kbd{C-x * a} automatically) before editing of the file begins.
30247 The Local Variables section must be within 3000 characters of the
30248 end of the file for Emacs to find it, and it must be in the last
30249 page of the file if the file has any page separators.
30250 @xref{File Variables, , Local Variables in Files, emacs, the
30253 Note that @kbd{C-x * a} does not update the formulas it finds.
30254 To do this, type, say, @kbd{M-1 C-x * u} after @w{@kbd{C-x * a}}.
30255 Generally this should not be a problem, though, because the
30256 formulas will have been up-to-date already when the file was
30259 Normally, @kbd{C-x * a} activates all the formulas it finds, but
30260 any previous active formulas remain active as well. With a
30261 positive numeric prefix argument, @kbd{C-x * a} first deactivates
30262 all current active formulas, then actives the ones it finds in
30263 its scan of the buffer. With a negative prefix argument,
30264 @kbd{C-x * a} simply deactivates all formulas.
30266 Embedded mode has two symbols, @samp{Active} and @samp{~Active},
30267 which it puts next to the major mode name in a buffer's mode line.
30268 It puts @samp{Active} if it has reason to believe that all
30269 formulas in the buffer are active, because you have typed @kbd{C-x * a}
30270 and Calc has not since had to deactivate any formulas (which can
30271 happen if Calc goes to update an @samp{=>} formula somewhere because
30272 a variable changed, and finds that the formula is no longer there
30273 due to some kind of editing outside of Embedded mode). Calc puts
30274 @samp{~Active} in the mode line if some, but probably not all,
30275 formulas in the buffer are active. This happens if you activate
30276 a few formulas one at a time but never use @kbd{C-x * a}, or if you
30277 used @kbd{C-x * a} but then Calc had to deactivate a formula
30278 because it lost track of it. If neither of these symbols appears
30279 in the mode line, no embedded formulas are active in the buffer
30280 (e.g., before Embedded mode has been used, or after a @kbd{M-- C-x * a}).
30282 Embedded formulas can refer to assignments both before and after them
30283 in the buffer. If there are several assignments to a variable, the
30284 nearest preceding assignment is used if there is one, otherwise the
30285 following assignment is used.
30299 As well as simple variables, you can also assign to subscript
30300 expressions of the form @samp{@var{var}_@var{number}} (as in
30301 @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
30302 Assignments to other kinds of objects can be represented by Calc,
30303 but the automatic linkage between assignments and references works
30304 only for plain variables and these two kinds of subscript expressions.
30306 If there are no assignments to a given variable, the global
30307 stored value for the variable is used (@pxref{Storing Variables}),
30308 or, if no value is stored, the variable is left in symbolic form.
30309 Note that global stored values will be lost when the file is saved
30310 and loaded in a later Emacs session, unless you have used the
30311 @kbd{s p} (@code{calc-permanent-variable}) command to save them;
30312 @pxref{Operations on Variables}.
30314 The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
30315 recomputation of @samp{=>} forms on and off. If you turn automatic
30316 recomputation off, you will have to use @kbd{C-x * u} to update these
30317 formulas manually after an assignment has been changed. If you
30318 plan to change several assignments at once, it may be more efficient
30319 to type @kbd{m C}, change all the assignments, then use @kbd{M-1 C-x * u}
30320 to update the entire buffer afterwards. The @kbd{m C} command also
30321 controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
30322 Operator}. When you turn automatic recomputation back on, the
30323 stack will be updated but the Embedded buffer will not; you must
30324 use @kbd{C-x * u} to update the buffer by hand.
30326 @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
30327 @section Mode Settings in Embedded Mode
30330 @pindex calc-embedded-preserve-modes
30332 The mode settings can be changed while Calc is in embedded mode, but
30333 by default they will revert to their original values when embedded mode
30334 is ended. However, the modes saved when the mode-recording mode is
30335 @code{Save} (see below) and the modes in effect when the @kbd{m e}
30336 (@code{calc-embedded-preserve-modes}) command is given
30337 will be preserved when embedded mode is ended.
30339 Embedded mode has a rather complicated mechanism for handling mode
30340 settings in Embedded formulas. It is possible to put annotations
30341 in the file that specify mode settings either global to the entire
30342 file or local to a particular formula or formulas. In the latter
30343 case, different modes can be specified for use when a formula
30344 is the enabled Embedded mode formula.
30346 When you give any mode-setting command, like @kbd{m f} (for Fraction
30347 mode) or @kbd{d s} (for scientific notation), Embedded mode adds
30348 a line like the following one to the file just before the opening
30349 delimiter of the formula.
30352 % [calc-mode: fractions: t]
30353 % [calc-mode: float-format: (sci 0)]
30356 When Calc interprets an embedded formula, it scans the text before
30357 the formula for mode-setting annotations like these and sets the
30358 Calc buffer to match these modes. Modes not explicitly described
30359 in the file are not changed. Calc scans all the way to the top of
30360 the file, or up to a line of the form
30367 which you can insert at strategic places in the file if this backward
30368 scan is getting too slow, or just to provide a barrier between one
30369 ``zone'' of mode settings and another.
30371 If the file contains several annotations for the same mode, the
30372 closest one before the formula is used. Annotations after the
30373 formula are never used (except for global annotations, described
30376 The scan does not look for the leading @samp{% }, only for the
30377 square brackets and the text they enclose. In fact, the leading
30378 characters are different for different major modes. You can edit the
30379 mode annotations to a style that works better in context if you wish.
30380 @xref{Customizing Embedded Mode}, to see how to change the style
30381 that Calc uses when it generates the annotations. You can write
30382 mode annotations into the file yourself if you know the syntax;
30383 the easiest way to find the syntax for a given mode is to let
30384 Calc write the annotation for it once and see what it does.
30386 If you give a mode-changing command for a mode that already has
30387 a suitable annotation just above the current formula, Calc will
30388 modify that annotation rather than generating a new, conflicting
30391 Mode annotations have three parts, separated by colons. (Spaces
30392 after the colons are optional.) The first identifies the kind
30393 of mode setting, the second is a name for the mode itself, and
30394 the third is the value in the form of a Lisp symbol, number,
30395 or list. Annotations with unrecognizable text in the first or
30396 second parts are ignored. The third part is not checked to make
30397 sure the value is of a valid type or range; if you write an
30398 annotation by hand, be sure to give a proper value or results
30399 will be unpredictable. Mode-setting annotations are case-sensitive.
30401 While Embedded mode is enabled, the word @code{Local} appears in
30402 the mode line. This is to show that mode setting commands generate
30403 annotations that are ``local'' to the current formula or set of
30404 formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command
30405 causes Calc to generate different kinds of annotations. Pressing
30406 @kbd{m R} repeatedly cycles through the possible modes.
30408 @code{LocEdit} and @code{LocPerm} modes generate annotations
30409 that look like this, respectively:
30412 % [calc-edit-mode: float-format: (sci 0)]
30413 % [calc-perm-mode: float-format: (sci 5)]
30416 The first kind of annotation will be used only while a formula
30417 is enabled in Embedded mode. The second kind will be used only
30418 when the formula is @emph{not} enabled. (Whether the formula
30419 is ``active'' or not, i.e., whether Calc has seen this formula
30420 yet, is not relevant here.)
30422 @code{Global} mode generates an annotation like this at the end
30426 % [calc-global-mode: fractions t]
30429 Global mode annotations affect all formulas throughout the file,
30430 and may appear anywhere in the file. This allows you to tuck your
30431 mode annotations somewhere out of the way, say, on a new page of
30432 the file, as long as those mode settings are suitable for all
30433 formulas in the file.
30435 Enabling a formula with @kbd{C-x * e} causes a fresh scan for local
30436 mode annotations; you will have to use this after adding annotations
30437 above a formula by hand to get the formula to notice them. Updating
30438 a formula with @kbd{C-x * u} will also re-scan the local modes, but
30439 global modes are only re-scanned by @kbd{C-x * a}.
30441 Another way that modes can get out of date is if you add a local
30442 mode annotation to a formula that has another formula after it.
30443 In this example, we have used the @kbd{d s} command while the
30444 first of the two embedded formulas is active. But the second
30445 formula has not changed its style to match, even though by the
30446 rules of reading annotations the @samp{(sci 0)} applies to it, too.
30449 % [calc-mode: float-format: (sci 0)]
30455 We would have to go down to the other formula and press @kbd{C-x * u}
30456 on it in order to get it to notice the new annotation.
30458 Two more mode-recording modes selectable by @kbd{m R} are available
30459 which are also available outside of Embedded mode.
30460 (@pxref{General Mode Commands}.) They are @code{Save}, in which mode
30461 settings are recorded permanently in your Calc init file (the file given
30462 by the variable @code{calc-settings-file}, typically @file{~/.calc.el})
30463 rather than by annotating the current document, and no-recording
30464 mode (where there is no symbol like @code{Save} or @code{Local} in
30465 the mode line), in which mode-changing commands do not leave any
30466 annotations at all.
30468 When Embedded mode is not enabled, mode-recording modes except
30469 for @code{Save} have no effect.
30471 @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
30472 @section Customizing Embedded Mode
30475 You can modify Embedded mode's behavior by setting various Lisp
30476 variables described here. These variables are customizable
30477 (@pxref{Customizing Calc}), or you can use @kbd{M-x set-variable}
30478 or @kbd{M-x edit-options} to adjust a variable on the fly.
30479 (Another possibility would be to use a file-local variable annotation at
30480 the end of the file;
30481 @pxref{File Variables, , Local Variables in Files, emacs, the Emacs manual}.)
30482 Many of the variables given mentioned here can be set to depend on the
30483 major mode of the editing buffer (@pxref{Customizing Calc}).
30485 @vindex calc-embedded-open-formula
30486 The @code{calc-embedded-open-formula} variable holds a regular
30487 expression for the opening delimiter of a formula. @xref{Regexp Search,
30488 , Regular Expression Search, emacs, the Emacs manual}, to see
30489 how regular expressions work. Basically, a regular expression is a
30490 pattern that Calc can search for. A regular expression that considers
30491 blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
30492 @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this
30493 regular expression is not completely plain, let's go through it
30496 The surrounding @samp{" "} marks quote the text between them as a
30497 Lisp string. If you left them off, @code{set-variable} or
30498 @code{edit-options} would try to read the regular expression as a
30501 The most obvious property of this regular expression is that it
30502 contains indecently many backslashes. There are actually two levels
30503 of backslash usage going on here. First, when Lisp reads a quoted
30504 string, all pairs of characters beginning with a backslash are
30505 interpreted as special characters. Here, @code{\n} changes to a
30506 new-line character, and @code{\\} changes to a single backslash.
30507 So the actual regular expression seen by Calc is
30508 @samp{\`\|^ @r{(newline)} \|\$\$?}.
30510 Regular expressions also consider pairs beginning with backslash
30511 to have special meanings. Sometimes the backslash is used to quote
30512 a character that otherwise would have a special meaning in a regular
30513 expression, like @samp{$}, which normally means ``end-of-line,''
30514 or @samp{?}, which means that the preceding item is optional. So
30515 @samp{\$\$?} matches either one or two dollar signs.
30517 The other codes in this regular expression are @samp{^}, which matches
30518 ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
30519 which matches ``beginning-of-buffer.'' So the whole pattern means
30520 that a formula begins at the beginning of the buffer, or on a newline
30521 that occurs at the beginning of a line (i.e., a blank line), or at
30522 one or two dollar signs.
30524 The default value of @code{calc-embedded-open-formula} looks just
30525 like this example, with several more alternatives added on to
30526 recognize various other common kinds of delimiters.
30528 By the way, the reason to use @samp{^\n} rather than @samp{^$}
30529 or @samp{\n\n}, which also would appear to match blank lines,
30530 is that the former expression actually ``consumes'' only one
30531 newline character as @emph{part of} the delimiter, whereas the
30532 latter expressions consume zero or two newlines, respectively.
30533 The former choice gives the most natural behavior when Calc
30534 must operate on a whole formula including its delimiters.
30536 See the Emacs manual for complete details on regular expressions.
30537 But just for your convenience, here is a list of all characters
30538 which must be quoted with backslash (like @samp{\$}) to avoid
30539 some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note
30540 the backslash in this list; for example, to match @samp{\[} you
30541 must use @code{"\\\\\\["}. An exercise for the reader is to
30542 account for each of these six backslashes!)
30544 @vindex calc-embedded-close-formula
30545 The @code{calc-embedded-close-formula} variable holds a regular
30546 expression for the closing delimiter of a formula. A closing
30547 regular expression to match the above example would be
30548 @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the
30549 other one, except it now uses @samp{\'} (``end-of-buffer'') and
30550 @samp{\n$} (newline occurring at end of line, yet another way
30551 of describing a blank line that is more appropriate for this
30554 @vindex calc-embedded-open-word
30555 @vindex calc-embedded-close-word
30556 The @code{calc-embedded-open-word} and @code{calc-embedded-close-word}
30557 variables are similar expressions used when you type @kbd{C-x * w}
30558 instead of @kbd{C-x * e} to enable Embedded mode.
30560 @vindex calc-embedded-open-plain
30561 The @code{calc-embedded-open-plain} variable is a string which
30562 begins a ``plain'' formula written in front of the formatted
30563 formula when @kbd{d p} mode is turned on. Note that this is an
30564 actual string, not a regular expression, because Calc must be able
30565 to write this string into a buffer as well as to recognize it.
30566 The default string is @code{"%%% "} (note the trailing space), but may
30567 be different for certain major modes.
30569 @vindex calc-embedded-close-plain
30570 The @code{calc-embedded-close-plain} variable is a string which
30571 ends a ``plain'' formula. The default is @code{" %%%\n"}, but may be
30572 different for different major modes. Without
30573 the trailing newline here, the first line of a Big mode formula
30574 that followed might be shifted over with respect to the other lines.
30576 @vindex calc-embedded-open-new-formula
30577 The @code{calc-embedded-open-new-formula} variable is a string
30578 which is inserted at the front of a new formula when you type
30579 @kbd{C-x * f}. Its default value is @code{"\n\n"}. If this
30580 string begins with a newline character and the @kbd{C-x * f} is
30581 typed at the beginning of a line, @kbd{C-x * f} will skip this
30582 first newline to avoid introducing unnecessary blank lines in
30585 @vindex calc-embedded-close-new-formula
30586 The @code{calc-embedded-close-new-formula} variable is the corresponding
30587 string which is inserted at the end of a new formula. Its default
30588 value is also @code{"\n\n"}. The final newline is omitted by
30589 @w{@kbd{C-x * f}} if typed at the end of a line. (It follows that if
30590 @kbd{C-x * f} is typed on a blank line, both a leading opening
30591 newline and a trailing closing newline are omitted.)
30593 @vindex calc-embedded-announce-formula
30594 The @code{calc-embedded-announce-formula} variable is a regular
30595 expression which is sure to be followed by an embedded formula.
30596 The @kbd{C-x * a} command searches for this pattern as well as for
30597 @samp{=>} and @samp{:=} operators. Note that @kbd{C-x * a} will
30598 not activate just anything surrounded by formula delimiters; after
30599 all, blank lines are considered formula delimiters by default!
30600 But if your language includes a delimiter which can only occur
30601 actually in front of a formula, you can take advantage of it here.
30602 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, but may be
30603 different for different major modes.
30604 This pattern will check for @samp{%Embed} followed by any number of
30605 lines beginning with @samp{%} and a space. This last is important to
30606 make Calc consider mode annotations part of the pattern, so that the
30607 formula's opening delimiter really is sure to follow the pattern.
30609 @vindex calc-embedded-open-mode
30610 The @code{calc-embedded-open-mode} variable is a string (not a
30611 regular expression) which should precede a mode annotation.
30612 Calc never scans for this string; Calc always looks for the
30613 annotation itself. But this is the string that is inserted before
30614 the opening bracket when Calc adds an annotation on its own.
30615 The default is @code{"% "}, but may be different for different major
30618 @vindex calc-embedded-close-mode
30619 The @code{calc-embedded-close-mode} variable is a string which
30620 follows a mode annotation written by Calc. Its default value
30621 is simply a newline, @code{"\n"}, but may be different for different
30622 major modes. If you change this, it is a good idea still to end with a
30623 newline so that mode annotations will appear on lines by themselves.
30625 @node Programming, Copying, Embedded Mode, Top
30626 @chapter Programming
30629 There are several ways to ``program'' the Emacs Calculator, depending
30630 on the nature of the problem you need to solve.
30634 @dfn{Keyboard macros} allow you to record a sequence of keystrokes
30635 and play them back at a later time. This is just the standard Emacs
30636 keyboard macro mechanism, dressed up with a few more features such
30637 as loops and conditionals.
30640 @dfn{Algebraic definitions} allow you to use any formula to define a
30641 new function. This function can then be used in algebraic formulas or
30642 as an interactive command.
30645 @dfn{Rewrite rules} are discussed in the section on algebra commands.
30646 @xref{Rewrite Rules}. If you put your rewrite rules in the variable
30647 @code{EvalRules}, they will be applied automatically to all Calc
30648 results in just the same way as an internal ``rule'' is applied to
30649 evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}.
30652 @dfn{Lisp} is the programming language that Calc (and most of Emacs)
30653 is written in. If the above techniques aren't powerful enough, you
30654 can write Lisp functions to do anything that built-in Calc commands
30655 can do. Lisp code is also somewhat faster than keyboard macros or
30660 Programming features are available through the @kbd{z} and @kbd{Z}
30661 prefix keys. New commands that you define are two-key sequences
30662 beginning with @kbd{z}. Commands for managing these definitions
30663 use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing})
30664 command is described elsewhere; @pxref{Troubleshooting Commands}.
30665 The @kbd{Z C} (@code{calc-user-define-composition}) command is also
30666 described elsewhere; @pxref{User-Defined Compositions}.)
30669 * Creating User Keys::
30670 * Keyboard Macros::
30671 * Invocation Macros::
30672 * Algebraic Definitions::
30673 * Lisp Definitions::
30676 @node Creating User Keys, Keyboard Macros, Programming, Programming
30677 @section Creating User Keys
30681 @pindex calc-user-define
30682 Any Calculator command may be bound to a key using the @kbd{Z D}
30683 (@code{calc-user-define}) command. Actually, it is bound to a two-key
30684 sequence beginning with the lower-case @kbd{z} prefix.
30686 The @kbd{Z D} command first prompts for the key to define. For example,
30687 press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then
30688 prompted for the name of the Calculator command that this key should
30689 run. For example, the @code{calc-sincos} command is not normally
30690 available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the
30691 @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain
30692 in effect for the rest of this Emacs session, or until you redefine
30693 @kbd{z s} to be something else.
30695 You can actually bind any Emacs command to a @kbd{z} key sequence by
30696 backspacing over the @samp{calc-} when you are prompted for the command name.
30698 As with any other prefix key, you can type @kbd{z ?} to see a list of
30699 all the two-key sequences you have defined that start with @kbd{z}.
30700 Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
30702 User keys are typically letters, but may in fact be any key.
30703 (@key{META}-keys are not permitted, nor are a terminal's special
30704 function keys which generate multi-character sequences when pressed.)
30705 You can define different commands on the shifted and unshifted versions
30706 of a letter if you wish.
30709 @pindex calc-user-undefine
30710 The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
30711 For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
30712 key we defined above.
30715 @pindex calc-user-define-permanent
30716 @cindex Storing user definitions
30717 @cindex Permanent user definitions
30718 @cindex Calc init file, user-defined commands
30719 The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
30720 binding permanent so that it will remain in effect even in future Emacs
30721 sessions. (It does this by adding a suitable bit of Lisp code into
30722 your Calc init file; that is, the file given by the variable
30723 @code{calc-settings-file}, typically @file{~/.calc.el}.) For example,
30724 @kbd{Z P s} would register our @code{sincos} command permanently. If
30725 you later wish to unregister this command you must edit your Calc init
30726 file by hand. (@xref{General Mode Commands}, for a way to tell Calc to
30727 use a different file for the Calc init file.)
30729 The @kbd{Z P} command also saves the user definition, if any, for the
30730 command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user
30731 key could invoke a command, which in turn calls an algebraic function,
30732 which might have one or more special display formats. A single @kbd{Z P}
30733 command will save all of these definitions.
30734 To save an algebraic function, type @kbd{'} (the apostrophe)
30735 when prompted for a key, and type the function name. To save a command
30736 without its key binding, type @kbd{M-x} and enter a function name. (The
30737 @samp{calc-} prefix will automatically be inserted for you.)
30738 (If the command you give implies a function, the function will be saved,
30739 and if the function has any display formats, those will be saved, but
30740 not the other way around: Saving a function will not save any commands
30741 or key bindings associated with the function.)
30744 @pindex calc-user-define-edit
30745 @cindex Editing user definitions
30746 The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
30747 of a user key. This works for keys that have been defined by either
30748 keyboard macros or formulas; further details are contained in the relevant
30749 following sections.
30751 @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
30752 @section Programming with Keyboard Macros
30756 @cindex Programming with keyboard macros
30757 @cindex Keyboard macros
30758 The easiest way to ``program'' the Emacs Calculator is to use standard
30759 keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From
30760 this point on, keystrokes you type will be saved away as well as
30761 performing their usual functions. Press @kbd{C-x )} to end recording.
30762 Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
30763 execute your keyboard macro by replaying the recorded keystrokes.
30764 @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
30767 When you use @kbd{X} to invoke a keyboard macro, the entire macro is
30768 treated as a single command by the undo and trail features. The stack
30769 display buffer is not updated during macro execution, but is instead
30770 fixed up once the macro completes. Thus, commands defined with keyboard
30771 macros are convenient and efficient. The @kbd{C-x e} command, on the
30772 other hand, invokes the keyboard macro with no special treatment: Each
30773 command in the macro will record its own undo information and trail entry,
30774 and update the stack buffer accordingly. If your macro uses features
30775 outside of Calc's control to operate on the contents of the Calc stack
30776 buffer, or if it includes Undo, Redo, or last-arguments commands, you
30777 must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
30778 at all times. You could also consider using @kbd{K} (@code{calc-keep-args})
30779 instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
30781 Calc extends the standard Emacs keyboard macros in several ways.
30782 Keyboard macros can be used to create user-defined commands. Keyboard
30783 macros can include conditional and iteration structures, somewhat
30784 analogous to those provided by a traditional programmable calculator.
30787 * Naming Keyboard Macros::
30788 * Conditionals in Macros::
30789 * Loops in Macros::
30790 * Local Values in Macros::
30791 * Queries in Macros::
30794 @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
30795 @subsection Naming Keyboard Macros
30799 @pindex calc-user-define-kbd-macro
30800 Once you have defined a keyboard macro, you can bind it to a @kbd{z}
30801 key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
30802 This command prompts first for a key, then for a command name. For
30803 example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
30804 define a keyboard macro which negates the top two numbers on the stack
30805 (@key{TAB} swaps the top two stack elements). Now you can type
30806 @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
30807 sequence. The default command name (if you answer the second prompt with
30808 just the @key{RET} key as in this example) will be something like
30809 @samp{calc-User-n}. The keyboard macro will now be available as both
30810 @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more
30811 descriptive command name if you wish.
30813 Macros defined by @kbd{Z K} act like single commands; they are executed
30814 in the same way as by the @kbd{X} key. If you wish to define the macro
30815 as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
30816 give a negative prefix argument to @kbd{Z K}.
30818 Once you have bound your keyboard macro to a key, you can use
30819 @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}.
30821 @cindex Keyboard macros, editing
30822 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
30823 been defined by a keyboard macro tries to use the @code{edmacro} package
30824 edit the macro. Type @kbd{C-c C-c} to finish editing and update
30825 the definition stored on the key, or, to cancel the edit, kill the
30826 buffer with @kbd{C-x k}.
30827 The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC},
30828 @code{DEL}, and @code{NUL} must be entered as these three character
30829 sequences, written in all uppercase, as must the prefixes @code{C-} and
30830 @code{M-}. Spaces and line breaks are ignored. Other characters are
30831 copied verbatim into the keyboard macro. Basically, the notation is the
30832 same as is used in all of this manual's examples, except that the manual
30833 takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}},
30834 we take it for granted that it is clear we really mean
30835 @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}.
30838 @pindex read-kbd-macro
30839 The @kbd{C-x * m} (@code{read-kbd-macro}) command reads an Emacs ``region''
30840 of spelled-out keystrokes and defines it as the current keyboard macro.
30841 It is a convenient way to define a keyboard macro that has been stored
30842 in a file, or to define a macro without executing it at the same time.
30844 @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
30845 @subsection Conditionals in Keyboard Macros
30850 @pindex calc-kbd-if
30851 @pindex calc-kbd-else
30852 @pindex calc-kbd-else-if
30853 @pindex calc-kbd-end-if
30854 @cindex Conditional structures
30855 The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
30856 commands allow you to put simple tests in a keyboard macro. When Calc
30857 sees the @kbd{Z [}, it pops an object from the stack and, if the object is
30858 a non-zero value, continues executing keystrokes. But if the object is
30859 zero, or if it is not provably nonzero, Calc skips ahead to the matching
30860 @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for
30861 performing tests which conveniently produce 1 for true and 0 for false.
30863 For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
30864 function in the form of a keyboard macro. This macro duplicates the
30865 number on the top of the stack, pushes zero and compares using @kbd{a <}
30866 (@code{calc-less-than}), then, if the number was less than zero,
30867 executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign
30868 command is skipped.
30870 To program this macro, type @kbd{C-x (}, type the above sequence of
30871 keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be
30872 executed while you are making the definition as well as when you later
30873 re-execute the macro by typing @kbd{X}. Thus you should make sure a
30874 suitable number is on the stack before defining the macro so that you
30875 don't get a stack-underflow error during the definition process.
30877 Conditionals can be nested arbitrarily. However, there should be exactly
30878 one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
30881 The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
30882 two keystroke sequences. The general format is @kbd{@var{cond} Z [
30883 @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true
30884 (i.e., if the top of stack contains a non-zero number after @var{cond}
30885 has been executed), the @var{then-part} will be executed and the
30886 @var{else-part} will be skipped. Otherwise, the @var{then-part} will
30887 be skipped and the @var{else-part} will be executed.
30890 The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
30891 between any number of alternatives. For example,
30892 @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
30893 @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
30894 otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
30895 it will execute @var{part3}.
30897 More precisely, @kbd{Z [} pops a number and conditionally skips to the
30898 next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when
30899 actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}.
30900 @kbd{Z |} pops a number and conditionally skips to the next matching
30901 @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
30902 equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
30905 Calc's conditional and looping constructs work by scanning the
30906 keyboard macro for occurrences of character sequences like @samp{Z:}
30907 and @samp{Z]}. One side-effect of this is that if you use these
30908 constructs you must be careful that these character pairs do not
30909 occur by accident in other parts of the macros. Since Calc rarely
30910 uses shift-@kbd{Z} for any purpose except as a prefix character, this
30911 is not likely to be a problem. Another side-effect is that it will
30912 not work to define your own custom key bindings for these commands.
30913 Only the standard shift-@kbd{Z} bindings will work correctly.
30916 If Calc gets stuck while skipping characters during the definition of a
30917 macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g}
30918 actually adds a @kbd{C-g} keystroke to the macro.)
30920 @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
30921 @subsection Loops in Keyboard Macros
30926 @pindex calc-kbd-repeat
30927 @pindex calc-kbd-end-repeat
30928 @cindex Looping structures
30929 @cindex Iterative structures
30930 The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
30931 (@code{calc-kbd-end-repeat}) commands pop a number from the stack,
30932 which must be an integer, then repeat the keystrokes between the brackets
30933 the specified number of times. If the integer is zero or negative, the
30934 body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >}
30935 computes two to a nonnegative integer power. First, we push 1 on the
30936 stack and then swap the integer argument back to the top. The @kbd{Z <}
30937 pops that argument leaving the 1 back on top of the stack. Then, we
30938 repeat a multiply-by-two step however many times.
30940 Once again, the keyboard macro is executed as it is being entered.
30941 In this case it is especially important to set up reasonable initial
30942 conditions before making the definition: Suppose the integer 1000 just
30943 happened to be sitting on the stack before we typed the above definition!
30944 Another approach is to enter a harmless dummy definition for the macro,
30945 then go back and edit in the real one with a @kbd{Z E} command. Yet
30946 another approach is to type the macro as written-out keystroke names
30947 in a buffer, then use @kbd{C-x * m} (@code{read-kbd-macro}) to read the
30952 The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
30953 of a keyboard macro loop prematurely. It pops an object from the stack;
30954 if that object is true (a non-zero number), control jumps out of the
30955 innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
30956 after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no
30957 effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
30962 @pindex calc-kbd-for
30963 @pindex calc-kbd-end-for
30964 The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
30965 commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
30966 value of the counter available inside the loop. The general layout is
30967 @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (}
30968 command pops initial and final values from the stack. It then creates
30969 a temporary internal counter and initializes it with the value @var{init}.
30970 The @kbd{Z (} command then repeatedly pushes the counter value onto the
30971 stack and executes @var{body} and @var{step}, adding @var{step} to the
30972 counter each time until the loop finishes.
30974 @cindex Summations (by keyboard macros)
30975 By default, the loop finishes when the counter becomes greater than (or
30976 less than) @var{final}, assuming @var{initial} is less than (greater
30977 than) @var{final}. If @var{initial} is equal to @var{final}, the body
30978 executes exactly once. The body of the loop always executes at least
30979 once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
30980 squares of the integers from 1 to 10, in steps of 1.
30982 If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
30983 forced to use upward-counting conventions. In this case, if @var{initial}
30984 is greater than @var{final} the body will not be executed at all.
30985 Note that @var{step} may still be negative in this loop; the prefix
30986 argument merely constrains the loop-finished test. Likewise, a prefix
30987 argument of @mathit{-1} forces downward-counting conventions.
30991 @pindex calc-kbd-loop
30992 @pindex calc-kbd-end-loop
30993 The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
30994 (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
30995 @kbd{Z >}, except that they do not pop a count from the stack---they
30996 effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}}
30997 loop ought to include at least one @kbd{Z /} to make sure the loop
30998 doesn't run forever. (If any error message occurs which causes Emacs
30999 to beep, the keyboard macro will also be halted; this is a standard
31000 feature of Emacs. You can also generally press @kbd{C-g} to halt a
31001 running keyboard macro, although not all versions of Unix support
31004 The conditional and looping constructs are not actually tied to
31005 keyboard macros, but they are most often used in that context.
31006 For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
31007 ten copies of 23 onto the stack. This can be typed ``live'' just
31008 as easily as in a macro definition.
31010 @xref{Conditionals in Macros}, for some additional notes about
31011 conditional and looping commands.
31013 @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
31014 @subsection Local Values in Macros
31017 @cindex Local variables
31018 @cindex Restoring saved modes
31019 Keyboard macros sometimes want to operate under known conditions
31020 without affecting surrounding conditions. For example, a keyboard
31021 macro may wish to turn on Fraction mode, or set a particular
31022 precision, independent of the user's normal setting for those
31027 @pindex calc-kbd-push
31028 @pindex calc-kbd-pop
31029 Macros also sometimes need to use local variables. Assignments to
31030 local variables inside the macro should not affect any variables
31031 outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
31032 (@code{calc-kbd-pop}) commands give you both of these capabilities.
31034 When you type @kbd{Z `} (with a backquote or accent grave character),
31035 the values of various mode settings are saved away. The ten ``quick''
31036 variables @code{q0} through @code{q9} are also saved. When
31037 you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
31038 Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
31040 If a keyboard macro halts due to an error in between a @kbd{Z `} and
31041 a @kbd{Z '}, the saved values will be restored correctly even though
31042 the macro never reaches the @kbd{Z '} command. Thus you can use
31043 @kbd{Z `} and @kbd{Z '} without having to worry about what happens
31044 in exceptional conditions.
31046 If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
31047 you into a ``recursive edit.'' You can tell you are in a recursive
31048 edit because there will be extra square brackets in the mode line,
31049 as in @samp{[(Calculator)]}. These brackets will go away when you
31050 type the matching @kbd{Z '} command. The modes and quick variables
31051 will be saved and restored in just the same way as if actual keyboard
31052 macros were involved.
31054 The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
31055 and binary word size, the angular mode (Deg, Rad, or HMS), the
31056 simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
31057 Matrix or Scalar mode, Fraction mode, and the current complex mode
31058 (Polar or Rectangular). The ten ``quick'' variables' values (or lack
31059 thereof) are also saved.
31061 Most mode-setting commands act as toggles, but with a numeric prefix
31062 they force the mode either on (positive prefix) or off (negative
31063 or zero prefix). Since you don't know what the environment might
31064 be when you invoke your macro, it's best to use prefix arguments
31065 for all mode-setting commands inside the macro.
31067 In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
31068 listed above to their default values. As usual, the matching @kbd{Z '}
31069 will restore the modes to their settings from before the @kbd{C-u Z `}.
31070 Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode
31071 to its default (off) but leaves the other modes the same as they were
31072 outside the construct.
31074 The contents of the stack and trail, values of non-quick variables, and
31075 other settings such as the language mode and the various display modes,
31076 are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
31078 @node Queries in Macros, , Local Values in Macros, Keyboard Macros
31079 @subsection Queries in Keyboard Macros
31083 @c @pindex calc-kbd-report
31084 @c The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
31085 @c message including the value on the top of the stack. You are prompted
31086 @c to enter a string. That string, along with the top-of-stack value,
31087 @c is displayed unless @kbd{m w} (@code{calc-working}) has been used
31088 @c to turn such messages off.
31092 @pindex calc-kbd-query
31093 The @kbd{Z #} (@code{calc-kbd-query}) command prompts for an algebraic
31094 entry which takes its input from the keyboard, even during macro
31095 execution. All the normal conventions of algebraic input, including the
31096 use of @kbd{$} characters, are supported. The prompt message itself is
31097 taken from the top of the stack, and so must be entered (as a string)
31098 before the @kbd{Z #} command. (Recall, as a string it can be entered by
31099 pressing the @kbd{"} key and will appear as a vector when it is put on
31100 the stack. The prompt message is only put on the stack to provide a
31101 prompt for the @kbd{Z #} command; it will not play any role in any
31102 subsequent calculations.) This command allows your keyboard macros to
31103 accept numbers or formulas as interactive input.
31106 @kbd{2 @key{RET} "Power: " @key{RET} Z # 3 @key{RET} ^} will prompt for
31107 input with ``Power: '' in the minibuffer, then return 2 to the provided
31108 power. (The response to the prompt that's given, 3 in this example,
31109 will not be part of the macro.)
31111 @xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of
31112 @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
31113 keyboard input during a keyboard macro. In particular, you can use
31114 @kbd{C-x q} to enter a recursive edit, which allows the user to perform
31115 any Calculator operations interactively before pressing @kbd{C-M-c} to
31116 return control to the keyboard macro.
31118 @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
31119 @section Invocation Macros
31123 @pindex calc-user-invocation
31124 @pindex calc-user-define-invocation
31125 Calc provides one special keyboard macro, called up by @kbd{C-x * z}
31126 (@code{calc-user-invocation}), that is intended to allow you to define
31127 your own special way of starting Calc. To define this ``invocation
31128 macro,'' create the macro in the usual way with @kbd{C-x (} and
31129 @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
31130 There is only one invocation macro, so you don't need to type any
31131 additional letters after @kbd{Z I}. From now on, you can type
31132 @kbd{C-x * z} at any time to execute your invocation macro.
31134 For example, suppose you find yourself often grabbing rectangles of
31135 numbers into Calc and multiplying their columns. You can do this
31136 by typing @kbd{C-x * r} to grab, and @kbd{V R : *} to multiply columns.
31137 To make this into an invocation macro, just type @kbd{C-x ( C-x * r
31138 V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data,
31139 just mark the data in its buffer in the usual way and type @kbd{C-x * z}.
31141 Invocation macros are treated like regular Emacs keyboard macros;
31142 all the special features described above for @kbd{Z K}-style macros
31143 do not apply. @kbd{C-x * z} is just like @kbd{C-x e}, except that it
31144 uses the macro that was last stored by @kbd{Z I}. (In fact, the
31145 macro does not even have to have anything to do with Calc!)
31147 The @kbd{m m} command saves the last invocation macro defined by
31148 @kbd{Z I} along with all the other Calc mode settings.
31149 @xref{General Mode Commands}.
31151 @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
31152 @section Programming with Formulas
31156 @pindex calc-user-define-formula
31157 @cindex Programming with algebraic formulas
31158 Another way to create a new Calculator command uses algebraic formulas.
31159 The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
31160 formula at the top of the stack as the definition for a key. This
31161 command prompts for five things: The key, the command name, the function
31162 name, the argument list, and the behavior of the command when given
31163 non-numeric arguments.
31165 For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
31166 @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this
31167 formula on the @kbd{z m} key sequence. The next prompt is for a command
31168 name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
31169 for the new command. If you simply press @key{RET}, a default name like
31170 @code{calc-User-m} will be constructed. In our example, suppose we enter
31171 @kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
31173 If you want to give the formula a long-style name only, you can press
31174 @key{SPC} or @key{RET} when asked which single key to use. For example
31175 @kbd{Z F @key{RET} spam @key{RET}} defines the new command as
31176 @kbd{M-x calc-spam}, with no keyboard equivalent.
31178 The third prompt is for an algebraic function name. The default is to
31179 use the same name as the command name but without the @samp{calc-}
31180 prefix. (If this is of the form @samp{User-m}, the hyphen is removed so
31181 it won't be taken for a minus sign in algebraic formulas.)
31182 This is the name you will use if you want to enter your
31183 new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}.
31184 Then the new function can be invoked by pushing two numbers on the
31185 stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
31186 formula @samp{yow(x,y)}.
31188 The fourth prompt is for the function's argument list. This is used to
31189 associate values on the stack with the variables that appear in the formula.
31190 The default is a list of all variables which appear in the formula, sorted
31191 into alphabetical order. In our case, the default would be @samp{(a b)}.
31192 This means that, when the user types @kbd{z m}, the Calculator will remove
31193 two numbers from the stack, substitute these numbers for @samp{a} and
31194 @samp{b} (respectively) in the formula, then simplify the formula and
31195 push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m}
31196 would replace the 10 and 100 on the stack with the number 210, which is
31197 @expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula
31198 @samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and
31199 @expr{b=100} in the definition.
31201 You can rearrange the order of the names before pressing @key{RET} to
31202 control which stack positions go to which variables in the formula. If
31203 you remove a variable from the argument list, that variable will be left
31204 in symbolic form by the command. Thus using an argument list of @samp{(b)}
31205 for our function would cause @kbd{10 z m} to replace the 10 on the stack
31206 with the formula @samp{a + 20}. If we had used an argument list of
31207 @samp{(b a)}, the result with inputs 10 and 100 would have been 120.
31209 You can also put a nameless function on the stack instead of just a
31210 formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}.
31211 In this example, the command will be defined by the formula @samp{a + 2 b}
31212 using the argument list @samp{(a b)}.
31214 The final prompt is a y-or-n question concerning what to do if symbolic
31215 arguments are given to your function. If you answer @kbd{y}, then
31216 executing @kbd{z m} (using the original argument list @samp{(a b)}) with
31217 arguments @expr{10} and @expr{x} will leave the function in symbolic
31218 form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n},
31219 then the formula will always be expanded, even for non-constant
31220 arguments: @samp{10 + 2 x}. If you never plan to feed algebraic
31221 formulas to your new function, it doesn't matter how you answer this
31224 If you answered @kbd{y} to this question you can still cause a function
31225 call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
31226 Also, Calc will expand the function if necessary when you take a
31227 derivative or integral or solve an equation involving the function.
31230 @pindex calc-get-user-defn
31231 Once you have defined a formula on a key, you can retrieve this formula
31232 with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a
31233 key, and this command pushes the formula that was used to define that
31234 key onto the stack. Actually, it pushes a nameless function that
31235 specifies both the argument list and the defining formula. You will get
31236 an error message if the key is undefined, or if the key was not defined
31237 by a @kbd{Z F} command.
31239 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
31240 been defined by a formula uses a variant of the @code{calc-edit} command
31241 to edit the defining formula. Press @kbd{C-c C-c} to finish editing and
31242 store the new formula back in the definition, or kill the buffer with
31244 cancel the edit. (The argument list and other properties of the
31245 definition are unchanged; to adjust the argument list, you can use
31246 @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
31247 then re-execute the @kbd{Z F} command.)
31249 As usual, the @kbd{Z P} command records your definition permanently.
31250 In this case it will permanently record all three of the relevant
31251 definitions: the key, the command, and the function.
31253 You may find it useful to turn off the default simplifications with
31254 @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
31255 used as a function definition. For example, the formula @samp{deriv(a^2,v)}
31256 which might be used to define a new function @samp{dsqr(a,v)} will be
31257 ``simplified'' to 0 immediately upon entry since @code{deriv} considers
31258 @expr{a} to be constant with respect to @expr{v}. Turning off
31259 default simplifications cures this problem: The definition will be stored
31260 in symbolic form without ever activating the @code{deriv} function. Press
31261 @kbd{m D} to turn the default simplifications back on afterwards.
31263 @node Lisp Definitions, , Algebraic Definitions, Programming
31264 @section Programming with Lisp
31267 The Calculator can be programmed quite extensively in Lisp. All you
31268 do is write a normal Lisp function definition, but with @code{defmath}
31269 in place of @code{defun}. This has the same form as @code{defun}, but it
31270 automagically replaces calls to standard Lisp functions like @code{+} and
31271 @code{zerop} with calls to the corresponding functions in Calc's own library.
31272 Thus you can write natural-looking Lisp code which operates on all of the
31273 standard Calculator data types. You can then use @kbd{Z D} if you wish to
31274 bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command
31275 will not edit a Lisp-based definition.
31277 Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section
31278 assumes a familiarity with Lisp programming concepts; if you do not know
31279 Lisp, you may find keyboard macros or rewrite rules to be an easier way
31280 to program the Calculator.
31282 This section first discusses ways to write commands, functions, or
31283 small programs to be executed inside of Calc. Then it discusses how
31284 your own separate programs are able to call Calc from the outside.
31285 Finally, there is a list of internal Calc functions and data structures
31286 for the true Lisp enthusiast.
31289 * Defining Functions::
31290 * Defining Simple Commands::
31291 * Defining Stack Commands::
31292 * Argument Qualifiers::
31293 * Example Definitions::
31295 * Calling Calc from Your Programs::
31299 @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
31300 @subsection Defining New Functions
31304 The @code{defmath} function (actually a Lisp macro) is like @code{defun}
31305 except that code in the body of the definition can make use of the full
31306 range of Calculator data types. The prefix @samp{calcFunc-} is added
31307 to the specified name to get the actual Lisp function name. As a simple
31311 (defmath myfact (n)
31313 (* n (myfact (1- n)))
31318 This actually expands to the code,
31321 (defun calcFunc-myfact (n)
31323 (math-mul n (calcFunc-myfact (math-add n -1)))
31328 This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
31330 The @samp{myfact} function as it is defined above has the bug that an
31331 expression @samp{myfact(a+b)} will be simplified to 1 because the
31332 formula @samp{a+b} is not considered to be @code{posp}. A robust
31333 factorial function would be written along the following lines:
31336 (defmath myfact (n)
31338 (* n (myfact (1- n)))
31341 nil))) ; this could be simplified as: (and (= n 0) 1)
31344 If a function returns @code{nil}, it is left unsimplified by the Calculator
31345 (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)}
31346 will be simplified to @samp{myfact(a+3)} but no further. Beware that every
31347 time the Calculator reexamines this formula it will attempt to resimplify
31348 it, so your function ought to detect the returning-@code{nil} case as
31349 efficiently as possible.
31351 The following standard Lisp functions are treated by @code{defmath}:
31352 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
31353 @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
31354 @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
31355 @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for
31356 @code{math-nearly-equal}, which is useful in implementing Taylor series.
31358 For other functions @var{func}, if a function by the name
31359 @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
31360 name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
31361 is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
31362 used on the assumption that this is a to-be-defined math function. Also, if
31363 the function name is quoted as in @samp{('integerp a)} the function name is
31364 always used exactly as written (but not quoted).
31366 Variable names have @samp{var-} prepended to them unless they appear in
31367 the function's argument list or in an enclosing @code{let}, @code{let*},
31368 @code{for}, or @code{foreach} form,
31369 or their names already contain a @samp{-} character. Thus a reference to
31370 @samp{foo} is the same as a reference to @samp{var-foo}.
31372 A few other Lisp extensions are available in @code{defmath} definitions:
31376 The @code{elt} function accepts any number of index variables.
31377 Note that Calc vectors are stored as Lisp lists whose first
31378 element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
31379 the second element of vector @code{v}, and @samp{(elt m i j)}
31380 yields one element of a Calc matrix.
31383 The @code{setq} function has been extended to act like the Common
31384 Lisp @code{setf} function. (The name @code{setf} is recognized as
31385 a synonym of @code{setq}.) Specifically, the first argument of
31386 @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
31387 in which case the effect is to store into the specified
31388 element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x}
31389 into one element of a matrix.
31392 A @code{for} looping construct is available. For example,
31393 @samp{(for ((i 0 10)) body)} executes @code{body} once for each
31394 binding of @expr{i} from zero to 10. This is like a @code{let}
31395 form in that @expr{i} is temporarily bound to the loop count
31396 without disturbing its value outside the @code{for} construct.
31397 Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
31398 are also available. For each value of @expr{i} from zero to 10,
31399 @expr{j} counts from 0 to @expr{i-1} in steps of two. Note that
31400 @code{for} has the same general outline as @code{let*}, except
31401 that each element of the header is a list of three or four
31402 things, not just two.
31405 The @code{foreach} construct loops over elements of a list.
31406 For example, @samp{(foreach ((x (cdr v))) body)} executes
31407 @code{body} with @expr{x} bound to each element of Calc vector
31408 @expr{v} in turn. The purpose of @code{cdr} here is to skip over
31409 the initial @code{vec} symbol in the vector.
31412 The @code{break} function breaks out of the innermost enclosing
31413 @code{while}, @code{for}, or @code{foreach} loop. If given a
31414 value, as in @samp{(break x)}, this value is returned by the
31415 loop. (Lisp loops otherwise always return @code{nil}.)
31418 The @code{return} function prematurely returns from the enclosing
31419 function. For example, @samp{(return (+ x y))} returns @expr{x+y}
31420 as the value of a function. You can use @code{return} anywhere
31421 inside the body of the function.
31424 Non-integer numbers (and extremely large integers) cannot be included
31425 directly into a @code{defmath} definition. This is because the Lisp
31426 reader will fail to parse them long before @code{defmath} ever gets control.
31427 Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic
31428 formula can go between the quotes. For example,
31431 (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
31439 (defun calcFunc-sqexp (x)
31440 (and (math-numberp x)
31441 (calcFunc-exp (math-mul x '(float 5 -1)))))
31444 Note the use of @code{numberp} as a guard to ensure that the argument is
31445 a number first, returning @code{nil} if not. The exponential function
31446 could itself have been included in the expression, if we had preferred:
31447 @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion
31448 step of @code{myfact} could have been written
31454 A good place to put your @code{defmath} commands is your Calc init file
31455 (the file given by @code{calc-settings-file}, typically
31456 @file{~/.calc.el}), which will not be loaded until Calc starts.
31457 If a file named @file{.emacs} exists in your home directory, Emacs reads
31458 and executes the Lisp forms in this file as it starts up. While it may
31459 seem reasonable to put your favorite @code{defmath} commands there,
31460 this has the unfortunate side-effect that parts of the Calculator must be
31461 loaded in to process the @code{defmath} commands whether or not you will
31462 actually use the Calculator! If you want to put the @code{defmath}
31463 commands there (for example, if you redefine @code{calc-settings-file}
31464 to be @file{.emacs}), a better effect can be had by writing
31467 (put 'calc-define 'thing '(progn
31474 @vindex calc-define
31475 The @code{put} function adds a @dfn{property} to a symbol. Each Lisp
31476 symbol has a list of properties associated with it. Here we add a
31477 property with a name of @code{thing} and a @samp{(progn ...)} form as
31478 its value. When Calc starts up, and at the start of every Calc command,
31479 the property list for the symbol @code{calc-define} is checked and the
31480 values of any properties found are evaluated as Lisp forms. The
31481 properties are removed as they are evaluated. The property names
31482 (like @code{thing}) are not used; you should choose something like the
31483 name of your project so as not to conflict with other properties.
31485 The net effect is that you can put the above code in your @file{.emacs}
31486 file and it will not be executed until Calc is loaded. Or, you can put
31487 that same code in another file which you load by hand either before or
31488 after Calc itself is loaded.
31490 The properties of @code{calc-define} are evaluated in the same order
31491 that they were added. They can assume that the Calc modules @file{calc.el},
31492 @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
31493 that the @samp{*Calculator*} buffer will be the current buffer.
31495 If your @code{calc-define} property only defines algebraic functions,
31496 you can be sure that it will have been evaluated before Calc tries to
31497 call your function, even if the file defining the property is loaded
31498 after Calc is loaded. But if the property defines commands or key
31499 sequences, it may not be evaluated soon enough. (Suppose it defines the
31500 new command @code{tweak-calc}; the user can load your file, then type
31501 @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To
31502 protect against this situation, you can put
31505 (run-hooks 'calc-check-defines)
31508 @findex calc-check-defines
31510 at the end of your file. The @code{calc-check-defines} function is what
31511 looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
31512 has the advantage that it is quietly ignored if @code{calc-check-defines}
31513 is not yet defined because Calc has not yet been loaded.
31515 Examples of things that ought to be enclosed in a @code{calc-define}
31516 property are @code{defmath} calls, @code{define-key} calls that modify
31517 the Calc key map, and any calls that redefine things defined inside Calc.
31518 Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
31520 @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
31521 @subsection Defining New Simple Commands
31524 @findex interactive
31525 If a @code{defmath} form contains an @code{interactive} clause, it defines
31526 a Calculator command. Actually such a @code{defmath} results in @emph{two}
31527 function definitions: One, a @samp{calcFunc-} function as was just described,
31528 with the @code{interactive} clause removed. Two, a @samp{calc-} function
31529 with a suitable @code{interactive} clause and some sort of wrapper to make
31530 the command work in the Calc environment.
31532 In the simple case, the @code{interactive} clause has the same form as
31533 for normal Emacs Lisp commands:
31536 (defmath increase-precision (delta)
31537 "Increase precision by DELTA." ; This is the "documentation string"
31538 (interactive "p") ; Register this as a M-x-able command
31539 (setq calc-internal-prec (+ calc-internal-prec delta)))
31542 This expands to the pair of definitions,
31545 (defun calc-increase-precision (delta)
31546 "Increase precision by DELTA."
31549 (setq calc-internal-prec (math-add calc-internal-prec delta))))
31551 (defun calcFunc-increase-precision (delta)
31552 "Increase precision by DELTA."
31553 (setq calc-internal-prec (math-add calc-internal-prec delta)))
31557 where in this case the latter function would never really be used! Note
31558 that since the Calculator stores small integers as plain Lisp integers,
31559 the @code{math-add} function will work just as well as the native
31560 @code{+} even when the intent is to operate on native Lisp integers.
31562 @findex calc-wrapper
31563 The @samp{calc-wrapper} call invokes a macro which surrounds the body of
31564 the function with code that looks roughly like this:
31567 (let ((calc-command-flags nil))
31570 (calc-select-buffer)
31571 @emph{body of function}
31572 @emph{renumber stack}
31573 @emph{clear} Working @emph{message})
31574 @emph{realign cursor and window}
31575 @emph{clear Inverse, Hyperbolic, and Keep Args flags}
31576 @emph{update Emacs mode line}))
31579 @findex calc-select-buffer
31580 The @code{calc-select-buffer} function selects the @samp{*Calculator*}
31581 buffer if necessary, say, because the command was invoked from inside
31582 the @samp{*Calc Trail*} window.
31584 @findex calc-set-command-flag
31585 You can call, for example, @code{(calc-set-command-flag 'no-align)} to
31586 set the above-mentioned command flags. Calc routines recognize the
31587 following command flags:
31591 Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
31592 after this command completes. This is set by routines like
31595 @item clear-message
31596 Calc should call @samp{(message "")} if this command completes normally
31597 (to clear a ``Working@dots{}'' message out of the echo area).
31600 Do not move the cursor back to the @samp{.} top-of-stack marker.
31602 @item position-point
31603 Use the variables @code{calc-position-point-line} and
31604 @code{calc-position-point-column} to position the cursor after
31605 this command finishes.
31608 Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
31609 and @code{calc-keep-args-flag} at the end of this command.
31612 Switch to buffer @samp{*Calc Edit*} after this command.
31615 Do not move trail pointer to end of trail when something is recorded
31621 @vindex calc-Y-help-msgs
31622 Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
31623 extensions to Calc. There are no built-in commands that work with
31624 this prefix key; you must call @code{define-key} from Lisp (probably
31625 from inside a @code{calc-define} property) to add to it. Initially only
31626 @kbd{Y ?} is defined; it takes help messages from a list of strings
31627 (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All
31628 other undefined keys except for @kbd{Y} are reserved for use by
31629 future versions of Calc.
31631 If you are writing a Calc enhancement which you expect to give to
31632 others, it is best to minimize the number of @kbd{Y}-key sequences
31633 you use. In fact, if you have more than one key sequence you should
31634 consider defining three-key sequences with a @kbd{Y}, then a key that
31635 stands for your package, then a third key for the particular command
31636 within your package.
31638 Users may wish to install several Calc enhancements, and it is possible
31639 that several enhancements will choose to use the same key. In the
31640 example below, a variable @code{inc-prec-base-key} has been defined
31641 to contain the key that identifies the @code{inc-prec} package. Its
31642 value is initially @code{"P"}, but a user can change this variable
31643 if necessary without having to modify the file.
31645 Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
31646 command that increases the precision, and a @kbd{Y P D} command that
31647 decreases the precision.
31650 ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91.
31651 ;; (Include copyright or copyleft stuff here.)
31653 (defvar inc-prec-base-key "P"
31654 "Base key for inc-prec.el commands.")
31656 (put 'calc-define 'inc-prec '(progn
31658 (define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
31659 'increase-precision)
31660 (define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
31661 'decrease-precision)
31663 (setq calc-Y-help-msgs
31664 (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
31667 (defmath increase-precision (delta)
31668 "Increase precision by DELTA."
31670 (setq calc-internal-prec (+ calc-internal-prec delta)))
31672 (defmath decrease-precision (delta)
31673 "Decrease precision by DELTA."
31675 (setq calc-internal-prec (- calc-internal-prec delta)))
31677 )) ; end of calc-define property
31679 (run-hooks 'calc-check-defines)
31682 @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
31683 @subsection Defining New Stack-Based Commands
31686 To define a new computational command which takes and/or leaves arguments
31687 on the stack, a special form of @code{interactive} clause is used.
31690 (interactive @var{num} @var{tag})
31694 where @var{num} is an integer, and @var{tag} is a string. The effect is
31695 to pop @var{num} values off the stack, resimplify them by calling
31696 @code{calc-normalize}, and hand them to your function according to the
31697 function's argument list. Your function may include @code{&optional} and
31698 @code{&rest} parameters, so long as calling the function with @var{num}
31699 parameters is valid.
31701 Your function must return either a number or a formula in a form
31702 acceptable to Calc, or a list of such numbers or formulas. These value(s)
31703 are pushed onto the stack when the function completes. They are also
31704 recorded in the Calc Trail buffer on a line beginning with @var{tag},
31705 a string of (normally) four characters or less. If you omit @var{tag}
31706 or use @code{nil} as a tag, the result is not recorded in the trail.
31708 As an example, the definition
31711 (defmath myfact (n)
31712 "Compute the factorial of the integer at the top of the stack."
31713 (interactive 1 "fact")
31715 (* n (myfact (1- n)))
31720 is a version of the factorial function shown previously which can be used
31721 as a command as well as an algebraic function. It expands to
31724 (defun calc-myfact ()
31725 "Compute the factorial of the integer at the top of the stack."
31728 (calc-enter-result 1 "fact"
31729 (cons 'calcFunc-myfact (calc-top-list-n 1)))))
31731 (defun calcFunc-myfact (n)
31732 "Compute the factorial of the integer at the top of the stack."
31734 (math-mul n (calcFunc-myfact (math-add n -1)))
31735 (and (math-zerop n) 1)))
31738 @findex calc-slow-wrapper
31739 The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
31740 that automatically puts up a @samp{Working...} message before the
31741 computation begins. (This message can be turned off by the user
31742 with an @kbd{m w} (@code{calc-working}) command.)
31744 @findex calc-top-list-n
31745 The @code{calc-top-list-n} function returns a list of the specified number
31746 of values from the top of the stack. It resimplifies each value by
31747 calling @code{calc-normalize}. If its argument is zero it returns an
31748 empty list. It does not actually remove these values from the stack.
31750 @findex calc-enter-result
31751 The @code{calc-enter-result} function takes an integer @var{num} and string
31752 @var{tag} as described above, plus a third argument which is either a
31753 Calculator data object or a list of such objects. These objects are
31754 resimplified and pushed onto the stack after popping the specified number
31755 of values from the stack. If @var{tag} is non-@code{nil}, the values
31756 being pushed are also recorded in the trail.
31758 Note that if @code{calcFunc-myfact} returns @code{nil} this represents
31759 ``leave the function in symbolic form.'' To return an actual empty list,
31760 in the sense that @code{calc-enter-result} will push zero elements back
31761 onto the stack, you should return the special value @samp{'(nil)}, a list
31762 containing the single symbol @code{nil}.
31764 The @code{interactive} declaration can actually contain a limited
31765 Emacs-style code string as well which comes just before @var{num} and
31766 @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in
31769 (defmath foo (a b &optional c)
31770 (interactive "p" 2 "foo")
31774 In this example, the command @code{calc-foo} will evaluate the expression
31775 @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
31776 executed with a numeric prefix argument of @expr{n}.
31778 The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
31779 code as used with @code{defun}). It uses the numeric prefix argument as the
31780 number of objects to remove from the stack and pass to the function.
31781 In this case, the integer @var{num} serves as a default number of
31782 arguments to be used when no prefix is supplied.
31784 @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
31785 @subsection Argument Qualifiers
31788 Anywhere a parameter name can appear in the parameter list you can also use
31789 an @dfn{argument qualifier}. Thus the general form of a definition is:
31792 (defmath @var{name} (@var{param} @var{param...}
31793 &optional @var{param} @var{param...}
31799 where each @var{param} is either a symbol or a list of the form
31802 (@var{qual} @var{param})
31805 The following qualifiers are recognized:
31810 The argument must not be an incomplete vector, interval, or complex number.
31811 (This is rarely needed since the Calculator itself will never call your
31812 function with an incomplete argument. But there is nothing stopping your
31813 own Lisp code from calling your function with an incomplete argument.)
31817 The argument must be an integer. If it is an integer-valued float
31818 it will be accepted but converted to integer form. Non-integers and
31819 formulas are rejected.
31823 Like @samp{integer}, but the argument must be non-negative.
31827 Like @samp{integer}, but the argument must fit into a native Lisp integer,
31828 which on most systems means less than 2^23 in absolute value. The
31829 argument is converted into Lisp-integer form if necessary.
31833 The argument is converted to floating-point format if it is a number or
31834 vector. If it is a formula it is left alone. (The argument is never
31835 actually rejected by this qualifier.)
31838 The argument must satisfy predicate @var{pred}, which is one of the
31839 standard Calculator predicates. @xref{Predicates}.
31841 @item not-@var{pred}
31842 The argument must @emph{not} satisfy predicate @var{pred}.
31848 (defmath foo (a (constp (not-matrixp b)) &optional (float c)
31857 (defun calcFunc-foo (a b &optional c &rest d)
31858 (and (math-matrixp b)
31859 (math-reject-arg b 'not-matrixp))
31860 (or (math-constp b)
31861 (math-reject-arg b 'constp))
31862 (and c (setq c (math-check-float c)))
31863 (setq d (mapcar 'math-check-integer d))
31868 which performs the necessary checks and conversions before executing the
31869 body of the function.
31871 @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
31872 @subsection Example Definitions
31875 This section includes some Lisp programming examples on a larger scale.
31876 These programs make use of some of the Calculator's internal functions;
31880 * Bit Counting Example::
31884 @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
31885 @subsubsection Bit-Counting
31892 Calc does not include a built-in function for counting the number of
31893 ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u}
31894 to convert the integer to a set, and @kbd{V #} to count the elements of
31895 that set; let's write a function that counts the bits without having to
31896 create an intermediate set.
31899 (defmath bcount ((natnum n))
31900 (interactive 1 "bcnt")
31904 (setq count (1+ count)))
31905 (setq n (lsh n -1)))
31910 When this is expanded by @code{defmath}, it will become the following
31911 Emacs Lisp function:
31914 (defun calcFunc-bcount (n)
31915 (setq n (math-check-natnum n))
31917 (while (math-posp n)
31919 (setq count (math-add count 1)))
31920 (setq n (calcFunc-lsh n -1)))
31924 If the input numbers are large, this function involves a fair amount
31925 of arithmetic. A binary right shift is essentially a division by two;
31926 recall that Calc stores integers in decimal form so bit shifts must
31927 involve actual division.
31929 To gain a bit more efficiency, we could divide the integer into
31930 @var{n}-bit chunks, each of which can be handled quickly because
31931 they fit into Lisp integers. It turns out that Calc's arithmetic
31932 routines are especially fast when dividing by an integer less than
31933 1000, so we can set @var{n = 9} bits and use repeated division by 512:
31936 (defmath bcount ((natnum n))
31937 (interactive 1 "bcnt")
31939 (while (not (fixnump n))
31940 (let ((qr (idivmod n 512)))
31941 (setq count (+ count (bcount-fixnum (cdr qr)))
31943 (+ count (bcount-fixnum n))))
31945 (defun bcount-fixnum (n)
31948 (setq count (+ count (logand n 1))
31954 Note that the second function uses @code{defun}, not @code{defmath}.
31955 Because this function deals only with native Lisp integers (``fixnums''),
31956 it can use the actual Emacs @code{+} and related functions rather
31957 than the slower but more general Calc equivalents which @code{defmath}
31960 The @code{idivmod} function does an integer division, returning both
31961 the quotient and the remainder at once. Again, note that while it
31962 might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
31963 more efficient ways to split off the bottom nine bits of @code{n},
31964 actually they are less efficient because each operation is really
31965 a division by 512 in disguise; @code{idivmod} allows us to do the
31966 same thing with a single division by 512.
31968 @node Sine Example, , Bit Counting Example, Example Definitions
31969 @subsubsection The Sine Function
31976 A somewhat limited sine function could be defined as follows, using the
31977 well-known Taylor series expansion for
31978 @texline @math{\sin x}:
31979 @infoline @samp{sin(x)}:
31982 (defmath mysin ((float (anglep x)))
31983 (interactive 1 "mysn")
31984 (setq x (to-radians x)) ; Convert from current angular mode.
31985 (let ((sum x) ; Initial term of Taylor expansion of sin.
31987 (nfact 1) ; "nfact" equals "n" factorial at all times.
31988 (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
31989 (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution.
31990 (working "mysin" sum) ; Display "Working" message, if enabled.
31991 (setq nfact (* nfact (1- n) n)
31993 newsum (+ sum (/ x nfact)))
31994 (if (~= newsum sum) ; If newsum is "nearly equal to" sum,
31995 (break)) ; then we are done.
32000 The actual @code{sin} function in Calc works by first reducing the problem
32001 to a sine or cosine of a nonnegative number less than @cpiover{4}. This
32002 ensures that the Taylor series will converge quickly. Also, the calculation
32003 is carried out with two extra digits of precision to guard against cumulative
32004 round-off in @samp{sum}. Finally, complex arguments are allowed and handled
32005 by a separate algorithm.
32008 (defmath mysin ((float (scalarp x)))
32009 (interactive 1 "mysn")
32010 (setq x (to-radians x)) ; Convert from current angular mode.
32011 (with-extra-prec 2 ; Evaluate with extra precision.
32012 (cond ((complexp x)
32015 (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0.
32016 (t (mysin-raw x))))))
32018 (defmath mysin-raw (x)
32020 (mysin-raw (% x (two-pi)))) ; Now x < 7.
32022 (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2.
32024 (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4.
32025 ((< x (- (pi-over-4)))
32026 (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4,
32027 (t (mysin-series x)))) ; so the series will be efficient.
32031 where @code{mysin-complex} is an appropriate function to handle complex
32032 numbers, @code{mysin-series} is the routine to compute the sine Taylor
32033 series as before, and @code{mycos-raw} is a function analogous to
32034 @code{mysin-raw} for cosines.
32036 The strategy is to ensure that @expr{x} is nonnegative before calling
32037 @code{mysin-raw}. This function then recursively reduces its argument
32038 to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each
32039 test, and particularly the first comparison against 7, is designed so
32040 that small roundoff errors cannot produce an infinite loop. (Suppose
32041 we compared with @samp{(two-pi)} instead; if due to roundoff problems
32042 the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
32043 recursion could result!) We use modulo only for arguments that will
32044 clearly get reduced, knowing that the next rule will catch any reductions
32045 that this rule misses.
32047 If a program is being written for general use, it is important to code
32048 it carefully as shown in this second example. For quick-and-dirty programs,
32049 when you know that your own use of the sine function will never encounter
32050 a large argument, a simpler program like the first one shown is fine.
32052 @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
32053 @subsection Calling Calc from Your Lisp Programs
32056 A later section (@pxref{Internals}) gives a full description of
32057 Calc's internal Lisp functions. It's not hard to call Calc from
32058 inside your programs, but the number of these functions can be daunting.
32059 So Calc provides one special ``programmer-friendly'' function called
32060 @code{calc-eval} that can be made to do just about everything you
32061 need. It's not as fast as the low-level Calc functions, but it's
32062 much simpler to use!
32064 It may seem that @code{calc-eval} itself has a daunting number of
32065 options, but they all stem from one simple operation.
32067 In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
32068 string @code{"1+2"} as if it were a Calc algebraic entry and returns
32069 the result formatted as a string: @code{"3"}.
32071 Since @code{calc-eval} is on the list of recommended @code{autoload}
32072 functions, you don't need to make any special preparations to load
32073 Calc before calling @code{calc-eval} the first time. Calc will be
32074 loaded and initialized for you.
32076 All the Calc modes that are currently in effect will be used when
32077 evaluating the expression and formatting the result.
32084 @subsubsection Additional Arguments to @code{calc-eval}
32087 If the input string parses to a list of expressions, Calc returns
32088 the results separated by @code{", "}. You can specify a different
32089 separator by giving a second string argument to @code{calc-eval}:
32090 @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
32092 The ``separator'' can also be any of several Lisp symbols which
32093 request other behaviors from @code{calc-eval}. These are discussed
32096 You can give additional arguments to be substituted for
32097 @samp{$}, @samp{$$}, and so on in the main expression. For
32098 example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
32099 expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
32100 (assuming Fraction mode is not in effect). Note the @code{nil}
32101 used as a placeholder for the item-separator argument.
32108 @subsubsection Error Handling
32111 If @code{calc-eval} encounters an error, it returns a list containing
32112 the character position of the error, plus a suitable message as a
32113 string. Note that @samp{1 / 0} is @emph{not} an error by Calc's
32114 standards; it simply returns the string @code{"1 / 0"} which is the
32115 division left in symbolic form. But @samp{(calc-eval "1/")} will
32116 return the list @samp{(2 "Expected a number")}.
32118 If you bind the variable @code{calc-eval-error} to @code{t}
32119 using a @code{let} form surrounding the call to @code{calc-eval},
32120 errors instead call the Emacs @code{error} function which aborts
32121 to the Emacs command loop with a beep and an error message.
32123 If you bind this variable to the symbol @code{string}, error messages
32124 are returned as strings instead of lists. The character position is
32127 As a courtesy to other Lisp code which may be using Calc, be sure
32128 to bind @code{calc-eval-error} using @code{let} rather than changing
32129 it permanently with @code{setq}.
32136 @subsubsection Numbers Only
32139 Sometimes it is preferable to treat @samp{1 / 0} as an error
32140 rather than returning a symbolic result. If you pass the symbol
32141 @code{num} as the second argument to @code{calc-eval}, results
32142 that are not constants are treated as errors. The error message
32143 reported is the first @code{calc-why} message if there is one,
32144 or otherwise ``Number expected.''
32146 A result is ``constant'' if it is a number, vector, or other
32147 object that does not include variables or function calls. If it
32148 is a vector, the components must themselves be constants.
32155 @subsubsection Default Modes
32158 If the first argument to @code{calc-eval} is a list whose first
32159 element is a formula string, then @code{calc-eval} sets all the
32160 various Calc modes to their default values while the formula is
32161 evaluated and formatted. For example, the precision is set to 12
32162 digits, digit grouping is turned off, and the Normal language
32165 This same principle applies to the other options discussed below.
32166 If the first argument would normally be @var{x}, then it can also
32167 be the list @samp{(@var{x})} to use the default mode settings.
32169 If there are other elements in the list, they are taken as
32170 variable-name/value pairs which override the default mode
32171 settings. Look at the documentation at the front of the
32172 @file{calc.el} file to find the names of the Lisp variables for
32173 the various modes. The mode settings are restored to their
32174 original values when @code{calc-eval} is done.
32176 For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
32177 computes the sum of two numbers, requiring a numeric result, and
32178 using default mode settings except that the precision is 8 instead
32179 of the default of 12.
32181 It's usually best to use this form of @code{calc-eval} unless your
32182 program actually considers the interaction with Calc's mode settings
32183 to be a feature. This will avoid all sorts of potential ``gotchas'';
32184 consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
32185 when the user has left Calc in Symbolic mode or No-Simplify mode.
32187 As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
32188 checks if the number in string @expr{a} is less than the one in
32189 string @expr{b}. Without using a list, the integer 1 might
32190 come out in a variety of formats which would be hard to test for
32191 conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But
32192 see ``Predicates'' mode, below.)
32199 @subsubsection Raw Numbers
32202 Normally all input and output for @code{calc-eval} is done with strings.
32203 You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
32204 in place of @samp{(+ a b)}, but this is very inefficient since the
32205 numbers must be converted to and from string format as they are passed
32206 from one @code{calc-eval} to the next.
32208 If the separator is the symbol @code{raw}, the result will be returned
32209 as a raw Calc data structure rather than a string. You can read about
32210 how these objects look in the following sections, but usually you can
32211 treat them as ``black box'' objects with no important internal
32214 There is also a @code{rawnum} symbol, which is a combination of
32215 @code{raw} (returning a raw Calc object) and @code{num} (signaling
32216 an error if that object is not a constant).
32218 You can pass a raw Calc object to @code{calc-eval} in place of a
32219 string, either as the formula itself or as one of the @samp{$}
32220 arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
32221 addition function that operates on raw Calc objects. Of course
32222 in this case it would be easier to call the low-level @code{math-add}
32223 function in Calc, if you can remember its name.
32225 In particular, note that a plain Lisp integer is acceptable to Calc
32226 as a raw object. (All Lisp integers are accepted on input, but
32227 integers of more than six decimal digits are converted to ``big-integer''
32228 form for output. @xref{Data Type Formats}.)
32230 When it comes time to display the object, just use @samp{(calc-eval a)}
32231 to format it as a string.
32233 It is an error if the input expression evaluates to a list of
32234 values. The separator symbol @code{list} is like @code{raw}
32235 except that it returns a list of one or more raw Calc objects.
32237 Note that a Lisp string is not a valid Calc object, nor is a list
32238 containing a string. Thus you can still safely distinguish all the
32239 various kinds of error returns discussed above.
32246 @subsubsection Predicates
32249 If the separator symbol is @code{pred}, the result of the formula is
32250 treated as a true/false value; @code{calc-eval} returns @code{t} or
32251 @code{nil}, respectively. A value is considered ``true'' if it is a
32252 non-zero number, or false if it is zero or if it is not a number.
32254 For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
32255 one value is less than another.
32257 As usual, it is also possible for @code{calc-eval} to return one of
32258 the error indicators described above. Lisp will interpret such an
32259 indicator as ``true'' if you don't check for it explicitly. If you
32260 wish to have an error register as ``false'', use something like
32261 @samp{(eq (calc-eval ...) t)}.
32268 @subsubsection Variable Values
32271 Variables in the formula passed to @code{calc-eval} are not normally
32272 replaced by their values. If you wish this, you can use the
32273 @code{evalv} function (@pxref{Algebraic Manipulation}). For example,
32274 if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
32275 @code{var-a}), then @samp{(calc-eval "a+pi")} will return the
32276 formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
32277 will return @code{"7.14159265359"}.
32279 To store in a Calc variable, just use @code{setq} to store in the
32280 corresponding Lisp variable. (This is obtained by prepending
32281 @samp{var-} to the Calc variable name.) Calc routines will
32282 understand either string or raw form values stored in variables,
32283 although raw data objects are much more efficient. For example,
32284 to increment the Calc variable @code{a}:
32287 (setq var-a (calc-eval "evalv(a+1)" 'raw))
32295 @subsubsection Stack Access
32298 If the separator symbol is @code{push}, the formula argument is
32299 evaluated (with possible @samp{$} expansions, as usual). The
32300 result is pushed onto the Calc stack. The return value is @code{nil}
32301 (unless there is an error from evaluating the formula, in which
32302 case the return value depends on @code{calc-eval-error} in the
32305 If the separator symbol is @code{pop}, the first argument to
32306 @code{calc-eval} must be an integer instead of a string. That
32307 many values are popped from the stack and thrown away. A negative
32308 argument deletes the entry at that stack level. The return value
32309 is the number of elements remaining in the stack after popping;
32310 @samp{(calc-eval 0 'pop)} is a good way to measure the size of
32313 If the separator symbol is @code{top}, the first argument to
32314 @code{calc-eval} must again be an integer. The value at that
32315 stack level is formatted as a string and returned. Thus
32316 @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the
32317 integer is out of range, @code{nil} is returned.
32319 The separator symbol @code{rawtop} is just like @code{top} except
32320 that the stack entry is returned as a raw Calc object instead of
32323 In all of these cases the first argument can be made a list in
32324 order to force the default mode settings, as described above.
32325 Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
32326 second-to-top stack entry, formatted as a string using the default
32327 instead of current display modes, except that the radix is
32328 hexadecimal instead of decimal.
32330 It is, of course, polite to put the Calc stack back the way you
32331 found it when you are done, unless the user of your program is
32332 actually expecting it to affect the stack.
32334 Note that you do not actually have to switch into the @samp{*Calculator*}
32335 buffer in order to use @code{calc-eval}; it temporarily switches into
32336 the stack buffer if necessary.
32343 @subsubsection Keyboard Macros
32346 If the separator symbol is @code{macro}, the first argument must be a
32347 string of characters which Calc can execute as a sequence of keystrokes.
32348 This switches into the Calc buffer for the duration of the macro.
32349 For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
32350 vector @samp{[1,2,3,4,5]} on the stack and then replaces it
32351 with the sum of those numbers. Note that @samp{\r} is the Lisp
32352 notation for the carriage-return, @key{RET}, character.
32354 If your keyboard macro wishes to pop the stack, @samp{\C-d} is
32355 safer than @samp{\177} (the @key{DEL} character) because some
32356 installations may have switched the meanings of @key{DEL} and
32357 @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for
32358 ``pop-stack'' regardless of key mapping.
32360 If you provide a third argument to @code{calc-eval}, evaluation
32361 of the keyboard macro will leave a record in the Trail using
32362 that argument as a tag string. Normally the Trail is unaffected.
32364 The return value in this case is always @code{nil}.
32371 @subsubsection Lisp Evaluation
32374 Finally, if the separator symbol is @code{eval}, then the Lisp
32375 @code{eval} function is called on the first argument, which must
32376 be a Lisp expression rather than a Calc formula. Remember to
32377 quote the expression so that it is not evaluated until inside
32380 The difference from plain @code{eval} is that @code{calc-eval}
32381 switches to the Calc buffer before evaluating the expression.
32382 For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
32383 will correctly affect the buffer-local Calc precision variable.
32385 An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
32386 This is evaluating a call to the function that is normally invoked
32387 by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
32388 Note that this function will leave a message in the echo area as
32389 a side effect. Also, all Calc functions switch to the Calc buffer
32390 automatically if not invoked from there, so the above call is
32391 also equivalent to @samp{(calc-precision 17)} by itself.
32392 In all cases, Calc uses @code{save-excursion} to switch back to
32393 your original buffer when it is done.
32395 As usual the first argument can be a list that begins with a Lisp
32396 expression to use default instead of current mode settings.
32398 The result of @code{calc-eval} in this usage is just the result
32399 returned by the evaluated Lisp expression.
32406 @subsubsection Example
32409 @findex convert-temp
32410 Here is a sample Emacs command that uses @code{calc-eval}. Suppose
32411 you have a document with lots of references to temperatures on the
32412 Fahrenheit scale, say ``98.6 F'', and you wish to convert these
32413 references to Centigrade. The following command does this conversion.
32414 Place the Emacs cursor right after the letter ``F'' and invoke the
32415 command to change ``98.6 F'' to ``37 C''. Or, if the temperature is
32416 already in Centigrade form, the command changes it back to Fahrenheit.
32419 (defun convert-temp ()
32422 (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
32423 (let* ((top1 (match-beginning 1))
32424 (bot1 (match-end 1))
32425 (number (buffer-substring top1 bot1))
32426 (top2 (match-beginning 2))
32427 (bot2 (match-end 2))
32428 (type (buffer-substring top2 bot2)))
32429 (if (equal type "F")
32431 number (calc-eval "($ - 32)*5/9" nil number))
32433 number (calc-eval "$*9/5 + 32" nil number)))
32435 (delete-region top2 bot2)
32436 (insert-before-markers type)
32438 (delete-region top1 bot1)
32439 (if (string-match "\\.$" number) ; change "37." to "37"
32440 (setq number (substring number 0 -1)))
32444 Note the use of @code{insert-before-markers} when changing between
32445 ``F'' and ``C'', so that the character winds up before the cursor
32446 instead of after it.
32448 @node Internals, , Calling Calc from Your Programs, Lisp Definitions
32449 @subsection Calculator Internals
32452 This section describes the Lisp functions defined by the Calculator that
32453 may be of use to user-written Calculator programs (as described in the
32454 rest of this chapter). These functions are shown by their names as they
32455 conventionally appear in @code{defmath}. Their full Lisp names are
32456 generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
32457 apparent names. (Names that begin with @samp{calc-} are already in
32458 their full Lisp form.) You can use the actual full names instead if you
32459 prefer them, or if you are calling these functions from regular Lisp.
32461 The functions described here are scattered throughout the various
32462 Calc component files. Note that @file{calc.el} includes @code{autoload}s
32463 for only a few component files; when Calc wants to call an advanced
32464 function it calls @samp{(calc-extensions)} first; this function
32465 autoloads @file{calc-ext.el}, which in turn autoloads all the functions
32466 in the remaining component files.
32468 Because @code{defmath} itself uses the extensions, user-written code
32469 generally always executes with the extensions already loaded, so
32470 normally you can use any Calc function and be confident that it will
32471 be autoloaded for you when necessary. If you are doing something
32472 special, check carefully to make sure each function you are using is
32473 from @file{calc.el} or its components, and call @samp{(calc-extensions)}
32474 before using any function based in @file{calc-ext.el} if you can't
32475 prove this file will already be loaded.
32478 * Data Type Formats::
32479 * Interactive Lisp Functions::
32480 * Stack Lisp Functions::
32482 * Computational Lisp Functions::
32483 * Vector Lisp Functions::
32484 * Symbolic Lisp Functions::
32485 * Formatting Lisp Functions::
32489 @node Data Type Formats, Interactive Lisp Functions, Internals, Internals
32490 @subsubsection Data Type Formats
32493 Integers are stored in either of two ways, depending on their magnitude.
32494 Integers less than one million in absolute value are stored as standard
32495 Lisp integers. This is the only storage format for Calc data objects
32496 which is not a Lisp list.
32498 Large integers are stored as lists of the form @samp{(bigpos @var{d0}
32499 @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or
32500 @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers
32501 @mathit{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer
32502 from 0 to 999. The least significant digit is @var{d0}; the last digit,
32503 @var{dn}, which is always nonzero, is the most significant digit. For
32504 example, the integer @mathit{-12345678} is stored as @samp{(bigneg 678 345 12)}.
32506 The distinction between small and large integers is entirely hidden from
32507 the user. In @code{defmath} definitions, the Lisp predicate @code{integerp}
32508 returns true for either kind of integer, and in general both big and small
32509 integers are accepted anywhere the word ``integer'' is used in this manual.
32510 If the distinction must be made, native Lisp integers are called @dfn{fixnums}
32511 and large integers are called @dfn{bignums}.
32513 Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
32514 where @var{n} is an integer (big or small) numerator, @var{d} is an
32515 integer denominator greater than one, and @var{n} and @var{d} are relatively
32516 prime. Note that fractions where @var{d} is one are automatically converted
32517 to plain integers by all math routines; fractions where @var{d} is negative
32518 are normalized by negating the numerator and denominator.
32520 Floating-point numbers are stored in the form, @samp{(float @var{mant}
32521 @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
32522 @samp{10^@var{p}} in absolute value (@var{p} represents the current
32523 precision), and @var{exp} (the ``exponent'') is a fixnum. The value of
32524 the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number
32525 @mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints
32526 are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
32527 except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
32528 always nonzero. (If the rightmost digit is zero, the number is
32529 rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)
32531 Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
32532 @var{im})}, where @var{re} and @var{im} are each real numbers, either
32533 integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}.
32534 The @var{im} part is nonzero; complex numbers with zero imaginary
32535 components are converted to real numbers automatically.
32537 Polar complex numbers are stored in the form @samp{(polar @var{r}
32538 @var{theta})}, where @var{r} is a positive real value and @var{theta}
32539 is a real value or HMS form representing an angle. This angle is
32540 usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
32541 or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
32542 If the angle is 0 the value is converted to a real number automatically.
32543 (If the angle is 180 degrees, the value is usually also converted to a
32544 negative real number.)
32546 Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
32547 @var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
32548 a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
32549 float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
32550 in the range @samp{[0 ..@: 60)}.
32552 Date forms are stored as @samp{(date @var{n})}, where @var{n} is
32553 a real number that counts days since midnight on the morning of
32554 January 1, 1 AD. If @var{n} is an integer, this is a pure date
32555 form. If @var{n} is a fraction or float, this is a date/time form.
32557 Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
32558 positive real number or HMS form, and @var{n} is a real number or HMS
32559 form in the range @samp{[0 ..@: @var{m})}.
32561 Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
32562 is the mean value and @var{sigma} is the standard deviation. Each
32563 component is either a number, an HMS form, or a symbolic object
32564 (a variable or function call). If @var{sigma} is zero, the value is
32565 converted to a plain real number. If @var{sigma} is negative or
32566 complex, it is automatically normalized to be a positive real.
32568 Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
32569 where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
32570 @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask}
32571 is a binary integer where 1 represents the fact that the interval is
32572 closed on the high end, and 2 represents the fact that it is closed on
32573 the low end. (Thus 3 represents a fully closed interval.) The interval
32574 @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
32575 intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
32576 represent empty intervals. If @var{hi} is less than @var{lo}, the interval
32577 is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
32579 Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
32580 is the first element of the vector, @var{v2} is the second, and so on.
32581 An empty vector is stored as @samp{(vec)}. A matrix is simply a vector
32582 where all @var{v}'s are themselves vectors of equal lengths. Note that
32583 Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
32584 generally unused by Calc data structures.
32586 Variables are stored as @samp{(var @var{name} @var{sym})}, where
32587 @var{name} is a Lisp symbol whose print name is used as the visible name
32588 of the variable, and @var{sym} is a Lisp symbol in which the variable's
32589 value is actually stored. Thus, @samp{(var pi var-pi)} represents the
32590 special constant @samp{pi}. Almost always, the form is @samp{(var
32591 @var{v} var-@var{v})}. If the variable name was entered with @code{#}
32592 signs (which are converted to hyphens internally), the form is
32593 @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
32594 contains @code{#} characters, and @var{v} is a symbol that contains
32595 @code{-} characters instead. The value of a variable is the Calc
32596 object stored in its @var{sym} symbol's value cell. If the symbol's
32597 value cell is void or if it contains @code{nil}, the variable has no
32598 value. Special constants have the form @samp{(special-const
32599 @var{value})} stored in their value cell, where @var{value} is a formula
32600 which is evaluated when the constant's value is requested. Variables
32601 which represent units are not stored in any special way; they are units
32602 only because their names appear in the units table. If the value
32603 cell contains a string, it is parsed to get the variable's value when
32604 the variable is used.
32606 A Lisp list with any other symbol as the first element is a function call.
32607 The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
32608 and @code{|} represent special binary operators; these lists are always
32609 of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
32610 sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
32611 right. The symbol @code{neg} represents unary negation; this list is always
32612 of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a
32613 function that would be displayed in function-call notation; the symbol
32614 @var{func} is in general always of the form @samp{calcFunc-@var{name}}.
32615 The function cell of the symbol @var{func} should contain a Lisp function
32616 for evaluating a call to @var{func}. This function is passed the remaining
32617 elements of the list (themselves already evaluated) as arguments; such
32618 functions should return @code{nil} or call @code{reject-arg} to signify
32619 that they should be left in symbolic form, or they should return a Calc
32620 object which represents their value, or a list of such objects if they
32621 wish to return multiple values. (The latter case is allowed only for
32622 functions which are the outer-level call in an expression whose value is
32623 about to be pushed on the stack; this feature is considered obsolete
32624 and is not used by any built-in Calc functions.)
32626 @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
32627 @subsubsection Interactive Functions
32630 The functions described here are used in implementing interactive Calc
32631 commands. Note that this list is not exhaustive! If there is an
32632 existing command that behaves similarly to the one you want to define,
32633 you may find helpful tricks by checking the source code for that command.
32635 @defun calc-set-command-flag flag
32636 Set the command flag @var{flag}. This is generally a Lisp symbol, but
32637 may in fact be anything. The effect is to add @var{flag} to the list
32638 stored in the variable @code{calc-command-flags}, unless it is already
32639 there. @xref{Defining Simple Commands}.
32642 @defun calc-clear-command-flag flag
32643 If @var{flag} appears among the list of currently-set command flags,
32644 remove it from that list.
32647 @defun calc-record-undo rec
32648 Add the ``undo record'' @var{rec} to the list of steps to take if the
32649 current operation should need to be undone. Stack push and pop functions
32650 automatically call @code{calc-record-undo}, so the kinds of undo records
32651 you might need to create take the form @samp{(set @var{sym} @var{value})},
32652 which says that the Lisp variable @var{sym} was changed and had previously
32653 contained @var{value}; @samp{(store @var{var} @var{value})} which says that
32654 the Calc variable @var{var} (a string which is the name of the symbol that
32655 contains the variable's value) was stored and its previous value was
32656 @var{value} (either a Calc data object, or @code{nil} if the variable was
32657 previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
32658 which means that to undo requires calling the function @samp{(@var{undo}
32659 @var{args} @dots{})} and, if the undo is later redone, calling
32660 @samp{(@var{redo} @var{args} @dots{})}.
32663 @defun calc-record-why msg args
32664 Record the error or warning message @var{msg}, which is normally a string.
32665 This message will be replayed if the user types @kbd{w} (@code{calc-why});
32666 if the message string begins with a @samp{*}, it is considered important
32667 enough to display even if the user doesn't type @kbd{w}. If one or more
32668 @var{args} are present, the displayed message will be of the form,
32669 @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
32670 formatted on the assumption that they are either strings or Calc objects of
32671 some sort. If @var{msg} is a symbol, it is the name of a Calc predicate
32672 (such as @code{integerp} or @code{numvecp}) which the arguments did not
32673 satisfy; it is expanded to a suitable string such as ``Expected an
32674 integer.'' The @code{reject-arg} function calls @code{calc-record-why}
32675 automatically; @pxref{Predicates}.
32678 @defun calc-is-inverse
32679 This predicate returns true if the current command is inverse,
32680 i.e., if the Inverse (@kbd{I} key) flag was set.
32683 @defun calc-is-hyperbolic
32684 This predicate is the analogous function for the @kbd{H} key.
32687 @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
32688 @subsubsection Stack-Oriented Functions
32691 The functions described here perform various operations on the Calc
32692 stack and trail. They are to be used in interactive Calc commands.
32694 @defun calc-push-list vals n
32695 Push the Calc objects in list @var{vals} onto the stack at stack level
32696 @var{n}. If @var{n} is omitted it defaults to 1, so that the elements
32697 are pushed at the top of the stack. If @var{n} is greater than 1, the
32698 elements will be inserted into the stack so that the last element will
32699 end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
32700 The elements of @var{vals} are assumed to be valid Calc objects, and
32701 are not evaluated, rounded, or renormalized in any way. If @var{vals}
32702 is an empty list, nothing happens.
32704 The stack elements are pushed without any sub-formula selections.
32705 You can give an optional third argument to this function, which must
32706 be a list the same size as @var{vals} of selections. Each selection
32707 must be @code{eq} to some sub-formula of the corresponding formula
32708 in @var{vals}, or @code{nil} if that formula should have no selection.
32711 @defun calc-top-list n m
32712 Return a list of the @var{n} objects starting at level @var{m} of the
32713 stack. If @var{m} is omitted it defaults to 1, so that the elements are
32714 taken from the top of the stack. If @var{n} is omitted, it also
32715 defaults to 1, so that the top stack element (in the form of a
32716 one-element list) is returned. If @var{m} is greater than 1, the
32717 @var{m}th stack element will be at the end of the list, the @var{m}+1st
32718 element will be next-to-last, etc. If @var{n} or @var{m} are out of
32719 range, the command is aborted with a suitable error message. If @var{n}
32720 is zero, the function returns an empty list. The stack elements are not
32721 evaluated, rounded, or renormalized.
32723 If any stack elements contain selections, and selections have not
32724 been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
32725 this function returns the selected portions rather than the entire
32726 stack elements. It can be given a third ``selection-mode'' argument
32727 which selects other behaviors. If it is the symbol @code{t}, then
32728 a selection in any of the requested stack elements produces an
32729 ``invalid operation on selections'' error. If it is the symbol @code{full},
32730 the whole stack entry is always returned regardless of selections.
32731 If it is the symbol @code{sel}, the selected portion is always returned,
32732 or @code{nil} if there is no selection. (This mode ignores the @kbd{j e}
32733 command.) If the symbol is @code{entry}, the complete stack entry in
32734 list form is returned; the first element of this list will be the whole
32735 formula, and the third element will be the selection (or @code{nil}).
32738 @defun calc-pop-stack n m
32739 Remove the specified elements from the stack. The parameters @var{n}
32740 and @var{m} are defined the same as for @code{calc-top-list}. The return
32741 value of @code{calc-pop-stack} is uninteresting.
32743 If there are any selected sub-formulas among the popped elements, and
32744 @kbd{j e} has not been used to disable selections, this produces an
32745 error without changing the stack. If you supply an optional third
32746 argument of @code{t}, the stack elements are popped even if they
32747 contain selections.
32750 @defun calc-record-list vals tag
32751 This function records one or more results in the trail. The @var{vals}
32752 are a list of strings or Calc objects. The @var{tag} is the four-character
32753 tag string to identify the values. If @var{tag} is omitted, a blank tag
32757 @defun calc-normalize n
32758 This function takes a Calc object and ``normalizes'' it. At the very
32759 least this involves re-rounding floating-point values according to the
32760 current precision and other similar jobs. Also, unless the user has
32761 selected No-Simplify mode (@pxref{Simplification Modes}), this involves
32762 actually evaluating a formula object by executing the function calls
32763 it contains, and possibly also doing algebraic simplification, etc.
32766 @defun calc-top-list-n n m
32767 This function is identical to @code{calc-top-list}, except that it calls
32768 @code{calc-normalize} on the values that it takes from the stack. They
32769 are also passed through @code{check-complete}, so that incomplete
32770 objects will be rejected with an error message. All computational
32771 commands should use this in preference to @code{calc-top-list}; the only
32772 standard Calc commands that operate on the stack without normalizing
32773 are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
32774 This function accepts the same optional selection-mode argument as
32775 @code{calc-top-list}.
32778 @defun calc-top-n m
32779 This function is a convenient form of @code{calc-top-list-n} in which only
32780 a single element of the stack is taken and returned, rather than a list
32781 of elements. This also accepts an optional selection-mode argument.
32784 @defun calc-enter-result n tag vals
32785 This function is a convenient interface to most of the above functions.
32786 The @var{vals} argument should be either a single Calc object, or a list
32787 of Calc objects; the object or objects are normalized, and the top @var{n}
32788 stack entries are replaced by the normalized objects. If @var{tag} is
32789 non-@code{nil}, the normalized objects are also recorded in the trail.
32790 A typical stack-based computational command would take the form,
32793 (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
32794 (calc-top-list-n @var{n})))
32797 If any of the @var{n} stack elements replaced contain sub-formula
32798 selections, and selections have not been disabled by @kbd{j e},
32799 this function takes one of two courses of action. If @var{n} is
32800 equal to the number of elements in @var{vals}, then each element of
32801 @var{vals} is spliced into the corresponding selection; this is what
32802 happens when you use the @key{TAB} key, or when you use a unary
32803 arithmetic operation like @code{sqrt}. If @var{vals} has only one
32804 element but @var{n} is greater than one, there must be only one
32805 selection among the top @var{n} stack elements; the element from
32806 @var{vals} is spliced into that selection. This is what happens when
32807 you use a binary arithmetic operation like @kbd{+}. Any other
32808 combination of @var{n} and @var{vals} is an error when selections
32812 @defun calc-unary-op tag func arg
32813 This function implements a unary operator that allows a numeric prefix
32814 argument to apply the operator over many stack entries. If the prefix
32815 argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
32816 as outlined above. Otherwise, it maps the function over several stack
32817 elements; @pxref{Prefix Arguments}. For example,
32820 (defun calc-zeta (arg)
32822 (calc-unary-op "zeta" 'calcFunc-zeta arg))
32826 @defun calc-binary-op tag func arg ident unary
32827 This function implements a binary operator, analogously to
32828 @code{calc-unary-op}. The optional @var{ident} and @var{unary}
32829 arguments specify the behavior when the prefix argument is zero or
32830 one, respectively. If the prefix is zero, the value @var{ident}
32831 is pushed onto the stack, if specified, otherwise an error message
32832 is displayed. If the prefix is one, the unary function @var{unary}
32833 is applied to the top stack element, or, if @var{unary} is not
32834 specified, nothing happens. When the argument is two or more,
32835 the binary function @var{func} is reduced across the top @var{arg}
32836 stack elements; when the argument is negative, the function is
32837 mapped between the next-to-top @mathit{-@var{arg}} stack elements and the
32841 @defun calc-stack-size
32842 Return the number of elements on the stack as an integer. This count
32843 does not include elements that have been temporarily hidden by stack
32844 truncation; @pxref{Truncating the Stack}.
32847 @defun calc-cursor-stack-index n
32848 Move the point to the @var{n}th stack entry. If @var{n} is zero, this
32849 will be the @samp{.} line. If @var{n} is from 1 to the current stack size,
32850 this will be the beginning of the first line of that stack entry's display.
32851 If line numbers are enabled, this will move to the first character of the
32852 line number, not the stack entry itself.
32855 @defun calc-substack-height n
32856 Return the number of lines between the beginning of the @var{n}th stack
32857 entry and the bottom of the buffer. If @var{n} is zero, this
32858 will be one (assuming no stack truncation). If all stack entries are
32859 one line long (i.e., no matrices are displayed), the return value will
32860 be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big
32861 mode, the return value includes the blank lines that separate stack
32865 @defun calc-refresh
32866 Erase the @code{*Calculator*} buffer and reformat its contents from memory.
32867 This must be called after changing any parameter, such as the current
32868 display radix, which might change the appearance of existing stack
32869 entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing
32870 is suppressed, but a flag is set so that the entire stack will be refreshed
32871 rather than just the top few elements when the macro finishes.)
32874 @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
32875 @subsubsection Predicates
32878 The functions described here are predicates, that is, they return a
32879 true/false value where @code{nil} means false and anything else means
32880 true. These predicates are expanded by @code{defmath}, for example,
32881 from @code{zerop} to @code{math-zerop}. In many cases they correspond
32882 to native Lisp functions by the same name, but are extended to cover
32883 the full range of Calc data types.
32886 Returns true if @var{x} is numerically zero, in any of the Calc data
32887 types. (Note that for some types, such as error forms and intervals,
32888 it never makes sense to return true.) In @code{defmath}, the expression
32889 @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
32890 and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
32894 Returns true if @var{x} is negative. This accepts negative real numbers
32895 of various types, negative HMS and date forms, and intervals in which
32896 all included values are negative. In @code{defmath}, the expression
32897 @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
32898 and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
32902 Returns true if @var{x} is positive (and non-zero). For complex
32903 numbers, none of these three predicates will return true.
32906 @defun looks-negp x
32907 Returns true if @var{x} is ``negative-looking.'' This returns true if
32908 @var{x} is a negative number, or a formula with a leading minus sign
32909 such as @samp{-a/b}. In other words, this is an object which can be
32910 made simpler by calling @code{(- @var{x})}.
32914 Returns true if @var{x} is an integer of any size.
32918 Returns true if @var{x} is a native Lisp integer.
32922 Returns true if @var{x} is a nonnegative integer of any size.
32925 @defun fixnatnump x
32926 Returns true if @var{x} is a nonnegative Lisp integer.
32929 @defun num-integerp x
32930 Returns true if @var{x} is numerically an integer, i.e., either a
32931 true integer or a float with no significant digits to the right of
32935 @defun messy-integerp x
32936 Returns true if @var{x} is numerically, but not literally, an integer.
32937 A value is @code{num-integerp} if it is @code{integerp} or
32938 @code{messy-integerp} (but it is never both at once).
32941 @defun num-natnump x
32942 Returns true if @var{x} is numerically a nonnegative integer.
32946 Returns true if @var{x} is an even integer.
32949 @defun looks-evenp x
32950 Returns true if @var{x} is an even integer, or a formula with a leading
32951 multiplicative coefficient which is an even integer.
32955 Returns true if @var{x} is an odd integer.
32959 Returns true if @var{x} is a rational number, i.e., an integer or a
32964 Returns true if @var{x} is a real number, i.e., an integer, fraction,
32965 or floating-point number.
32969 Returns true if @var{x} is a real number or HMS form.
32973 Returns true if @var{x} is a float, or a complex number, error form,
32974 interval, date form, or modulo form in which at least one component
32979 Returns true if @var{x} is a rectangular or polar complex number
32980 (but not a real number).
32983 @defun rect-complexp x
32984 Returns true if @var{x} is a rectangular complex number.
32987 @defun polar-complexp x
32988 Returns true if @var{x} is a polar complex number.
32992 Returns true if @var{x} is a real number or a complex number.
32996 Returns true if @var{x} is a real or complex number or an HMS form.
33000 Returns true if @var{x} is a vector (this simply checks if its argument
33001 is a list whose first element is the symbol @code{vec}).
33005 Returns true if @var{x} is a number or vector.
33009 Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
33010 all of the same size.
33013 @defun square-matrixp x
33014 Returns true if @var{x} is a square matrix.
33018 Returns true if @var{x} is any numeric Calc object, including real and
33019 complex numbers, HMS forms, date forms, error forms, intervals, and
33020 modulo forms. (Note that error forms and intervals may include formulas
33021 as their components; see @code{constp} below.)
33025 Returns true if @var{x} is an object or a vector. This also accepts
33026 incomplete objects, but it rejects variables and formulas (except as
33027 mentioned above for @code{objectp}).
33031 Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
33032 i.e., one whose components cannot be regarded as sub-formulas. This
33033 includes variables, and all @code{objectp} types except error forms
33038 Returns true if @var{x} is constant, i.e., a real or complex number,
33039 HMS form, date form, or error form, interval, or vector all of whose
33040 components are @code{constp}.
33044 Returns true if @var{x} is numerically less than @var{y}. Returns false
33045 if @var{x} is greater than or equal to @var{y}, or if the order is
33046 undefined or cannot be determined. Generally speaking, this works
33047 by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In
33048 @code{defmath}, the expression @samp{(< x y)} will automatically be
33049 converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
33050 and @code{>=} are similarly converted in terms of @code{lessp}.
33054 Returns true if @var{x} comes before @var{y} in a canonical ordering
33055 of Calc objects. If @var{x} and @var{y} are both real numbers, this
33056 will be the same as @code{lessp}. But whereas @code{lessp} considers
33057 other types of objects to be unordered, @code{beforep} puts any two
33058 objects into a definite, consistent order. The @code{beforep}
33059 function is used by the @kbd{V S} vector-sorting command, and also
33060 by @kbd{a s} to put the terms of a product into canonical order:
33061 This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}.
33065 This is the standard Lisp @code{equal} predicate; it returns true if
33066 @var{x} and @var{y} are structurally identical. This is the usual way
33067 to compare numbers for equality, but note that @code{equal} will treat
33068 0 and 0.0 as different.
33071 @defun math-equal x y
33072 Returns true if @var{x} and @var{y} are numerically equal, either because
33073 they are @code{equal}, or because their difference is @code{zerop}. In
33074 @code{defmath}, the expression @samp{(= x y)} will automatically be
33075 converted to @samp{(math-equal x y)}.
33078 @defun equal-int x n
33079 Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
33080 is a fixnum which is not a multiple of 10. This will automatically be
33081 used by @code{defmath} in place of the more general @code{math-equal}
33085 @defun nearly-equal x y
33086 Returns true if @var{x} and @var{y}, as floating-point numbers, are
33087 equal except possibly in the last decimal place. For example,
33088 314.159 and 314.166 are considered nearly equal if the current
33089 precision is 6 (since they differ by 7 units), but not if the current
33090 precision is 7 (since they differ by 70 units). Most functions which
33091 use series expansions use @code{with-extra-prec} to evaluate the
33092 series with 2 extra digits of precision, then use @code{nearly-equal}
33093 to decide when the series has converged; this guards against cumulative
33094 error in the series evaluation without doing extra work which would be
33095 lost when the result is rounded back down to the current precision.
33096 In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
33097 The @var{x} and @var{y} can be numbers of any kind, including complex.
33100 @defun nearly-zerop x y
33101 Returns true if @var{x} is nearly zero, compared to @var{y}. This
33102 checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
33103 to @var{y} itself, to within the current precision, in other words,
33104 if adding @var{x} to @var{y} would have a negligible effect on @var{y}
33105 due to roundoff error. @var{X} may be a real or complex number, but
33106 @var{y} must be real.
33110 Return true if the formula @var{x} represents a true value in
33111 Calc, not Lisp, terms. It tests if @var{x} is a non-zero number
33112 or a provably non-zero formula.
33115 @defun reject-arg val pred
33116 Abort the current function evaluation due to unacceptable argument values.
33117 This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
33118 Lisp error which @code{normalize} will trap. The net effect is that the
33119 function call which led here will be left in symbolic form.
33122 @defun inexact-value
33123 If Symbolic mode is enabled, this will signal an error that causes
33124 @code{normalize} to leave the formula in symbolic form, with the message
33125 ``Inexact result.'' (This function has no effect when not in Symbolic mode.)
33126 Note that if your function calls @samp{(sin 5)} in Symbolic mode, the
33127 @code{sin} function will call @code{inexact-value}, which will cause your
33128 function to be left unsimplified. You may instead wish to call
33129 @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will
33130 return the formula @samp{sin(5)} to your function.
33134 This signals an error that will be reported as a floating-point overflow.
33138 This signals a floating-point underflow.
33141 @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
33142 @subsubsection Computational Functions
33145 The functions described here do the actual computational work of the
33146 Calculator. In addition to these, note that any function described in
33147 the main body of this manual may be called from Lisp; for example, if
33148 the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
33149 this means @code{calc-sqrt} is an interactive stack-based square-root
33150 command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
33151 is the actual Lisp function for taking square roots.
33153 The functions @code{math-add}, @code{math-sub}, @code{math-mul},
33154 @code{math-div}, @code{math-mod}, and @code{math-neg} are not included
33155 in this list, since @code{defmath} allows you to write native Lisp
33156 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
33157 respectively, instead.
33159 @defun normalize val
33160 (Full form: @code{math-normalize}.)
33161 Reduce the value @var{val} to standard form. For example, if @var{val}
33162 is a fixnum, it will be converted to a bignum if it is too large, and
33163 if @var{val} is a bignum it will be normalized by clipping off trailing
33164 (i.e., most-significant) zero digits and converting to a fixnum if it is
33165 small. All the various data types are similarly converted to their standard
33166 forms. Variables are left alone, but function calls are actually evaluated
33167 in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
33170 If a function call fails, because the function is void or has the wrong
33171 number of parameters, or because it returns @code{nil} or calls
33172 @code{reject-arg} or @code{inexact-result}, @code{normalize} returns
33173 the formula still in symbolic form.
33175 If the current simplification mode is ``none'' or ``numeric arguments
33176 only,'' @code{normalize} will act appropriately. However, the more
33177 powerful simplification modes (like Algebraic Simplification) are
33178 not handled by @code{normalize}. They are handled by @code{calc-normalize},
33179 which calls @code{normalize} and possibly some other routines, such
33180 as @code{simplify} or @code{simplify-units}. Programs generally will
33181 never call @code{calc-normalize} except when popping or pushing values
33185 @defun evaluate-expr expr
33186 Replace all variables in @var{expr} that have values with their values,
33187 then use @code{normalize} to simplify the result. This is what happens
33188 when you press the @kbd{=} key interactively.
33191 @defmac with-extra-prec n body
33192 Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
33193 digits. This is a macro which expands to
33197 (let ((calc-internal-prec (+ calc-internal-prec @var{n})))
33201 The surrounding call to @code{math-normalize} causes a floating-point
33202 result to be rounded down to the original precision afterwards. This
33203 is important because some arithmetic operations assume a number's
33204 mantissa contains no more digits than the current precision allows.
33207 @defun make-frac n d
33208 Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling
33209 @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
33212 @defun make-float mant exp
33213 Build a floating-point value out of @var{mant} and @var{exp}, both
33214 of which are arbitrary integers. This function will return a
33215 properly normalized float value, or signal an overflow or underflow
33216 if @var{exp} is out of range.
33219 @defun make-sdev x sigma
33220 Build an error form out of @var{x} and the absolute value of @var{sigma}.
33221 If @var{sigma} is zero, the result is the number @var{x} directly.
33222 If @var{sigma} is negative or complex, its absolute value is used.
33223 If @var{x} or @var{sigma} is not a valid type of object for use in
33224 error forms, this calls @code{reject-arg}.
33227 @defun make-intv mask lo hi
33228 Build an interval form out of @var{mask} (which is assumed to be an
33229 integer from 0 to 3), and the limits @var{lo} and @var{hi}. If
33230 @var{lo} is greater than @var{hi}, an empty interval form is returned.
33231 This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
33234 @defun sort-intv mask lo hi
33235 Build an interval form, similar to @code{make-intv}, except that if
33236 @var{lo} is less than @var{hi} they are simply exchanged, and the
33237 bits of @var{mask} are swapped accordingly.
33240 @defun make-mod n m
33241 Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo
33242 forms do not allow formulas as their components, if @var{n} or @var{m}
33243 is not a real number or HMS form the result will be a formula which
33244 is a call to @code{makemod}, the algebraic version of this function.
33248 Convert @var{x} to floating-point form. Integers and fractions are
33249 converted to numerically equivalent floats; components of complex
33250 numbers, vectors, HMS forms, date forms, error forms, intervals, and
33251 modulo forms are recursively floated. If the argument is a variable
33252 or formula, this calls @code{reject-arg}.
33256 Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if
33257 @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
33258 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
33259 undefined or cannot be determined.
33263 Return the number of digits of integer @var{n}, effectively
33264 @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is
33265 considered to have zero digits.
33268 @defun scale-int x n
33269 Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}}
33270 digits with truncation toward zero.
33273 @defun scale-rounding x n
33274 Like @code{scale-int}, except that a right shift rounds to the nearest
33275 integer rather than truncating.
33279 Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
33280 If @var{n} is outside the permissible range for Lisp integers (usually
33281 24 binary bits) the result is undefined.
33285 Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
33288 @defun quotient x y
33289 Divide integer @var{x} by integer @var{y}; return an integer quotient
33290 and discard the remainder. If @var{x} or @var{y} is negative, the
33291 direction of rounding is undefined.
33295 Perform an integer division; if @var{x} and @var{y} are both nonnegative
33296 integers, this uses the @code{quotient} function, otherwise it computes
33297 @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but
33298 slower than for @code{quotient}.
33302 Divide integer @var{x} by integer @var{y}; return the integer remainder
33303 and discard the quotient. Like @code{quotient}, this works only for
33304 integer arguments and is not well-defined for negative arguments.
33305 For a more well-defined result, use @samp{(% @var{x} @var{y})}.
33309 Divide integer @var{x} by integer @var{y}; return a cons cell whose
33310 @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
33311 is @samp{(imod @var{x} @var{y})}.
33315 Compute @var{x} to the power @var{y}. In @code{defmath} code, this can
33316 also be written @samp{(^ @var{x} @var{y})} or
33317 @w{@samp{(expt @var{x} @var{y})}}.
33320 @defun abs-approx x
33321 Compute a fast approximation to the absolute value of @var{x}. For
33322 example, for a rectangular complex number the result is the sum of
33323 the absolute values of the components.
33327 @findex gamma-const
33333 @findex pi-over-180
33334 @findex sqrt-two-pi
33338 The function @samp{(pi)} computes @samp{pi} to the current precision.
33339 Other related constant-generating functions are @code{two-pi},
33340 @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
33341 @code{e}, @code{sqrt-e}, @code{ln-2}, @code{ln-10}, @code{phi} and
33342 @code{gamma-const}. Each function returns a floating-point value in the
33343 current precision, and each uses caching so that all calls after the
33344 first are essentially free.
33347 @defmac math-defcache @var{func} @var{initial} @var{form}
33348 This macro, usually used as a top-level call like @code{defun} or
33349 @code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
33350 It defines a function @code{func} which returns the requested value;
33351 if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
33352 form which serves as an initial value for the cache. If @var{func}
33353 is called when the cache is empty or does not have enough digits to
33354 satisfy the current precision, the Lisp expression @var{form} is evaluated
33355 with the current precision increased by four, and the result minus its
33356 two least significant digits is stored in the cache. For example,
33357 calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
33358 digits, rounds it down to 32 digits for future use, then rounds it
33359 again to 30 digits for use in the present request.
33362 @findex half-circle
33363 @findex quarter-circle
33364 @defun full-circle symb
33365 If the current angular mode is Degrees or HMS, this function returns the
33366 integer 360. In Radians mode, this function returns either the
33367 corresponding value in radians to the current precision, or the formula
33368 @samp{2*pi}, depending on the Symbolic mode. There are also similar
33369 function @code{half-circle} and @code{quarter-circle}.
33372 @defun power-of-2 n
33373 Compute two to the integer power @var{n}, as a (potentially very large)
33374 integer. Powers of two are cached, so only the first call for a
33375 particular @var{n} is expensive.
33378 @defun integer-log2 n
33379 Compute the base-2 logarithm of @var{n}, which must be an integer which
33380 is a power of two. If @var{n} is not a power of two, this function will
33384 @defun div-mod a b m
33385 Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if
33386 there is no solution, or if any of the arguments are not integers.
33389 @defun pow-mod a b m
33390 Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a},
33391 @var{b}, and @var{m} are integers, this uses an especially efficient
33392 algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}.
33396 Compute the integer square root of @var{n}. This is the square root
33397 of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
33398 If @var{n} is itself an integer, the computation is especially efficient.
33401 @defun to-hms a ang
33402 Convert the argument @var{a} into an HMS form. If @var{ang} is specified,
33403 it is the angular mode in which to interpret @var{a}, either @code{deg}
33404 or @code{rad}. Otherwise, the current angular mode is used. If @var{a}
33405 is already an HMS form it is returned as-is.
33408 @defun from-hms a ang
33409 Convert the HMS form @var{a} into a real number. If @var{ang} is specified,
33410 it is the angular mode in which to express the result, otherwise the
33411 current angular mode is used. If @var{a} is already a real number, it
33415 @defun to-radians a
33416 Convert the number or HMS form @var{a} to radians from the current
33420 @defun from-radians a
33421 Convert the number @var{a} from radians to the current angular mode.
33422 If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
33425 @defun to-radians-2 a
33426 Like @code{to-radians}, except that in Symbolic mode a degrees to
33427 radians conversion yields a formula like @samp{@var{a}*pi/180}.
33430 @defun from-radians-2 a
33431 Like @code{from-radians}, except that in Symbolic mode a radians to
33432 degrees conversion yields a formula like @samp{@var{a}*180/pi}.
33435 @defun random-digit
33436 Produce a random base-1000 digit in the range 0 to 999.
33439 @defun random-digits n
33440 Produce a random @var{n}-digit integer; this will be an integer
33441 in the interval @samp{[0, 10^@var{n})}.
33444 @defun random-float
33445 Produce a random float in the interval @samp{[0, 1)}.
33448 @defun prime-test n iters
33449 Determine whether the integer @var{n} is prime. Return a list which has
33450 one of these forms: @samp{(nil @var{f})} means the number is non-prime
33451 because it was found to be divisible by @var{f}; @samp{(nil)} means it
33452 was found to be non-prime by table look-up (so no factors are known);
33453 @samp{(nil unknown)} means it is definitely non-prime but no factors
33454 are known because @var{n} was large enough that Fermat's probabilistic
33455 test had to be used; @samp{(t)} means the number is definitely prime;
33456 and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
33457 iterations, is @var{p} percent sure that the number is prime. The
33458 @var{iters} parameter is the number of Fermat iterations to use, in the
33459 case that this is necessary. If @code{prime-test} returns ``maybe,''
33460 you can call it again with the same @var{n} to get a greater certainty;
33461 @code{prime-test} remembers where it left off.
33464 @defun to-simple-fraction f
33465 If @var{f} is a floating-point number which can be represented exactly
33466 as a small rational number. return that number, else return @var{f}.
33467 For example, 0.75 would be converted to 3:4. This function is very
33471 @defun to-fraction f tol
33472 Find a rational approximation to floating-point number @var{f} to within
33473 a specified tolerance @var{tol}; this corresponds to the algebraic
33474 function @code{frac}, and can be rather slow.
33477 @defun quarter-integer n
33478 If @var{n} is an integer or integer-valued float, this function
33479 returns zero. If @var{n} is a half-integer (i.e., an integer plus
33480 @mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer,
33481 it returns 1 or 3. If @var{n} is anything else, this function
33482 returns @code{nil}.
33485 @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
33486 @subsubsection Vector Functions
33489 The functions described here perform various operations on vectors and
33492 @defun math-concat x y
33493 Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
33494 in a symbolic formula. @xref{Building Vectors}.
33497 @defun vec-length v
33498 Return the length of vector @var{v}. If @var{v} is not a vector, the
33499 result is zero. If @var{v} is a matrix, this returns the number of
33500 rows in the matrix.
33503 @defun mat-dimens m
33504 Determine the dimensions of vector or matrix @var{m}. If @var{m} is not
33505 a vector, the result is an empty list. If @var{m} is a plain vector
33506 but not a matrix, the result is a one-element list containing the length
33507 of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns,
33508 the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors
33509 produce lists of more than two dimensions. Note that the object
33510 @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
33511 and is treated by this and other Calc routines as a plain vector of two
33515 @defun dimension-error
33516 Abort the current function with a message of ``Dimension error.''
33517 The Calculator will leave the function being evaluated in symbolic
33518 form; this is really just a special case of @code{reject-arg}.
33521 @defun build-vector args
33522 Return a Calc vector with @var{args} as elements.
33523 For example, @samp{(build-vector 1 2 3)} returns the Calc vector
33524 @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
33527 @defun make-vec obj dims
33528 Return a Calc vector or matrix all of whose elements are equal to
33529 @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
33533 @defun row-matrix v
33534 If @var{v} is a plain vector, convert it into a row matrix, i.e.,
33535 a matrix whose single row is @var{v}. If @var{v} is already a matrix,
33539 @defun col-matrix v
33540 If @var{v} is a plain vector, convert it into a column matrix, i.e., a
33541 matrix with each element of @var{v} as a separate row. If @var{v} is
33542 already a matrix, leave it alone.
33546 Map the Lisp function @var{f} over the Calc vector @var{v}. For example,
33547 @samp{(map-vec 'math-floor v)} returns a vector of the floored components
33551 @defun map-vec-2 f a b
33552 Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
33553 If @var{a} and @var{b} are vectors of equal length, the result is a
33554 vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
33555 for each pair of elements @var{ai} and @var{bi}. If either @var{a} or
33556 @var{b} is a scalar, it is matched with each value of the other vector.
33557 For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
33558 with each element increased by one. Note that using @samp{'+} would not
33559 work here, since @code{defmath} does not expand function names everywhere,
33560 just where they are in the function position of a Lisp expression.
33563 @defun reduce-vec f v
33564 Reduce the function @var{f} over the vector @var{v}. For example, if
33565 @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
33566 If @var{v} is a matrix, this reduces over the rows of @var{v}.
33569 @defun reduce-cols f m
33570 Reduce the function @var{f} over the columns of matrix @var{m}. For
33571 example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
33572 is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
33576 Return the @var{n}th row of matrix @var{m}. This is equivalent to
33577 @samp{(elt m n)}. For a slower but safer version, use @code{mrow}.
33578 (@xref{Extracting Elements}.)
33582 Return the @var{n}th column of matrix @var{m}, in the form of a vector.
33583 The arguments are not checked for correctness.
33586 @defun mat-less-row m n
33587 Return a copy of matrix @var{m} with its @var{n}th row deleted. The
33588 number @var{n} must be in range from 1 to the number of rows in @var{m}.
33591 @defun mat-less-col m n
33592 Return a copy of matrix @var{m} with its @var{n}th column deleted.
33596 Return the transpose of matrix @var{m}.
33599 @defun flatten-vector v
33600 Flatten nested vector @var{v} into a vector of scalars. For example,
33601 if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
33604 @defun copy-matrix m
33605 If @var{m} is a matrix, return a copy of @var{m}. This maps
33606 @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
33607 element of the result matrix will be @code{eq} to the corresponding
33608 element of @var{m}, but none of the @code{cons} cells that make up
33609 the structure of the matrix will be @code{eq}. If @var{m} is a plain
33610 vector, this is the same as @code{copy-sequence}.
33613 @defun swap-rows m r1 r2
33614 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In
33615 other words, unlike most of the other functions described here, this
33616 function changes @var{m} itself rather than building up a new result
33617 matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
33618 is true, with the side effect of exchanging the first two rows of
33622 @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
33623 @subsubsection Symbolic Functions
33626 The functions described here operate on symbolic formulas in the
33629 @defun calc-prepare-selection num
33630 Prepare a stack entry for selection operations. If @var{num} is
33631 omitted, the stack entry containing the cursor is used; otherwise,
33632 it is the number of the stack entry to use. This function stores
33633 useful information about the current stack entry into a set of
33634 variables. @code{calc-selection-cache-num} contains the number of
33635 the stack entry involved (equal to @var{num} if you specified it);
33636 @code{calc-selection-cache-entry} contains the stack entry as a
33637 list (such as @code{calc-top-list} would return with @code{entry}
33638 as the selection mode); and @code{calc-selection-cache-comp} contains
33639 a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
33640 which allows Calc to relate cursor positions in the buffer with
33641 their corresponding sub-formulas.
33643 A slight complication arises in the selection mechanism because
33644 formulas may contain small integers. For example, in the vector
33645 @samp{[1, 2, 1]} the first and last elements are @code{eq} to each
33646 other; selections are recorded as the actual Lisp object that
33647 appears somewhere in the tree of the whole formula, but storing
33648 @code{1} would falsely select both @code{1}'s in the vector. So
33649 @code{calc-prepare-selection} also checks the stack entry and
33650 replaces any plain integers with ``complex number'' lists of the form
33651 @samp{(cplx @var{n} 0)}. This list will be displayed the same as a
33652 plain @var{n} and the change will be completely invisible to the
33653 user, but it will guarantee that no two sub-formulas of the stack
33654 entry will be @code{eq} to each other. Next time the stack entry
33655 is involved in a computation, @code{calc-normalize} will replace
33656 these lists with plain numbers again, again invisibly to the user.
33659 @defun calc-encase-atoms x
33660 This modifies the formula @var{x} to ensure that each part of the
33661 formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
33662 described above. This function may use @code{setcar} to modify
33663 the formula in-place.
33666 @defun calc-find-selected-part
33667 Find the smallest sub-formula of the current formula that contains
33668 the cursor. This assumes @code{calc-prepare-selection} has been
33669 called already. If the cursor is not actually on any part of the
33670 formula, this returns @code{nil}.
33673 @defun calc-change-current-selection selection
33674 Change the currently prepared stack element's selection to
33675 @var{selection}, which should be @code{eq} to some sub-formula
33676 of the stack element, or @code{nil} to unselect the formula.
33677 The stack element's appearance in the Calc buffer is adjusted
33678 to reflect the new selection.
33681 @defun calc-find-nth-part expr n
33682 Return the @var{n}th sub-formula of @var{expr}. This function is used
33683 by the selection commands, and (unless @kbd{j b} has been used) treats
33684 sums and products as flat many-element formulas. Thus if @var{expr}
33685 is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
33686 @var{n} equal to four will return @samp{d}.
33689 @defun calc-find-parent-formula expr part
33690 Return the sub-formula of @var{expr} which immediately contains
33691 @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
33692 is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
33693 will return @samp{(c+1)*d}. If @var{part} turns out not to be a
33694 sub-formula of @var{expr}, the function returns @code{nil}. If
33695 @var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
33696 This function does not take associativity into account.
33699 @defun calc-find-assoc-parent-formula expr part
33700 This is the same as @code{calc-find-parent-formula}, except that
33701 (unless @kbd{j b} has been used) it continues widening the selection
33702 to contain a complete level of the formula. Given @samp{a} from
33703 @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
33704 return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
33705 return the whole expression.
33708 @defun calc-grow-assoc-formula expr part
33709 This expands sub-formula @var{part} of @var{expr} to encompass a
33710 complete level of the formula. If @var{part} and its immediate
33711 parent are not compatible associative operators, or if @kbd{j b}
33712 has been used, this simply returns @var{part}.
33715 @defun calc-find-sub-formula expr part
33716 This finds the immediate sub-formula of @var{expr} which contains
33717 @var{part}. It returns an index @var{n} such that
33718 @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
33719 If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
33720 If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This
33721 function does not take associativity into account.
33724 @defun calc-replace-sub-formula expr old new
33725 This function returns a copy of formula @var{expr}, with the
33726 sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
33729 @defun simplify expr
33730 Simplify the expression @var{expr} by applying various algebraic rules.
33731 This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This
33732 always returns a copy of the expression; the structure @var{expr} points
33733 to remains unchanged in memory.
33735 More precisely, here is what @code{simplify} does: The expression is
33736 first normalized and evaluated by calling @code{normalize}. If any
33737 @code{AlgSimpRules} have been defined, they are then applied. Then
33738 the expression is traversed in a depth-first, bottom-up fashion; at
33739 each level, any simplifications that can be made are made until no
33740 further changes are possible. Once the entire formula has been
33741 traversed in this way, it is compared with the original formula (from
33742 before the call to @code{normalize}) and, if it has changed,
33743 the entire procedure is repeated (starting with @code{normalize})
33744 until no further changes occur. Usually only two iterations are
33745 needed:@: one to simplify the formula, and another to verify that no
33746 further simplifications were possible.
33749 @defun simplify-extended expr
33750 Simplify the expression @var{expr}, with additional rules enabled that
33751 help do a more thorough job, while not being entirely ``safe'' in all
33752 circumstances. (For example, this mode will simplify @samp{sqrt(x^2)}
33753 to @samp{x}, which is only valid when @var{x} is positive.) This is
33754 implemented by temporarily binding the variable @code{math-living-dangerously}
33755 to @code{t} (using a @code{let} form) and calling @code{simplify}.
33756 Dangerous simplification rules are written to check this variable
33757 before taking any action.
33760 @defun simplify-units expr
33761 Simplify the expression @var{expr}, treating variable names as units
33762 whenever possible. This works by binding the variable
33763 @code{math-simplifying-units} to @code{t} while calling @code{simplify}.
33766 @defmac math-defsimplify funcs body
33767 Register a new simplification rule; this is normally called as a top-level
33768 form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol
33769 (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
33770 applied to the formulas which are calls to the specified function. Or,
33771 @var{funcs} can be a list of such symbols; the rule applies to all
33772 functions on the list. The @var{body} is written like the body of a
33773 function with a single argument called @code{expr}. The body will be
33774 executed with @code{expr} bound to a formula which is a call to one of
33775 the functions @var{funcs}. If the function body returns @code{nil}, or
33776 if it returns a result @code{equal} to the original @code{expr}, it is
33777 ignored and Calc goes on to try the next simplification rule that applies.
33778 If the function body returns something different, that new formula is
33779 substituted for @var{expr} in the original formula.
33781 At each point in the formula, rules are tried in the order of the
33782 original calls to @code{math-defsimplify}; the search stops after the
33783 first rule that makes a change. Thus later rules for that same
33784 function will not have a chance to trigger until the next iteration
33785 of the main @code{simplify} loop.
33787 Note that, since @code{defmath} is not being used here, @var{body} must
33788 be written in true Lisp code without the conveniences that @code{defmath}
33789 provides. If you prefer, you can have @var{body} simply call another
33790 function (defined with @code{defmath}) which does the real work.
33792 The arguments of a function call will already have been simplified
33793 before any rules for the call itself are invoked. Since a new argument
33794 list is consed up when this happens, this means that the rule's body is
33795 allowed to rearrange the function's arguments destructively if that is
33796 convenient. Here is a typical example of a simplification rule:
33799 (math-defsimplify calcFunc-arcsinh
33800 (or (and (math-looks-negp (nth 1 expr))
33801 (math-neg (list 'calcFunc-arcsinh
33802 (math-neg (nth 1 expr)))))
33803 (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
33804 (or math-living-dangerously
33805 (math-known-realp (nth 1 (nth 1 expr))))
33806 (nth 1 (nth 1 expr)))))
33809 This is really a pair of rules written with one @code{math-defsimplify}
33810 for convenience; the first replaces @samp{arcsinh(-x)} with
33811 @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
33812 replaces @samp{arcsinh(sinh(x))} with @samp{x}.
33815 @defun common-constant-factor expr
33816 Check @var{expr} to see if it is a sum of terms all multiplied by the
33817 same rational value. If so, return this value. If not, return @code{nil}.
33818 For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
33819 3 is a common factor of all the terms.
33822 @defun cancel-common-factor expr factor
33823 Assuming @var{expr} is a sum with @var{factor} as a common factor,
33824 divide each term of the sum by @var{factor}. This is done by
33825 destructively modifying parts of @var{expr}, on the assumption that
33826 it is being used by a simplification rule (where such things are
33827 allowed; see above). For example, consider this built-in rule for
33831 (math-defsimplify calcFunc-sqrt
33832 (let ((fac (math-common-constant-factor (nth 1 expr))))
33833 (and fac (not (eq fac 1))
33834 (math-mul (math-normalize (list 'calcFunc-sqrt fac))
33836 (list 'calcFunc-sqrt
33837 (math-cancel-common-factor
33838 (nth 1 expr) fac)))))))
33842 @defun frac-gcd a b
33843 Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
33844 rational numbers. This is the fraction composed of the GCD of the
33845 numerators of @var{a} and @var{b}, over the GCD of the denominators.
33846 It is used by @code{common-constant-factor}. Note that the standard
33847 @code{gcd} function uses the LCM to combine the denominators.
33850 @defun map-tree func expr many
33851 Try applying Lisp function @var{func} to various sub-expressions of
33852 @var{expr}. Initially, call @var{func} with @var{expr} itself as an
33853 argument. If this returns an expression which is not @code{equal} to
33854 @var{expr}, apply @var{func} again until eventually it does return
33855 @var{expr} with no changes. Then, if @var{expr} is a function call,
33856 recursively apply @var{func} to each of the arguments. This keeps going
33857 until no changes occur anywhere in the expression; this final expression
33858 is returned by @code{map-tree}. Note that, unlike simplification rules,
33859 @var{func} functions may @emph{not} make destructive changes to
33860 @var{expr}. If a third argument @var{many} is provided, it is an
33861 integer which says how many times @var{func} may be applied; the
33862 default, as described above, is infinitely many times.
33865 @defun compile-rewrites rules
33866 Compile the rewrite rule set specified by @var{rules}, which should
33867 be a formula that is either a vector or a variable name. If the latter,
33868 the compiled rules are saved so that later @code{compile-rules} calls
33869 for that same variable can return immediately. If there are problems
33870 with the rules, this function calls @code{error} with a suitable
33874 @defun apply-rewrites expr crules heads
33875 Apply the compiled rewrite rule set @var{crules} to the expression
33876 @var{expr}. This will make only one rewrite and only checks at the
33877 top level of the expression. The result @code{nil} if no rules
33878 matched, or if the only rules that matched did not actually change
33879 the expression. The @var{heads} argument is optional; if is given,
33880 it should be a list of all function names that (may) appear in
33881 @var{expr}. The rewrite compiler tags each rule with the
33882 rarest-looking function name in the rule; if you specify @var{heads},
33883 @code{apply-rewrites} can use this information to narrow its search
33884 down to just a few rules in the rule set.
33887 @defun rewrite-heads expr
33888 Compute a @var{heads} list for @var{expr} suitable for use with
33889 @code{apply-rewrites}, as discussed above.
33892 @defun rewrite expr rules many
33893 This is an all-in-one rewrite function. It compiles the rule set
33894 specified by @var{rules}, then uses @code{map-tree} to apply the
33895 rules throughout @var{expr} up to @var{many} (default infinity)
33899 @defun match-patterns pat vec not-flag
33900 Given a Calc vector @var{vec} and an uncompiled pattern set or
33901 pattern set variable @var{pat}, this function returns a new vector
33902 of all elements of @var{vec} which do (or don't, if @var{not-flag} is
33903 non-@code{nil}) match any of the patterns in @var{pat}.
33906 @defun deriv expr var value symb
33907 Compute the derivative of @var{expr} with respect to variable @var{var}
33908 (which may actually be any sub-expression). If @var{value} is specified,
33909 the derivative is evaluated at the value of @var{var}; otherwise, the
33910 derivative is left in terms of @var{var}. If the expression contains
33911 functions for which no derivative formula is known, new derivative
33912 functions are invented by adding primes to the names; @pxref{Calculus}.
33913 However, if @var{symb} is non-@code{nil}, the presence of undifferentiable
33914 functions in @var{expr} instead cancels the whole differentiation, and
33915 @code{deriv} returns @code{nil} instead.
33917 Derivatives of an @var{n}-argument function can be defined by
33918 adding a @code{math-derivative-@var{n}} property to the property list
33919 of the symbol for the function's derivative, which will be the
33920 function name followed by an apostrophe. The value of the property
33921 should be a Lisp function; it is called with the same arguments as the
33922 original function call that is being differentiated. It should return
33923 a formula for the derivative. For example, the derivative of @code{ln}
33927 (put 'calcFunc-ln\' 'math-derivative-1
33928 (function (lambda (u) (math-div 1 u))))
33931 The two-argument @code{log} function has two derivatives,
33933 (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx
33934 (function (lambda (x b) ... )))
33935 (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db
33936 (function (lambda (x b) ... )))
33940 @defun tderiv expr var value symb
33941 Compute the total derivative of @var{expr}. This is the same as
33942 @code{deriv}, except that variables other than @var{var} are not
33943 assumed to be constant with respect to @var{var}.
33946 @defun integ expr var low high
33947 Compute the integral of @var{expr} with respect to @var{var}.
33948 @xref{Calculus}, for further details.
33951 @defmac math-defintegral funcs body
33952 Define a rule for integrating a function or functions of one argument;
33953 this macro is very similar in format to @code{math-defsimplify}.
33954 The main difference is that here @var{body} is the body of a function
33955 with a single argument @code{u} which is bound to the argument to the
33956 function being integrated, not the function call itself. Also, the
33957 variable of integration is available as @code{math-integ-var}. If
33958 evaluation of the integral requires doing further integrals, the body
33959 should call @samp{(math-integral @var{x})} to find the integral of
33960 @var{x} with respect to @code{math-integ-var}; this function returns
33961 @code{nil} if the integral could not be done. Some examples:
33964 (math-defintegral calcFunc-conj
33965 (let ((int (math-integral u)))
33967 (list 'calcFunc-conj int))))
33969 (math-defintegral calcFunc-cos
33970 (and (equal u math-integ-var)
33971 (math-from-radians-2 (list 'calcFunc-sin u))))
33974 In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
33975 relying on the general integration-by-substitution facility to handle
33976 cosines of more complicated arguments. An integration rule should return
33977 @code{nil} if it can't do the integral; if several rules are defined for
33978 the same function, they are tried in order until one returns a non-@code{nil}
33982 @defmac math-defintegral-2 funcs body
33983 Define a rule for integrating a function or functions of two arguments.
33984 This is exactly analogous to @code{math-defintegral}, except that @var{body}
33985 is written as the body of a function with two arguments, @var{u} and
33989 @defun solve-for lhs rhs var full
33990 Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
33991 the variable @var{var} on the lefthand side; return the resulting righthand
33992 side, or @code{nil} if the equation cannot be solved. The variable
33993 @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that
33994 the return value is a formula which does not contain @var{var}; this is
33995 different from the user-level @code{solve} and @code{finv} functions,
33996 which return a rearranged equation or a functional inverse, respectively.
33997 If @var{full} is non-@code{nil}, a full solution including dummy signs
33998 and dummy integers will be produced. User-defined inverses are provided
33999 as properties in a manner similar to derivatives:
34002 (put 'calcFunc-ln 'math-inverse
34003 (function (lambda (x) (list 'calcFunc-exp x))))
34006 This function can call @samp{(math-solve-get-sign @var{x})} to create
34007 a new arbitrary sign variable, returning @var{x} times that sign, and
34008 @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
34009 variable multiplied by @var{x}. These functions simply return @var{x}
34010 if the caller requested a non-``full'' solution.
34013 @defun solve-eqn expr var full
34014 This version of @code{solve-for} takes an expression which will
34015 typically be an equation or inequality. (If it is not, it will be
34016 interpreted as the equation @samp{@var{expr} = 0}.) It returns an
34017 equation or inequality, or @code{nil} if no solution could be found.
34020 @defun solve-system exprs vars full
34021 This function solves a system of equations. Generally, @var{exprs}
34022 and @var{vars} will be vectors of equal length.
34023 @xref{Solving Systems of Equations}, for other options.
34026 @defun expr-contains expr var
34027 Returns a non-@code{nil} value if @var{var} occurs as a subexpression
34030 This function might seem at first to be identical to
34031 @code{calc-find-sub-formula}. The key difference is that
34032 @code{expr-contains} uses @code{equal} to test for matches, whereas
34033 @code{calc-find-sub-formula} uses @code{eq}. In the formula
34034 @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
34035 @code{eq} to each other.
34038 @defun expr-contains-count expr var
34039 Returns the number of occurrences of @var{var} as a subexpression
34040 of @var{expr}, or @code{nil} if there are no occurrences.
34043 @defun expr-depends expr var
34044 Returns true if @var{expr} refers to any variable the occurs in @var{var}.
34045 In other words, it checks if @var{expr} and @var{var} have any variables
34049 @defun expr-contains-vars expr
34050 Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
34051 contains only constants and functions with constant arguments.
34054 @defun expr-subst expr old new
34055 Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
34056 by @var{new}. This treats @code{lambda} forms specially with respect
34057 to the dummy argument variables, so that the effect is always to return
34058 @var{expr} evaluated at @var{old} = @var{new}.
34061 @defun multi-subst expr old new
34062 This is like @code{expr-subst}, except that @var{old} and @var{new}
34063 are lists of expressions to be substituted simultaneously. If one
34064 list is shorter than the other, trailing elements of the longer list
34068 @defun expr-weight expr
34069 Returns the ``weight'' of @var{expr}, basically a count of the total
34070 number of objects and function calls that appear in @var{expr}. For
34071 ``primitive'' objects, this will be one.
34074 @defun expr-height expr
34075 Returns the ``height'' of @var{expr}, which is the deepest level to
34076 which function calls are nested. (Note that @samp{@var{a} + @var{b}}
34077 counts as a function call.) For primitive objects, this returns zero.
34080 @defun polynomial-p expr var
34081 Check if @var{expr} is a polynomial in variable (or sub-expression)
34082 @var{var}. If so, return the degree of the polynomial, that is, the
34083 highest power of @var{var} that appears in @var{expr}. For example,
34084 for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns
34085 @code{nil} unless @var{expr}, when expanded out by @kbd{a x}
34086 (@code{calc-expand}), would consist of a sum of terms in which @var{var}
34087 appears only raised to nonnegative integer powers. Note that if
34088 @var{var} does not occur in @var{expr}, then @var{expr} is considered
34089 a polynomial of degree 0.
34092 @defun is-polynomial expr var degree loose
34093 Check if @var{expr} is a polynomial in variable or sub-expression
34094 @var{var}, and, if so, return a list representation of the polynomial
34095 where the elements of the list are coefficients of successive powers of
34096 @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
34097 list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
34098 produce the list @samp{(1 2 1)}. The highest element of the list will
34099 be non-zero, with the special exception that if @var{expr} is the
34100 constant zero, the returned value will be @samp{(0)}. Return @code{nil}
34101 if @var{expr} is not a polynomial in @var{var}. If @var{degree} is
34102 specified, this will not consider polynomials of degree higher than that
34103 value. This is a good precaution because otherwise an input of
34104 @samp{(x+1)^1000} will cause a huge coefficient list to be built. If
34105 @var{loose} is non-@code{nil}, then a looser definition of a polynomial
34106 is used in which coefficients are no longer required not to depend on
34107 @var{var}, but are only required not to take the form of polynomials
34108 themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose
34109 polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
34110 x))}. The result will never be @code{nil} in loose mode, since any
34111 expression can be interpreted as a ``constant'' loose polynomial.
34114 @defun polynomial-base expr pred
34115 Check if @var{expr} is a polynomial in any variable that occurs in it;
34116 if so, return that variable. (If @var{expr} is a multivariate polynomial,
34117 this chooses one variable arbitrarily.) If @var{pred} is specified, it should
34118 be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
34119 and which should return true if @code{mpb-top-expr} (a global name for
34120 the original @var{expr}) is a suitable polynomial in @var{subexpr}.
34121 The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
34122 you can use @var{pred} to specify additional conditions. Or, you could
34123 have @var{pred} build up a list of every suitable @var{subexpr} that
34127 @defun poly-simplify poly
34128 Simplify polynomial coefficient list @var{poly} by (destructively)
34129 clipping off trailing zeros.
34132 @defun poly-mix a ac b bc
34133 Mix two polynomial lists @var{a} and @var{b} (in the form returned by
34134 @code{is-polynomial}) in a linear combination with coefficient expressions
34135 @var{ac} and @var{bc}. The result is a (not necessarily simplified)
34136 polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.
34139 @defun poly-mul a b
34140 Multiply two polynomial coefficient lists @var{a} and @var{b}. The
34141 result will be in simplified form if the inputs were simplified.
34144 @defun build-polynomial-expr poly var
34145 Construct a Calc formula which represents the polynomial coefficient
34146 list @var{poly} applied to variable @var{var}. The @kbd{a c}
34147 (@code{calc-collect}) command uses @code{is-polynomial} to turn an
34148 expression into a coefficient list, then @code{build-polynomial-expr}
34149 to turn the list back into an expression in regular form.
34152 @defun check-unit-name var
34153 Check if @var{var} is a variable which can be interpreted as a unit
34154 name. If so, return the units table entry for that unit. This
34155 will be a list whose first element is the unit name (not counting
34156 prefix characters) as a symbol and whose second element is the
34157 Calc expression which defines the unit. (Refer to the Calc sources
34158 for details on the remaining elements of this list.) If @var{var}
34159 is not a variable or is not a unit name, return @code{nil}.
34162 @defun units-in-expr-p expr sub-exprs
34163 Return true if @var{expr} contains any variables which can be
34164 interpreted as units. If @var{sub-exprs} is @code{t}, the entire
34165 expression is searched. If @var{sub-exprs} is @code{nil}, this
34166 checks whether @var{expr} is directly a units expression.
34169 @defun single-units-in-expr-p expr
34170 Check whether @var{expr} contains exactly one units variable. If so,
34171 return the units table entry for the variable. If @var{expr} does
34172 not contain any units, return @code{nil}. If @var{expr} contains
34173 two or more units, return the symbol @code{wrong}.
34176 @defun to-standard-units expr which
34177 Convert units expression @var{expr} to base units. If @var{which}
34178 is @code{nil}, use Calc's native base units. Otherwise, @var{which}
34179 can specify a units system, which is a list of two-element lists,
34180 where the first element is a Calc base symbol name and the second
34181 is an expression to substitute for it.
34184 @defun remove-units expr
34185 Return a copy of @var{expr} with all units variables replaced by ones.
34186 This expression is generally normalized before use.
34189 @defun extract-units expr
34190 Return a copy of @var{expr} with everything but units variables replaced
34194 @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
34195 @subsubsection I/O and Formatting Functions
34198 The functions described here are responsible for parsing and formatting
34199 Calc numbers and formulas.
34201 @defun calc-eval str sep arg1 arg2 @dots{}
34202 This is the simplest interface to the Calculator from another Lisp program.
34203 @xref{Calling Calc from Your Programs}.
34206 @defun read-number str
34207 If string @var{str} contains a valid Calc number, either integer,
34208 fraction, float, or HMS form, this function parses and returns that
34209 number. Otherwise, it returns @code{nil}.
34212 @defun read-expr str
34213 Read an algebraic expression from string @var{str}. If @var{str} does
34214 not have the form of a valid expression, return a list of the form
34215 @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
34216 into @var{str} of the general location of the error, and @var{msg} is
34217 a string describing the problem.
34220 @defun read-exprs str
34221 Read a list of expressions separated by commas, and return it as a
34222 Lisp list. If an error occurs in any expressions, an error list as
34223 shown above is returned instead.
34226 @defun calc-do-alg-entry initial prompt no-norm
34227 Read an algebraic formula or formulas using the minibuffer. All
34228 conventions of regular algebraic entry are observed. The return value
34229 is a list of Calc formulas; there will be more than one if the user
34230 entered a list of values separated by commas. The result is @code{nil}
34231 if the user presses Return with a blank line. If @var{initial} is
34232 given, it is a string which the minibuffer will initially contain.
34233 If @var{prompt} is given, it is the prompt string to use; the default
34234 is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will
34235 be returned exactly as parsed; otherwise, they will be passed through
34236 @code{calc-normalize} first.
34238 To support the use of @kbd{$} characters in the algebraic entry, use
34239 @code{let} to bind @code{calc-dollar-values} to a list of the values
34240 to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
34241 @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used}
34242 will have been changed to the highest number of consecutive @kbd{$}s
34243 that actually appeared in the input.
34246 @defun format-number a
34247 Convert the real or complex number or HMS form @var{a} to string form.
34250 @defun format-flat-expr a prec
34251 Convert the arbitrary Calc number or formula @var{a} to string form,
34252 in the style used by the trail buffer and the @code{calc-edit} command.
34253 This is a simple format designed
34254 mostly to guarantee the string is of a form that can be re-parsed by
34255 @code{read-expr}. Most formatting modes, such as digit grouping,
34256 complex number format, and point character, are ignored to ensure the
34257 result will be re-readable. The @var{prec} parameter is normally 0; if
34258 you pass a large integer like 1000 instead, the expression will be
34259 surrounded by parentheses unless it is a plain number or variable name.
34262 @defun format-nice-expr a width
34263 This is like @code{format-flat-expr} (with @var{prec} equal to 0),
34264 except that newlines will be inserted to keep lines down to the
34265 specified @var{width}, and vectors that look like matrices or rewrite
34266 rules are written in a pseudo-matrix format. The @code{calc-edit}
34267 command uses this when only one stack entry is being edited.
34270 @defun format-value a width
34271 Convert the Calc number or formula @var{a} to string form, using the
34272 format seen in the stack buffer. Beware the string returned may
34273 not be re-readable by @code{read-expr}, for example, because of digit
34274 grouping. Multi-line objects like matrices produce strings that
34275 contain newline characters to separate the lines. The @var{w}
34276 parameter, if given, is the target window size for which to format
34277 the expressions. If @var{w} is omitted, the width of the Calculator
34281 @defun compose-expr a prec
34282 Format the Calc number or formula @var{a} according to the current
34283 language mode, returning a ``composition.'' To learn about the
34284 structure of compositions, see the comments in the Calc source code.
34285 You can specify the format of a given type of function call by putting
34286 a @code{math-compose-@var{lang}} property on the function's symbol,
34287 whose value is a Lisp function that takes @var{a} and @var{prec} as
34288 arguments and returns a composition. Here @var{lang} is a language
34289 mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
34290 @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
34291 In Big mode, Calc actually tries @code{math-compose-big} first, then
34292 tries @code{math-compose-normal}. If this property does not exist,
34293 or if the function returns @code{nil}, the function is written in the
34294 normal function-call notation for that language.
34297 @defun composition-to-string c w
34298 Convert a composition structure returned by @code{compose-expr} into
34299 a string. Multi-line compositions convert to strings containing
34300 newline characters. The target window size is given by @var{w}.
34301 The @code{format-value} function basically calls @code{compose-expr}
34302 followed by @code{composition-to-string}.
34305 @defun comp-width c
34306 Compute the width in characters of composition @var{c}.
34309 @defun comp-height c
34310 Compute the height in lines of composition @var{c}.
34313 @defun comp-ascent c
34314 Compute the portion of the height of composition @var{c} which is on or
34315 above the baseline. For a one-line composition, this will be one.
34318 @defun comp-descent c
34319 Compute the portion of the height of composition @var{c} which is below
34320 the baseline. For a one-line composition, this will be zero.
34323 @defun comp-first-char c
34324 If composition @var{c} is a ``flat'' composition, return the first
34325 (leftmost) character of the composition as an integer. Otherwise,
34329 @defun comp-last-char c
34330 If composition @var{c} is a ``flat'' composition, return the last
34331 (rightmost) character, otherwise return @code{nil}.
34334 @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
34335 @comment @subsubsection Lisp Variables
34338 @comment (This section is currently unfinished.)
34340 @node Hooks, , Formatting Lisp Functions, Internals
34341 @subsubsection Hooks
34344 Hooks are variables which contain Lisp functions (or lists of functions)
34345 which are called at various times. Calc defines a number of hooks
34346 that help you to customize it in various ways. Calc uses the Lisp
34347 function @code{run-hooks} to invoke the hooks shown below. Several
34348 other customization-related variables are also described here.
34350 @defvar calc-load-hook
34351 This hook is called at the end of @file{calc.el}, after the file has
34352 been loaded, before any functions in it have been called, but after
34353 @code{calc-mode-map} and similar variables have been set up.
34356 @defvar calc-ext-load-hook
34357 This hook is called at the end of @file{calc-ext.el}.
34360 @defvar calc-start-hook
34361 This hook is called as the last step in a @kbd{M-x calc} command.
34362 At this point, the Calc buffer has been created and initialized if
34363 necessary, the Calc window and trail window have been created,
34364 and the ``Welcome to Calc'' message has been displayed.
34367 @defvar calc-mode-hook
34368 This hook is called when the Calc buffer is being created. Usually
34369 this will only happen once per Emacs session. The hook is called
34370 after Emacs has switched to the new buffer, the mode-settings file
34371 has been read if necessary, and all other buffer-local variables
34372 have been set up. After this hook returns, Calc will perform a
34373 @code{calc-refresh} operation, set up the mode line display, then
34374 evaluate any deferred @code{calc-define} properties that have not
34375 been evaluated yet.
34378 @defvar calc-trail-mode-hook
34379 This hook is called when the Calc Trail buffer is being created.
34380 It is called as the very last step of setting up the Trail buffer.
34381 Like @code{calc-mode-hook}, this will normally happen only once
34385 @defvar calc-end-hook
34386 This hook is called by @code{calc-quit}, generally because the user
34387 presses @kbd{q} or @kbd{C-x * c} while in Calc. The Calc buffer will
34388 be the current buffer. The hook is called as the very first
34389 step, before the Calc window is destroyed.
34392 @defvar calc-window-hook
34393 If this hook is non-@code{nil}, it is called to create the Calc window.
34394 Upon return, this new Calc window should be the current window.
34395 (The Calc buffer will already be the current buffer when the
34396 hook is called.) If the hook is not defined, Calc will
34397 generally use @code{split-window}, @code{set-window-buffer},
34398 and @code{select-window} to create the Calc window.
34401 @defvar calc-trail-window-hook
34402 If this hook is non-@code{nil}, it is called to create the Calc Trail
34403 window. The variable @code{calc-trail-buffer} will contain the buffer
34404 which the window should use. Unlike @code{calc-window-hook}, this hook
34405 must @emph{not} switch into the new window.
34408 @defvar calc-embedded-mode-hook
34409 This hook is called the first time that Embedded mode is entered.
34412 @defvar calc-embedded-new-buffer-hook
34413 This hook is called each time that Embedded mode is entered in a
34417 @defvar calc-embedded-new-formula-hook
34418 This hook is called each time that Embedded mode is enabled for a
34422 @defvar calc-edit-mode-hook
34423 This hook is called by @code{calc-edit} (and the other ``edit''
34424 commands) when the temporary editing buffer is being created.
34425 The buffer will have been selected and set up to be in
34426 @code{calc-edit-mode}, but will not yet have been filled with
34427 text. (In fact it may still have leftover text from a previous
34428 @code{calc-edit} command.)
34431 @defvar calc-mode-save-hook
34432 This hook is called by the @code{calc-save-modes} command,
34433 after Calc's own mode features have been inserted into the
34434 Calc init file and just before the ``End of mode settings''
34435 message is inserted.
34438 @defvar calc-reset-hook
34439 This hook is called after @kbd{C-x * 0} (@code{calc-reset}) has
34440 reset all modes. The Calc buffer will be the current buffer.
34443 @defvar calc-other-modes
34444 This variable contains a list of strings. The strings are
34445 concatenated at the end of the modes portion of the Calc
34446 mode line (after standard modes such as ``Deg'', ``Inv'' and
34447 ``Hyp''). Each string should be a short, single word followed
34448 by a space. The variable is @code{nil} by default.
34451 @defvar calc-mode-map
34452 This is the keymap that is used by Calc mode. The best time
34453 to adjust it is probably in a @code{calc-mode-hook}. If the
34454 Calc extensions package (@file{calc-ext.el}) has not yet been
34455 loaded, many of these keys will be bound to @code{calc-missing-key},
34456 which is a command that loads the extensions package and
34457 ``retypes'' the key. If your @code{calc-mode-hook} rebinds
34458 one of these keys, it will probably be overridden when the
34459 extensions are loaded.
34462 @defvar calc-digit-map
34463 This is the keymap that is used during numeric entry. Numeric
34464 entry uses the minibuffer, but this map binds every non-numeric
34465 key to @code{calcDigit-nondigit} which generally calls
34466 @code{exit-minibuffer} and ``retypes'' the key.
34469 @defvar calc-alg-ent-map
34470 This is the keymap that is used during algebraic entry. This is
34471 mostly a copy of @code{minibuffer-local-map}.
34474 @defvar calc-store-var-map
34475 This is the keymap that is used during entry of variable names for
34476 commands like @code{calc-store} and @code{calc-recall}. This is
34477 mostly a copy of @code{minibuffer-local-completion-map}.
34480 @defvar calc-edit-mode-map
34481 This is the (sparse) keymap used by @code{calc-edit} and other
34482 temporary editing commands. It binds @key{RET}, @key{LFD},
34483 and @kbd{C-c C-c} to @code{calc-edit-finish}.
34486 @defvar calc-mode-var-list
34487 This is a list of variables which are saved by @code{calc-save-modes}.
34488 Each entry is a list of two items, the variable (as a Lisp symbol)
34489 and its default value. When modes are being saved, each variable
34490 is compared with its default value (using @code{equal}) and any
34491 non-default variables are written out.
34494 @defvar calc-local-var-list
34495 This is a list of variables which should be buffer-local to the
34496 Calc buffer. Each entry is a variable name (as a Lisp symbol).
34497 These variables also have their default values manipulated by
34498 the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
34499 Since @code{calc-mode-hook} is called after this list has been
34500 used the first time, your hook should add a variable to the
34501 list and also call @code{make-local-variable} itself.
34504 @node Copying, GNU Free Documentation License, Programming, Top
34505 @appendix GNU GENERAL PUBLIC LICENSE
34508 @node GNU Free Documentation License, Customizing Calc, Copying, Top
34509 @appendix GNU Free Documentation License
34510 @include doclicense.texi
34512 @node Customizing Calc, Reporting Bugs, GNU Free Documentation License, Top
34513 @appendix Customizing Calc
34515 The usual prefix for Calc is the key sequence @kbd{C-x *}. If you wish
34516 to use a different prefix, you can put
34519 (global-set-key "NEWPREFIX" 'calc-dispatch)
34523 in your .emacs file.
34524 (@xref{Key Bindings,,Customizing Key Bindings,emacs,
34525 The GNU Emacs Manual}, for more information on binding keys.)
34526 A convenient way to start Calc is with @kbd{C-x * *}; to make it equally
34527 convenient for users who use a different prefix, the prefix can be
34528 followed by @kbd{=}, @kbd{&}, @kbd{#}, @kbd{\}, @kbd{/}, @kbd{+} or
34529 @kbd{-} as well as @kbd{*} to start Calc, and so in many cases the last
34530 character of the prefix can simply be typed twice.
34532 Calc is controlled by many variables, most of which can be reset
34533 from within Calc. Some variables are less involved with actual
34534 calculation, and can be set outside of Calc using Emacs's
34535 customization facilities. These variables are listed below.
34536 Typing @kbd{M-x customize-variable RET @var{variable-name} RET}
34537 will bring up a buffer in which the variable's value can be redefined.
34538 Typing @kbd{M-x customize-group RET calc RET} will bring up a buffer which
34539 contains all of Calc's customizable variables. (These variables can
34540 also be reset by putting the appropriate lines in your .emacs file;
34541 @xref{Init File, ,Init File, emacs, The GNU Emacs Manual}.)
34543 Some of the customizable variables are regular expressions. A regular
34544 expression is basically a pattern that Calc can search for.
34545 See @ref{Regexp Search,, Regular Expression Search, emacs, The GNU Emacs Manual}
34546 to see how regular expressions work.
34548 @defvar calc-settings-file
34549 The variable @code{calc-settings-file} holds the file name in
34550 which commands like @kbd{m m} and @kbd{Z P} store ``permanent''
34552 If @code{calc-settings-file} is not your user init file (typically
34553 @file{~/.emacs}) and if the variable @code{calc-loaded-settings-file} is
34554 @code{nil}, then Calc will automatically load your settings file (if it
34555 exists) the first time Calc is invoked.
34557 The default value for this variable is @code{"~/.calc.el"}.
34560 @defvar calc-gnuplot-name
34561 See @ref{Graphics}.@*
34562 The variable @code{calc-gnuplot-name} should be the name of the
34563 GNUPLOT program (a string). If you have GNUPLOT installed on your
34564 system but Calc is unable to find it, you may need to set this
34565 variable. You may also need to set some Lisp variables to show Calc how
34566 to run GNUPLOT on your system, see @ref{Devices, ,Graphical Devices} .
34567 The default value of @code{calc-gnuplot-name} is @code{"gnuplot"}.
34570 @defvar calc-gnuplot-plot-command
34571 @defvarx calc-gnuplot-print-command
34572 See @ref{Devices, ,Graphical Devices}.@*
34573 The variables @code{calc-gnuplot-plot-command} and
34574 @code{calc-gnuplot-print-command} represent system commands to
34575 display and print the output of GNUPLOT, respectively. These may be
34576 @code{nil} if no command is necessary, or strings which can include
34577 @samp{%s} to signify the name of the file to be displayed or printed.
34578 Or, these variables may contain Lisp expressions which are evaluated
34579 to display or print the output.
34581 The default value of @code{calc-gnuplot-plot-command} is @code{nil},
34582 and the default value of @code{calc-gnuplot-print-command} is
34586 @defvar calc-language-alist
34587 See @ref{Basic Embedded Mode}.@*
34588 The variable @code{calc-language-alist} controls the languages that
34589 Calc will associate with major modes. When Calc embedded mode is
34590 enabled, it will try to use the current major mode to
34591 determine what language should be used. (This can be overridden using
34592 Calc's mode changing commands, @xref{Mode Settings in Embedded Mode}.)
34593 The variable @code{calc-language-alist} consists of a list of pairs of
34594 the form @code{(@var{MAJOR-MODE} . @var{LANGUAGE})}; for example,
34595 @code{(latex-mode . latex)} is one such pair. If Calc embedded is
34596 activated in a buffer whose major mode is @var{MAJOR-MODE}, it will set itself
34597 to use the language @var{LANGUAGE}.
34599 The default value of @code{calc-language-alist} is
34601 ((latex-mode . latex)
34603 (plain-tex-mode . tex)
34604 (context-mode . tex)
34606 (pascal-mode . pascal)
34609 (fortran-mode . fortran)
34610 (f90-mode . fortran))
34614 @defvar calc-embedded-announce-formula
34615 @defvarx calc-embedded-announce-formula-alist
34616 See @ref{Customizing Embedded Mode}.@*
34617 The variable @code{calc-embedded-announce-formula} helps determine
34618 what formulas @kbd{C-x * a} will activate in a buffer. It is a
34619 regular expression, and when activating embedded formulas with
34620 @kbd{C-x * a}, it will tell Calc that what follows is a formula to be
34621 activated. (Calc also uses other patterns to find formulas, such as
34622 @samp{=>} and @samp{:=}.)
34624 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which checks
34625 for @samp{%Embed} followed by any number of lines beginning with
34626 @samp{%} and a space.
34628 The variable @code{calc-embedded-announce-formula-alist} is used to
34629 set @code{calc-embedded-announce-formula} to different regular
34630 expressions depending on the major mode of the editing buffer.
34631 It consists of a list of pairs of the form @code{(@var{MAJOR-MODE} .
34632 @var{REGEXP})}, and its default value is
34634 ((c++-mode . "//Embed\n\\(// .*\n\\)*")
34635 (c-mode . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*")
34636 (f90-mode . "!Embed\n\\(! .*\n\\)*")
34637 (fortran-mode . "C Embed\n\\(C .*\n\\)*")
34638 (html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
34639 (html-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
34640 (nroff-mode . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*")
34641 (pascal-mode . "@{Embed@}\n\\(@{.*@}\n\\)*")
34642 (sgml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
34643 (xml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
34644 (texinfo-mode . "@@c Embed\n\\(@@c .*\n\\)*"))
34646 Any major modes added to @code{calc-embedded-announce-formula-alist}
34647 should also be added to @code{calc-embedded-open-close-plain-alist}
34648 and @code{calc-embedded-open-close-mode-alist}.
34651 @defvar calc-embedded-open-formula
34652 @defvarx calc-embedded-close-formula
34653 @defvarx calc-embedded-open-close-formula-alist
34654 See @ref{Customizing Embedded Mode}.@*
34655 The variables @code{calc-embedded-open-formula} and
34656 @code{calc-embedded-open-formula} control the region that Calc will
34657 activate as a formula when Embedded mode is entered with @kbd{C-x * e}.
34658 They are regular expressions;
34659 Calc normally scans backward and forward in the buffer for the
34660 nearest text matching these regular expressions to be the ``formula
34663 The simplest delimiters are blank lines. Other delimiters that
34664 Embedded mode understands by default are:
34667 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
34668 @samp{\[ \]}, and @samp{\( \)};
34670 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
34672 Lines beginning with @samp{@@} (Texinfo delimiters).
34674 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
34676 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
34679 The variable @code{calc-embedded-open-close-formula-alist} is used to
34680 set @code{calc-embedded-open-formula} and
34681 @code{calc-embedded-close-formula} to different regular
34682 expressions depending on the major mode of the editing buffer.
34683 It consists of a list of lists of the form
34684 @code{(@var{MAJOR-MODE} @var{OPEN-FORMULA-REGEXP}
34685 @var{CLOSE-FORMULA-REGEXP})}, and its default value is
34689 @defvar calc-embedded-open-word
34690 @defvarx calc-embedded-close-word
34691 @defvarx calc-embedded-open-close-word-alist
34692 See @ref{Customizing Embedded Mode}.@*
34693 The variables @code{calc-embedded-open-word} and
34694 @code{calc-embedded-close-word} control the region that Calc will
34695 activate when Embedded mode is entered with @kbd{C-x * w}. They are
34696 regular expressions.
34698 The default values of @code{calc-embedded-open-word} and
34699 @code{calc-embedded-close-word} are @code{"^\\|[^-+0-9.eE]"} and
34700 @code{"$\\|[^-+0-9.eE]"} respectively.
34702 The variable @code{calc-embedded-open-close-word-alist} is used to
34703 set @code{calc-embedded-open-word} and
34704 @code{calc-embedded-close-word} to different regular
34705 expressions depending on the major mode of the editing buffer.
34706 It consists of a list of lists of the form
34707 @code{(@var{MAJOR-MODE} @var{OPEN-WORD-REGEXP}
34708 @var{CLOSE-WORD-REGEXP})}, and its default value is
34712 @defvar calc-embedded-open-plain
34713 @defvarx calc-embedded-close-plain
34714 @defvarx calc-embedded-open-close-plain-alist
34715 See @ref{Customizing Embedded Mode}.@*
34716 The variables @code{calc-embedded-open-plain} and
34717 @code{calc-embedded-open-plain} are used to delimit ``plain''
34718 formulas. Note that these are actual strings, not regular
34719 expressions, because Calc must be able to write these string into a
34720 buffer as well as to recognize them.
34722 The default string for @code{calc-embedded-open-plain} is
34723 @code{"%%% "}, note the trailing space. The default string for
34724 @code{calc-embedded-close-plain} is @code{" %%%\n"}, without
34725 the trailing newline here, the first line of a Big mode formula
34726 that followed might be shifted over with respect to the other lines.
34728 The variable @code{calc-embedded-open-close-plain-alist} is used to
34729 set @code{calc-embedded-open-plain} and
34730 @code{calc-embedded-close-plain} to different strings
34731 depending on the major mode of the editing buffer.
34732 It consists of a list of lists of the form
34733 @code{(@var{MAJOR-MODE} @var{OPEN-PLAIN-STRING}
34734 @var{CLOSE-PLAIN-STRING})}, and its default value is
34736 ((c++-mode "// %% " " %%\n")
34737 (c-mode "/* %% " " %% */\n")
34738 (f90-mode "! %% " " %%\n")
34739 (fortran-mode "C %% " " %%\n")
34740 (html-helper-mode "<!-- %% " " %% -->\n")
34741 (html-mode "<!-- %% " " %% -->\n")
34742 (nroff-mode "\\\" %% " " %%\n")
34743 (pascal-mode "@{%% " " %%@}\n")
34744 (sgml-mode "<!-- %% " " %% -->\n")
34745 (xml-mode "<!-- %% " " %% -->\n")
34746 (texinfo-mode "@@c %% " " %%\n"))
34748 Any major modes added to @code{calc-embedded-open-close-plain-alist}
34749 should also be added to @code{calc-embedded-announce-formula-alist}
34750 and @code{calc-embedded-open-close-mode-alist}.
34753 @defvar calc-embedded-open-new-formula
34754 @defvarx calc-embedded-close-new-formula
34755 @defvarx calc-embedded-open-close-new-formula-alist
34756 See @ref{Customizing Embedded Mode}.@*
34757 The variables @code{calc-embedded-open-new-formula} and
34758 @code{calc-embedded-close-new-formula} are strings which are
34759 inserted before and after a new formula when you type @kbd{C-x * f}.
34761 The default value of @code{calc-embedded-open-new-formula} is
34762 @code{"\n\n"}. If this string begins with a newline character and the
34763 @kbd{C-x * f} is typed at the beginning of a line, @kbd{C-x * f} will skip
34764 this first newline to avoid introducing unnecessary blank lines in the
34765 file. The default value of @code{calc-embedded-close-new-formula} is
34766 also @code{"\n\n"}. The final newline is omitted by @w{@kbd{C-x * f}}
34767 if typed at the end of a line. (It follows that if @kbd{C-x * f} is
34768 typed on a blank line, both a leading opening newline and a trailing
34769 closing newline are omitted.)
34771 The variable @code{calc-embedded-open-close-new-formula-alist} is used to
34772 set @code{calc-embedded-open-new-formula} and
34773 @code{calc-embedded-close-new-formula} to different strings
34774 depending on the major mode of the editing buffer.
34775 It consists of a list of lists of the form
34776 @code{(@var{MAJOR-MODE} @var{OPEN-NEW-FORMULA-STRING}
34777 @var{CLOSE-NEW-FORMULA-STRING})}, and its default value is
34781 @defvar calc-embedded-open-mode
34782 @defvarx calc-embedded-close-mode
34783 @defvarx calc-embedded-open-close-mode-alist
34784 See @ref{Customizing Embedded Mode}.@*
34785 The variables @code{calc-embedded-open-mode} and
34786 @code{calc-embedded-close-mode} are strings which Calc will place before
34787 and after any mode annotations that it inserts. Calc never scans for
34788 these strings; Calc always looks for the annotation itself, so it is not
34789 necessary to add them to user-written annotations.
34791 The default value of @code{calc-embedded-open-mode} is @code{"% "}
34792 and the default value of @code{calc-embedded-close-mode} is
34794 If you change the value of @code{calc-embedded-close-mode}, it is a good
34795 idea still to end with a newline so that mode annotations will appear on
34796 lines by themselves.
34798 The variable @code{calc-embedded-open-close-mode-alist} is used to
34799 set @code{calc-embedded-open-mode} and
34800 @code{calc-embedded-close-mode} to different strings
34801 expressions depending on the major mode of the editing buffer.
34802 It consists of a list of lists of the form
34803 @code{(@var{MAJOR-MODE} @var{OPEN-MODE-STRING}
34804 @var{CLOSE-MODE-STRING})}, and its default value is
34806 ((c++-mode "// " "\n")
34807 (c-mode "/* " " */\n")
34808 (f90-mode "! " "\n")
34809 (fortran-mode "C " "\n")
34810 (html-helper-mode "<!-- " " -->\n")
34811 (html-mode "<!-- " " -->\n")
34812 (nroff-mode "\\\" " "\n")
34813 (pascal-mode "@{ " " @}\n")
34814 (sgml-mode "<!-- " " -->\n")
34815 (xml-mode "<!-- " " -->\n")
34816 (texinfo-mode "@@c " "\n"))
34818 Any major modes added to @code{calc-embedded-open-close-mode-alist}
34819 should also be added to @code{calc-embedded-announce-formula-alist}
34820 and @code{calc-embedded-open-close-plain-alist}.
34823 @defvar calc-multiplication-has-precedence
34824 The variable @code{calc-multiplication-has-precedence} determines
34825 whether multiplication has precedence over division in algebraic formulas
34826 in normal language modes. If @code{calc-multiplication-has-precedence}
34827 is non-@code{nil}, then multiplication has precedence, and so for
34828 example @samp{a/b*c} will be interpreted as @samp{a/(b*c)}. If
34829 @code{calc-multiplication-has-precedence} is @code{nil}, then
34830 multiplication has the same precedence as division, and so for example
34831 @samp{a/b*c} will be interpreted as @samp{(a/b)*c}. The default value
34832 of @code{calc-multiplication-has-precedence} is @code{t}.
34835 @node Reporting Bugs, Summary, Customizing Calc, Top
34836 @appendix Reporting Bugs
34839 If you find a bug in Calc, send e-mail to Jay Belanger,
34842 jay.p.belanger@@gmail.com
34846 There is an automatic command @kbd{M-x report-calc-bug} which helps
34847 you to report bugs. This command prompts you for a brief subject
34848 line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to
34849 send your mail. Make sure your subject line indicates that you are
34850 reporting a Calc bug; this command sends mail to the maintainer's
34853 If you have suggestions for additional features for Calc, please send
34854 them. Some have dared to suggest that Calc is already top-heavy with
34855 features; this obviously cannot be the case, so if you have ideas, send
34858 At the front of the source file, @file{calc.el}, is a list of ideas for
34859 future work. If any enthusiastic souls wish to take it upon themselves
34860 to work on these, please send a message (using @kbd{M-x report-calc-bug})
34861 so any efforts can be coordinated.
34863 The latest version of Calc is available from Savannah, in the Emacs
34864 CVS tree. See @uref{http://savannah.gnu.org/projects/emacs}.
34867 @node Summary, Key Index, Reporting Bugs, Top
34868 @appendix Calc Summary
34871 This section includes a complete list of Calc 2.1 keystroke commands.
34872 Each line lists the stack entries used by the command (top-of-stack
34873 last), the keystrokes themselves, the prompts asked by the command,
34874 and the result of the command (also with top-of-stack last).
34875 The result is expressed using the equivalent algebraic function.
34876 Commands which put no results on the stack show the full @kbd{M-x}
34877 command name in that position. Numbers preceding the result or
34878 command name refer to notes at the end.
34880 Algebraic functions and @kbd{M-x} commands that don't have corresponding
34881 keystrokes are not listed in this summary.
34882 @xref{Command Index}. @xref{Function Index}.
34887 \vskip-2\baselineskip \null
34888 \gdef\sumrow#1{\sumrowx#1\relax}%
34889 \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
34892 \hbox to5em{\sl\hss#1}%
34893 \hbox to5em{\tt#2\hss}%
34894 \hbox to4em{\sl#3\hss}%
34895 \hbox to5em{\rm\hss#4}%
34900 \gdef\sumlpar{{\rm(}}%
34901 \gdef\sumrpar{{\rm)}}%
34902 \gdef\sumcomma{{\rm,\thinspace}}%
34903 \gdef\sumexcl{{\rm!}}%
34904 \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
34905 \gdef\minus#1{{\tt-}}%
34909 @catcode`@(=@active @let(=@sumlpar
34910 @catcode`@)=@active @let)=@sumrpar
34911 @catcode`@,=@active @let,=@sumcomma
34912 @catcode`@!=@active @let!=@sumexcl
34916 @advance@baselineskip-2.5pt
34919 @r{ @: C-x * a @: @: 33 @:calc-embedded-activate@:}
34920 @r{ @: C-x * b @: @: @:calc-big-or-small@:}
34921 @r{ @: C-x * c @: @: @:calc@:}
34922 @r{ @: C-x * d @: @: @:calc-embedded-duplicate@:}
34923 @r{ @: C-x * e @: @: 34 @:calc-embedded@:}
34924 @r{ @: C-x * f @:formula @: @:calc-embedded-new-formula@:}
34925 @r{ @: C-x * g @: @: 35 @:calc-grab-region@:}
34926 @r{ @: C-x * i @: @: @:calc-info@:}
34927 @r{ @: C-x * j @: @: @:calc-embedded-select@:}
34928 @r{ @: C-x * k @: @: @:calc-keypad@:}
34929 @r{ @: C-x * l @: @: @:calc-load-everything@:}
34930 @r{ @: C-x * m @: @: @:read-kbd-macro@:}
34931 @r{ @: C-x * n @: @: 4 @:calc-embedded-next@:}
34932 @r{ @: C-x * o @: @: @:calc-other-window@:}
34933 @r{ @: C-x * p @: @: 4 @:calc-embedded-previous@:}
34934 @r{ @: C-x * q @:formula @: @:quick-calc@:}
34935 @r{ @: C-x * r @: @: 36 @:calc-grab-rectangle@:}
34936 @r{ @: C-x * s @: @: @:calc-info-summary@:}
34937 @r{ @: C-x * t @: @: @:calc-tutorial@:}
34938 @r{ @: C-x * u @: @: @:calc-embedded-update-formula@:}
34939 @r{ @: C-x * w @: @: @:calc-embedded-word@:}
34940 @r{ @: C-x * x @: @: @:calc-quit@:}
34941 @r{ @: C-x * y @: @:1,28,49 @:calc-copy-to-buffer@:}
34942 @r{ @: C-x * z @: @: @:calc-user-invocation@:}
34943 @r{ @: C-x * : @: @: 36 @:calc-grab-sum-down@:}
34944 @r{ @: C-x * _ @: @: 36 @:calc-grab-sum-across@:}
34945 @r{ @: C-x * ` @:editing @: 30 @:calc-embedded-edit@:}
34946 @r{ @: C-x * 0 @:(zero) @: @:calc-reset@:}
34949 @r{ @: 0-9 @:number @: @:@:number}
34950 @r{ @: . @:number @: @:@:0.number}
34951 @r{ @: _ @:number @: @:-@:number}
34952 @r{ @: e @:number @: @:@:1e number}
34953 @r{ @: # @:number @: @:@:current-radix@tfn{#}number}
34954 @r{ @: P @:(in number) @: @:+/-@:}
34955 @r{ @: M @:(in number) @: @:mod@:}
34956 @r{ @: @@ ' " @: (in number)@: @:@:HMS form}
34957 @r{ @: h m s @: (in number)@: @:@:HMS form}
34960 @r{ @: ' @:formula @: 37,46 @:@:formula}
34961 @r{ @: $ @:formula @: 37,46 @:$@:formula}
34962 @r{ @: " @:string @: 37,46 @:@:string}
34965 @r{ a b@: + @: @: 2 @:add@:(a,b) a+b}
34966 @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b}
34967 @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b}
34968 @r{ a b@: / @: @: 2 @:div@:(a,b) a/b}
34969 @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b}
34970 @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)}
34971 @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b}
34972 @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b}
34973 @r{ a b@: : @: @: 2 @:fdiv@:(a,b)}
34974 @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b}
34975 @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a}
34976 @r{ a b@: H | @: @: 2 @:append@:(a,b)}
34977 @r{ a b@: I H | @: @: @:append@:(b,a)}
34978 @r{ a@: & @: @: 1 @:inv@:(a) 1/a}
34979 @r{ a@: ! @: @: 1 @:fact@:(a) a!}
34980 @r{ a@: = @: @: 1 @:evalv@:(a)}
34981 @r{ a@: M-% @: @: @:percent@:(a) a%}
34984 @r{ ... a@: @key{RET} @: @: 1 @:@:... a a}
34985 @r{ ... a@: @key{SPC} @: @: 1 @:@:... a a}
34986 @r{... a b@: @key{TAB} @: @: 3 @:@:... b a}
34987 @r{. a b c@: M-@key{TAB} @: @: 3 @:@:... b c a}
34988 @r{... a b@: @key{LFD} @: @: 1 @:@:... a b a}
34989 @r{ ... a@: @key{DEL} @: @: 1 @:@:...}
34990 @r{... a b@: M-@key{DEL} @: @: 1 @:@:... b}
34991 @r{ @: M-@key{RET} @: @: 4 @:calc-last-args@:}
34992 @r{ a@: ` @:editing @: 1,30 @:calc-edit@:}
34995 @r{ ... a@: C-d @: @: 1 @:@:...}
34996 @r{ @: C-k @: @: 27 @:calc-kill@:}
34997 @r{ @: C-w @: @: 27 @:calc-kill-region@:}
34998 @r{ @: C-y @: @: @:calc-yank@:}
34999 @r{ @: C-_ @: @: 4 @:calc-undo@:}
35000 @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:}
35001 @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:}
35004 @r{ @: [ @: @: @:@:[...}
35005 @r{[.. a b@: ] @: @: @:@:[a,b]}
35006 @r{ @: ( @: @: @:@:(...}
35007 @r{(.. a b@: ) @: @: @:@:(a,b)}
35008 @r{ @: , @: @: @:@:vector or rect complex}
35009 @r{ @: ; @: @: @:@:matrix or polar complex}
35010 @r{ @: .. @: @: @:@:interval}
35013 @r{ @: ~ @: @: @:calc-num-prefix@:}
35014 @r{ @: < @: @: 4 @:calc-scroll-left@:}
35015 @r{ @: > @: @: 4 @:calc-scroll-right@:}
35016 @r{ @: @{ @: @: 4 @:calc-scroll-down@:}
35017 @r{ @: @} @: @: 4 @:calc-scroll-up@:}
35018 @r{ @: ? @: @: @:calc-help@:}
35021 @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a}
35022 @r{ @: o @: @: 4 @:calc-realign@:}
35023 @r{ @: p @:precision @: 31 @:calc-precision@:}
35024 @r{ @: q @: @: @:calc-quit@:}
35025 @r{ @: w @: @: @:calc-why@:}
35026 @r{ @: x @:command @: @:M-x calc-@:command}
35027 @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:}
35030 @r{ a@: A @: @: 1 @:abs@:(a)}
35031 @r{ a b@: B @: @: 2 @:log@:(a,b)}
35032 @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a}
35033 @r{ a@: C @: @: 1 @:cos@:(a)}
35034 @r{ a@: I C @: @: 1 @:arccos@:(a)}
35035 @r{ a@: H C @: @: 1 @:cosh@:(a)}
35036 @r{ a@: I H C @: @: 1 @:arccosh@:(a)}
35037 @r{ @: D @: @: 4 @:calc-redo@:}
35038 @r{ a@: E @: @: 1 @:exp@:(a)}
35039 @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a}
35040 @r{ a@: F @: @: 1,11 @:floor@:(a,d)}
35041 @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)}
35042 @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)}
35043 @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)}
35044 @r{ a@: G @: @: 1 @:arg@:(a)}
35045 @r{ @: H @:command @: 32 @:@:Hyperbolic}
35046 @r{ @: I @:command @: 32 @:@:Inverse}
35047 @r{ a@: J @: @: 1 @:conj@:(a)}
35048 @r{ @: K @:command @: 32 @:@:Keep-args}
35049 @r{ a@: L @: @: 1 @:ln@:(a)}
35050 @r{ a@: H L @: @: 1 @:log10@:(a)}
35051 @r{ @: M @: @: @:calc-more-recursion-depth@:}
35052 @r{ @: I M @: @: @:calc-less-recursion-depth@:}
35053 @r{ a@: N @: @: 5 @:evalvn@:(a)}
35054 @r{ @: P @: @: @:@:pi}
35055 @r{ @: I P @: @: @:@:gamma}
35056 @r{ @: H P @: @: @:@:e}
35057 @r{ @: I H P @: @: @:@:phi}
35058 @r{ a@: Q @: @: 1 @:sqrt@:(a)}
35059 @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2}
35060 @r{ a@: R @: @: 1,11 @:round@:(a,d)}
35061 @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)}
35062 @r{ a@: H R @: @: 1,11 @:fround@:(a,d)}
35063 @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)}
35064 @r{ a@: S @: @: 1 @:sin@:(a)}
35065 @r{ a@: I S @: @: 1 @:arcsin@:(a)}
35066 @r{ a@: H S @: @: 1 @:sinh@:(a)}
35067 @r{ a@: I H S @: @: 1 @:arcsinh@:(a)}
35068 @r{ a@: T @: @: 1 @:tan@:(a)}
35069 @r{ a@: I T @: @: 1 @:arctan@:(a)}
35070 @r{ a@: H T @: @: 1 @:tanh@:(a)}
35071 @r{ a@: I H T @: @: 1 @:arctanh@:(a)}
35072 @r{ @: U @: @: 4 @:calc-undo@:}
35073 @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:}
35076 @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b}
35077 @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b}
35078 @r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b}
35079 @r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b}
35080 @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b}
35081 @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b}
35082 @r{ a b@: a @{ @: @: 2 @:in@:(a,b)}
35083 @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b}
35084 @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b}
35085 @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a}
35086 @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c}
35087 @r{ a@: a . @: @: 1 @:rmeq@:(a)}
35088 @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:}
35091 @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)}
35092 @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)}
35093 @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)}
35094 @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b}
35097 @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)}
35098 @r{ a b@: a % @: @: 2 @:prem@:(a,b)}
35099 @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]}
35100 @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b}
35103 @r{ a@: a a @: @: 1 @:apart@:(a)}
35104 @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)}
35105 @r{ a@: a c @:v @: 38 @:collect@:(a,v)}
35106 @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)}
35107 @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)}
35108 @r{ a@: a e @: @: @:esimplify@:(a)}
35109 @r{ a@: a f @: @: 1 @:factor@:(a)}
35110 @r{ a@: H a f @: @: 1 @:factors@:(a)}
35111 @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)}
35112 @r{ a@: a i @:v @: 38 @:integ@:(a,v)}
35113 @r{ a@: a m @:pats @: 38 @:match@:(a,pats)}
35114 @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)}
35115 @r{ data x@: a p @: @: 28 @:polint@:(data,x)}
35116 @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)}
35117 @r{ a@: a n @: @: 1 @:nrat@:(a)}
35118 @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)}
35119 @r{ a@: a s @: @: @:simplify@:(a)}
35120 @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)}
35121 @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:}
35122 @r{ a@: a x @: @: 4,8 @:expand@:(a)}
35125 @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)}
35126 @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)}
35127 @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)}
35128 @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)}
35129 @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)}
35130 @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)}
35131 @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)}
35132 @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)}
35133 @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)}
35134 @r{ a@: a P @:v @: 38 @:roots@:(a,v)}
35135 @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)}
35136 @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)}
35137 @r{ a@: a S @:v @: 38 @:solve@:(a,v)}
35138 @r{ a@: I a S @:v @: 38 @:finv@:(a,v)}
35139 @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)}
35140 @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)}
35141 @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)}
35142 @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)}
35143 @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)}
35146 @r{ a b@: b a @: @: 9 @:and@:(a,b,w)}
35147 @r{ a@: b c @: @: 9 @:clip@:(a,w)}
35148 @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)}
35149 @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)}
35150 @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)}
35151 @r{ a@: b n @: @: 9 @:not@:(a,w)}
35152 @r{ a b@: b o @: @: 9 @:or@:(a,b,w)}
35153 @r{ v@: b p @: @: 1 @:vpack@:(v)}
35154 @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)}
35155 @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)}
35156 @r{ a@: b t @: @: 10 @:rot@:(a,n,w)}
35157 @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)}
35158 @r{ a@: b u @: @: 1 @:vunpack@:(a)}
35159 @r{ @: b w @:w @: 9,50 @:calc-word-size@:}
35160 @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)}
35163 @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)}
35164 @r{ r n p@: b F @: @: @:fv@:(r,n,p)}
35165 @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)}
35166 @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)}
35167 @r{ v@: b I @: @: 19 @:irr@:(v)}
35168 @r{ v@: I b I @: @: 19 @:irrb@:(v)}
35169 @r{ a@: b L @: @: 10 @:ash@:(a,n,w)}
35170 @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)}
35171 @r{ r n a@: b M @: @: @:pmt@:(r,n,a)}
35172 @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)}
35173 @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)}
35174 @r{ r v@: b N @: @: 19 @:npv@:(r,v)}
35175 @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)}
35176 @r{ r n p@: b P @: @: @:pv@:(r,n,p)}
35177 @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)}
35178 @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)}
35179 @r{ a@: b R @: @: 10 @:rash@:(a,n,w)}
35180 @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)}
35181 @r{ c s l@: b S @: @: @:sln@:(c,s,l)}
35182 @r{ n p a@: b T @: @: @:rate@:(n,p,a)}
35183 @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)}
35184 @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)}
35185 @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)}
35187 @r{ r p a@: b # @: @: @:nper@:(r,p,a)}
35188 @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)}
35189 @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)}
35190 @r{ a b@: b % @: @: @:relch@:(a,b)}
35193 @r{ a@: c c @: @: 5 @:pclean@:(a,p)}
35194 @r{ a@: c 0-9 @: @: @:pclean@:(a,p)}
35195 @r{ a@: H c c @: @: 5 @:clean@:(a,p)}
35196 @r{ a@: H c 0-9 @: @: @:clean@:(a,p)}
35197 @r{ a@: c d @: @: 1 @:deg@:(a)}
35198 @r{ a@: c f @: @: 1 @:pfloat@:(a)}
35199 @r{ a@: H c f @: @: 1 @:float@:(a)}
35200 @r{ a@: c h @: @: 1 @:hms@:(a)}
35201 @r{ a@: c p @: @: @:polar@:(a)}
35202 @r{ a@: I c p @: @: @:rect@:(a)}
35203 @r{ a@: c r @: @: 1 @:rad@:(a)}
35206 @r{ a@: c F @: @: 5 @:pfrac@:(a,p)}
35207 @r{ a@: H c F @: @: 5 @:frac@:(a,p)}
35210 @r{ a@: c % @: @: @:percent@:(a*100)}
35213 @r{ @: d . @:char @: 50 @:calc-point-char@:}
35214 @r{ @: d , @:char @: 50 @:calc-group-char@:}
35215 @r{ @: d < @: @: 13,50 @:calc-left-justify@:}
35216 @r{ @: d = @: @: 13,50 @:calc-center-justify@:}
35217 @r{ @: d > @: @: 13,50 @:calc-right-justify@:}
35218 @r{ @: d @{ @:label @: 50 @:calc-left-label@:}
35219 @r{ @: d @} @:label @: 50 @:calc-right-label@:}
35220 @r{ @: d [ @: @: 4 @:calc-truncate-up@:}
35221 @r{ @: d ] @: @: 4 @:calc-truncate-down@:}
35222 @r{ @: d " @: @: 12,50 @:calc-display-strings@:}
35223 @r{ @: d @key{SPC} @: @: @:calc-refresh@:}
35224 @r{ @: d @key{RET} @: @: 1 @:calc-refresh-top@:}
35227 @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:}
35228 @r{ @: d 2 @: @: 50 @:calc-binary-radix@:}
35229 @r{ @: d 6 @: @: 50 @:calc-hex-radix@:}
35230 @r{ @: d 8 @: @: 50 @:calc-octal-radix@:}
35233 @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:}
35234 @r{ @: d c @: @: 50 @:calc-complex-notation@:}
35235 @r{ @: d d @:format @: 50 @:calc-date-notation@:}
35236 @r{ @: d e @: @: 5,50 @:calc-eng-notation@:}
35237 @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:}
35238 @r{ @: d g @: @:12,13,50 @:calc-group-digits@:}
35239 @r{ @: d h @:format @: 50 @:calc-hms-notation@:}
35240 @r{ @: d i @: @: 50 @:calc-i-notation@:}
35241 @r{ @: d j @: @: 50 @:calc-j-notation@:}
35242 @r{ @: d l @: @: 12,50 @:calc-line-numbering@:}
35243 @r{ @: d n @: @: 5,50 @:calc-normal-notation@:}
35244 @r{ @: d o @:format @: 50 @:calc-over-notation@:}
35245 @r{ @: d p @: @: 12,50 @:calc-show-plain@:}
35246 @r{ @: d r @:radix @: 31,50 @:calc-radix@:}
35247 @r{ @: d s @: @: 5,50 @:calc-sci-notation@:}
35248 @r{ @: d t @: @: 27 @:calc-truncate-stack@:}
35249 @r{ @: d w @: @: 12,13 @:calc-auto-why@:}
35250 @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:}
35253 @r{ @: d B @: @: 50 @:calc-big-language@:}
35254 @r{ @: d C @: @: 50 @:calc-c-language@:}
35255 @r{ @: d E @: @: 50 @:calc-eqn-language@:}
35256 @r{ @: d F @: @: 50 @:calc-fortran-language@:}
35257 @r{ @: d M @: @: 50 @:calc-mathematica-language@:}
35258 @r{ @: d N @: @: 50 @:calc-normal-language@:}
35259 @r{ @: d O @: @: 50 @:calc-flat-language@:}
35260 @r{ @: d P @: @: 50 @:calc-pascal-language@:}
35261 @r{ @: d T @: @: 50 @:calc-tex-language@:}
35262 @r{ @: d L @: @: 50 @:calc-latex-language@:}
35263 @r{ @: d U @: @: 50 @:calc-unformatted-language@:}
35264 @r{ @: d W @: @: 50 @:calc-maple-language@:}
35267 @r{ a@: f [ @: @: 4 @:decr@:(a,n)}
35268 @r{ a@: f ] @: @: 4 @:incr@:(a,n)}
35271 @r{ a b@: f b @: @: 2 @:beta@:(a,b)}
35272 @r{ a@: f e @: @: 1 @:erf@:(a)}
35273 @r{ a@: I f e @: @: 1 @:erfc@:(a)}
35274 @r{ a@: f g @: @: 1 @:gamma@:(a)}
35275 @r{ a b@: f h @: @: 2 @:hypot@:(a,b)}
35276 @r{ a@: f i @: @: 1 @:im@:(a)}
35277 @r{ n a@: f j @: @: 2 @:besJ@:(n,a)}
35278 @r{ a b@: f n @: @: 2 @:min@:(a,b)}
35279 @r{ a@: f r @: @: 1 @:re@:(a)}
35280 @r{ a@: f s @: @: 1 @:sign@:(a)}
35281 @r{ a b@: f x @: @: 2 @:max@:(a,b)}
35282 @r{ n a@: f y @: @: 2 @:besY@:(n,a)}
35285 @r{ a@: f A @: @: 1 @:abssqr@:(a)}
35286 @r{ x a b@: f B @: @: @:betaI@:(x,a,b)}
35287 @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)}
35288 @r{ a@: f E @: @: 1 @:expm1@:(a)}
35289 @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)}
35290 @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)}
35291 @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)}
35292 @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)}
35293 @r{ a b@: f I @: @: 2 @:ilog@:(a,b)}
35294 @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a}
35295 @r{ a@: f L @: @: 1 @:lnp1@:(a)}
35296 @r{ a@: f M @: @: 1 @:mant@:(a)}
35297 @r{ a@: f Q @: @: 1 @:isqrt@:(a)}
35298 @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2}
35299 @r{ a n@: f S @: @: 2 @:scf@:(a,n)}
35300 @r{ y x@: f T @: @: @:arctan2@:(y,x)}
35301 @r{ a@: f X @: @: 1 @:xpon@:(a)}
35304 @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:}
35305 @r{ @: g b @: @: 12 @:calc-graph-border@:}
35306 @r{ @: g c @: @: @:calc-graph-clear@:}
35307 @r{ @: g d @: @: 41 @:calc-graph-delete@:}
35308 @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:}
35309 @r{ @: g g @: @: 12 @:calc-graph-grid@:}
35310 @r{ @: g h @:title @: @:calc-graph-header@:}
35311 @r{ @: g j @: @: 4 @:calc-graph-juggle@:}
35312 @r{ @: g k @: @: 12 @:calc-graph-key@:}
35313 @r{ @: g l @: @: 12 @:calc-graph-log-x@:}
35314 @r{ @: g n @:name @: @:calc-graph-name@:}
35315 @r{ @: g p @: @: 42 @:calc-graph-plot@:}
35316 @r{ @: g q @: @: @:calc-graph-quit@:}
35317 @r{ @: g r @:range @: @:calc-graph-range-x@:}
35318 @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:}
35319 @r{ @: g t @:title @: @:calc-graph-title-x@:}
35320 @r{ @: g v @: @: @:calc-graph-view-commands@:}
35321 @r{ @: g x @:display @: @:calc-graph-display@:}
35322 @r{ @: g z @: @: 12 @:calc-graph-zero-x@:}
35325 @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:}
35326 @r{ @: g C @:command @: @:calc-graph-command@:}
35327 @r{ @: g D @:device @: 43,44 @:calc-graph-device@:}
35328 @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:}
35329 @r{ @: g H @: @: 12 @:calc-graph-hide@:}
35330 @r{ @: g K @: @: @:calc-graph-kill@:}
35331 @r{ @: g L @: @: 12 @:calc-graph-log-y@:}
35332 @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:}
35333 @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:}
35334 @r{ @: g P @: @: 42 @:calc-graph-print@:}
35335 @r{ @: g R @:range @: @:calc-graph-range-y@:}
35336 @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:}
35337 @r{ @: g T @:title @: @:calc-graph-title-y@:}
35338 @r{ @: g V @: @: @:calc-graph-view-trail@:}
35339 @r{ @: g X @:format @: @:calc-graph-geometry@:}
35340 @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:}
35343 @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:}
35344 @r{ @: g C-r @:range @: @:calc-graph-range-z@:}
35345 @r{ @: g C-t @:title @: @:calc-graph-title-z@:}
35348 @r{ @: h b @: @: @:calc-describe-bindings@:}
35349 @r{ @: h c @:key @: @:calc-describe-key-briefly@:}
35350 @r{ @: h f @:function @: @:calc-describe-function@:}
35351 @r{ @: h h @: @: @:calc-full-help@:}
35352 @r{ @: h i @: @: @:calc-info@:}
35353 @r{ @: h k @:key @: @:calc-describe-key@:}
35354 @r{ @: h n @: @: @:calc-view-news@:}
35355 @r{ @: h s @: @: @:calc-info-summary@:}
35356 @r{ @: h t @: @: @:calc-tutorial@:}
35357 @r{ @: h v @:var @: @:calc-describe-variable@:}
35360 @r{ @: j 1-9 @: @: @:calc-select-part@:}
35361 @r{ @: j @key{RET} @: @: 27 @:calc-copy-selection@:}
35362 @r{ @: j @key{DEL} @: @: 27 @:calc-del-selection@:}
35363 @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:}
35364 @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:}
35365 @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:}
35368 @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:}
35369 @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:}
35370 @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:}
35371 @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:}
35372 @r{ @: j & @: @: 27 @:calc-sel-invert@:}
35375 @r{ @: j a @: @: 27 @:calc-select-additional@:}
35376 @r{ @: j b @: @: 12 @:calc-break-selections@:}
35377 @r{ @: j c @: @: @:calc-clear-selections@:}
35378 @r{ @: j d @: @: 12,50 @:calc-show-selections@:}
35379 @r{ @: j e @: @: 12 @:calc-enable-selections@:}
35380 @r{ @: j l @: @: 4,27 @:calc-select-less@:}
35381 @r{ @: j m @: @: 4,27 @:calc-select-more@:}
35382 @r{ @: j n @: @: 4 @:calc-select-next@:}
35383 @r{ @: j o @: @: 4,27 @:calc-select-once@:}
35384 @r{ @: j p @: @: 4 @:calc-select-previous@:}
35385 @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:}
35386 @r{ @: j s @: @: 4,27 @:calc-select-here@:}
35387 @r{ @: j u @: @: 27 @:calc-unselect@:}
35388 @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:}
35391 @r{ @: j C @: @: 27 @:calc-sel-commute@:}
35392 @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:}
35393 @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:}
35394 @r{ @: j I @: @: 27 @:calc-sel-isolate@:}
35395 @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)}
35396 @r{ @: j L @: @: 4,27 @:calc-commute-left@:}
35397 @r{ @: j M @: @: 27 @:calc-sel-merge@:}
35398 @r{ @: j N @: @: 27 @:calc-sel-negate@:}
35399 @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:}
35400 @r{ @: j R @: @: 4,27 @:calc-commute-right@:}
35401 @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:}
35402 @r{ @: j U @: @: 27 @:calc-sel-unpack@:}
35405 @r{ @: k a @: @: @:calc-random-again@:}
35406 @r{ n@: k b @: @: 1 @:bern@:(n)}
35407 @r{ n x@: H k b @: @: 2 @:bern@:(n,x)}
35408 @r{ n m@: k c @: @: 2 @:choose@:(n,m)}
35409 @r{ n m@: H k c @: @: 2 @:perm@:(n,m)}
35410 @r{ n@: k d @: @: 1 @:dfact@:(n) n!!}
35411 @r{ n@: k e @: @: 1 @:euler@:(n)}
35412 @r{ n x@: H k e @: @: 2 @:euler@:(n,x)}
35413 @r{ n@: k f @: @: 4 @:prfac@:(n)}
35414 @r{ n m@: k g @: @: 2 @:gcd@:(n,m)}
35415 @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)}
35416 @r{ n m@: k l @: @: 2 @:lcm@:(n,m)}
35417 @r{ n@: k m @: @: 1 @:moebius@:(n)}
35418 @r{ n@: k n @: @: 4 @:nextprime@:(n)}
35419 @r{ n@: I k n @: @: 4 @:prevprime@:(n)}
35420 @r{ n@: k p @: @: 4,28 @:calc-prime-test@:}
35421 @r{ m@: k r @: @: 14 @:random@:(m)}
35422 @r{ n m@: k s @: @: 2 @:stir1@:(n,m)}
35423 @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)}
35424 @r{ n@: k t @: @: 1 @:totient@:(n)}
35427 @r{ n p x@: k B @: @: @:utpb@:(x,n,p)}
35428 @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)}
35429 @r{ v x@: k C @: @: @:utpc@:(x,v)}
35430 @r{ v x@: I k C @: @: @:ltpc@:(x,v)}
35431 @r{ n m@: k E @: @: @:egcd@:(n,m)}
35432 @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)}
35433 @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)}
35434 @r{ m s x@: k N @: @: @:utpn@:(x,m,s)}
35435 @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)}
35436 @r{ m x@: k P @: @: @:utpp@:(x,m)}
35437 @r{ m x@: I k P @: @: @:ltpp@:(x,m)}
35438 @r{ v x@: k T @: @: @:utpt@:(x,v)}
35439 @r{ v x@: I k T @: @: @:ltpt@:(x,v)}
35442 @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:}
35443 @r{ @: m d @: @: @:calc-degrees-mode@:}
35444 @r{ @: m e @: @: @:calc-embedded-preserve-modes@:}
35445 @r{ @: m f @: @: 12 @:calc-frac-mode@:}
35446 @r{ @: m g @: @: 52 @:calc-get-modes@:}
35447 @r{ @: m h @: @: @:calc-hms-mode@:}
35448 @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:}
35449 @r{ @: m m @: @: @:calc-save-modes@:}
35450 @r{ @: m p @: @: 12 @:calc-polar-mode@:}
35451 @r{ @: m r @: @: @:calc-radians-mode@:}
35452 @r{ @: m s @: @: 12 @:calc-symbolic-mode@:}
35453 @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:}
35454 @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:}
35455 @r{ @: m w @: @: 13 @:calc-working@:}
35456 @r{ @: m x @: @: @:calc-always-load-extensions@:}
35459 @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:}
35460 @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:}
35461 @r{ @: m C @: @: 12 @:calc-auto-recompute@:}
35462 @r{ @: m D @: @: @:calc-default-simplify-mode@:}
35463 @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:}
35464 @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:}
35465 @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:}
35466 @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:}
35467 @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:}
35468 @r{ @: m S @: @: 12 @:calc-shift-prefix@:}
35469 @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:}
35472 @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:}
35473 @r{ @: s d @:var, decl @: @:calc-declare-variable@:}
35474 @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:}
35475 @r{ @: s i @:buffer @: @:calc-insert-variables@:}
35476 @r{ @: s k @:const, var @: 29 @:calc-copy-special-constant@:}
35477 @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)}
35478 @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:}
35479 @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)}
35480 @r{ @: s p @:var @: 29 @:calc-permanent-variable@:}
35481 @r{ @: s r @:var @: 29 @:@:v (recalled value)}
35482 @r{ @: r 0-9 @: @: @:calc-recall-quick@:}
35483 @r{ a@: s s @:var @: 28,29 @:calc-store@:}
35484 @r{ a@: s 0-9 @: @: @:calc-store-quick@:}
35485 @r{ a@: s t @:var @: 29 @:calc-store-into@:}
35486 @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:}
35487 @r{ @: s u @:var @: 29 @:calc-unstore@:}
35488 @r{ a@: s x @:var @: 29 @:calc-store-exchange@:}
35491 @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:}
35492 @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:}
35493 @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:}
35494 @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:}
35495 @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:}
35496 @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:}
35497 @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:}
35498 @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:}
35499 @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:}
35500 @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:}
35501 @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:}
35502 @r{ @: s U @:editing @: 30 @:calc-edit-Units@:}
35503 @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:}
35506 @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)}
35507 @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)}
35508 @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)}
35509 @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)}
35510 @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)}
35511 @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)}
35512 @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)}
35513 @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)}
35514 @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))}
35515 @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @tfn{:=} b}
35516 @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @tfn{=>}}
35519 @r{ @: t [ @: @: 4 @:calc-trail-first@:}
35520 @r{ @: t ] @: @: 4 @:calc-trail-last@:}
35521 @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:}
35522 @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:}
35523 @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:}
35526 @r{ @: t b @: @: 4 @:calc-trail-backward@:}
35527 @r{ @: t d @: @: 12,50 @:calc-trail-display@:}
35528 @r{ @: t f @: @: 4 @:calc-trail-forward@:}
35529 @r{ @: t h @: @: @:calc-trail-here@:}
35530 @r{ @: t i @: @: @:calc-trail-in@:}
35531 @r{ @: t k @: @: 4 @:calc-trail-kill@:}
35532 @r{ @: t m @:string @: @:calc-trail-marker@:}
35533 @r{ @: t n @: @: 4 @:calc-trail-next@:}
35534 @r{ @: t o @: @: @:calc-trail-out@:}
35535 @r{ @: t p @: @: 4 @:calc-trail-previous@:}
35536 @r{ @: t r @:string @: @:calc-trail-isearch-backward@:}
35537 @r{ @: t s @:string @: @:calc-trail-isearch-forward@:}
35538 @r{ @: t y @: @: 4 @:calc-trail-yank@:}
35541 @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)}
35542 @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)}
35543 @r{ d@: t D @: @: 15 @:date@:(d)}
35544 @r{ d@: t I @: @: 4 @:incmonth@:(d,n)}
35545 @r{ d@: t J @: @: 16 @:julian@:(d,z)}
35546 @r{ d@: t M @: @: 17 @:newmonth@:(d,n)}
35547 @r{ @: t N @: @: 16 @:now@:(z)}
35548 @r{ d@: t P @:1 @: 31 @:year@:(d)}
35549 @r{ d@: t P @:2 @: 31 @:month@:(d)}
35550 @r{ d@: t P @:3 @: 31 @:day@:(d)}
35551 @r{ d@: t P @:4 @: 31 @:hour@:(d)}
35552 @r{ d@: t P @:5 @: 31 @:minute@:(d)}
35553 @r{ d@: t P @:6 @: 31 @:second@:(d)}
35554 @r{ d@: t P @:7 @: 31 @:weekday@:(d)}
35555 @r{ d@: t P @:8 @: 31 @:yearday@:(d)}
35556 @r{ d@: t P @:9 @: 31 @:time@:(d)}
35557 @r{ d@: t U @: @: 16 @:unixtime@:(d,z)}
35558 @r{ d@: t W @: @: 17 @:newweek@:(d,w)}
35559 @r{ d@: t Y @: @: 17 @:newyear@:(d,n)}
35562 @r{ a b@: t + @: @: 2 @:badd@:(a,b)}
35563 @r{ a b@: t - @: @: 2 @:bsub@:(a,b)}
35566 @r{ @: u a @: @: 12 @:calc-autorange-units@:}
35567 @r{ a@: u b @: @: @:calc-base-units@:}
35568 @r{ a@: u c @:units @: 18 @:calc-convert-units@:}
35569 @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:}
35570 @r{ @: u e @: @: @:calc-explain-units@:}
35571 @r{ @: u g @:unit @: @:calc-get-unit-definition@:}
35572 @r{ @: u p @: @: @:calc-permanent-units@:}
35573 @r{ a@: u r @: @: @:calc-remove-units@:}
35574 @r{ a@: u s @: @: @:usimplify@:(a)}
35575 @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:}
35576 @r{ @: u u @:unit @: @:calc-undefine-unit@:}
35577 @r{ @: u v @: @: @:calc-enter-units-table@:}
35578 @r{ a@: u x @: @: @:calc-extract-units@:}
35579 @r{ a@: u 0-9 @: @: @:calc-quick-units@:}
35582 @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)}
35583 @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)}
35584 @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)}
35585 @r{ v@: u G @: @: 19 @:vgmean@:(v)}
35586 @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)}
35587 @r{ v@: u M @: @: 19 @:vmean@:(v)}
35588 @r{ v@: I u M @: @: 19 @:vmeane@:(v)}
35589 @r{ v@: H u M @: @: 19 @:vmedian@:(v)}
35590 @r{ v@: I H u M @: @: 19 @:vhmean@:(v)}
35591 @r{ v@: u N @: @: 19 @:vmin@:(v)}
35592 @r{ v@: u S @: @: 19 @:vsdev@:(v)}
35593 @r{ v@: I u S @: @: 19 @:vpsdev@:(v)}
35594 @r{ v@: H u S @: @: 19 @:vvar@:(v)}
35595 @r{ v@: I H u S @: @: 19 @:vpvar@:(v)}
35596 @r{ @: u V @: @: @:calc-view-units-table@:}
35597 @r{ v@: u X @: @: 19 @:vmax@:(v)}
35600 @r{ v@: u + @: @: 19 @:vsum@:(v)}
35601 @r{ v@: u * @: @: 19 @:vprod@:(v)}
35602 @r{ v@: u # @: @: 19 @:vcount@:(v)}
35605 @r{ @: V ( @: @: 50 @:calc-vector-parens@:}
35606 @r{ @: V @{ @: @: 50 @:calc-vector-braces@:}
35607 @r{ @: V [ @: @: 50 @:calc-vector-brackets@:}
35608 @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:}
35609 @r{ @: V , @: @: 50 @:calc-vector-commas@:}
35610 @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:}
35611 @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:}
35612 @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:}
35613 @r{ @: V / @: @: 12,50 @:calc-break-vectors@:}
35614 @r{ @: V . @: @: 12,50 @:calc-full-vectors@:}
35617 @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)}
35618 @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)}
35619 @r{ s@: V ~ @: @: 1 @:vcompl@:(s)}
35620 @r{ s@: V # @: @: 1 @:vcard@:(s)}
35621 @r{ s@: V : @: @: 1 @:vspan@:(s)}
35622 @r{ s@: V + @: @: 1 @:rdup@:(s)}
35625 @r{ m@: V & @: @: 1 @:inv@:(m) 1/m}
35628 @r{ v@: v a @:n @: @:arrange@:(v,n)}
35629 @r{ a@: v b @:n @: @:cvec@:(a,n)}
35630 @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)}
35631 @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)}
35632 @r{ m@: v c @:0 @: 31 @:getdiag@:(m)}
35633 @r{ v@: v d @: @: 25 @:diag@:(v,n)}
35634 @r{ v m@: v e @: @: 2 @:vexp@:(v,m)}
35635 @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)}
35636 @r{ v a@: v f @: @: 26 @:find@:(v,a,n)}
35637 @r{ v@: v h @: @: 1 @:head@:(v)}
35638 @r{ v@: I v h @: @: 1 @:tail@:(v)}
35639 @r{ v@: H v h @: @: 1 @:rhead@:(v)}
35640 @r{ v@: I H v h @: @: 1 @:rtail@:(v)}
35641 @r{ @: v i @:n @: 31 @:idn@:(1,n)}
35642 @r{ @: v i @:0 @: 31 @:idn@:(1)}
35643 @r{ h t@: v k @: @: 2 @:cons@:(h,t)}
35644 @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)}
35645 @r{ v@: v l @: @: 1 @:vlen@:(v)}
35646 @r{ v@: H v l @: @: 1 @:mdims@:(v)}
35647 @r{ v m@: v m @: @: 2 @:vmask@:(v,m)}
35648 @r{ v@: v n @: @: 1 @:rnorm@:(v)}
35649 @r{ a b c@: v p @: @: 24 @:calc-pack@:}
35650 @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)}
35651 @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)}
35652 @r{ m@: v r @:0 @: 31 @:getdiag@:(m)}
35653 @r{ v i j@: v s @: @: @:subvec@:(v,i,j)}
35654 @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)}
35655 @r{ m@: v t @: @: 1 @:trn@:(m)}
35656 @r{ v@: v u @: @: 24 @:calc-unpack@:}
35657 @r{ v@: v v @: @: 1 @:rev@:(v)}
35658 @r{ @: v x @:n @: 31 @:index@:(n)}
35659 @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)}
35662 @r{ v@: V A @:op @: 22 @:apply@:(op,v)}
35663 @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)}
35664 @r{ m@: V D @: @: 1 @:det@:(m)}
35665 @r{ s@: V E @: @: 1 @:venum@:(s)}
35666 @r{ s@: V F @: @: 1 @:vfloor@:(s)}
35667 @r{ v@: V G @: @: @:grade@:(v)}
35668 @r{ v@: I V G @: @: @:rgrade@:(v)}
35669 @r{ v@: V H @:n @: 31 @:histogram@:(v,n)}
35670 @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)}
35671 @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)}
35672 @r{ m@: V J @: @: 1 @:ctrn@:(m)}
35673 @r{ m@: V L @: @: 1 @:lud@:(m)}
35674 @r{ v@: V M @:op @: 22,23 @:map@:(op,v)}
35675 @r{ v@: V N @: @: 1 @:cnorm@:(v)}
35676 @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)}
35677 @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)}
35678 @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)}
35679 @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)}
35680 @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)}
35681 @r{ v@: V S @: @: @:sort@:(v)}
35682 @r{ v@: I V S @: @: @:rsort@:(v)}
35683 @r{ m@: V T @: @: 1 @:tr@:(m)}
35684 @r{ v@: V U @:op @: 22 @:accum@:(op,v)}
35685 @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)}
35686 @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)}
35687 @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)}
35688 @r{ s t@: V V @: @: 2 @:vunion@:(s,t)}
35689 @r{ s t@: V X @: @: 2 @:vxor@:(s,t)}
35692 @r{ @: Y @: @: @:@:user commands}
35695 @r{ @: z @: @: @:@:user commands}
35698 @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:}
35699 @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:}
35700 @r{ @: Z : @: @: @:calc-kbd-else@:}
35701 @r{ @: Z ] @: @: @:calc-kbd-end-if@:}
35704 @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:}
35705 @r{ c@: Z / @: @: 45 @:calc-kbd-break@:}
35706 @r{ @: Z @} @: @: @:calc-kbd-end-loop@:}
35707 @r{ n@: Z < @: @: @:calc-kbd-repeat@:}
35708 @r{ @: Z > @: @: @:calc-kbd-end-repeat@:}
35709 @r{ n m@: Z ( @: @: @:calc-kbd-for@:}
35710 @r{ s@: Z ) @: @: @:calc-kbd-end-for@:}
35713 @r{ @: Z C-g @: @: @:@:cancel if/loop command}
35716 @r{ @: Z ` @: @: @:calc-kbd-push@:}
35717 @r{ @: Z ' @: @: @:calc-kbd-pop@:}
35718 @r{ @: Z # @: @: @:calc-kbd-query@:}
35721 @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:}
35722 @r{ @: Z D @:key, command @: @:calc-user-define@:}
35723 @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:}
35724 @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:}
35725 @r{ @: Z G @:key @: @:calc-get-user-defn@:}
35726 @r{ @: Z I @: @: @:calc-user-define-invocation@:}
35727 @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:}
35728 @r{ @: Z P @:key @: @:calc-user-define-permanent@:}
35729 @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:}
35730 @r{ @: Z T @: @: 12 @:calc-timing@:}
35731 @r{ @: Z U @:key @: @:calc-user-undefine@:}
35741 Positive prefix arguments apply to @expr{n} stack entries.
35742 Negative prefix arguments apply to the @expr{-n}th stack entry.
35743 A prefix of zero applies to the entire stack. (For @key{LFD} and
35744 @kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
35748 Positive prefix arguments apply to @expr{n} stack entries.
35749 Negative prefix arguments apply to the top stack entry
35750 and the next @expr{-n} stack entries.
35754 Positive prefix arguments rotate top @expr{n} stack entries by one.
35755 Negative prefix arguments rotate the entire stack by @expr{-n}.
35756 A prefix of zero reverses the entire stack.
35760 Prefix argument specifies a repeat count or distance.
35764 Positive prefix arguments specify a precision @expr{p}.
35765 Negative prefix arguments reduce the current precision by @expr{-p}.
35769 A prefix argument is interpreted as an additional step-size parameter.
35770 A plain @kbd{C-u} prefix means to prompt for the step size.
35774 A prefix argument specifies simplification level and depth.
35775 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}.
35779 A negative prefix operates only on the top level of the input formula.
35783 Positive prefix arguments specify a word size of @expr{w} bits, unsigned.
35784 Negative prefix arguments specify a word size of @expr{w} bits, signed.
35788 Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument
35789 cannot be specified in the keyboard version of this command.
35793 From the keyboard, @expr{d} is omitted and defaults to zero.
35797 Mode is toggled; a positive prefix always sets the mode, and a negative
35798 prefix always clears the mode.
35802 Some prefix argument values provide special variations of the mode.
35806 A prefix argument, if any, is used for @expr{m} instead of taking
35807 @expr{m} from the stack. @expr{M} may take any of these values:
35809 {@advance@tableindent10pt
35813 Random integer in the interval @expr{[0 .. m)}.
35815 Random floating-point number in the interval @expr{[0 .. m)}.
35817 Gaussian with mean 1 and standard deviation 0.
35819 Gaussian with specified mean and standard deviation.
35821 Random integer or floating-point number in that interval.
35823 Random element from the vector.
35831 A prefix argument from 1 to 6 specifies number of date components
35832 to remove from the stack. @xref{Date Conversions}.
35836 A prefix argument specifies a time zone; @kbd{C-u} says to take the
35837 time zone number or name from the top of the stack. @xref{Time Zones}.
35841 A prefix argument specifies a day number (0-6, 0-31, or 0-366).
35845 If the input has no units, you will be prompted for both the old and
35850 With a prefix argument, collect that many stack entries to form the
35851 input data set. Each entry may be a single value or a vector of values.
35855 With a prefix argument of 1, take a single
35856 @texline @var{n}@math{\times2}
35857 @infoline @mathit{@var{N}x2}
35858 matrix from the stack instead of two separate data vectors.
35862 The row or column number @expr{n} may be given as a numeric prefix
35863 argument instead. A plain @kbd{C-u} prefix says to take @expr{n}
35864 from the top of the stack. If @expr{n} is a vector or interval,
35865 a subvector/submatrix of the input is created.
35869 The @expr{op} prompt can be answered with the key sequence for the
35870 desired function, or with @kbd{x} or @kbd{z} followed by a function name,
35871 or with @kbd{$} to take a formula from the top of the stack, or with
35872 @kbd{'} and a typed formula. In the last two cases, the formula may
35873 be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
35874 may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
35875 last argument of the created function), or otherwise you will be
35876 prompted for an argument list. The number of vectors popped from the
35877 stack by @kbd{V M} depends on the number of arguments of the function.
35881 One of the mapping direction keys @kbd{_} (horizontal, i.e., map
35882 by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
35883 reduce down), or @kbd{=} (map or reduce by rows) may be used before
35884 entering @expr{op}; these modify the function name by adding the letter
35885 @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
35886 or @code{d} for ``down.''
35890 The prefix argument specifies a packing mode. A nonnegative mode
35891 is the number of items (for @kbd{v p}) or the number of levels
35892 (for @kbd{v u}). A negative mode is as described below. With no
35893 prefix argument, the mode is taken from the top of the stack and
35894 may be an integer or a vector of integers.
35896 {@advance@tableindent-20pt
35900 (@var{2}) Rectangular complex number.
35902 (@var{2}) Polar complex number.
35904 (@var{3}) HMS form.
35906 (@var{2}) Error form.
35908 (@var{2}) Modulo form.
35910 (@var{2}) Closed interval.
35912 (@var{2}) Closed .. open interval.
35914 (@var{2}) Open .. closed interval.
35916 (@var{2}) Open interval.
35918 (@var{2}) Fraction.
35920 (@var{2}) Float with integer mantissa.
35922 (@var{2}) Float with mantissa in @expr{[1 .. 10)}.
35924 (@var{1}) Date form (using date numbers).
35926 (@var{3}) Date form (using year, month, day).
35928 (@var{6}) Date form (using year, month, day, hour, minute, second).
35936 A prefix argument specifies the size @expr{n} of the matrix. With no
35937 prefix argument, @expr{n} is omitted and the size is inferred from
35942 The prefix argument specifies the starting position @expr{n} (default 1).
35946 Cursor position within stack buffer affects this command.
35950 Arguments are not actually removed from the stack by this command.
35954 Variable name may be a single digit or a full name.
35958 Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or
35959 @key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the
35960 buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation
35961 of the result of the edit.
35965 The number prompted for can also be provided as a prefix argument.
35969 Press this key a second time to cancel the prefix.
35973 With a negative prefix, deactivate all formulas. With a positive
35974 prefix, deactivate and then reactivate from scratch.
35978 Default is to scan for nearest formula delimiter symbols. With a
35979 prefix of zero, formula is delimited by mark and point. With a
35980 non-zero prefix, formula is delimited by scanning forward or
35981 backward by that many lines.
35985 Parse the region between point and mark as a vector. A nonzero prefix
35986 parses @var{n} lines before or after point as a vector. A zero prefix
35987 parses the current line as a vector. A @kbd{C-u} prefix parses the
35988 region between point and mark as a single formula.
35992 Parse the rectangle defined by point and mark as a matrix. A positive
35993 prefix @var{n} divides the rectangle into columns of width @var{n}.
35994 A zero or @kbd{C-u} prefix parses each line as one formula. A negative
35995 prefix suppresses special treatment of bracketed portions of a line.
35999 A numeric prefix causes the current language mode to be ignored.
36003 Responding to a prompt with a blank line answers that and all
36004 later prompts by popping additional stack entries.
36008 Answer for @expr{v} may also be of the form @expr{v = v_0} or
36013 With a positive prefix argument, stack contains many @expr{y}'s and one
36014 common @expr{x}. With a zero prefix, stack contains a vector of
36015 @expr{y}s and a common @expr{x}. With a negative prefix, stack
36016 contains many @expr{[x,y]} vectors. (For 3D plots, substitute
36017 @expr{z} for @expr{y} and @expr{x,y} for @expr{x}.)
36021 With any prefix argument, all curves in the graph are deleted.
36025 With a positive prefix, refines an existing plot with more data points.
36026 With a negative prefix, forces recomputation of the plot data.
36030 With any prefix argument, set the default value instead of the
36031 value for this graph.
36035 With a negative prefix argument, set the value for the printer.
36039 Condition is considered ``true'' if it is a nonzero real or complex
36040 number, or a formula whose value is known to be nonzero; it is ``false''
36045 Several formulas separated by commas are pushed as multiple stack
36046 entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
36047 delimiters may be omitted. The notation @kbd{$$$} refers to the value
36048 in stack level three, and causes the formula to replace the top three
36049 stack levels. The notation @kbd{$3} refers to stack level three without
36050 causing that value to be removed from the stack. Use @key{LFD} in place
36051 of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
36052 to evaluate variables.
36056 The variable is replaced by the formula shown on the right. The
36057 Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
36059 @texline @math{x \coloneq a-x}.
36060 @infoline @expr{x := a-x}.
36064 Press @kbd{?} repeatedly to see how to choose a model. Answer the
36065 variables prompt with @expr{iv} or @expr{iv;pv} to specify
36066 independent and parameter variables. A positive prefix argument
36067 takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
36068 and a vector from the stack.
36072 With a plain @kbd{C-u} prefix, replace the current region of the
36073 destination buffer with the yanked text instead of inserting.
36077 All stack entries are reformatted; the @kbd{H} prefix inhibits this.
36078 The @kbd{I} prefix sets the mode temporarily, redraws the top stack
36079 entry, then restores the original setting of the mode.
36083 A negative prefix sets the default 3D resolution instead of the
36084 default 2D resolution.
36088 This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
36089 @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
36090 @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12
36091 grabs the @var{n}th mode value only.
36095 (Space is provided below for you to keep your own written notes.)
36103 @node Key Index, Command Index, Summary, Top
36104 @unnumbered Index of Key Sequences
36108 @node Command Index, Function Index, Key Index, Top
36109 @unnumbered Index of Calculator Commands
36111 Since all Calculator commands begin with the prefix @samp{calc-}, the
36112 @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
36113 types @samp{calc-} for you. Thus, @kbd{x last-args} is short for
36114 @kbd{M-x calc-last-args}.
36118 @node Function Index, Concept Index, Command Index, Top
36119 @unnumbered Index of Algebraic Functions
36121 This is a list of built-in functions and operators usable in algebraic
36122 expressions. Their full Lisp names are derived by adding the prefix
36123 @samp{calcFunc-}, as in @code{calcFunc-sqrt}.
36125 All functions except those noted with ``*'' have corresponding
36126 Calc keystrokes and can also be found in the Calc Summary.
36131 @node Concept Index, Variable Index, Function Index, Top
36132 @unnumbered Concept Index
36136 @node Variable Index, Lisp Function Index, Concept Index, Top
36137 @unnumbered Index of Variables
36139 The variables in this list that do not contain dashes are accessible
36140 as Calc variables. Add a @samp{var-} prefix to get the name of the
36141 corresponding Lisp variable.
36143 The remaining variables are Lisp variables suitable for @code{setq}ing
36144 in your Calc init file or @file{.emacs} file.
36148 @node Lisp Function Index, , Variable Index, Top
36149 @unnumbered Index of Lisp Math Functions
36151 The following functions are meant to be used with @code{defmath}, not
36152 @code{defun} definitions. For names that do not start with @samp{calc-},
36153 the corresponding full Lisp name is derived by adding a prefix of
36162 arch-tag: 77a71809-fa4d-40be-b2cc-da3e8fb137c0